Skip to content

Releases

team 0.5.23

Choose a tag to compare

@github-actions github-actions released this 22 Nov 20:26
817442a

Added

  • A Claude Code seat on Anthropic signs in with no session login on a machine whose secret store holds the entry CLAUDE_CODE_OAUTH_TOKEN (the long-lived token claude setup-token prints): its launch line takes CLAUDE_CODE_OAUTH_TOKEN={secret:CLAUDE_CODE_OAUTH_TOKEN}, filled with the store's lookup like a provider key, so the value reaches that seat's shell only and never a record, status, log or plan. The store is asked whether it holds the entry by name alone (the Keychain lookup without -w; the encrypted file's entry names, nothing decrypted). Only a line proved to run Claude Code itself on Anthropic takes it (the shipped claude-code launcher, or leading assignments then the claude binary); a line through env, a shell, a wrapper or a launcher script, or one that names its own Anthropic credential, endpoint or settings file, never does. The route is enforced: the seat's own --settings file sets ANTHROPIC_BASE_URL to Anthropic's endpoint and empties every CLAUDE_CODE_USE_… switch, above the user's and project's settings and any exported variable, and the launch line clears the same variables and the other Anthropic credentials; the token is handed only when that file is in place. Only the machine's managed Claude settings stand above it, so a machine with a managed settings file, its drop-in folder or (on macOS) the managed preferences domain gives no seat the token, and team doctor names the file as the reason. A seat's reusable record never keeps the lookup. It is opt-in: the advised policy claude-auth is login by default (the session login, as before) and store turns it on, at entity, project or team level, for a personal subscription that receives no organization-managed settings (server-delivered settings stand above anything TeamCLI writes and cannot be detected locally). team doctor, under store where no session login is found, names the seats that sign in from the store, or names claude setup-token and the entry to keep it under. See Headless Claude sign-in.
  • Every seat has a name. A seat with no nickname, whose label is not <Name> · <role>, is handed the first free name of its entity's pool at team add (and team seat add) and at team up, which names every unnamed seat of the team, started or not, before anything launches. Three words in the entity's entry of entities.yaml decide how: names.pool (greek-myth, the built-in pool and the default, or a list of names read in order), names.auto (on, the default, or off, under which team doctor notes each seat with no name) and names.unique (entity, project, team or off), held as for a name set by hand. The name is written as a manual one is, nickname: <Name> and label: "<Name> · <role>"; a label with no middle dot is kept whole as the role part (Gemini tester becomes <Name> · Gemini tester). A seat with a nickname or a name of its own is never renamed; a human seat and a counted entry are not named. The pick and the write are one transaction under the registry's teams lock, and a first run publishes its name through a claim in ~/.config/team/name-claims.json, so two runs in two checkouts never take one name; an add whose name was taken meanwhile is refused (add.name-taken). A handed-out name moves the seat's approval with it only when its stanza is otherwise exactly what was approved and the approval is still the one the run judged; a nickname set by hand still needs a new approval. A run that cannot hand out a name says why and goes on: a launch never waits for a name. team names fill [--dry-run] [--entity <name>] names them when asked, whatever names.auto says. See Names handed out.
  • team restart <own-seat> --self: a seat, the entity's main orchestrator included by the owner's policy, queues its own restart from its own recorded pane; no seat can queue another's. The daemon relaunches it with its conversation once the terminal host reports it idle at an empty prompt (no turn, no unsent text, no dialog), read again right before the stop, in a short-lived child so its heartbeat never waits. The signed request runs only while the seat's record still names its pane, launch and conversation and the load guard lets a launch through. A refusal before the first effect on the pane ends restart.deferred and requeues the request; after the stop begins, any outcome is said once to the team's lead and the request is dropped, never run twice. A self-restart resumes the conversation or does not run: a line that cannot carry it, or a CLI that refuses the resume, ends restart.continuity, and no fresh conversation is started. A request that waits 30 minutes is given up and said to the lead. See A seat's restart of itself.

team 0.5.22

Choose a tag to compare

@github-actions github-actions released this 22 Nov 15:22
d846d3e

0.5.20 and 0.5.21 were never published to npm: this release carries the 0.5.21 section below as well as this one.

Added

  • desktop_control, a team and seat setting (default true), says whether a seat may control the computer: computer use, the user's browser, desktop apps and the connectors that act under the user's own accounts. Set false, a Codex seat's line, recorded recipe and managed app-server carry the feature pins that turn them off, and a Claude Code seat's settings deny the computer and browser tools and the claude.ai connectors. It is read at launch; team doctor and team check name a seat set false whose recorded line lacks the pins, with team restart <seat>.

  • Every seat whose CLI has a tested typed wake (Cursor, Gemini CLI, Grok, Antigravity, and Codex without a bound queue) is wakeable while idle: its WAKE cell says typed-wake, and the idle dispatcher types the wake itself. The typed-wake rules are unchanged: an empty composer only, never over a draft, never a person's pane. A Jules seat is said to read no inbox.

  • The warm send host: with the daemon's --send-server, team send, team reply and team ack run in one warm process instead of starting the runtime each time. A line the host cannot take is run by the CLI itself; TEAMCLI_SEND_HOST=0 skips the host for one run.

  • Each seat's status row says when a message last reached it and flags a failed route.

  • After a machine restart the daemon brings back the registered team sessions that ran, one start per session, on a fresh proof.

  • team restart <seat>@<team> restarts another team's seat, for that team's leads and the entity's main orchestrator; team up <seat> starts one seat.

  • team drops --read --id takes the 8-character id the reader line prints.

  • Each entity names one projects root per machine: the folder its repositories sit directly under, set with team config set <entity>.root <folder> (an absolute path or ~/…, read with get, removed with unset) in the machine's own entities file, never in a team file. A team file writes {root} in place of that full path — in a launch line, a rule, a brief, a seat's folder, a trust path — and the word is filled with this machine's folder whenever the file is read, so the same file reads on every machine: {root}/docs is ~/Code/acme/docs on one and /home/acme/repos/docs on another. The entity's and project's own rules read the word the same way. A file that writes {root} where its entity names no root, or that names no entity, is refused when it is read, on the line that writes it and naming the command that sets one, so a launch never runs a literal {root}; a file without the word reads exactly as before. Each entity's worktrees sit in <root>/worktrees unless team config set <entity>.worktrees <folder> names another (a server keeps ~/worktrees beside ~/repos), and a team file names that folder {worktrees}, with the same filling and refusal; the vault-root policy takes {root}/… and {worktrees}/… too. Editors that write a value back — team swap, team add, team rename, team launchers migrate — write full paths inside the entity's folders as the words again, on the lines they change. A folder holds only letters, digits and / . _ - @ + after a leading ~/ and is never the filesystem's root, the home or a folder above it; where the machine has a signed charter, a folder is filled only when its real path lies inside a charter root, and the charter signs every root as its real path, so a link put in place later widens nothing. team down and team status still read a team whose folder is gone; an entity's or project's rule whose word cannot be filled refuses the team. An approval is bound to the paths as they were filled in, so moving a root needs fresh approvals. team setup signs the charter over these roots, and over a worktrees folder outside its root, when no --roots is given, and refuses when no entity names one, instead of guessing folders under the home or falling back to ~/Code; a folder it finds there is named only as a suggestion. team config set <entity>.root creates the entity's entry, and the entities file, when a fresh machine has none. team doctor warns about every value that writes a full path inside the entity's root, and team migrate --root rewrites those paths as {root}/… line by line, keeping every comment: --dry-run lists each line it would change, and the owner's run writes them and prints each one.

  • team git, team gh and a provider seat's key read the system's secret store, on Linux as on macOS. On Linux the store is one encrypted dotenv file per entity, ~/.config/sops/<entity>.env.sops (sops with the machine's age key; TEAMCLI_SECRETS_FILE names another absolute path), and its entries keep generic names, so no entity's name is ever part of a key's name: the GitHub token is GITHUB_SEAT_TOKEN and must be a fine-grained token (github_pat_…), the provider keys DEEPSEEK_API_KEY, KIMI_API_KEY and GLM_API_KEY. An identity's github.secret and an account's secret name another generic entry beside the keychain name, which macOS keeps reading as before; a plain name is read under its env form (deepseek-api-key is DEEPSEEK_API_KEY). A command or a seat with no entity opens no file. The pay-per-use names ANTHROPIC_API_KEY and GEMINI_API_KEY are never read. A provider seat whose key the machine's store cannot look up is refused before its workspace is made. On macOS nothing changes: the Keychain lookup and the launch line are the ones they were.

  • A launch answers Claude Code's development-channels warning for the team's own inbox channel, so a Claude seat no longer waits at it on a machine where no one is at the pane. Claude Code has no supported way to approve a named development channel ahead of the start. The wait right after up, restart, reload or add launched the seat presses Enter on the dialog's marked first option, only on that seat's own pane, only for a line it launched with the flag for server:team-inbox, and only when the screen is exactly that dialog for that one channel; each answer is logged with the seat, the channel and the time. A second showing is not answered, and no other dialog ever is. On every platform.

  • team doctor reports, when the machine daemon runs, whether the daemon and the seats keep their temporary files in one folder. A Claude Code seat's session socket sits under its own temp folder and the daemon looks under its own alone, so two folders are a warning naming both. The daemon records its folder at its start; the seats' is measured when doctor runs in a seat's pane, and is otherwise the folder a pane team up starts gets. On every platform.

  • A vendor move by team swap (<vendor>:<model>) names the provider key on the seat's line as ANTHROPIC_AUTH_TOKEN={secret:<item>}, and every launch fills it with the system's secret store's own lookup of the item, so the same team file launches on Linux and on macOS. A line an earlier swap wrote keeps its own lookup and launches byte for byte as before. On macOS a new swap's filled word is the shipped claude-code launcher's: the Keychain lookup by service name (find-generic-password -s <item> -w, double-quoted), no longer narrowed by -a "$USER"; it finds the same item. A store with no lookup for the item refuses the seat before its workspace is made. Where the profile's own presence check cannot run (no Keychain tool on the machine), the swap asks the system's secret store for the team's entity whether it holds the item, so a vendor move works on Linux; a missing entry is refused naming the store, not a command.

  • team daemon install, restart and uninstall work on Linux: the machine daemon runs as the user's systemd user service, with the same retained runtime copy, bounded load retries, rollback and start admission as on macOS. On an account that does not linger, the install says the daemon stops at logout; an administrator's loginctl enable-linger <user> keeps it running on a headless server.

  • A machine with no owner signer of its own (a headless server) can pin the owner seat from the machine that holds the signers. team owner-seat export --out <file> writes the seat's public signer records and accepted signer names, signed with one confirmation on the owner's device; team owner-seat pin --from <file> pins it on the other machine. Both print one fingerprint for the owner to compare. The first pin is trust on first use, from the owner's terminal on that machine; a changed seat is pinned only from a newer export signed by a signer already pinned there.

  • Owner requests travel between the two machines as files until machines are linked. On the pinned machine a request names that machine inside its signed parameters, and team approvals export <id> --out <file> writes it out. On the signer machine team approvals sign --from <file> --out <file> shows the usual card, which names the other machine, and writes the signed answer. Back on the pinned machine team approvals answer --from <file> records it once it verifies against the pinned seat; the command then runs with --approval <id>. An answer never runs on another machine, expires with the window signed into its request (at most fifteen minutes there), and is spent once in the machine's approval ledger. A carried request carries every action's argument words, and the card is never shown, signed or run unless each action's argument hash is the hash of the words it shows.

  • A shared Linux server keeps its owner state where no entity account can change it. team owner-seat install --account <names>, run once as the administrator (--dry-run prints every step first), makes the owner helper's own user, the system owner folder, the helper's code folder, an approval ledger only the helper writes, and the one rule through which the named accounts start the helper. The pin and the machine record go in the sys...

Read more

team 0.5.19

Choose a tag to compare

@github-actions github-actions released this 07 Nov 14:56
b9294a0

Fixed

  • 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.

Changed

  • Releases publish only when every required check succeeded and both platform builds produced the same package as the published tarball. A manual release run must select a version tag.

team 0.5.18

Choose a tag to compare

@github-actions github-actions released this 07 Nov 10:24
007155f

Fixed

  • 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.

Changed

  • 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.

Known issue

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.

team 0.5.17

Choose a tag to compare

@github-actions github-actions released this 07 Nov 06:36
51e7185

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.

Fixed

  • The wildcard general-grant release table records analyse, checkpoint and show at the
    existing v0.5.16 tag, so grants signed before it report their added reach.

Known issue

Copying 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.

team 0.5.15

Choose a tag to compare

@github-actions github-actions released this 06 Nov 20:15
b22ca31

Security

  • 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 on ~/.config/team and on the whole project .agents folder. That reaches other seats' drops, their hook settings, and the team state on the machine. The profile now grants the seat's worktree and start folder, and only that seat's own paths: under the git common dir, objects/, refs/, logs/ and worktrees/; under .agents, send-drops//, messages/ and the seat's own state folder seat-state///. Only existing directories are granted; any surviving grant that is not a directory refuses the seat before launch. The packed-refs file is never granted. A fetch or pack-refs that must rewrite packed refs is refused (EPERM at packed-refs.lock) and fails loudly; commits and loose-ref fetches work. The common dir's config and hooks and the seat's hook settings file are not granted. Nothing under ~/.config/team is granted. A start at the shared project root is refused; give the seat its own worktree or clone. A Grok seat whose sandbox profile cannot be written is now refused instead of launched without a sandbox. If Grok cannot apply its sandbox for a reason outside these grants, it may still run unsandboxed; the launch does not yet refuse that warning on screen. If a Grok seat's pane shows "sandbox could not be applied", stop that seat; a later release refuses it at launch. This was local only: the seat runs as the same user on the same machine. Nothing was reachable over the network. Upgrade; the next launch writes the narrowed profile and removes the leftover [profiles.team-seat-] table. No configuration change is needed. The profile extends Grok's workspace preset, as before; what that preset grants beyond this list is not measured.

Known issue

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.

team 0.5.14

Choose a tag to compare

@github-actions github-actions released this 06 Nov 18:21
f2be107

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.

Fixed

  • A listed Muse hint drawn in typed blue, another colour, or an undeclared grey stays a draft. The empty-box reading is a faint hint or a colour the composer declares, the same rule as a rotating hint. A longer line on that row stays a draft too.
  • The CI timing recorder counts a test file once. A nested describe suite is not a second unit, and a report that has only describe rows keeps the sum of those rows under the file.
  • The daemon answers health and status requests without re-reading the team state for every seat.

Security

  • team drops --read now checks the caller (affected: 0.5.1 through 0.5.13). Before this
    release, team drops --read --seat <seat> served any seat's waiting messages to any process run
    inside that team's folder, and wrote their signed read receipts. One seat could therefore read
    another seat's messages and mark them read, so the real recipient never saw them. Now only the
    seat itself writes a read receipt. --read serves a seat's messages to that seat, as the
    turn-start hook runs it, and the owner or a lead (the orchestrator or the operator) may read
    another seat's drops only as a peek: the body is shown, no receipt is written, nothing is marked
    read, and the message still waits for its seat. A peek is logged with the reader, the seat and
    the ids. Every other caller is refused, the refusal is logged, and nothing is receipted. This
    was local only: the caller had to run on the
    same machine, as the same user, inside a folder holding that team's file. Nothing was reachable
    over the network, and no key or credential was exposed. Upgrade to 0.5.14; no configuration
    change is needed.

Known issues

the refusal reason can vary when two agent records share a millisecond; the decision is unaffected.

team 0.5.13

Choose a tag to compare

@github-actions github-actions released this 06 Nov 01:25
24509d5

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.

Fixed

  • A send to a managed Codex seat whose endpoint is not listening now says the endpoint is
    blocked, with the socket's own reason: the message stays in the seat's mailbox, the lead
    gets one signed notice, and the outcome is queued, not woken. A reply takes the same path.
  • A managed Codex seat whose endpoint does not start is left out with one line instead of
    falling back to --no-daemon, and team check names each ready Codex seat whose endpoint
    record is absent or unusable.
  • A send reports the leg that actually ran: a mailbox drop says queued, a channel
    notification says notified, not yet read, and neither says the seat was woken. A recorded
    socket that is gone is reported as that failure, never as an event-adapter wake.
  • A send's --json document accepts the channel leg.
  • team reply and team ack run from a seat's shell now recognise the seat placed in the
    team's session, as team send already did, so a seat behind a launcher wrapper is no longer
    refused as unplaced.
  • A reply to a seat held by another command is queued instead of refused: the signed answer
    is written to the seat's mailbox, and the watch delivers it once the seat is free.
  • An idle Codex pane whose last row shows ? for shortcuts with the account's warning now
    reads idle, while a box holding text still reads unsent.
  • A Cursor seat launched through the terminal host now records its conversation, and a
    restored pane ties back to its launch.
  • A typed wake to an Antigravity seat answers the CLI's bottom feedback survey with Skip once,
    then reads the prompt again before typing.
  • The watch's chores child awaits its pane proof read, so a slow terminal-host read no longer
    stalls its heartbeat.
  • team status reports a machine daemon whose health probe timed out but whose heartbeat is
    recent as busy under load, not hung.
  • team up records a live Claude seat's socket address even when it leaves the seat at
    launched, so a send reaches it without a restart.
  • team up binds an address only to the seat and session that own the pane: it skips a pane
    the terminal host names for another seat, or one another declared seat's record already
    claims, and leaves a record standing in another session neither refreshed nor cleared — a
    send can no longer wake another seat's process.
  • team check names the repair that works: team up for a live seat whose record holds no
    address or whose pane was restored (its own plan adopts the running process in place), and
    team register when the record names no held process or stands in another session. A pane
    two seats both claim is named once for the pane, and only a pane no proof binds names a
    restart, which records the address itself. The stale-socket line names the machine's restart
    load limit.
  • A managed Codex seat's inbox tool starts after a restore or reload: its launch epoch is
    carried through both, team reload registers the inbox again when the registration is
    missing, and a managed endpoint that died is started again in place.
  • An idle Muse box that shows its rotating hint reads as empty, so a typed wake can reach the
    seat. The unsent check and team status say the box reads as holding text, and never ask
    anyone to clear it.
  • A command that waits on a team lock now stops at its deadline in every case, including a lock
    whose holder record cannot be read and a stale record the folder refuses to remove, so a
    wedged lock can no longer hang a run. A no-wait attempt is refused at once, and the refusal
    names the process holding the lock now, never one that has exited.

team 0.5.12

Choose a tag to compare

@github-actions github-actions released this 06 Nov 00:22
151c03a

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.

Delivery

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.

Re-wake

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.

Read receipts

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.

Messages

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.

Client answers

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.

Trace

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.

Daemon start

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.

Chores

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.

Webhook deadline

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.

Typed wakes

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.

Scroll-back

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.

Codex prompt chrome

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.

Exit text

team down and team restart clear the exit text they typed when the submit Enter is refused or
never runs.

End of turn

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.

Sidebar order

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.

Placement

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.

Actions and comments

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.

Lead settings

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.

Development mode

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.

Main orchestrator

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.

Heartbeat

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.

Store

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.

Chores liveness

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 s...

Read more

team 0.5.11

Choose a tag to compare

@github-actions github-actions released this 02 Nov 17:07
213132c

Clearer delivery reports and approval cards, steadier team recovery, and tighter checks before
an action changes a team or answers a dialog.

Added

  • team peek shows a seat's captured screen lines with credential masking, without sending
    input to its terminal.
  • Seats can receive accepted inbox records through a webhook with configurable headers and
    request bodies. Delivery reports identify the route that accepted a message, and status shows
    whether each seat can be woken while idle or reads its inbox on its next turn.
  • team answer handles questions, plan approvals and confirmations on supported CLI versions.
    The watch reports these dialogs, includes their visible text and flags incomplete questions.
  • An entity can require unique seat nicknames across teams. Configuration changes keep a
    seat's label and nickname together, and checks report conflicting names.
  • Owner-signed send grants can address another team's orchestrator within the same entity.
    team daemon restart accepts a verified general grant that covers the daemon operation.

Changed

  • Owner approval cards describe the action in plain words, with optional --reason text and
    the full record in details. Development-mode changes can be sent as an owner-seat request.
  • A team's lead can restart its own stopped seat. A failed revival preserves the stopped
    mark. Development mode admits the lead's supported team and seat edits with a warning and an
    audit record written after a successful change.
  • The machine daemon reports health while roots are starting, follows current registry
    records, renews its own watch heartbeat and reports failed endpoints. Installation uses a
    verified program copy without grant credentials in the service definition, and a failed
    refresh restores and checks the previous program.
  • Custom screen rules require a matching condition. The reason field belongs only to
    rate-limit rules.

Fixed

  • Supported quoted Claude Code launch scripts keep resume and session options inside the
    script. Launch records and fallback reports describe the conversation actually started,
    and managed endpoint sockets remain usable for teams in deeply nested folders.
  • Managed Codex conversations can accept queued messages during a running turn or dialog.
  • Launched-team commands read current registry records. Inbox registration works without a
    local team file and retries a failed registration before leaving the seat unlaunched.
  • Workflow runs preserve error transitions even when the requested destination is the error
    state, and check each step before saving it.
  • Restored seats refresh their displayed state on the first watch cycle. Status reads a
    wrapper's model only from an unambiguous welcome header. Slow process and screen reads finish
    before the state lock is taken.
  • Signed bus verification keeps an authenticated checkpoint across restarts. Closing a bus
    cancels deferred work, and webhook delivery preserves configured header and body values
    while refusing redirects and unsafe file inputs.
  • Approval history checks read the complete record chain and distinguish a missing prior
    record from a team with no approval history. Policy logs credit the caller who made a change.
  • A seat's declaration time now changes only when its cross-session acceptance setting changes,
    so a rewritten hook command no longer makes a running seat look stale to senders.
  • A recovery pass that launches no seat leaves running seats' hook files untouched, so it
    cannot move their declaration times.
  • team route reports the same stale session state a send would meet, instead of calling a
    socket live that a send would pass over.
  • Hook commands name the installed program instead of the private copy the system's service
    manager runs, so a later refresh cannot leave a seat's hooks naming a removed folder.

Security

  • Grant and approval checks follow the operation, entity and resolved target folder the
    command actually names. Grant denials and approval revocations require the record's owner.
  • Dialog answers recheck the recorded launch, supported CLI version, current dialog and
    resolved trust folder immediately before acting.
  • Credential checks recognise framed tokens in team configuration. Private-text checks also
    scan binary-looking files and complete commit messages containing NUL bytes.