NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
npm
npm
Ship with a team that never sleeps. Specialized agents, from any lab.
Latest stable
0.5.19
Last release 15 days ago
07 Nov 2026
Ships unpredictably
gaps range from 8 days to 10.6 years
Nearly every release is documented
notes for 27 of 28 stable releases
Nothing withdrawn
no release was ever pulled
11 years old
28 releases · first in 2016
Drag across the ruler to compare, or tap a release to open it.
Internal references removed from shipped files.
Internal references removed from shipped files.
Issuing a general grant refuses a chain of more than four ancestors before the grant is signed or written. team check and team doctor each print that grant's chain, whether it is a wildcard, whether it may issue, and when it expires.
Prepared releases check operation rows against the dated release heading before tagging; development can keep operations declared unshipped. New relea
Prepared releases check operation rows against the dated release heading before tagging; development can keep operations declared unshipped. New release rows use the release day’s end in UTC as a conservative widening boundary.
Caller placement retries one incomplete process walk, keeps refusing incomplete chains or a parent change during the read, and names the failure cause without logging command arguments or environment values.
State files, delivery markers, logs, queues and first-run admission now refuse unsafe links and publish through checked private files.
New team logs and replaced task queues and repository exclude files now use owner-only 0600 permissions.
State writes accept a physical child path under a root spelled through an ancestor alias. A declared root that is itself a symbolic link is refused; use its real folder path.
Copying a seat with no label to a number-like name now keeps its name and label as text.
Labels with # inside quotes are no longer cut short, and rewriting them preserves only the outside comment.
team start is owner-only: a general grant never admits it.
Owners who relied on a wildcard grant for forget now need an explicit grant or a per-use approval.
A reply that team send --wait shows is not proof of who wrote it: a seat on the same machine can write a record that looks like another seat’s reply. Check the sender another way before acting on it.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Carries the v0.5.16 content. v0.5.16 was tagged but never published to npm.
Carries the v0.5.16 content. v0.5.16 was tagged but never published to npm.
Read-only project analysis, checkpoint requests, named launchers, and guarded start folders for Grok and Cursor.
analyse, checkpoint and show at theCopying a seat that has no label to a name that looks like a number (for example 123456789012) is refused; pick a name that starts with a letter. Fixed in the next release.
Grok sandbox grants were wider than the seat (affected: 0.5.12 through 0.5.14). Before this release, a Grok seat's sandbox profile granted read-write
Grok's workspace preset also grants the folder a Grok seat starts in; a Grok seat started in a shared lobby can write that lobby. Until the next release, start Grok seats in their own worktree.
A listed Muse hint is the empty box only when it is faint or drawn in the colour the composer declares. A listed hint in another colour stays a draft,
A listed Muse hint is the empty box only when it is faint or drawn in the colour the composer declares. A listed hint in another colour stays a draft, and a typed wake does not type over it.
team drops --read now checks the caller (affected: 0.5.1 through 0.5.13). Before thisteam drops --read --seat <seat> served any seat's waiting messages to any process run--read serves a seat's messages to that seat, as thethe refusal reason can vary when two agent records share a millisecond; the decision is unaffected.
Message delivery now reports only the leg that ran, a seat behind a launcher wrapper can answer, and a managed Codex endpoint that is down is named in
Message delivery now reports only the leg that ran, a seat behind a launcher wrapper can
answer, and a managed Codex endpoint that is down is named instead of typed into.
--no-daemon, and team check names each ready Codex seat whose endpoint--json document accepts the channel leg.team reply and team ack run from a seat's shell now recognise the seat placed in theteam send already did, so a seat behind a launcher wrapper is no longer? for shortcuts with the account's warning nowteam status reports a machine daemon whose health probe timed out but whose heartbeat isteam up records a live Claude seat's socket address even when it leaves the seat atteam up binds an address only to the seat and session that own the pane: it skips a paneteam check names the repair that works: team up for a live seat whose record holds noteam register when the record names no held process or stands in another session. A paneteam reload registers the inbox again when the registration isteam status say the box reads as holding text, and never askA send walks one cascade and stops at the first leg that takes it. A message stays in the mailbox until the seat that must read it signs the receipt.
A send walks one cascade and stops at the first leg that takes it. A message stays in the mailbox
until the seat that must read it signs the receipt.
A send tries three leg classes, in order, and stops at the first one that takes the message. First
the channel: a live socket, a runtime queue, or the CLI's own session. Then a webhook the sender
posts itself. Then a gated typed nudge, one trigger line into an idle prompt. The mailbox sits under
all three and is the last resort. The inbox server is how a seat reads that mailbox; it is not a
wake, and a delivery order that still names it is reported unavailable. A seat marked human uses the
mailbox only. A reply walks the same cascade toward the sender and reports the leg that took it.
The sender does not move on because a receipt is missing. The watch does. When the unread window
passes with no receipt the seat signed, the watch tries the next leg down the cascade. The window is
30 seconds for a seat that can be woken while idle, 60 seconds for a typed or pull-only seat, or the
team's own setting. At twice that window the sender and the lead are told the message is queued, not
woken. A mailbox drop that no leg can wake ends with those words.
Only the seat signs a read receipt: its inbox read, its drops read, an acknowledgement, or a reply.
A frame the channel took is reported delivered as taken. Delivered as read means the seat signed the
receipt. The frame's last line names the record and the two acts that settle it: a reply marks it
read, and an acknowledgement marks it read when no answer is needed. A taken frame that is still
unread is re-woken once, with that hint.
team messages serves and signs one mailbox: the caller's own. A run as the owner serves the
owner's mailbox, and a run as a seat serves the mailbox of the seat it is placed as. A caller placed
nowhere is refused. A record waiting on another seat's mailbox is listed as waiting; a seat's run
does not show its body, and the owner's run shows a verified body read-only without spending that
seat's receipt.
A client that holds a bundle grant can open a thread with a seat the grant reaches. That seat can
now answer it: team reply and team ack accept a verified bundle grant, and the ops the grant
signed decide which of the two is allowed — a reply needs the reply op, an acknowledgement needs the
ack op, and a bundle without it is refused as before. The grant is verified, and the recipient
re-checked, while the grant lock is held. A reply whose recipient seat, or whose agent id, moved
while it waited is refused and writes nothing; it says to send the reply again.
Each step of a message writes a signed event on that message's id. team trace prints the steps in
order with the time between them. A send prints the id on its last line.
The daemon answers as soon as it is bound. Each root's first store scan runs behind that, and status
reports the scan while it runs and when it finishes.
Heavy work for a root — its watch, its presence steps, and its fallback sweep — runs in a supervised
child. The release default is one child per root. The daemon's own loop keeps answering. A child
that has exited is not given another beat. A cold event-log read verifies from a signed checkpoint
in slices, and the send endpoint's terminal host is read off the loop that answers health, so
neither holds the daemon up.
The sender's webhook post waits for the webhook-sender-deadline-ms policy: 3 seconds when unset, a
whole number of milliseconds from 500 to 10000. It waits the tighter of that bound and the seat
row's own answer bound. A post that outlives the wait is reported unknown, not failed, and is not
posted again. An answer that arrives after the wait is still recorded.
Antigravity, Grok, Codex, Muse, and Cursor can declare a typed wake. A send types one trigger line,
never the message, into a prompt two reads showed empty and idle, presses Enter only while the box
still holds that line, at most three times, and calls the send delivered only when the working
screen shows and the box no longer holds the line. Otherwise it is not delivered, the line is not
typed again, and the message stays for a later wake. The line names how that profile reads its
inbox. delivered (typed wake) is a history outcome. Muse's faint placeholder reads as an empty
box, and a typed wake waits out a drawing line before it presses Enter.
A pane scrolled back over its transcript hides the prompt, so a wake used to find a screen it did
not recognise and refuse. Codex's scroll-back view is now read as its own screen, in two layouts:
the footer on the last row with the prompt hidden, and the marker directly above the prompt with the
status footer on the last row. Both are read from the pane's bottom rows only, never from a
transcript row higher up that quotes them. The wake presses the view's own return key once, then
reads the prompt twice before typing, and keeps every guard it already had: a draft the return
reveals, a working turn, or a dialog refuses, and Enter is pressed only while two reads agree on the
line. A scrolled pane whose host word says unknown is woken this way too. A footer this build does
not know is still an unrecognised screen, and nothing is typed into it; a launch keeps reading the
view as unrecognised.
The hint row Codex draws after the scroll-back return — esc again to edit previous message — is
the prompt's own chrome: the empty composer reads idle and a wake may type its line there, and the
hint is never answered with esc. With a line in the box, Codex hides its shortcuts row and draws the
account's warning row under the status row; that row is the pane's own chrome too, so the box still
reads unsent and a typed wake presses its guarded Enter into the line it typed. Neither row is read
from a transcript row that quotes it, and no key is pressed into either.
team down and team restart clear the exit text they typed when the submit Enter is refused or
never runs.
A seat whose tools do not include the inbox is told, in its own rules, to read its drops at the end
of every turn.
team order puts the sidebar back in roster order, restarting one seat at a time. An owner who
names a session or a team file has that choice followed by the placement and by every restart the
pass delegates.
When the terminal host hands a live session to a new server, placement follows the new server's root
process, and a caller keeps its seat placement and any development-mode lift across the handoff.
A seat may read workflow runs, and may run the Actions commands its policy allows. The release set
is rerunning the failed jobs of a run, and starting the deploy and ci workflows on a named ref. A
lower level may only drop a command. Deleting or dismissing a comment is refused; the seat posts a
superseding comment instead.
Every seat's rules carry the owner's reserved scope, and under it the line that checkouts, seats,
and team config belong to the teams. A lead's rules also say when a lead may act in a seat's pane,
and when a lead in development mode may restore a stopped seat. Those two lines ship on, and each
can be turned off. The third ships off: inside an entity, an entity may turn on the line that a
decision the main orchestrator relays from the owner is quoted, cited, and acted on — off by
default, because a relayed decision carries the owner's authority and a sender's claim to relay one
does not yet verify. The reserved scope stays whatever is set.
Under development mode, the owner lift on team config set and team add admits only its subject:
the target team's lead, placed in that team's session, or the entity's main orchestrator. An
always rule for an owner action admits only its subject as well, and the rule spent is the one
naming the caller's team; revoking an approval is one of those actions. While development mode is on
for a team, team check reports a pending owner card that asks for anything beyond the general
grant and the development-mode switch as policy drift.
In development mode, team restart, team order and team worktree continue when a stored
approval does not verify: each names the record and the unverified lines, restart names
team approve as the command that writes a new approval, and none of them signs one. Outside
development mode the refusal is unchanged; order and worktree say that standing cannot be renewed in
this build.
The entity's main orchestrator can reach any seat of the entity's teams. A seat can answer that
orchestrator on the thread the orchestrator opened, and cannot open a thread toward it. A restart of
a stopped seat by that orchestrator is judged by who the caller is.
daemon.heartbeat is a whole number of seconds from 1 to 60. Unset, the beat is 5 seconds. The
daemon records it and answers a health probe while other work runs.
Two first writers of a new home share the state folders and the pending folder. A folder that is
already a real folder of this user is used. A link, a file, or another user's folder is still
refused.
A chores child reports the processor time it has been charged on every heartbeat, so a healthy beat
does not stop to read the process table. The daemon asks the process table only for a child that has
gone silent: one question at a time, off the answering loop. A reading that fails, or runs
backwards, spares the child. A child still being charged work is not forced off. A child that has
not yet had time to hear a beat is not judged silent. A root's next child waits 60 seconds from the
moment the last one was ended, including when the start itself throws, so a child that comes up
under load is not replaced again inside that minute.
A seat written on one line, or as a list at the seats header's own column, can be revived. Restart
decides that the seat exists from the validated record, and clears or re-marks the stopped mark
through that record, wherever the text holds the key. A record that no longer validates keeps the
old line writer. A registry team can declare a seat no launch has run for yet. Up, add, restart and
reload write that seat's roster line before the plan runs, so the first launch can register. A name
the launching record does not declare is refused, and the registry is left as it was.
An exact listed line drawn in one non-bold colour reads as idle, so a seat that has gone idle can be
woken. A second colour, a bold word, or a cursor cell stays text. A webhook delivery the seat has
not read is posted once more, with the same message id. The wake marker stops a second pass.
A tasks hint is an empty box only when the whole row is that exact text. The same words with
anything after them stay a draft, so a wake does not type over a draft. A listed tasks sentence in
one non-bold colour is that empty box. The same words split across two colours stay a draft.
Two reads that hold exactly the wake line press Enter, and a listed placeholder row under that line
does not spoil the hold. A working screen that still holds the line is not delivered. The wait stays
inside the existing bound. A bound that ends with the line still there leaves the message for a
later wake.
When unread mail is due and the seat's screen is one the watch does not recognise, the watch does
not type into it. It tells the lead once and records the message delivered but blocked. The notice
is owed once the message is due, not only inside twice the unread window: a pass that first looks
late still names the screen, where the queued, not woken report was the only word before. Twice the
window keeps the notice single — a report already standing for the same seat and screen is the one
later messages join. A screen the watch already knows keeps its own handling, so a later idle screen
can still be typed.
Some states keep the wake path from looking at a seat at all: the message already has a retry, or a
proven presence says the seat is mid-turn. When the oldest unread message has waited past twice the
seat's unread window, the watch now names the seat to the lead anyway, once per episode, for every
seat not marked human and not stopped. The notice says what waits — how many messages, and the
oldest one's age — and why: the screen is not recognised, or presence has said working for longer
than watch.stuck_after. That bound is 15 minutes when the team does not set it, and it is never
scaled by the tempo; a working word younger than it is a live turn and gets no notice. The episode
closes when the seat reads one of the messages the notice named, or its state is recognised and
fresh again. The blocked-screen report shares the episode, so one stall is one notice, and the
queued, not woken report stays quiet while an episode is open. The notice types nothing, takes no
seat lock, and leaves every pending retry and wake marker as it found it.
The stuck-episode marker is taken from the pass's own folder listing: an absent marker costs no
read, and a marker is read at most once per seat per pass.
One watch pass reads each message file once. It checks a receipt before it reads the record, and the
unread set and the unacked set from that read are what the pass wakes, reports and waits on. A later
check in the same pass uses that set. It does not open the file again. A very large drop folder,
tens of thousands of old messages, still slows the hosted watch until archived drops are reclaimed
in the next release.
After a machine loses power, the terminal host reopens the sessions it can, but the agent names it
had given their panes do not survive. A caller places itself by that name, so every restored seat
reads as unplaced and its sends and reads are refused. team up now re-ties a restored seat to its
record when the proof holds: the pane is the recorded one, in the recorded workspace, and either its
conversation is the one the record names, or — when neither side names a conversation — the declared
CLI is alone in its workspace, at an idle prompt, with nothing unsent in its box. The run names the
pane back, repaints the sidebar line and records the process the pane holds now; nothing is typed
into the pane and nothing is closed, and the seat counts as neither repaired nor refused. A pane
that fails the proof is left as it is, with the reason said.
A seat whose program the terminal host did not bring back is launched again. When its recorded pane
is back at its shell, the seat runs in that same pane; when the pane is gone or was replaced, the
seat launches from the beginning in a workspace of its own, and the workspace left behind closes
without input once the seat is ready — only while it still holds nothing but the old pane and is not
named for another seat. Replacing, removing or stopping a seat closes the workspace it vacates once
the replacement is ready, or at once when nothing replaces it, and only when the host, read just
before the close, shows no CLI and no other seat's pane in it. A team keeps one watch workspace: one
that already carries the team's label is reused instead of a second being made.
A restored pane that runs the bare CLI where the seat's own launch line starts a wrapper — an
alternate endpoint — is not adopted: every turn would lack the wrapper's settings. team up lets
the bare CLI exit by its own exit word or keys in that same pane, launches the seat again there
through its own launch line with its conversation resumed, and neither closes nor replaces the
workspace.
A Codex seat whose recorded managed endpoint did not survive the host is not left on it. When the
record names this seat's own socket and that socket is not live, or the recorded process is gone, or
the process now at that pid started at another time, team up lets the CLI exit in its pane and
launches the seat again there, so the launch starts a fresh endpoint and attaches to it. A live
endpoint stays. A record that is absent or not this seat's, and a start time this build cannot read,
leave the pane as it is: nothing is relaunched on a guess. The relaunch is the Codex binary itself
with the managed endpoint on. A wrapper, or a line that already names --remote or --no-daemon,
is not given one.
A launch asks the terminal host for the seat's name, and asks again when the host refuses because
the agent is still starting. The asks stay inside the naming wait: the first pause is a quarter of a
second and each later one doubles up to two seconds, cut to whatever the wait has left. A pane the
host has begun naming for another seat is left to that seat. Only the wait running out leaves the
seat unnamed, at launched.
One command runs the restore across every registered team: team up --all, which only the owner or
a lead in development mode runs, takes the teams in a fixed order — a team whose folder holds
another team's first, then by session name — runs the ordinary pass for each team whose session is
running and whose record holds seats, and skips a team whose session is not running rather than
starting it cold. One team's failure never stops the next; the run ends with a line counting the
teams swept and the seats repaired, skipped and refused, and a run that restores nothing says so
instead of reporting success. The daemon's startup pass does the same for the checkouts its unit
names and retries a session that is still restoring — five seconds, then twice as long each time up
to a minute, for five minutes and a quarter — before it reports that session pending. That pass is
this home's unit alone: a loaded job whose path is not the unit file this home installed is not this
daemon's, and the retry does not borrow it. A seat lock left by the previous boot is stale unless
its process is alive and its start time matches the one recorded, so a reused pid no longer holds a
seat shut.
team check names each restore gap with its repair: a restored pane that holds the seat's
conversation or declared CLI, a seat whose CLI did not come back, a pane running no CLI, and a
process the record cannot tie to the launch. team restart proves the team of a restored session
from the team it was launched from, then the team the folder holds, then the team the registry
records for the session, and says which one it fell back to. A restored pane is team up's to
re-tie, not restart's; restart takes one only while the host still names the seat on the recorded
pane, and only with --abandon.
Clearer delivery reports and approval cards, steadier team recovery, and tighter checks before an action changes a team or answers a dialog.
Clearer delivery reports and approval cards, steadier team recovery, and tighter checks before
an action changes a team or answers a dialog.
team peek shows a seat's captured screen lines with credential masking, without sendingteam answer handles questions, plan approvals and confirmations on supported CLI versions.team daemon restart accepts a verified general grant that covers the daemon operation.--reason text andreason field belongs only toteam route reports the same stale session state a send would meet, instead of calling a0.5.10 is one release for everything since 0.5.5. The work prepared as 0.5.6 through 0.5.9 is folded in here: the owner seat and grants, the registry,
0.5.10 is one release for everything since 0.5.5. The work prepared as 0.5.6 through 0.5.9 is
folded in here: the owner seat and grants, the registry, quiet starts, the general grant on
every command, the end of typed messaging, and the managed Codex endpoint.
Nothing is ever typed into a seat. No message, wake, reminder, watch nudge, rules line or
restart handover is sent by typing into a seat's terminal or prompt. Every message ends in the
seat's bus inbox and reaches the seat by the route its own launch installed: an event adapter
that wakes it — the development channel its launch loads, or a socket its launch accepts whose
recorded address still stands — a Codex runtime queue under the managed endpoint that holds
the message between turns, or an inbox the seat reads when it next takes a turn. The sender is
told which, in plain words: woken through its event adapter, woken through its runtime queue,
queued and read at its next turn (pull-only), or queued with no way to be woken while it is
idle. A send that ends without a delivery never answers a bare "unconfirmed"; the bus-inbox
drop's own line still says queued, no event adapter when it takes the send. Starting a CLI in
a terminal, its exit keys and team answer (a permission dialog, not a message) are unchanged.
team messages serves them to a reader in the checkout. An ordinary MCP inboxinbox_check and inbox_read, and pushes nothing. A seat whoseteam restart <seat> carries them; where it has none, no launch ever carries them, and thetyped delivery order names the seat's own adapters. For a Claude seat it* covers ops added later. The client bundle formerly named developer is the defaultdeveloper remains its alias), and it may run team down --abandon.team config set|unset --request lets the owner seat approve a team-record change.team grant --request reports whether the owner was notified, presents a Touch ID card,team development-mode), off bylocal-fast lifts the caller gates of up, down, remove, register, add,restart, init, reload and rename; the team-file approval the delegate and grant gatesup, add, remove, down, register, reload) and the add, remove and downgrant, delegate, revoke, policy set and unset, check --repair, removedown --abandon, broker, tempo, daemon install, uninstall and fault-watch; theagy 1.4.3, in team reload. Beyond the lifts this entry lists, the client panedev mode continues clause, exceptdown's caller-placement line under a policy or the machine record, which carries the levelteam up --general form admits a launch with no request. team init --general creates a team for aninit.general-refused. A grant's ops may be the wildcard *,team client general-grant defaults to --ops '*'.team client general-grant takes --general <grant.json> and --key <client.key>. The dispatcher verifies it once for the command's ownreply, in place of the walked caller). A command added later is covered with no wiring ofup, init and config keep their own admission, and the grant-issuing command--general (a holder issues with --via). Every command name is a general-grant op,team.general-usage (2: --general--key, or on the grant-issuing command) and team.general-refused (1: expired,--general--key on every command and subcommand.team up starts the bus in its own workspace, team down closes it, and a droppedteam messages --client --follow prints eachteam down --abandon answers known prompts and saves unsent text before stopping a seat.team config set syncs the agent launch. A Grok seat resumes with grok -r <id> and anagy --conversation=<id>. After team down, team up resumes theteam up --no-launch gives seats their rules only, with no general seatwork-item definition ships with the workflow, and team next takes the run store's holdteam daemon status --json exposes it as gitHead. The pair tells an install that changed either the version orteam status names when the hosted watch started and which build is cycling. A route thewatch: running in the daemon since <start>, version <version>,unknown when itteam agents prune retires agent records no roster names. It lists one row for each--apply--apply is the owner's, from a terminal rather than a seat's pane, and ateam brief prune retires a seat's own launch-brief retry sidecars. A held launch--apply, removes the ones whose--apply verifies eachpush, between-turns, pull-on-turn or none — thepush seatnone. A send thatsent (unconfirmed), sent (channel) andqueued (receiver busy) lines, and to action_summary in --json, in plain words: woken through its event adapter, woken through its runtime queue, queued; <seat> reads it at its next turn (pull-only), or queued; <seat> has no way to be woken while idle. Ateam check names a Claude Code seat whose sends skip its socket. A live seat whoseteam config set seats.<seat>.inbound accept for theteam restart <seat> for the other two. A seat with no socket at all gets onetyped wake word is a choice, not a finding, and neither is anteam config set writes a value with its unit as plain text.team up closes the legacy watch workspaces it replaced. Only when theup closes each leftover workspace labelled asteam remove retires the removed seat's agent record. The record is kept, never deleted:--keep, which only stops the seat, keeps the record and its rosterteam config set and unset keep the record's comments. Only the changed key's lines[] rather than regenerating the record, acomments_kept: false--json.team next, in the command and in the daemon, and the workflow's reservation take leave a recordteam plan marks such a record (its seat cannot be woken while idle) after its title, and team up warns that <seat> is a lead seat and <cli> cannot be woken while it is idle; time-bound work is never dispatched to it (a reviewerinbox_check tool description name both ends, with an inbox_read for eachteam daemon install --general <grant.json> --key <client.key> installs a unit thatunplaced and refused at every start. An install admitted by the general door writes thedaemon) and refuses, exit 1, oncedaemon. Only theteam up writes the rules file before the-c pairs, so the seat keeps its team inbox server, and theteam mcp serve finds its team without a --file. A server started without one takes its--session, and never reads the--file itteam down, and a detached agent is named by caller.queued, no event adapter rather than unreachable.= spellings all count as the same option. A quoted config or prompt word is not read as a--.inbound word, and an address the seat's record names that still exists and does notteam restart takes theregister.replaced), and an id another live seat's record of the team carries is refusedregister.handle-held). Both refusals name what they found and leave the record unchanged,pull-only and why. After the; pull-only: <reason> and --json carries pull_only, rather than reporting a restart doneteam status labels the seat with the model it runs, and a send is not held for a false drift.model_from: launcher), never guessed: a launch line the reader cannot followclaude launchteam check, the watch and team up read a live seat's model from its recordedteam status reads the send's own socket eligibility. The REACH column walks the send'ssocket only whileteam config set, unset and team add file an owner request from a team root that is notteam config get does — a checkout'sGemini with version 4 Argon reads as the same model as a screen readingGemini Argon 4, so the seat's sends are no longer held as a false drift. A token carrying a2B, a tag such as A4 — stays part of the model,team config report adds a seat the approval still holds and the record no longer names, and asession: <old> to keep the old default, never a re-approval this version does not have. team migrateteam reply to another team lands where that team's reader reads. The record is writtenteam messagesdelivered only after the record passes that reader's checks, and a write it cannotNo migration. Grants signed before 0.5.7 keep their listed ops; only a grant whose ops are * covers ops added in later releases.
*team init --general <grant.json> --key <client.key>: a general grant that covers initinit.general-refused.init joins the general-grant op vocabulary.* (every op, including ops later releases add). It isteam client general-grant defaults to --ops '*' when --ops is absent, so one owner0.5.6 lets the owner approve from the owner seat instead of a terminal, adds general grants (one owner signature covering every entity or a listed set
0.5.6 lets the owner approve from the owner seat instead of a terminal, adds general grants
(one owner signature covering every entity or a listed set), delivers messages on a seat's
development channel, and makes team up --no-launch quieter.
developer is now the default bundle, and it may runteam down --abandon.team up --general admits a launch under such a grant with no request.team config set/unset --request lets the owner seatteam grant --request reports honestly whether the owner was notified, presents a Touch IDteam send delivers there and redelivers once; themessage.arrived from the bus.team up starts it in its own workspace, team down closes it, and a droppedteam messages --client --follow prints each reply on the client thread as it lands.team down --abandon answers known prompts and saves unsent text before stopping a seat.grok -r <id> and an Antigravity seat with agy --conversation=<id>.config set syncs the agent launch.team up --no-launch: seats get their rules only (no general seat brief), the stopteam config set writes a value with its unit as plain text.scripts/gates and resolve siblings from their own directory.team down; a detached agent is named by caller.Deprecated: the file source and --file . team-config.source: file and --file remain as a legacy and test path only. team init writes the registry and…
0.5.5 moves the team's definition into the registry. The team is read from and written to
~/.config/team/team-config/, approvals are signed over one canonical team record instead of
the file's text, and team migrate imports .agents/team.yaml and retires it. It also brings
client grant bundles and replies, the message-display wake line, a usage wall read as
blocked, and the dry workflow runner. 0.5.4 was never published as a stable release: its
release candidates are folded in here.
team migrate in each project, from a terminal outside herdr. It verifies the import,.agents/team.yaml to the Trash (or renames it .migrated); --keep-file keepsteam up.team check says so: the default session<entity>-<project>, and approvals made before canonical signing are rewritten inteam migrate.<entity>-<project>. A team file that names anentity and omits session: now runs in the herdr session <entity>-<project> instead of thesession: still overrides the default persession is an owner section, so an affected team must be approved again: team check`session` changed: "web" -> "acme-web" and say to approve again, or to set session: web to keep the old one;team status does not compare approvals, and team approve is gone.team-config.source: registry).agents/team.yaml is no longer read; a leftover file is named by oneteam up, team check and team status. Edit the team with team config.The manager client grant bundle. team grant --client <id> --entity <entity> --public-key <file> --team <team> --bundle manager --request asks the owner to sign one grant that lets a client with no
terminal run one team: the operator's list, the team's own reads, restart, reload, and the seat
lifecycle (add and remove), as an explicit list of 28 ops at vocabulary 6, for ninety days at most.
It needs --team. team add and team remove take --client <grant> --key <key> --team <team>, which
is verified on the exact team before the terminal check that refuses a caller with no herdr record;
a human's pane, the orchestrator and the operator are never targets, the approval record is left
as it was, and the run says the roster change is for the owner to approve with the owner seat. team restart, team reload, team seats, team seat and team sessions take the same --client form.
observer and operator still never carry add or remove, and the commands that change who may do
what stay out of every bundle. See Client grant bundles.
The developer client grant bundle. --bundle developer is the manager's list plus rename, swap,
pause, resume, hold, release, tempo, queue, lock, unlock, worktree, raise, route, pr,
workflow and proc (44 ops, vocabulary 7), for one team and ninety days at most. team pause,
team resume and team hold take --client <grant> --key <key>, verified on the exact team; a client's
pause is as graceful as the owner's (ongoing work finishes, only new work is withheld until resume) and
takes no <team> and no --all. The commands that change who may do what (grant, revoke, delegate,
owner-seat, policy, settings, development-mode, answer, config, broker, bus, daemon,
register, client, init) stay out of every bundle. The other developer ops are listed in the grant and
admit nothing until their route is wired. See Client grant bundles.
team config get|set|unset|edit edits the team's record. One schema-validated editor for
what .agents/team.yaml used to hold: dotted paths (seats.lead.model, watch.unread_after),
values read as YAML, and edit opens the whole record in $EDITOR. Every write is validated
first, is the owner's, and names what the approval no longer covers. See
team config.
The registry read and write path. team-config.source, team import and team migrate
read the team from the registry; team init, team add, team remove and the other writers
write the registry record, with created_by, the restore check and the policy read.
Client grant bundles. observer and operator bundles, client up/down/send/status
forms, and a policy cap on a client grant's duration.
Seat-to-client replies through team reply and team messages --client; client commands
are refused inside a team pane.
The message-display wake line. A send's wake line names how the message is displayed.
A usage wall reads as blocked: quota, and team pause can pause one seat.
team archive snapshots a team into an archive, and team init can start from one.
team status counts unclaimed backlog items beside the queue depths.
team doctor --jules names the Jules CLI's missing step.
Workflows: the definition schema, the statechart core, team workflow check, waits and
timers, the dry runner, and team workflow run --dry and replay.
Watch: the aggregate watch report, ownership that survives a restart, recovery of a hosted
watch that leaves, and the scoped fault-watch diagnostic.
Restore: every drifted seat restored in one pass, with a one-line summary.
An optional issue_tracker field on the team record; a real-CLI capture corpus per tested
version; recognition of the Cursor 2026.10.19 and Muse 1.4.11 ready screens.
team migrate retires .agents/team.yaml. After the import is read back.agents/team.yaml.migrated when no Trash can be reached; it is never deleted. --keep-fileteam up. The owner's team up on a team the.agents/team.yaml first and says so on one line; the file isteam migrate. A leftover file beside a registry team is named by one line inteam up, team check and team status, which do not refuse.file source and --file. team-config.source: file and --file remainteam init writes the registry and never a file under theteam-record-c14n-v1), not the file text, so formatting and comments do not invalidate anclients: section added or edited after the last approval is honoured as the live file writes it while the approval standing is verified, like watch and budgets; an unverified standing falls back to the default seats. It was refused since team approve was removed.team up keeps the bound registry record and cleans a partial relaunch; a non-working restoredteam check names the default-session move; the current project's approval store is read.0.5.3 is the event-driven send release: a message to another seat is delivered by the first route that can take it, accepted rather than refused while
0.5.3 is the event-driven send release: a message to another seat is delivered by the first
route that can take it, accepted rather than refused while the receiver is busy, and confirmed
by a signed read receipt instead of a guess. Admission is bound to the seats the team file
declares; a restored seat is recognized by its signed registry record; and a send to a seat
whose running model has drifted is held rather than delivered.
Socket-first delivery for Claude receivers. A send to a Claude seat is walked over the
session socket first when the receiving team's inbound policy accepts — an explicit
inbound: accept, or no inbound word at all with the settings-attested accept. An explicit
hold or refuse wins; the team file and the launch do not both have to say accept. A frame the
receiver's dialog holds falls through to the next leg with the same message id, and that
socket is not dialed again until the setting is rewritten.
A busy receiver queues instead of refusing. When another command holds the seat's lock,
the reachable legs write the signed record and its <id>.pending marker without the lock,
type nothing, dial nothing, and answer queued (receiver busy) with the id the delivery
keeps. A running watch or the seat's own watcher finishes the delivery from that marker;
retries retain the same message id and consult the signed receipts. A compose seat has no
queue leg, so its held lock stays a refusal.
Codex gets a typed wake before the inbox fallback. For a Codex receiver with no declared
delivery order, the runtime queue leads when its signed Codex daemon setting is on, then a
typed wake, then the inbox; when the setting is off, the typed wake leads. An inbox write
alone does not wake an idle Codex TUI. A declared order is still followed as written.
Route diagnostics before the send. team send --dry-run names the channel the walk would
take, and under --json lists every leg as candidate or skipped with the reason,
including the implied socket leg a Claude receiver's files keep out. team route <seat>
answers the pair's rule, the live pane and the socket's state (live, stale, pane,
unread or none) before a sender dials anything.
Signed read receipts, and team ack. team ack <id> marks a message read without
printing it: one signed read receipt beside the record, written once and never replaced.
team reply marks a message read by answering it, and team messages publishes the same
receipt before it shows a body. A receipt is the only thing that earns delivered (read);
nothing claims a seat acted on a message it read. An inbox message unread after ten minutes
falls to the trigger line, and a drop no watcher read is given up on after thirty minutes
with its path, never called lost.
--file and --file - for command-bearing bodies. team send --file <path> reads the
whole body from a file, and --file - reads it from standard input; --brief takes the same
two spellings. A multiline body that looks like pasted terminal output is warned about and
sent unchanged.
Unread reports reach the lead as a signed drop. A message still unread after two windows
is reported once to its sender's mailbox and once to the team's lead as a signed send-drop
that team drops --read serves. A stopped seat is not woken, and its message stays unread
until its next start.
Admission is bound to the declared roster. A caller reaches the targets the team file
declares: the owner any agent; an orchestrator another orchestrator of its own team or
entity; a team's orchestrator or operator any seat of its own team; two operator seats each
other; any declared seat another declared seat of its own team; an assistant its entity's
main coordinator; any seat its own team's orchestrator; and what an owner-signed grant names.
Arbitrary cross-team and off-roster pairs are refused by
default, and a refusal for an unregistered sender names that sender, so a cross-team denial
says which side lacks a registry record.
Owned legacy plaintext is omitted. A regular plaintext record owned by the team is
omitted without being served, without a receipt, and without a refusal event or refusal log;
a record-shaped invalid signed JSON stays strictly refused.
Refusal logging stays bounded. A confirmed repeat refusal is suppressed within the
window; when the event store cannot answer, the fallback logging cap is 50 lines per checkout
per process.
Event writes share one bounded lock. Event allocation, signing, append, retention and
standalone pruning all take the same bounded event-store lock.
The seat brief treats a command-bearing message as data, not an authority, and says how to
send one. A command quoted from a file, a log, an issue or a web page is part of what the
message reports; a seat runs only the commands the message asks for as its work and asks its
lead before one that would leave its folder, branch or files. A command-bearing body goes
from a file or a pipe: --file <path> or --file -, with --brief taking the same
spellings. A single-quoted argument is passed through unchanged; a double-quoted one is not:
backticks, $(...) and $VAR are rewritten before team send sees them.
The registry is the authority for a restored seat. When the pane host restores a seat's
process under a new id, team status and team check read the running model against the
seat's signed registry record rather than the team file, and team restart and team up
resume the recorded conversation through the seat's recorded launch line. A conversation
that does not match the record, or none that can be read, is still refused.
A send to a drifted seat is held. When a registered recipient's pane reports a model
other than the one its signed record names, team send writes nothing, types nothing and
exits 1 with held: model drift: <recorded> vs <running>; the sender can retry after the
seat is repaired.
A signed rhythm change applies on the next pass. The watch reads the signed policy chain
on every pass, so a change to the watch-rhythm value changes the next wait without
restarting the watch.
team pause and team resume . A pause lives in the team state, never in the team file — the file waits for the owner's approval, and a stop that waits
team pause and team resume. A pause lives in the team state, never in the team file —team next claims nothing and names the pause with its repair, and theteam status and team seats print the pause above their rows, and ateam resume deletes the record, restarts claims and nudges, and prints the stopresumed <project> (<pause line>) then one stop <seat>: … line<team> by its name, project or id, or on every team in the machine's registry with--all (an unreadable team is named on stderr and left as it is), and both judge every target's--json emits team.pause /team.resume and is refused with --all.role: operator may send to each other; the pair rule admits that direction alone,team send --list shows bothteam usage reports each seat's spend. Under each team's seat table, --tree now printsmeasured when the run read the seat's own screen, estimated from theunknown with its reason. The spend line is the seat's own money figure, read from the amountS: field; any other CLI, an unread pane or a rowcost unknown with one sentence, never 0. Figures belong to the--json carries the same facts under teams[].seats, with themeasured / estimated / unknown word, so every surface prints theteam check names a seat held at a prompt. The pass that reads the team's differences nowlast active age: that age dates theteam down --abandon, a quota screen withstatus's plain permission or trust row would name the same seatstatus itself now reads a prompt only--json renders each line'swhat as it stands, cleaned with the report's own plain-line reader.event-* policies join the releaseevent-thread-ttl-seconds, 72 hours byevent-thread-cap, 50), how many days the eventevent-retention-days, 30), when a held record reaches the leadevent-held-threshold-seconds, 600), when a seat that watches nothing reads unreachableevent-unreachable-threshold-seconds, 600), when an idle seat's lead is toldevent-idle-threshold-seconds, 300), and how often the bus reconcilesevent-reconcile-interval-seconds, 120). Each takes a whole number — seconds, days fors suffix; the shorter fieldteam bus reads the held, retention and reconcile numbers when itteam reply reads the thread life and cap from the caller'sherdr wait agent-status waiter per eligibleblocked raises seat.at-prompt — the screen is read once todone raises seat.done, idle past the idle-lead threshold raisesseat.idle once per idle stretch, and working after blocked raises the newseat.unblocked, which closes the open prompt notice and cancels its climb clock; unknownblocked -> working -> blocked flicker within the one-pass grace windowseat.at-prompt twice. Profiles whose herdr status is unreliable keep the screenhuman: true seats are never waited on and their screens are never read, and a statusteam sessions lists the session records TeamCLI keeps. Every launch and stop command nowup and add write a start when a pane takes the launch line;restart closes a record with reason restart, reload with swap, and down or removeowner-stop; a start that finds a session still open for the same team, herdr sessioncrash, and a launch after a drift repair or a reload closes the oldswap and links the new one. A record holds what the launching command knew — seat,team sessions [<seat>] [--by model|team|entity] [--json] lists them from every state folder on the machine, so it runs anywhere and needs noswap, restart, crash,owner-stop; quota is in the vocabulary with no writer yet) and COST, which prints unknown0 — until a command measures it. --by groups the listing under one heading per--json carries each record whole, absent keys absent. A Claude Code launch line--session-id <uuid> appended; one that already carries--session-id, --resume/-r or --continue/-c is left as the owner wrote it, and an idteam add <name> --like <seat> copies a declared seat. Without --temporary, --like now<name>, with its stopped mark and count: dropped (a counted source is split first) and itsup would start it, and the entry is written before the launch, so ahuman: true source isadd.like-exists) and the source one it does; a copy the file's own validation refuses — aleads, assistant or nickname — stops before anything is written or launched. The new--until and --worktree still need --temporary;--like alone is now a declared copy.inputclear), optionally the keys that empty it mid-turn (clear_working), the paste surfacepaste: bracketed, the one measured), and whether the CLI takes text while a turn runsmid_turn). claude-code, codex and cursor carry one, each from a run recorded over its own<drop>.draft), clears the box with the profile's keys — the mid-turn key while the seat isthe unsent text was pasted back, or …; its copy is at <path>); a delivered exit restores therestart restarts an idle seatrestart-drafts/<session>/<seat>.draft under the session lock, prints the copy's path in the--abandon still closes the workspace without a copy.who row fordocs/reference/cli.md prints it under each command's Who may run it heading. The rows areCOMMAND_GATES (src/permissions/map.ts) as they stand, never reworded, andany-caller, seat-only,leads-only, team-change, team-pause and team-read join the map, error.rule carriesteam-change, team-read and terminal, and a difference repair names the actor it namedteam-change, team-pause, any-caller, seat-only and leads-only, anyteam-read.team mcp serve with --file: the server resolves the team from it instead of the folder itrestart's realup, add and reload already do. The codex launch-line route-c values now carry the --file pair, with themcp add argv carries the path byte for byte. A named file is read and only that file: an emptyteam mcp serve exits 2 with the loader's message--file '' is refused by the parser withteam mcp: --file needs a value.team usage tells a file it cannot read from one that does not load. The team-file loaderunreadable, so team usage keeps the two faces the case had: the owner reads the loader'scannot be read: the owner reads the reason, prefixed by the team file path — never does not load for a file that never loaded. A file that loads and still has a problem keeps its loadteam 0.5.1 is the first release since 0.5.0, and it changes how a message reaches a seat: a seat's own inbox when its CLI carries one, the drop file w
team 0.5.1 is the first release since 0.5.0, and it changes how a message reaches a seat: a
seat's own inbox when its CLI carries one, the drop file with nothing typed when it does not, and
the typed trigger line last. Messages become signed records with threads and replies; a send can
wait for its answer; and the owner gets one bus, one event log, and one delivery path that does
not depend on a seat being free.
The default delivery order, and the words a level may add. A send whose receiving seat
declares no order walks mcp-inbox, then drop, then typed: the seat's own inbox when a
server serves it, the mode-0600 drop file with nothing typed into the pane when one does not,
and the typed trigger line last. native is never in the default — the sender chooses it and
records the delivery itself — and it is the one leg a declared word may add to the order in
force. A seat whose file declares no word takes the one its shape implies: a pane marked
human walks drop alone, and a CLI whose launch installs no watcher leaves drop out.
A drop leg, and team drops. A receiving seat's order may name drop: the record is
written as the typed leg's own drop file and nothing is typed at all — no trigger line, no
socket frame, no daemon round trip. The console line is <seat>: sent (unconfirmed) (drop, <n> ms), exit 0: the record is the message, safely on disk. A running watch promotes a read drop
once, with one delivered (read) history line, and a drop no watcher read thirty minutes after
the send is given up on with the file's path. team drops reads the receiving seat's own
folder — one row per waiting drop, the sender named from the signed record — and its --follow
prints each drop that arrives. --read is the launch's turn-start read: it verifies each
record, writes the read receipt before printing the body, and hands over at most ten records a
run.
The message record, threads, and team reply. A plain send writes the message whole as one
signed record — body, sender, the rule that admitted the send, and the thread — before the
delivery leg runs; the typed, drop and mcp-inbox legs all carry that one record. team messages
reads what is still waiting, verifies the signature, prints the body and writes the read
receipt in one step. The history keeps the conversation: every line carries thread, a reply
also carries in_reply_to, and the feed derives a status — sent, held, delivered, read
or replied — from the outcome. team reply <id> <text> answers the sender on its thread;
--close ends it, and a thread also ends when its newest record is 72 hours old or when it
reaches 50 records. A reply on a closed thread opens a new one that cites the record it
answers.
A waited send. team send --wait writes the signed record through the receiving seat's
delivery walk, then waits on the thread for the first verified reply until the --timeout
window (120 seconds by default) closes. A reply makes the run answered (exit 0); a window
that closes with no reply makes it timeout (exit 1) and leaves the thread open, so a late
reply still lands on it, and an answered --json document carries the thread id.
The native leg, as a handoff. When the recipient's CLI carries the cross-session channel
and the sender's own file declares cli: claude-code, a send to the native leg becomes a
handoff: one pending record, the exact to: target, and a team send --confirm <id> line for
the sender to run. The confirm reads the recipient's visible lines for the handoff's nonce and
records delivered when it sees it, sent (unconfirmed) when it does not. An unconfirmed
handoff past ten minutes is claimed by a running watch and handed to the remaining legs of the
recipient's order, so a late confirm finds no record and nothing is delivered twice.
team mcp serve, and the mcp-inbox leg. team mcp serve --seat <seat> runs the MCP server
a seat's launch line starts, with two tools over that seat's own drop folder and a receipt
written before the body leaves. A send to a seat whose listener is live takes the mcp-inbox
leg: the same 0600 drop file in the seat's inbox, nothing typed. The receipt the read leaves
makes the outcome delivered (read) — the seat read the message, never a claim that it acted
on it — and a message still unread ten minutes after the send is handed to the retry, which
types its trigger once. team feed shows one row per message when its outcome moves.
The inbox registered with each CLI, and read each turn. A seat's launch registers the server where a measured route exists — Codex's launch line carries it, Gemini and Grok register through their own project settings, and Cursor's project MCP config is merged — and a seat whose CLI carries the server is asked, in its rules, to check its inbox at the start of each turn and read each message before acting.
team bus, routing, and the owner's own delivery. The owner starts team bus in a
foreground terminal outside herdr, one per clone: it owns the project's event log, appends each
event as a signed record, reconciles durable records when it starts and every two minutes
after, and serves publish and subscribe on its socket. With a bus answering, team watch
publishes the events its reports imply and, after a sequence gap, re-announces the reports that
are still true; with no bus it polls exactly as before. An event routed or addressed to the
owner reaches the owner with no seat in the path: a machine notification and a signed record in
the owner's mailbox, so a held or unreachable seat silences neither. A kind on the owner's
immediacy list rings and lands as its own record; everything else collects in the pass and
lands as one digest.
Human seats are never touched. A seat the team file marks human: true walks the drop leg
alone, whatever its order or the default says: the typed trigger, the native frame and the
seat's own inbox are kept out, and --wait writes the record on the drop leg and types
nothing. up, down, add, restart, remove, reload, answer and register each name
the seat and refuse to type at it, press a key or close its pane.
team raise, and two refusal events. team raise <kind> <text> carries one line from the
team's lead to the owner at once: a signed record in the owner's mailbox, the matching
release.ready or decision.needed event, and the machine notification; the same kind and line
within the hour merges as one record, and ten raises reach the owner per team per UTC day. A
record or receipt that fails verification raises record.invalid, and an identity or admission
a send or reply rule denies raises security.refused; both reach the owner alone, carry the
rule and object and never the refused content, and count repeats instead of flooding.
Tested ranges. The Antigravity profile is tested with CLI 1.2.16 to 1.4.2, and its launch test's boundary moves to 1.4.3. The Cursor profile is tested with 2026.10.01 to 2026.10.16, and its boundary moves to 2026.10.17.
--wait works. 0.5.0 refused a waited send and pointed at the native leg; 0.5.1 writes the
record through the delivery walk and waits on the thread, with answered and timeout as its
two endings.mcp-inbox, drop, typed. A send that reached a pane by
the typed trigger in 0.5.0 now leaves a drop file with nothing typed when the seat's CLI has no
inbox, and the seat's watcher picks it up. native is never walked unless the sender chooses
it or a level's declared word adds it.sent (unconfirmed), exit 0;
a read inbox message ends delivered (read). Every run still ends in one word.human: true is left untouched
by every command that used to type at it, including --wait, which writes the record and
types nothing.--close, a thread ends when its newest record is 72
hours old or when it reaches 50 records.Nothing starts the bus for you in 0.5.1. Start one team bus per clone in a foreground terminal
outside herdr, and leave it running: it owns the event log, runs the reconciliation pass, and
serves the socket. Ctrl-C removes the socket and exits 0. It refuses to start when the caller is
not the owner, when a bus already answers, or when another start holds the socket lock. With no
bus running, team watch polls as it did in 0.5.0 and the owner's delivery still works through
the watch.
npm install -g team
Before 0.5.1 is latest, the release candidate installs from the next tag:
npm install -g team@next
Node 22 or later, and herdr run the team.
Run two commands first:
team doctor — it checks this machine against the file and names whatever is missing.team check — it reads the file, the state, herdr, the registries and the agents' records, and
reports the differences alone, each with its repair.Running seats keep working as they are. Relaunch one with team restart <seat>, or the team with
team down, then team up as two commands, when you want it on this build. The file changes no
shape: a seat may now carry human: true, and a delivery order may name drop.
team bus per clone, in a terminal outside herdr. A
team that never starts it keeps the 0.5.0 behaviour: a polling watch and no event log.The drop leg, and human seats. A receiving seat's delivery order may name drop: the walk
writes the record as the typed leg's own 0600 drop file and types nothing at all — no trigger
line, no socket frame, no daemon round trip, no pane read — so a receiver that watches its own
drop folder finds the message there. Its console line is <seat>: sent (unconfirmed) (drop, <n> ms), exit 0: the record is the message, safely on disk, and no signed receipt has come
back yet. Beside it the send leaves the marker <id>.pending; the seat's own watcher reads the
drop and writes the signed <id>.read.json receipt, and a running watch promotes it once — one
delivered (read) history line, the marker cleared, nothing typed. A drop no watcher read
thirty minutes after the send is given up on with the file's path: the marker is cleared, the
record stays in the folder, and it is never typed and never called lost. The history line says
via: drop and the JSON channel is drop; the leg sits in the default order between the
seat's own MCP inbox and the typed trigger. The typed leg stays terminal, and a drop-leg marker
is never typed or retried; team drops reads the receiver's own folder, and its --follow
prints each drop that arrives. A dry run names only the legs it can
reach: the phrase stops at the first terminal typed leg, and names only the drop channel when
drop leads. A seat the team file marks human: true walks the drop leg alone, whatever its
order or the default says: the typed trigger, the native frame and the seat's own inbox are
kept out, the reason for each leg the order holds recorded on the history line, so the message
arrives in the drop file and nothing reaches a pane or an inbox; a delivery_order written on
such a seat is not a team check difference, because the seat walks drop alone whatever the
word says. A person reads the drop and writes no receipt, so no marker waits there, and an
expired handoff's fallback walks the same one leg. --wait is
allowed for such a seat: the record is written on its drop leg, nothing is typed, and the run
awaits a reply record on the thread. The watch types no retry, nudge, work drop or ring there,
giving a held drop up with the reason instead.
team drops. The receiving seat reads its own folder under
.agents/send-drops/<session>/<seat>: one row per waiting drop, the sender the record's payload
names — the owner, a seat's name, or a registered name — or, in a raw body file an earlier
build wrote, the sender its first line names; unknown when there is neither, and when a record
does not verify against the message key. A drop with the signed <id>.read.json receipt beside
it is read, and is not listed — a receipt the key did not sign, or one naming another message,
seat, checkout or session, proves nothing and the drop is still listed; a name with a dot in it
is a sidecar, never a drop. Apart from --read's receipt, the command only reads: it moves,
deletes and marks nothing, and a folder that does not exist yet is an empty one. Only the seat
itself, on the pane the state records for it, may run it; the owner,
another seat and a seat on another pane are refused. --follow prints
from <sender> — <path> for each drop that appears while it runs — the drops already on disk
are waiting, not new — flushed per line for a Monitor in the receiving seat, and Ctrl-C stops it
with exit 0. --json prints one team.drops document; it and --follow cannot be combined,
and --read combines with neither. --read --seat <seat> [--session <session>] is the
launch's own turn-start read: it verifies each waiting record with the checkout's message key,
writes the signed <id>.read.json receipt beside it before printing its body, hands over at
most ten records a run, and asks for no placed caller, because a CLI's hook runs outside any
pane. The team file must declare the seat, and a session it is given must be the team file's
own; a record it cannot verify or receipt is a refusal and its body is not printed. --read is
the one mode that writes, and it writes only the receipt (mode 0600): the drop itself is never
moved, deleted or marked. --seat or --session without --read is an invocation error.
The message record, threads, and team reply. A plain send writes the message whole as one
signed record — the body, the sender, the rule that admitted the send, and the thread — into
the recipient's folder at .agents/send-drops/<session>/<seat>/<id>, mode 0600, by renaming a
temporary file into place, in the leg that takes the send and before that leg delivers it; a
walk no leg takes writes no record. The record is the message, and the typed, drop and
mcp-inbox legs all carry it. team messages reads every record still waiting,
verifies its signature with the checkout's message key, prints the body and writes the signed
read receipt <id>.read.json in that one step; the seat's inbox server writes the same receipt
for each message it returns, and verifies the record before anything is shown, so an unsigned
or tampered file prints no body and leaves no receipt. The history keeps the conversation:
every line carries thread, the first message's id, a reply also carries in_reply_to, the
feed's DETAIL opens a reply with re <id>: , and its --json event carries a status derived
from the outcome — sent, held, delivered, read or replied — never a stored one.
team reply <id> <text> answers the sender of a record on its thread: one signed reply record,
delivered as the drop leg delivers — left in the sender's folder, nothing typed, no frame sent
— and the signed <id>.replied.json receipt beside the record it answers. team reply <id> --close writes a signed <id>.closed.json instead; a thread also ends when its newest record
is 72 hours old or when it reaches 50 records, and a reply on a closed thread opens a new
thread that cites the record it answers. A reply goes only to the sender, admitted by
reply-on-open-thread; a record the owner sent has no seat to answer, so a reply to it is
refused before anything is written.
A waited send. team send --wait writes the signed record through the receiving seat's
delivery walk — mcp-inbox, drop or typed, or drop alone when the seat's file marks it
human: true, so nothing is typed into a person's pane — then waits on the thread for the first
verified reply record until the --timeout window (120 seconds by default) closes. A reply makes
the run answered (exit 0); a window that closes with no reply makes it timeout (exit 1) and
leaves the thread open, so a late team reply still lands on it, and an answered --json
document carries the thread id.
The native leg, as a handoff. When the recipient's CLI carries the cross-session channel and
the sender's own file declares cli: claude-code, a send to the native leg becomes a handoff:
the run resolves the recipient live, admits the pair, writes one pending record (0600, a
temporary file renamed into place), and prints the exact to: target, the body and the
team send --confirm <id> line, exiting 0 with status native. The sender makes the call;
--confirm takes the record by rename before it writes the one history line (delivered,
via: native, the span from the handoff to the confirm) and clears it, so a second confirm
finds none. The confirm reads the recipient's visible 40 lines for the handoff's nonce
(nv-<8 hex>): the window that shows it records delivered, and its absence — or a nonce
already scrolled off — records sent (unconfirmed). An unconfirmed handoff past ten minutes is
claimed by a running watch on the sender's team, recorded native: unconfirmed after 10m, and
handed to the remaining legs of the recipient's order — a live inbox takes the body, the drop
leg leaves it in the drop file, or the typed leg types its trigger — so a late --confirm
finds no record and nothing is delivered twice. A handoff that cannot resolve the recipient's
live pane or its socket hands the send to the next leg the recipient's order holds, and a
record that cannot be written refuses. Without a running watch, an unconfirmed record does not
fall back, and no timer sweeps it: the folder is pruned only when another pending record is
written or a confirm next reads it, so a record nobody touches again outlives the 24 hours.
team mcp serve, and the mcp-inbox leg. team mcp serve --seat <seat> runs the MCP server
a seat's launch line starts: two tools over that seat's own drop folder, the seat and session
fixed at launch, an id a lowercase UUID only, and a receipt written before the body leaves; a
folder path that is a link at any step refuses service rather than being followed, and the
listener marker carries the server's pid while it runs, removed at exit only while it still
names that pid. A send to a seat whose listener is live takes the mcp-inbox leg: it writes the
same 0600 drop file into the seat's inbox and types nothing; the receipt its inbox_read
leaves makes the outcome delivered (read) — the seat read the message, never a claim that it
acted on it — and a wait that ends without one records sent (unconfirmed), exit 0, the file
being the message safely on disk. A marker absent, malformed, dead or naming another seat,
session or root is mcp-inbox: no live inbox listener, and the walk moves on. A receipt that
lands after the sender has gone is promoted by the watch — one delivered (read) history line,
nothing typed — and a message still unread ten minutes after the send is handed to the retry,
which types its trigger once and records mcp-inbox: no receipt within 10m; a typed record
always goes before an inbox one, so an inbox message never delays a held send's retry.
team feed shows one row per message when its outcome moves: the latest line once, in its
chronological place, keeping the address the send recorded when the later line has none, and a
--follow pass still prints the update.
The inbox registered with each CLI, and read each turn. A seat's launch registers the server
where a measured route exists: a codex launch line carries the registration itself, with no
file written into the seat's folder; a gemini or grok seat's launch runs that CLI's own
mcp add -s project, the file it writes being the CLI's own project settings; and a cursor
seat's launch merges the server into its project MCP config and carries the approval flag, so
the CLI loads what team registered for it. The server names the seat it launched for, and the
session it serves is the team file's in the seat's folder. Where that folder is a git work tree
that does not ignore a file the registration would write, registration is refused, the seat
still launches on its drop and typed legs, and its line carries the reason. A seat whose CLI
carries the server is asked, in its rules, to call inbox_check at the start of each turn and
inbox_read for each message, then act on what it read.
team bus, and the project event log. The owner starts team bus in a foreground terminal
outside herdr, one per clone: it owns the project's event log (events.jsonl), appends each
event as a signed record, runs the reconciliation pass over durable message and seat records
when it starts and every two minutes after, and serves publish and subscribe on
.agents/bus.sock; Ctrl-C removes the socket and exits 0. A segment rotates at 100 MB, and
when the bus starts an idle live file is sealed and the oldest sealed segments are dropped
whole once their last write is thirty days old or the retained files together pass 100 MB; one
signed team.event-log-dropped record names the dropped sequence range and whether the age
window or a size bound dropped it, so a reader and a gap-resync see a declared hole rather than
an unexplained one. Nothing starts it for you in 0.5.1.
It refuses to start when the caller is not the owner, when a bus is already answering, when
another start holds the socket lock, or when the socket cannot be bound, and exits 2 on a bad
invocation or a team file it cannot read. With a bus answering, team watch reads new events
in sequence order and publishes the events its reports imply — seat.unreachable,
seat.at-prompt, seat.prompt-escalated and seat.blocked — to the log, and after a sequence
gap re-announces the reports that are still true; with no bus running it polls exactly as
before. The reconciliation pass appends only the events the on-disk records imply and the log
is missing, keyed by kind,
record and session, so a pass over unchanged records adds no second
event. A seat that is not a default recipient may not subscribe itself to a privileged kind —
a grant, a policy, seat.at-prompt, or one the owner has named — and the bus refuses it with
privileged-self-subscription, logs the refusal, and raises team.policy-refused to the
owner.
Routing, and the owner's own delivery. An event's recipients come from its kind's release
defaults, folded through the routing words in force: a word may add a recipient for a kind,
and cannot remove one it did not add, and a privileged kind keeps its default owner. A
recipient may name a seat by its plain name or by the agent registry id that holds it — a
claimed pane must match the one the registry holds, a retired agent's id names nobody, and an
id the registry does not know is left as written. An event routed or addressed to owner
reaches the owner with no seat in the path: the machine notification the watch raises and a
signed record in the owner's mailbox, the list team messages reads, so a held or unreachable
seat silences neither, and the watch's owner report merges with the operator's copy of the
same observation, so the owner's list holds it once. A kind on the owner's immediacy list —
owner-at-once, an owner-sovereign setting whose release default holds seat.at-prompt only
at a permission, trust, login, vendor-notice or rate-limit prompt, seat.prompt-escalated at
every climb, and seat.unreachable and seat.done only for the team's lead, plus every
roster, grant and policy event, both raise kinds and both refusals — rings and lands as its
own record; everything else collects in the pass and lands as one digest record at its flush,
and both ids are deterministic, so a watch restarted from cursor 0 rings and writes nothing
again. --no-notify never silences an owner push.
The watcher each launch leaves. The launch plan reads, once per seat, how the seat's CLI
will learn that a drop is waiting — the turn-start hook the launch installs, the MCP inbox
server its profile registers, or nothing — carries it through the launch's steps, and stores
it in the seat's record; team up --dry-run names it under the launch line it would type:
reads its drops at each turn start, reads its drops through its MCP inbox, or watches nothing: a drop sent here is never read.
A general seat brief, delivered first. up writes TeamCLI's built-in general brief into
every declared seat's drop folder as one signed message record before the plan types a rules
line into any pane, human seats included; add, restart and reload write it to the one seat
they act on and refuse a human pane, so a human seat's record comes from up alone. Nothing is
typed into any pane. The text is the package's own, embedded from its accepted source; the
record's id is derived from the text, so the same brief has one id in every seat's folder and a
second run leaves a verified record and its time as they are. A file already at that id that
does not verify is replaced through the signed record writer, and a link, a folder or a FIFO
there is refused, never followed. The session's state records each delivery, and team check
opens and verifies the delivered record, naming a launched seat whose record is missing or does
not verify, with its repair.
bun run brief:check fails unless the embedded text still hashes to its pinned value, and given
the source it compares the two byte for byte and names the first line that differs; CI runs the
pin.
The command guard a claude-code seat carries. The per-launch settings file a claude-code
seat loads now carries a shipped PreToolUse hook, run by this install's own interpreter
before every Bash tool call, that denies a conservative set of commands and hands the model
one line of guidance back instead: chmod and chown, sudo, a recursive rm, pkill,
killall and a kill that asks for SIGKILL, a curl or wget download piped into a shell,
a forced git push (--force, -f, a + refspec), git reset --hard, a destructive git clean (-f with -x or -d), a forced branch deletion (-D, or -d -f), dd and mkfs,
shutdown, reboot, launchctl, crontab and npm publish. It judges commands, never
words: a sentence in a quote, a heredoc body and a send body are arguments to the command that
carries them, while unquoted ;, &, newlines and pipes separate a line into commands judged
one by one; a leading assignment and the prefixes that run another command (env, command,
exec, nohup, nice, time, timeout, stdbuf) are read through to it, and xargs and
find -exec are judged as the command they carry. command -v asks where a name is and
passes, and a payload the hook cannot read is left to the CLI, so a CLI that changes its
payload never freezes a seat. The hook never asks — it allows a command or denies it — and a
deny wins over the owner's user-wide ask, measured on Claude Code 2.1.302, so an unattended
seat does not freeze at a permission prompt it cannot answer. A human seat carries no guard,
because a human's pane is never launched into, and neither does a seat whose launch line names
its own settings file: the guard rides the one TeamCLI writes. Each deny raises
security.refused with the command's class as the rule and the seat as the object, never the
command line, which may hold a secret. It is a best-effort net against an unattended prompt,
not a sandbox: a shell can always reach a command another way, deliberate evasions are out of
scope, and the climb of an unanswered prompt to the lead and the owner is the backstop.
Readable sender names. A team file or a seat may write sender_name — auto, nickname,
seat or seat@team — and every sender headline TeamCLI prints by hand reads by the word in
force: the first line of a drop file, the FROM cell of team drops and team messages, the
SEAT cell of team feed, and the display name a claude-code seat's session is launched with
(--name). The default, auto, reads a sender inside its own team as its nickname (the seat
name when the file writes none) and one from another team as seat@team, because a nickname is
unique only inside one team; nickname always reads the nickname, seat always the seat name,
and seat@team always the address. The word is read nearest first — the reading seat's own
word, then the team file's, then the project's registry record, then auto — so one team's
file decides how senders read to it. It changes presentation only: every signed record keeps
the seat in from and the registry id in from_id, and the --json readings keep the
record's own fields. A feed line records the sender's team with the send, so a sender from
another team reads by its address and never as a local nickname of the same name; a line
written before that field reads as the plain seat name. A registry that cannot answer is no
answer: the seat name stands.
The default delivery order, and the words a level may add. A send whose receiving seat
declares no order walks mcp-inbox, then drop, then typed: the seat's own inbox when a
server serves it, the 0600 drop file with nothing typed into the pane when one does not, and
the typed trigger line last. native is never in the default — the sender chooses it and
records the delivery itself — and it is the one leg a declared word may add to the order in
force; a word naming any other leg the order does not have is still set aside. A seat whose
file declares no word takes the one its shape implies: a pane marked human walks drop
alone, and a CLI whose launch installs no watcher — no turn-start hook and no MCP inbox —
leaves drop out, because nothing on its side would read the file.
A human seat's pane is never touched, whichever command reaches it. up skips the seat in
its plan — no workspace, no launch line, no key — says why, and does not count it short of
ready; down leaves it running, types no exit line and closes no workspace, even with
--abandon; add and restart name one seat and refuse with that reason. remove takes the
seat out of the file (or marks it stopped under --keep) without typing the exit line,
pressing a key or closing the pane, which keeps running, and its closing line says why in
down's words. reload refuses with the reason before the launch record is read; answer
refuses after the caller admission and before the seat's lock, state or screen is read, and
names the spare; register adopts the pane as before but writes no rules file and types no
rules line, even when a record written before the mark says a trust dialog is waiting. The
send daemon refuses a human seat at its own queue — the CLI's walk takes the drop leg alone
earlier — so no trigger is typed, no frame is sent and no worker is started.
team raise, and two owner events. team raise <kind> <text> carries one line from the
team's lead to the owner at once: a signed record in the owner's mailbox, the matching
release.ready or decision.needed event, and the machine notification. Both kinds are routed
to owner alone and stand in the owner-at-once list, so the watch rings them instead of
batching them into the pass's digest, and the record is written under the id the event's own
delivery would use, so the watch finds it already there and does not deliver it twice. The
orchestrator's seat, or a seat the file marks leads, may raise; the owner and every other seat
are refused by name, and a lead's seat must be on the pane the state records for it. The same
kind and line from the same seat within the hour is one record, rewritten as <line> (×N) and
adds no event, and ten raises reach the owner per team per UTC day, an eleventh refused with the
reason. --dry-run reads the log and the record, says what would happen, and writes nothing.
Two refusal events reach the owner. A record or receipt that fails verification — in the
seat's inbox server, in team drops --read, or in the message list — raises record.invalid,
and an identity or admission the send and reply rules deny raises security.refused. Both
kinds are privileged, routed to owner alone and on the owner-at-once list, so the watch rings
them and writes the owner's record at once, never into a person's pane; each event carries the
refusal's rule and object (a record id, a seat, a path) and never the refused content, and one
event stands per rule and object in an hour with every occurrence counted in
.agents/team.log, so a refusal loop counts instead of flooding.
A prompt that is not cleared climbs. A seat held at a permission, vendor-notice or
rate-limit prompt starts a clock, and one still held after prompt_escalation_seconds — five
minutes in this release — reports <seat> is still at a <prompt> prompt after <n> minutes: the team's lead has not cleared it, and the entity's lead and the owner are told and raises
seat.prompt-escalated, once for that prompt spell; a prompt that clears before the window is
the lead acting, and its clock goes. The kind is privileged and on the owner-at-once list, and
its release routing is the entity's own lead and the owner; the owner stands even when the
registry names no entity lead, so a climb is never silent. The entity's lead is the
lead-marked seat of the team whose project is the entity — that team's roster, root and
session — and the climb is left there as one signed runtime record in that lead's mailbox,
where that team's watch rings it as a message. The team's own orchestrator keeps no clock: its
seat.at-prompt reaches the routing table's lead and operator, and because the prompted seat is
the lead, it also reaches the entity's lead and the owner; the same mailbox record is left. A
watch that restarts mid-spell starts the clock again, so a prompt held
across a restart can climb once more. Nothing is typed into any pane — a climb is an event
and a record, never a keystroke — so a human seat's prompt climbs the same way. The check is
one of the five the watch file cannot turn off.
The Antigravity profile is tested with CLI 1.2.16 to 1.4.2: the 1.4.2 screens — trust, idle, unsent, working, question, permission and exit — are captured as fixtures, the trust dialog is unchanged, its fresh idle footer carries no model row again as on 1.4.0 — the row appears under the box once a turn has run — and the launch test's boundary moves to 1.4.3.
The Cursor profile is tested with CLI 2026.10.01 to 2026.10.16: the 2026.10.16 screens — trust,
idle, unsent, working, question, permission and exit — are captured as fixtures, the trust
dialog still marks [a] Trust this workspace with the same key, so that build gets its own
trust record beside the two earlier ones, and the launch test's boundary moves to 2026.10.17.
A receipt file that proves nothing is replaced, not trusted. The signed read receipt is
write-once per status for the message and context it verifies for: a signed receipt already at
<id>.<status>.json that names this message, seat, checkout and session is left untouched, so
a second read adds nothing. A regular file at that name that does not verify — unsigned,
unreadable, another message's, or signed for another seat, session or checkout — is replaced
by the signed receipt, so a planted or stale file cannot keep a message waiting forever; a
name held by a link, a folder or a FIFO is refused, and nothing is written through it.
team doctor names a launch record that carries the pane's process identity and no seat id —
the one team seats shows as - in its ID column — with the sibling note and the same repair
as the process note (team register <seat>), and a lead's own seat draws neither note.
A watch retry never types a held line into a pane back at its shell: it reads the pane's process identity under the seat's lock and refuses the same state the typed leg and the daemon refuse — no line typed, no Enter, the reason said — and the drop file stays for a person to send again.
team reload says and logs a seat it leaves out. A close re-read that refuses the seat (moved,
working, replaced process, unsent box) and a rules line whose read-back fails each print
<seat>: left out: <reason> in up's words and write the same line to the log, where the run
used to say nothing; a rules line this run typed that cannot be read back is cleared with the
profile's clearing key, the key up sends, and its record says the line was cleared and names
run up again. A ready seat still prints only the run's one success line.
team drops, team messages, team next, team plan, team issues, team bus and
team broker work at a team root that is not a git repository. Each resolved its root through
git before reading the team file, so a folder holding .agents/team.yaml outside any checkout
was refused with the no-repository sentence; each now takes the shared resolution — the
enclosing checkout, or the plain root in this folder. A folder that is neither a checkout nor a
team root keeps the no-repository refusal and exit 2, and an unreadable or invalid team file
keeps its own exit.
team reply admits a placed seat in its own session. A seat a real launch placed carries its
session in the session-aware reading only, and the command judged the sessionless one, so the
seat's own reply — and its own --close — was refused as a caller of another session is not that seat; it now judges the same session-aware placement team send does.
team init keeps .agents/send-drops/ out of git. The exclude list it writes to
.git/info/exclude — never .gitignore — names the drop folder beside .agents/messages/, so
the records a send leaves in a seat's folder never show up as untracked changes.
team init keeps the bus's start files out of git. The exclude list now also names
.agents/bus.sock, .agents/bus.sock.lock, the lock's takeover claim and the private temp an
atomic create keeps, beside the broker's own entries, so a running bus no longer leaves an
untracked socket and lock in the checkout. The bus's event log and its sealed segments live in
the project store, not in the checkout, so nothing else under .agents is missing.
A running seat's draft is never typed over by a direct send. The direct typed leg read a
running turn as an empty box — the caution stages run before the composer stage — so a send
typed its trigger into a draft a person had written during the turn, and the first Enter
submitted both. The composer below a working screen is now read too: when it holds unsent
text, nothing is typed and the send is held with the box's text, the record and the pending
marker are kept, and a running watch retries it when the seat is idle; a clear composer on a
working screen still takes the line. The same read backs the one guard the daemon, the retry
and the nudge share, so every typed path judges a working screen by its composer.
The event thresholds ship as fixed defaults; an owner-only team policy set for them comes in
0.5.2.
No team can override the general seat brief yet: it is TeamCLI's built-in default, shipped in the package, and every team receives that text. A registry-held definition, overridable by an entity or a project, is deferred to 0.5.2.
One column per quarter.