Skip to content

Latest commit

 

History

History
499 lines (341 loc) · 183 KB

pstack-differences.md

File metadata and controls

499 lines (341 loc) · 183 KB

Differences from pstack

Orbit copies pstack (pstack/ in cursor/plugins) at commit 0b46ec3, the SHA that every skills.json entry pins. Every pstack. line quotes 0b46ec3, not newer upstream. The previous pin, e1cc031, differs from 0b46ec3 under pstack/ by three commits. e58dd04 moved the Gemini panel slug from gemini-4-carbon-high to gemini-4-neon-high, added setup-pstack's paragraph that migrates older Gemini entries, and reworded the Gemini cap. dd24b67 moved the slug to gemini-4-neon-xhigh and rewrote that paragraph and the cap to match. 0b46ec3 changed only statechart, which orbit does not vendor. So a line that says what e1cc031 holds or changed still holds at 0b46ec3. A line that names de8ee15, the pin before e1cc031, quotes text that orbit kept after e1cc031 cut or rewrote it. For Claude Code tool and path mappings, orbit follows pstack's adapter, pstack/docs/harness/claude-code.md. For T3 Code, orbit adds its own adapter, plugin/docs/harness/t3-code.md with t3-seats.md beside it (T3 Code host). On a design fork, check pstack first. Record each difference here with its reason.

In the orbit. lines, paths under agents/, hooks/ and skills/, rules.md and rules-shared.md are relative to plugin/, the folder the plugin ships from. Other paths are relative to the repo root.

Loading rules

  • pstack. The user runs /poteto-mode per task, typed as /pstack:poteto-mode in Claude Code (README.md).
  • orbit. Four SessionStart hooks print the rules every session (hooks/hooks.json). Three print rules.md, split at # Delegation and # Writing the reply, and the fourth prints rules-shared.md (Shared rules). The first line of rules.md sends a goal with no named skill through /orbit:start, and a go-ahead on a change Claude proposed outside a flow counts as a goal. Poteto-mode's Non-negotiables follow it. agents/poteto-agent.md reads rules-shared.md itself.
  • Why. Rules hold without the user remembering a command. No per-task command loads, so routing has to live in the rules. Claude Code caps each hook's stdout at 10,000 characters and replaces longer output with a file path and a preview of the first 2,000 characters (code.claude.com/docs/en/hooks, read 2026-11-17), so one hook would drop most of rules.md. Two hooks split at # Code Quality left the second part at 9,931 characters at 0.55.0, so the next rules edit would have crossed the cap with no error. The four parts print about 6,300, 8,100, 7,300 and 1,800 characters at 0.71.0, and tests/hooks/session-start.test.sh fails a part of 9,000 characters or more. The parts arrive in the order the hooks finish. Subagents don't get the SessionStart output. A "go" after a question-and-answer exchange once edited the main checkout with no worktree and collided with another session (transcript audit, 2026-11-10), so a go-ahead now enters a flow and its Worktree gate.

Shared rules

  • pstack. poteto-agent reads all of poteto-mode's SKILL.md, the lead's sections included (agents/poteto-agent.md). pstack has no rules file for agents alone.
  • orbit. rules-shared.md holds the four sections the lead and its delegates share. They are Bash, which is the "One plain command per Bash call" paragraph from rules.md Delegation, then Code Quality, Files and Comments. The text moved verbatim except for one sentence, and the # Bash heading is new. Comments opened with "Comments follow the same rule as the reply.", which pointed at Writing the reply in rules.md. It now names those rules itself, as short declarative sentences with no long-dash character and no colon joining two clauses. rules.md keeps the lead's sections. A fourth SessionStart hook prints rules-shared.md, so the lead's injected text holds the same sections as before (Loading rules). The rules skill reads both files when the hook output is missing. agents/poteto-agent.md reads the playbook SKILL.md and rules-shared.md, and skips rules.md. It carries one sentence of its own from Task End's Always-pause list, to stop and report to its parent before an irreversible write. The Delegate gate gives a prose unit's brief the paths of skills/unslop/SKILL.md and skills/technical-writing/SKILL.md. An autopilot owner's brief names rules-shared.md beside rules.md (skills/playbook/playbooks/autopilot-full.md step 2).
  • Why. Across 1,474 subagents since 2026-11-09, 403 of 418 poteto-agent delegates read all of rules.md before working, because their agent file said to (transcript audit, 2026-11-20). rules.md was 3,498 words, about 7.7k tokens, and most of it is the lead's routing, triggers, delegation, shipping, Task End, reply style and Workflow Defaults. A delegate now reads 2,488 words before work in place of 5,660, the playbook's 2,183 and rules-shared.md's 305. The lead's injected rules went from 3,498 words to 3,507, the new heading and the longer Comments sentence (measured with wc -w, 2026-11-20). A fourth hook, rather than the shared file appended to one part, keeps every part under the cap and lets the test compare the parts with the two files in order. Skipping rules.md drops three things a delegate still needs, so each comes back in a narrower place. The Always-pause list lives in Task End, so poteto-agent carries its one sentence. The unslop and technical-writing triggers live in Non-negotiables, so the Delegate gate names both skills for prose units only. An autopilot owner is a general-purpose agent that runs a flow of its own and gets no SessionStart output, so its brief names both rules files (diff review of #91, 2026-11-20).

Bash rule in agents

  • pstack. pstack ships two agents, poteto-agent and comment-sicko, and neither carries a rule on the form of a shell command (agents/).
  • orbit. gitops, advisor, verifier and comment-sicko each carry the rule in their own file, in two to four sentences. Each forbids an && chain around git and a shell variable or $(...) in a git argument. gitops, the advisor and comment-sicko forbid git -C or cd into another checkout only while the session is isolated in a worktree, as rules-shared.md Bash does. Otherwise gitops and the advisor use git -C <path> for a checkout their brief names. The verifier always runs isolated in its own worktree, so its clause stays unconditional and names another checkout of this repo, which leaves its scratch repo under /tmp allowed. gitops also names a heredoc and passes a commit body as a second -m.
  • Why. Subagents never get the SessionStart output, and these four agents read no rules file. In a ship cleanup eval run on 2026-11-19 (tests/ship/cleanup.mjs), the advisor ran R=<root>; ... git -C $R config ... and gitops ran [ "$(git rev-parse HEAD)" = <sha> ] && git push origin HEAD:main. The guard refused both, with "names git in a form too complex to verify" and "redirects git to the shared checkout via -C". Across all sessions since 2026-11-09 the guard refused 687 calls, 1.75 h in all (transcript audit, 2026-11-20). The rule sits inline, not as a read of rules-shared.md. gitops spawns several times per ship, and a read costs 305 words plus one more turn that re-sends the whole context, while the inline rule adds 98 words to gitops, 83 to the advisor, 51 to comment-sicko and 23 to the verifier (measured with wc -w, 2026-11-20). The git -C clause is conditional because the T3 adapter (docs/harness/t3-code.md Where a child runs step 10) and autopilot-full step 2 send gitops into an owner's worktree with git -C <path> from a session that is not isolated, and an unconditional ban would refuse that round (diff review of #91, 2026-11-20).

Orbit-written skills

  • pstack. poteto-mode's SKILL.md holds Non-negotiables, Principles, Autonomy, Subagents, Writing the reply and the playbook index. It has no gates. de8ee15 also had a Comments section. pstack ships its own correct.
  • orbit. skills/start, skills/ship, skills/correct, skills/rules, skills/setup and skills/playbook/SKILL.md are orbit's text, with no skills.json entry (Setup, Running another skill). The playbook SKILL.md holds the gates, Principles, Stack rules and the index. poteto-mode's other sections live in rules.md. correct keeps pstack's order (architecture, then a type or lint, then a test, then a doc) and its rule table, but handles one named mistake with one guard. It drops the class sweep, the exception rule and the Reply:.
  • Why. start and ship are entry commands that pstack's single /poteto-mode doesn't need. The Worktree, Plan and Delegate gates are orbit's. rules.md loads every session, so the always-on sections go there. correct's rewrite has no recorded reason.

Native task progress

  • pstack. Orbit's start entry point has no upstream counterpart (Orbit-written skills).
  • orbit. skills/start/SKILL.md uses Claude's TaskCreate / TaskUpdate / TaskList or TodoWrite. It falls back to a list in the reply only when no native task tool is available and the work is a multistep plan, meaning the goal holds two or more separate tasks the user would name. Single-task work, including building and landing one change, gets a line of progress instead. That list holds only the user's tasks, each with a checkbox. It shows once at the start, a task's line shows again when its state changes, and the final reply shows the closed list. The playbook's steps and gates are tracked silently and never printed. Steps update as they start and finish, skipped steps retain their reason and complete, and a resumed task reuses its list.
  • Why. The previous instruction named only TodoWrite, so Codex and Claude sessions offering newer task tools fell back to text. Native updates let T3 display the flow's steps and progress in its task UI (operator request, 2026-11-17). A text list opened once and never updated, or closed with a sentence of evidence per item, hid progress. A reply list of playbook steps and gates was clutter, because the user needs only the tasks and their progress (operator request, 2026-11-19). A checklist for single-task work was noise, so it shows only for a multistep plan (operator request, 2026-11-19).

Trigger list

  • pstack. e1cc031 cuts poteto-mode's Non-negotiables to ten short lines and adds one. "Starting any agent, whether a Task subagent or a Project worker → the first line of its kickoff is Read <path>/worker.md before anything else." worker.md holds the operator's rules for every started agent, among them "The bar in your kickoff is the whole bar. Add no check, gate, sign-off or review round above it." (poteto-mode/SKILL.md, poteto-mode/worker.md)
  • orbit. rules.md Non-negotiables keep the de8ee15 trigger list with orbit's edits, including "Nontrivial change, architecture decision, or "are we sure?" → /orbit:how." Orbit ships no worker.md and adds no kickoff line. Agents get the operator's rules through rules-shared.md, their own agent files and the Delegate gate brief.
  • Why. rules.md is orbit's counterpart of poteto-mode's triggers, and it carries orbit and T3 Code triggers that the short list lacks. The prod-ready program rewrites rules.md in a later unit (P5), which can port the shorter wording. worker.md's "Add no check, gate, sign-off or review round above it" would cut orbit's Plan gate and pre-land Independent verifier (P13 review, 2026-11-17).

Worktree for the main chat

  • pstack. "Work from a git worktree off trunk, and keep unrelated work out of it" (playbooks/opening-a-pr.md), with no tool named and no recovery steps. de8ee15 also had "Dirty branch with unrelated work: patch out, fresh worktree, apply. Snarled worktree: reset from main, redo minimally."
  • orbit. The Worktree gate (skills/playbook/SKILL.md) calls EnterWorktree named <type>-<slug>, then runs git branch -m <type>/<slug>. It carries both de8ee15 recovery sentences, which e1cc031 cut, and they override its skip-when-in-a-worktree rule. "Reset from main" becomes a fresh worktree. Either case runs ExitWorktree with keep first. Shipping step 7 removes a task's worktree and branch once it lands, and /orbit:worktree-cleanup prunes abandoned ones (Shipping).
  • Why. Claude Code's worktree tools. gitops never runs reset --hard (agents/gitops.md). EnterWorktree names the branch worktree-<name>, so the gate renames it. Opening a PR pushes <type>/<slug>, and the worktree-cleanup audit matches PRs by local branch name.

Worktree setup

  • pstack. No setup step.
  • orbit. Before entering, if git check-ignore -q .claude/worktrees fails, the Worktree gate appends .claude/worktrees to .git/info/exclude. After entering, it runs vp install when the project has a lockfile. Gitignored files the Check needs, such as .env* or .claude/settings.local.json, come in through the project's .worktreeinclude, which Claude Code copies into each new worktree. When one is missing, the gate adds its pattern there and copies the file in once.
  • Why. Orbit's choice. EnterWorktree puts worktrees under .claude/worktrees, so the exclude keeps them out of the main checkout's git status without a tracked .gitignore edit. A fresh worktree has no installed dependencies, so the Check line can't run without the install. It also has no gitignored files, and agents copied .env.local in by hand in 4 sessions (transcript audit, 2026-11-10). .worktreeinclude makes the copy happen once per project instead of once per worktree.

Plan gate

  • pstack. No plan gate and no advisor. pstack ships only poteto-agent and comment-sicko (agents/).
  • orbit. The Plan gate (skills/playbook/SKILL.md) runs when a change adds a module or touches more than 3 files. The lead reads the project sources for those paths, briefs orbit:advisor (agents/advisor.md, Fable at high unless the project's advisor row changes it, read-only) with the plan and the sources, and acts on its verdict. If the spawn fails because Fable is unavailable or its usage limit is reached, the lead retries once on Opus (rules.md Workflow Defaults, Models). The advisor has no T3 Code tools, because it only reads and returns a verdict. The advisor also picks a fork before it reaches the user (Test before asking) and reviews each PR's diff in Shipping (Diff review).
  • Why. Orbit's choice. A second model checks a multi-file plan against the project's rules before code exists, when a wrong shape costs least to fix. The advisor moved from Opus to Fable on 2026-11-10. Anthropic's Fable 5.2 launch page (https://www.anthropic.com/claude-fable-and-mythos-5-2) names Fable for the advisor role, where "Haiku, Sonnet, or Opus models consult it". The same page recommends Opus as the daily driver, so under the defaults the lead runs on Opus and a Fable advisor is a second model.

Running another skill

  • pstack. "Read <pstack>/skills/<name>/SKILL.md and follow it. The Skill tool refuses most pstack skills." (docs/harness/claude-code.md)
  • orbit. The Skill tool runs start, playbook, ship, how, why, architect, arena, interrogate, swarm, figure-it-out, deslop, no-comments, unslop, technical-writing, control-ui, control-cli, pause-safely, worktree-cleanup and rules. Flows read the principle leaves, tdd, benchmark-checklist, show-me-your-work, ketchup and typescript-best-practices by path. rules.md gives benchmark-checklist and show-me-your-work the bundled path, <orbit-plugin>/skills/<name>/SKILL.md. It gives bugbot-triage.md the bundled path <orbit-plugin>/skills/playbook/references/bugbot-triage.md. Skill bodies give a bundled path relative to the skill's own directory, such as ../arena/SKILL.md. setup, correct, recall, reflect, automate-me, session-pickup, create-verification-skill and maintain-verification-skill keep disable-model-invocation, so the user types them.
  • Why. ${CLAUDE_SKILL_DIR} expands only in a skill that the Skill tool loads or the user types. playbook and worktree-cleanup find their files through it. Flows also pass $ARGUMENTS, which a Read by path can't. The SessionStart hooks print rules.md and rules-shared.md through sed, which rewrites <orbit-plugin> to the plugin root. Grok loads the plugin but drops the SessionStart output and leaves ${CLAUDE_PLUGIN_ROOT} unexpanded in skill bodies. It gives the model each skill's base directory, so a relative path resolves there, and a lead without the hook output loads the rules skill, which reads ../../rules.md and ../../rules-shared.md. Agents keep ${CLAUDE_PLUGIN_ROOT}, which Claude Code and Grok expand in agent bodies.

T3 Code host

  • pstack. pstack's Claude Code adapter (pstack/docs/harness/claude-code.md) maps Cursor names to Claude Code. Its Cursor-only features section skips what Claude Code lacks. "Claude Code has no Cursor Automations, Bugbot, Cursor cloud agents, or built-in PR tool. When a step needs one, put one line in your reply, Skipped in Claude Code: <step>. <reason>., then go on to the next step."
  • orbit. plugin/docs/harness/t3-code.md maps pstack's names to T3 Code in three columns, pstack, T3 Code and T3 tool absent. It sits under docs/harness/, the folder pstack uses for a host adapter. Before calling a T3 tool, each agent checks that tool itself. The tool is present when it is in the agent's tool list, or when ToolSearch with select:mcp__t3-code__<name> loads it. With no ToolSearch, a tool not in the list is absent. T3 tools may load late, so the agent tries a missing tool's name once, by ToolSearch select: or else by its first real call, before it calls the tool absent. The probe has no families and never keys on another tool of the same family. Any mcp__t3-code__ tool in the list tells the agent the host is T3, never that another tool is present. A tool that is not present takes the absent column. The rows map Task, environment: "cloud", Cursor Automations, SendToUser secret requests, a built-in PR tool, a wait on a PR event and background work the agent waits on. The Automations row adds that a request only to schedule calls schedule_task and does not run its prompt now. The secrets row adds the sudo flow, a delivery: "file" secret fed to sudo -S -p '' <cmd> on stdin, with any other input as a file argument. Seven rows are orbit's own, since pstack's adapter has none of them. They are /loop, a question about a T3 thread by its id, a browser step the user asked for, a lead in T3 plan mode, gitops's CI wait, a verdict's proof table and the user's Stop. /loop maps to schedule_task bound to the thread when that tool is present. A question about a thread runs t3_thread_read on it before the answer, and without that tool the agent says it cannot read the thread and writes no skip line. A verdict's proof table goes through html_preview with an HTML file path or inline HTML, then html_render, when both are present, else into an in-chat table, as swarm Phase D's result table. A chart for a trend or comparison, such as ketchup's, takes the same row, else a Mermaid chart (ketchup). The built-in PR tool row links each PR gitops creates, takes over or pushes to, with link_pull_requests for several, and says when linking fails. The PR wait is two rows. gitops asked to wait on CI runs the watcher once with --once on every host and reports the verdict (gitops agent). The lead's own wait follows babysit's Host watcher (Babysit). In T3 it reads once with --once, calls watch_pull_request on a pending TIMEOUT, ends the turn, and unwatches before a handback. In T3 with that tool off it reads once per turn and hands back. Outside T3 it runs the bare watcher under /loop. Bugbot and Cursor cloud agents keep the adapter's rows in both columns. Paths is one sentence, because T3 changes no path. Models keeps rules.md's Claude mapping and adds a row for a non-Claude slug, a panel seat on another family, with a Seats on another family subsection that points to plugin/docs/harness/t3-seats.md (Seats on another family). The lead calls orchestrator_capabilities once per thread, and again only after an error or a user-named provider change, or with search for a model the Models table names. The session's family is the driverKind of the provider whose providerInstanceId equals inheritedProviderInstanceId. The roster is the list of entries in the other-family row's Model cell. An empty cell, no row and inherit give no roster. When no provider matches inheritedProviderInstanceId, the reply says so. A list then skips the seat with no entry tried, and with no list the session-family seat runs. The session-family seat is the seat the skill names, run on the session's own family as an Agent spawn. The other-family row picks the seat (Model per role), and its Effort maps onto the model's own option id. The cell resolves to one of four outcomes, which t3-seats.md holds as one table (Ranked providers). An empty cell runs the session-family seat, and the reply says that no seat on another family is configured. A list tries at most three candidates outside the session's family, in list order, and never a provider it leaves out. Each candidate's model passes a family check on its id, and auto and default seats say family unverified. When every candidate fails, the seat is skipped and the reply says so, unless the list ends with inherit. Before the lead calls an explicit pick unavailable because its model is not listed, it calls orchestrator_capabilities with search set to the model id. The lead spawns the seat with delegate_task, ends the turn, reads the result with task_status when the child's completion wakes it, and settles the child thread. Each spawn carries a clientRequestId naming the skill, the seat and the round, reused on a retry of the same call and new for a new round or a fallback. A seat or child that runs commands skips a provider whose listed runtimeModes lacks the parent's runtime mode. A child's question goes through t3_pending_request on its childThreadId, answered from the brief's context or else by the user, and archive is only for a child the lead abandons or when that tool is absent. A failed seat puts <entry> unavailable: <reason> in the reply and moves to the next candidate, after task_cancel on a child that still runs. t3_thread_send only answers or steers a running child. In the absent column the session-family seat runs, and the reply names each seat's model. "Roster" has no pstack name. pstack says "family", which arena Phase A step 3 defines by slug prefix, and "pool", as in arena cross-judge pool. Read-only and shared-checkout children stay foreground Agent calls. Under a T3 lead with delegate_task, a child that needs its own checkout or runs while the lead keeps working, such as a parallel delegate, the native verifier or an autopilot owner's build round, is a same-provider delegate_task child, and a panel seat on another family is a cross-provider one (Own-checkout children). Each Agent call passes run_in_background: false, and parallel spawns go as several calls in one message (Agent call defaults). A new round's brief carries the original brief, the prior round's findings, the responses to them and the objections still open. A skipped step gets the line Skipped outside T3: <step>. <reason>. The built-in PR tool row's absent column is gh pr create and writes no line, as pstack's adapter says, "That is not a skip, so write no line." rules.md Delegation points at the file once, in Host tools. The one exception to the probe is a session connected to T3 from outside. When a call there returns the error that the tool needs an agent running inside T3 Code, that tool and the rest of the tools that act as the calling thread take the absent column, and t3_thread_launch never stands in for them unless the user asked for a new thread. A verifier whose verifier row reads other-family or other-family, inherit runs as a seat on another family through delegate_task (Independent verifier). The native verifier runs as a same-provider child (Own-checkout children). A browser step the user asked for runs preview_status first, then preview_open only if no tab can be automated, and closes a tab it opened with t3_preview_close before the reply, unless the user asked for it or uses it. No agent uses preview_* unasked to verify or show its own edit. Without the tools, the step runs on the control-ui harness. A lead in T3 plan mode reads its mode from orchestrator_capabilities and passes interactionMode: "plan" on every delegate_task, never "default", and omits the field when unsure. A native child's brief carries T3's plan-mode rule verbatim, and the lead spawns no code writer in plan mode. The user's Stop ends the thread's PR watches and stops its delegated tasks. Nothing re-arms on its own, and resumed PR work goes back through the lead's PR wait row (Playbooks as skills). The read trigger in the adapter's opening names the browser step and a child in plan mode.
  • Why. T3 Code has a tool for three of the adapter's rows. schedule_task covers Automations, request_secret covers secret requests, and link_pull_request follows gh pr create for the built-in PR tool. T3's runtime rule for every thread (runtimeInstructions.ts line 3 in pingdotgg/t3code at c2eb8f3) says "Link each PR you create, take over, or push to: link_pull_request, or link_pull_requests for several, full URL, every stack layer, as your next call. Host tools don't link for you. If linking fails, say so." The old row's "A later push to a linked PR needs no new link." contradicted "push to", and link_pull_request is idempotent (Tool.Idempotent in T3's pr-tools.ts), so a repeat link costs nothing. The same line sets the PR wait, quoted under Babysit. Bugbot and cloud agents have no T3 tool, so their rows match the adapter's. A probe beats an environment variable, because T3 can turn a tool off inside a T3 session and the variable says nothing about which (T3-native plan, rejected alternatives, 2026-11-16). The probe checks each tool, not one per family, because T3 can turn one tool off and leave the rest of its family on (inferred). pstack keeps its host adapter at docs/harness/claude-code.md, so orbit's T3 adapter takes the same folder under plugin/. The T3-native plan renders each verdict's proof table in the coordinator thread with html_render, and swarm Phase D already returns its result table in chat, which covers a session without the tool. Being in T3 also doesn't give every agent the tools. An orbit:verifier saw none until its tools frontmatter named them (T3 probe lane, 2026-11-16), so each agent probes for itself. Owners, verifiers and swarm workers once ran as delegate_task child threads. The threads cluttered the sidebar, needed settling by hand, and died in a T3 restart as a subagent would (T3-native plan, rejected alternatives). So orbit moved them to Agent, which gives a worktree, parallel runs and fresh context. T3's rule sends a separate checkout and a background agent to delegate_task, so P7 of the prod-ready program moved the children that need either back to child threads and kept the read-only ones native (Own-checkout children). pstack ships a Claude Code adapter beside its Cursor-native text, so the absent column keeps orbit working in plain Claude Code and in a T3 session with a tool turned off. The skip line says "outside T3" because an absent tool can also mean a T3 session with that tool off (inferred). The PR row once had the lead write Skipped outside T3: link PR., and under claude -p with no T3 the reply carried it on every PR (interrogate, 2026-11-16). The probe lane on 2026-11-16 also saw /loop with no interval schedule its wake with ScheduleWakeup, as the /loop row says. pstack's adapter maps a non-Claude slug as "Omit model so the agent runs on the session model, and say so." Orbit's absent column departs from that line. Each skill's Claude seat already is the session-family seat orbit runs without T3, and a caveat on every non-T3 run is noise (advisor plan gate, 2026-11-16). Orbit keys family on driverKind because the capabilities result carries no family field, and driverKind is its only per-provider kind (inferred). A provider of another driverKind can still list a Claude model, and some list a model named default, so an explicit other-family pick is the fix (advisor, 2026-11-16). t3_background_wait refuses delegate_task ids ("Subagent, Agent tool, and delegate_task IDs don't go here.", T3-3 probe, 2026-11-16), so the lead ends the turn and the child's completion wakes it. An aggregator provider of another driverKind can host a model of the session's own family (advisor, 2026-11-16), so the family check reads each candidate model's id (Ranked providers). orchestrator_capabilities returns a short list and takes search, so a model missing from the first result can still be in the catalog. The skill's Claude seat became the session-family seat when other providers could lead, and the name stayed. T3's orchestrator MCP doc (c2eb8f3) says a call without clientRequestId creates new work, a provider runs a runtime mode it does not offer as approval-required, approvals are not routed to the parent, and a child's question waits on t3_pending_request. The same doc's delegate_task section says "Each independent delegated review round uses a new delegate_task call with the original brief, prior findings, responses, and unresolved objections." (2026-11-16, re-checked 2026-11-17) T3's system prompt for every thread (orchestrationInstructions.ts in pingdotgg/t3code at c2eb8f3) sets six more rules. The probe retry is its "T3 tools may load late. Try the name once before you call it absent." (line 20). The capabilities rule is its "Call orchestrator_capabilities once per thread, before the first delegate_task. Again only after an error or a user-named provider change." (line 10). Orbit keeps the search call for a named model beside it, because the first result is a short list. The thread row is its "Given a thread id, t3_thread_read it before you answer about it." (line 15). That prompt carries the rule from the thread's first turn, so the row needs no trigger in rules.md Host tools. The sudo flow and the schedule-only rule are its "Sudo: if sudo -n <cmd> needs a password, use delivery: "file" and run sudo -S -p '' <cmd> < "$file"; the password takes stdin, so give other input as a file argument. Asked only to schedule: schedule_task without running its prompt." (line 19). The proof table follows its "pass an HTML file path or inline HTML to html_preview, then html_render" (line 23). T3's outside-agents doc (docs/user/outside-agents.md in pingdotgg/t3code at c2eb8f3, read 2026-11-16, re-checked 2026-11-17) says the tools that act as the calling thread, "subagents, secret requests, rendered HTML, the browser preview, devices, and worktree handoff", "still appear in an outside agent's tool list, but calling one returns an error saying it needs an agent running inside T3 Code." So for a session connected from outside, a listed tool is not proof, and that error marks the whole group absent. The same doc hands an outside agent's work off with t3_thread_launch, but T3's own rules start a thread only on request, so the probe never swaps it in for an absent tool (user directive, 2026-11-16). The browser row copies T3's system prompt. "Never use preview_* unasked to verify or show your own edit. ... Close a tab you opened before you reply, unless the user asked for it or uses it." (orchestrationInstructions.ts:24) and "When browser work was asked, preview_* is the browser you share with the user: preview_status first, then preview_open if no tab can be automated." and "Switch browsers only if the tools are absent or preview_open says unsupported, the user asks, or two preview calls fail on one step. Then quote the error and switch." (line 36). The plan-mode row follows T3's orchestrator MCP doc, "For local delegation, provider, model, runtime mode, and interaction mode inherit from the parent when omitted" (line 245) and "A child interaction mode may stay equal to or narrow from default to plan. It may not escalate from plan to default." (line 534). A wrong explicit plan would narrow a child the lead meant to run in default, so an unsure lead omits the field and T3 inherits it (inferred). A native Agent child gets none of T3's mode text (inferred), so its brief carries T3's ACP plan-mode instruction (line 68). The Stop row follows docs/orchestration-v2/feature-lifecycles.md:254, "A Stop also holds the queue, ends the thread's pull request watches, and drops wakes its delegated tasks still owe, so nothing automatic restarts the thread." T3's source-control doc adds that watching ends "when you press Stop on the thread" and that "Subagents cannot watch pull requests" (docs/user/source-control.md:340-345). The adapter is two files, where pstack has one per host. rules.md Host tools. has every T3 lead read t3-code.md whole, and at 6,144 words it held a section most sessions never use. Seats on another family applies only when the other-family row lists providers or the verifier row is other-family or other-family, inherit. It moved verbatim into t3-seats.md, and t3-code.md keeps a pointer that names the condition. A lead with no roster reads 3,429 words in place of 6,144, and one with a roster reads 5,365 (measured with wc -w, 2026-11-20, before 0.70.0 cut the adapter's lead-provider lines). The pieces of the seats section that hold for every child stayed in t3-code.md, because Where a child runs uses them for every same-provider child. They are the orchestrator_capabilities paragraph, the Effort-to-target.options paragraph, the workState rule, the link rule, the t3_background_wait, t3_thread_interrupt and archive rules, and the rule for a child's pending question. The skills that use a roster seat condition on the other-family row listing providers, so a lead with no roster never opens t3-seats.md to find out. Where a child runs step 5 names agents/<name>.md itself, so a verifier child needs no second file. The pointer also states the reply line for an empty other-family row, which a lead with no roster still writes.

Claude is the only lead

  • pstack. pstack's text uses Cursor names, and its one adapter, pstack/docs/harness/claude-code.md, maps them for Claude Code. It maps no other host's names.
  • orbit. Claude, through Claude Code, is the only lead. The rules skill tells a lead that is not running in Claude Code that orbit leads only under Claude Code, and stops. Codex, Grok and other families run only as panel seats on another family and as the verifier seat, through delegate_task (Seats on another family). /orbit:start uses only Claude's task tools, and /orbit:setup no longer links Codex or checks what Codex and Grok load (Setup).
  • Why. The user decided on 2026-11-20 that leads on providers other than Claude made orbit hard to manage. Rules carried a fork on the lead's provider, with its own tool names, model defaults, load path and reading rules. Seats on other families stay, because a second family still checks a Claude author's work. Before 0.70.0, Codex and Grok could lead a T3 thread through a second adapter file, and docs/trails/ keeps that history.

Commits

  • pstack. No actor named. "Commit liberally" (playbooks/feature.md step 4). "Rebase into small, ordered commits" (feature.md step 6) and "Rebase into small, landable commits" (opening-a-pr.md). Bodies follow /technical-writing.
  • orbit. The parent reviews each unit, then orbit:gitops commits it by path, with a subject and a body that says why, under technical-writing (agents/gitops.md). Unpushed fixes fold in with fixup and autosquash. Feature step 6 and refactoring step 8 keep pstack's rebase into small, ordered commits. gitops runs it before Shipping, with fixup and autosquash on unpushed units, and never rewrites a pushed commit. Refactor commits land in step 8's order, and bug's failing repro is its own unit before the fix.
  • Why. Review comes before commit, and git output stays out of the main context. Orbit once dropped the rebase step on the grounds that units committed in order leave nothing to rebase. Fix rounds and parallel units still leave commits worth folding, and the user asked to "club all 3 commits into one so i can see overall changes" (transcript audit, 2026-11-10). So the step matches pstack again. A pushed commit stays, because rewriting it takes a force-push.

gitops agent

  • pstack. No git agent. The working agent commits and runs the forge.
  • orbit. agents/gitops.md runs every commit, push, rebase and forge write, with model: sonnet and effort: low. A gitops row in the project's Models table can change either (Model per role). It never deletes a branch, except in shipping step 7, where it removes the worktrees still left for a landed branch by absolute path from its starting directory, never through cd or -C and never with --force, and deletes the branch. It never switches, merges or fast-forwards that starting checkout, which is the user's. In T3 the lead removes each settled child's worktree first, as the adapter says (Shipping). Its tools add ToolSearch and three named T3 tools, link_pull_request, link_pull_requests and list_thread_pull_requests. Before linking a PR it checks for the link tools per the adapter's probe (T3 Code host), and that check gates only the link. When they are present, gitops links each PR it creates, takes over or pushes to, as its next call, with link_pull_requests for several. It skips PRs it only reads or reviews and says when linking fails. Asked to wait on CI, on every host, it runs orbit's watch-pr once with --once and reports the verdict and reason. After PR work its last line is PR <full URL>, head <SHA>, checks and reviews <state>. It never runs gh pr checks --watch. It waits this way even when the lead's brief names another command or a re-check loop. On a conflicted cherry-pick it runs git cherry-pick --abort before it reports.
  • Why. Orbit-only agent, so no pstack model applies. Git and gh work is routine, so it runs on a cheaper tier than the session by default. The cleanup exception lets gitops run the step it would otherwise stop at. In the ship cleanup eval at d840cd4 (2026-11-19), gitops removed a worktree through cd <root> && git worktree remove and the worktree guard refused it, while a git worktree remove <absolute path> with no redirect went through (Shipping). T3 tools are deferred, so gitops needs ToolSearch to load them. In the T3 probe lane on 2026-11-16, gitops with this tool list loaded and called list_thread_pull_requests, and ${CLAUDE_PLUGIN_ROOT} expanded in its body, so the watcher path resolves. Naming three PR tools keeps gitops off T3's thread, schedule and preview tools (inferred). The wait was watch-pr --timeout 120, which sleeps between polls for up to 120 s. T3's runtime rule (runtimeInstructions.ts line 3 at c2eb8f3) says "Delegated children never watch, even if the brief says babysit." and "For PR waits, no sleep, loops, gh --watch, Monitor or ScheduleWakeup." So gitops makes one --once read, which never sleeps and needs no Bash timeout. The last line is the same rule's "After PR work, a child's last line is: PR , head , checks and reviews ." The link rule follows the same line (T3 Code host). gitops reports once and returns, so the lead, which stays in the thread, owns any longer wait (inferred). In one T3 lane the lead named gh pr checks and a periodic re-check in its brief, and gitops never probed and slept in a loop between checks (T3 lane, 2026-11-16). When the brief named no command, gitops probed and ran watch-pr once. The old absent branch ran gh pr checks --watch and ran it again when the watch timed out, which is the loop shape that lane caught. pstack has no gh pr checks --watch. Its babysit waits on GitHub CI with the watcher (playbooks/babysit.md), and a code search of cursor/plugins finds the command only in cursor-team-kit, outside pstack (2026-11-16). So gitops waits the same way on every host, and rules.md Host tools. has the brief name the PR, not a command. A cherry-pick left in progress would block the lead's serial rerun of the unit on the task head, so gitops aborts it (P7 review, 2026-11-17).

Commit trailers

  • pstack. No such hook. pstack ships no hooks (pstack/plugin.json).
  • orbit. A PreToolUse hook on Bash (hooks/no-claude-trailer.sh) refuses a git commit or git commit-tree at command position whose command, or the message file -F/--file names, holds a Co-Authored-By: Claude trailer, and tells the agent to commit again without it. A command that only mentions both strings passes. It never reads the description.
  • Why. Agents added the trailer despite an empty attribution.commit and gitops's "No trailers". Leads copied it into briefs, and later agents copied it from git log, so the text rule didn't hold. A hook holds it structurally (principle Encode Lessons in Structure).

Model per role

  • pstack. setup-pstack writes ~/.claude/rules/pstack-models.md (docs/harness/claude-code.md). Flows name a model slot each, such as "your configured feature model (default claude-opus-5-5-xhigh-fast)" (playbooks/feature.md) and "your configured hillclimb model" (playbooks/hillclimb.md). The defaults are "Code, prose, and judgment: claude-opus-5-5-xhigh-fast" and "Trivial mechanical edits: claude-opus-5-5-high-fast" (poteto-mode/SKILL.md Subagents). The adapter maps a Claude slug to its model and effort and says "Drop -fast". "A gemini-* or other non-Claude slug" maps to "Omit model so the agent runs on the session model, and say so." "Verification always runs on the swarm workers model, claude-opus-5-5-high-fast by default." The adapter's setup step says "Never put the role lines in CLAUDE.md or AGENTS.md." de8ee15's defaults were "grok-4.7-xhigh-fast for code, claude-opus-5-5-xhigh for prose and judgment", and the hardest changes went "to your strongest judgment model".
  • orbit. A ### Models table in the project's Workflow block replaces most of pstack-models.md, with | Task | Use for | Model | Effort | rows (rules.md Workflow Defaults, Models). The user file ~/.claude/rules/orbit-models.md holds rows in the same format, and /orbit:setup writes its other-family and verifier rows (Setup). Each cell comes from the project's table, else from the user file, else the default. The per-flow slots become per-unit work types that the project names, such as shader-math or data-tuning. The Delegate gate runs each code delegate on the work type whose Use for fits its unit, at that row's model and exact effort. A work type's cell may add , <value> after <n> failed tries. A failed try is a delegate whose work fails review or the check, or that crashes or returns nothing. Parallel attempts count no tries, and each part of a split unit starts at zero. A unit that fits two work types splits when each part verifies on its own, else runs as the type of its hardest part, and row order breaks a tie. A unit that turns out to fit another type is re-briefed under it, and its try count starts over. With no work types, or none that fits, a prose delegate (docs, written explanations) runs on the judgment role and code delegates tier by difficulty. The hardest run with model: "opus" (the judgment role). Trivial mechanical edits run on the code role, and so does every other delegate unless the project's code row is sonnet or haiku. Then the rest run on the session model. The lead's reply names each unit no work type fit. Six Task names are orbit's roles. other-family is a panel seat on another family under T3 Code (Seats on another family). Its empty Model runs the skill's own seat, and the reply says that none is configured. inherit keeps the session-family seat. Otherwise its Model is an ordered list of <providerInstanceId> or <providerInstanceId>/<model> entries, which tries at most three listed providers outside the parent's family, in list order, as pstack's arena cross-judge pool does. inherit may end the list (Ranked providers). A bare <providerInstanceId> takes that provider's first eligible model. judgment defaults to opus. It is every spawn a skill names with model: "opus" or as the judgment model, such as interrogate's first adversary, arena's first runner, autopilot owners and the how explainer. A skill's model: "opus" names that role, so it is not a step's own model. code defaults to inherit. It is interrogate's second adversary, arena's second runner, swarm workers, recall's source investigators and every spawn no role or work type covers. gitops, verifier and advisor default to their agent's frontmatter model and effort, and rules.md Delegation hands gitops its row's model and effort when the table has a gitops row. orbit:comment-sicko takes no row and runs on its frontmatter, so a code row doesn't move it. Panels name their roles, so they never take a work type. The lead passes the resolved model as the Agent call's model, which overrides the agent's frontmatter, and inherit omits it, so the spawn gets Claude Code's default subagent model (CLAUDE_CODE_SUBAGENT_MODEL when set, else the session model). A step that names its own model or effort keeps it, such as recall's haiku and the trail reviewer. rules.md's "Match the model to the job" passes an effort a step or row names as written, and otherwise picks one for the job, with no speed. The bug, feature, refactoring, perf and hillclimb playbooks point pstack's line at rules.md, as "Pick each subagent's reasoning level for the job, per the Delegation section of rules.md." Their delegate steps drop pstack's configured <flow> model (default ...) slug for the Delegate gate. swarm and arena reword it to pick each worker's or runner's effort per "Match the model to the job". interrogate runs arena's step 3 and sets each adversary's effort to high (Review). how and show-me-your-work drop it, and why and reflect spawn nothing. The verifier takes the verifier row, not the code model, and keeps its own effort: high when the row names none. agents/poteto-agent.md carries effort: medium and agents/comment-sicko.md carries effort: medium, which pstack's agent files don't. The lead still picks poteto-agent's level, so its frontmatter only catches a missed pick. The verifier row's Model may also be other-family or other-family, inherit. Under T3 Code with a roster, the lead then fills each PR's verifier as a seat on another family, picked as the other-family row picks its seat. When no candidate is left, it runs the native verifier only if the verifier Model is other-family, inherit, and otherwise asks the user or holds the PR (Independent verifier). /orbit:setup writes that row as other-family, inherit or other-family, from the user's answer to its second question. With no such row, the verifier keeps its frontmatter. No other row takes a provider list, so the other-family row stays the one cross-provider list. A spawn that fails because its model is unavailable or at its usage limit retries once on the session model, and an orbit:advisor on Fable retries on Opus. No native spawn moves to another provider.
  • Why. At de8ee15 the adapter's setup defaults mapped to opus xhigh and to inherit-parent for every grok role, which is orbit's judgment default of opus and code default of inherit. pstack's 17 role lines then held only those two values by default, so two roles, judgment and code, carry every default, and the prose and judgment lines took judgment. e1cc031 cut the role lines to nine, moved every default to an Opus 5.5 -fast slug at xhigh or high, and gave the panels Fable and Gemini seats. Orbit drops that routing and keeps its two roles (Effort ceiling, Panel seats). A table in the project's AGENTS.md travels with the repo and sets the mapping where the project's cost and quality tradeoff lives. The adapter keeps one user's model picks out of the repo (inferred), and orbit's table holds the project's own work types, which belong in the repo. Which T3 providers a user has enabled is the user's, not the project's, so the other-family choice also lives in a user file, as pstack's model rule does, and a project row still wins. Per-unit work types are the user's call, 2026-11-07. Task is the user's word for a row's name. "Work type" names the project's rows, so they don't clash with the playbook's task types (bug, feature) or with orbit's roles. inherit is Claude Code's frontmatter value for the session model. Claude Code has no Auto model, so pstack's inherit-parent and auto become one value. The after <n> failed tries step and the re-brief came with the work types (5a3d474), with no recorded reason. A unit moves to a costlier model or effort only after the cheaper one has failed on it, and a re-briefed unit runs under its new row's cells, so tries under the old row don't count (inferred). comment-sicko has no line in setup-pstack, so it gets no row. One flow mixes kinds of work, so a bug fix can need shader-math for its fix and docs for a doc unit, and a per-flow slot can't tell them apart. The verifier takes its own row because the user named it as its own role, so a cheaper code row doesn't move it. pstack sends "Trivial mechanical edits" to "your fast code model" and leaves the middle tier to each playbook's line. Orbit has no playbook lines, so a cheaper code row once took every delegate short of the hardest. The user said "never code with sonnet unless its very small" (transcript audit, 2026-11-10), so a sonnet or haiku code row now gets only the trivial edits. The guard first compared the code row's price with the session model's. In a Fable session an Opus code row counts as cheaper, so that test sent every delegate short of the hardest back to Fable. Naming sonnet and haiku keeps the guard on the user's reason and lets a Fable lead's code run on Opus (Fable lead). Claude Code has no per-spawn speed, so the fast-mode rule is dropped. The routing eval (tests/routing/run.mjs) caught leads that passed no effort, gitops in 2 of 3 runs and comment-sicko once, so every orbit agent's frontmatter now holds a level the spawn falls back to. poteto-agent's level moved from high to medium on 2026-11-11. The user said "in most cases: for coding opus 5.5 medium is good enough" and "allow poteto-agent to run high if the task requires it". A missed pick on a hard unit now runs at medium, which the user accepts. other-family is its own role, not the code row moved to the roster. The T3-native plan's Appendix B rejects that move, because code also covers code delegates, swarm workers and live lanes, and a child on another provider loads no orbit rules. The name follows pstack's "another family". The operator asked on 2026-11-16 to default to the current agent for most work, unless more providers add real value, and named the verifier as the one helper that prefers another family. pstack keeps verification on the swarm workers model. That was a grok slug by default at de8ee15, so a Claude lead's verifier ran off its family there too. e1cc031 moved the default to claude-opus-5-5-high-fast. The advisor plan gate (2026-11-16) ruled out per-row fallback lists. Their , separator collides with , <value> after <n> failed tries, setup cannot know the lead's family, and a project cell overrides the whole user cell. The same verdict kept native fallbacks on the lead's provider, because moving gitops or a half-finished code child to another provider loses its hooks, its tools limit and the worktree guard. The retry on an unavailable model departs from T3's system prompt, "Provider or model unavailable: say so. Never switch unasked or fall back to native tools, Workflow or CLIs." (orchestrationInstructions.ts:10 in pingdotgg/t3code at c2eb8f3). It switches the model unasked. Orbit keeps it only for native Agent spawns, keeps each spawn on its provider, and has the reply name the model that ran, so the switch is said. A seat on another family never retries this way. It moves only to the next entry the user listed, and otherwise skips or asks (Ranked providers). Without the retry, a Models row whose model is at its usage limit would stop every spawn on that row until the user edits the row (inferred).

Ranked providers

  • pstack. No provider ranking and no cap. The arena cross-judge pool line lists slugs in order, and "The judge is never from the parent's vendor". When a slug fails, arena uses "the nearest valid slug of the same family, then the next such entry, or skip the judge, and say so." (skills/arena/SKILL.md)
  • orbit. The host adapter resolves the other-family Model cell to one of four outcomes in one table. An empty cell or no row runs the session-family seat, and the reply says that no seat on another family is configured and that /orbit:setup lists providers. inherit runs the session-family seat. A list gives at most three candidates, one per providerInstanceId, in list order. A candidate's provider is outside the session's driverKind, is enabled, can run a cross-provider child task, lists models and, for a seat that runs commands, offers the parent's runtime mode. Its model passes the family check, which runs before the listing check. The check splits the model's id at -, /, . and :, and refuses a token that equals the session's family word or names its vendor, anthropic for claude, openai for gpt and xai for grok. That word is inheritedModel's, else, for an alias such as opus, that of the session provider's first model whose id holds the alias as a token. With neither, the session's family is unknown, no entry fails the check on that ground, and every seat says family unverified. auto and default are opaque. A bare entry takes one only when every model its provider lists is opaque, and that seat says family unverified. The lead tries the candidates in order for one seat and never tries a fourth. When every candidate fails, the seat is skipped with the line Skipped <skill>'s seat on another family: every listed entry failed., and only a list that ends with inherit runs the session-family seat. The verifier never skips. With no inherit in the verifier row, the lead asks the user before a native verifier runs, or holds the PR when no user can answer. Setup's question about that inherit recommends no. /orbit:setup recommends the first three enabled providers ranked Codex (codex), Muse (muse), Gemini (gemini), then Grok (grok), and by providerInstanceId within a kind. Setup names a typed entry that falls after the third outside the session's family, says that a seat tries it only when an earlier entry fails the seat's checks, and accepts the list. The ranking lives only in that recommendation.
  • Why. T3's system prompt for every thread says "Provider or model unavailable: say so. Never switch unasked or fall back to native tools, Workflow or CLIs." (orchestrationInstructions.ts:10 in pingdotgg/t3code at c2eb8f3). Before this change, an empty cell filled the seat from a provider the user never listed, and a failed list fell back to the session's family without asking. A provider the user listed counts as asked (prod-ready plan, Appendix B row 2), so the list is the roster, and a trailing inherit is the user's written yes to the native fallback. Setup first recommended yes to its native verifier question, on the advisor's call, so that a PR would not wait on the user. The operator replaced that default with no, the strict reading of "Never switch unasked or fall back to native tools" (operator, 2026-11-17). With no, a PR whose listed verifiers all fail holds and the lead asks. A skipped seat follows pstack's arena, which skips its judge when no entry is left. The same prompt says "Every new delegate review or re-check is a new delegate_task (brief, findings, objections), never a t3_thread_send." (line 11), so t3_thread_send only answers or steers a running child. Issue #27 on aayushbtw/orbit found that driverKind is not the model's family. An aggregator of another driverKind can serve the session's own family, and a model named default says nothing about what it runs, so the check reads the model's id. Issue #28 asked setup and the runtime cap to agree, so both count the first three entries outside the lead's kind. The runtime counts candidates after each seat's checks, so a later entry runs when an earlier one fails them, and setup names that entry instead of refusing it (adversarial review, 2026-11-17). The session's family word once came from inheritedModel and from every model the session's own provider lists. An aggregator lead lists several families, so that rule refused every seat (adversarial review, 2026-11-17). The operator asked to rank providers, keep at most three, and named the order Claude, Codex, Muse, Gemini, Grok (2026-11-17). Claude left the ranking when it became the only lead (user decision, 2026-11-20). A live orchestrator_capabilities result on 2026-11-17 listed Muse with driverKind muse, disabled, and no Gemini provider, so the gemini id is unverified. In the same result fx, kiro and pi listed only default. A model id such as openai/o3 has no family word, so a gpt-family session once passed it through the family check although OpenAI serves it. Mapping three vendor names to their family words was a one-clause change, smaller than a new family unverified case for every vendor prefix, and it agrees with the lane grader (P9 review, 2026-11-17). Live T3 lanes under a Claude lead on claude-opus-5-5 ran four cases (tests/t3/fixtures/). seat-empty and seat-all-fail ran at 41b1c74, and seat-listed and verifier-all-fail ran at 31ee0b3. Untested live: the inherit outcome, a list that ends with inherit, the family check against an aggregator or a vendor prefix, the cap, the verifier's hold with no user, and setup's ranked recommendation and second question.

Setup

  • pstack. setup-pstack detects the model slugs a Task can take, loads pstack-models.mdc when it exists, asks for a budget, shows every role and asks to accept or change roles, validates each slug against the detected set, overwrites the whole file "so re-runs stay idempotent", and tells the user it "applies to new sessions" (skills/setup-pstack/SKILL.md). The Claude Code adapter writes ~/.claude/rules/pstack-models.md with no frontmatter, because "Claude Code loads every .md file in ~/.claude/rules/ into each new session", and says "Never put the role lines in CLAUDE.md or AGENTS.md." Steps 7 and 8 offer verification skills.
  • orbit. skills/setup (/orbit:setup), orbit's text with no skills.json entry. Setup runs on any host, and only its T3 provider step keeps setup-pstack's shape. Its first step runs skills/setup/scripts/doctor.sh, a read-only script that writes no files, needs no network and always exits 0. The doctor checks git, gh and its login, node, bun, jq, the git repo and origin/main, the Workflow block and install drift. setup-pstack has no such check. Each change that setup could make becomes an offer. Setup asks about every offer in one multi-select question at the end and changes nothing without a yes. It drops the budget, the role list and the verification-skill offers. docs/setup.md, a doc an agent followed to install orbit per provider, is gone. When the install record's version differs from the version of the folder Claude Code installs orbit from, setup offers claude plugin marketplace update and then claude plugin update. That folder is the marketplace's installLocation joined with the plugin's source. With no install record, as under --plugin-dir, setup skips the drift check. In a git repo with no Workflow block and no vpr, setup offers a filled block from skills/setup/workflow-block.md for the root AGENTS.md, never CLAUDE.md. The lead finds the project's Check command in the root package.json scripts or Makefile and never runs it. The template moved there from templates/workflow-block.md, which now only points to it. The T3 provider step runs only when orchestrator_capabilities is present per the adapter's Probe. Otherwise setup prints a skip line and goes on. The step keeps setup-pstack's detect, load current state, show and confirm, validate, write and confirm. It shows every provider, enabled with its models or disabled, and marks the session's family. It asks two questions in one call, with no budget and no other role. The first asks which providers in order fill the other-family seat, and recommends the ranked list from Ranked providers as fallbacks for one seat, not several reviewers. The second asks whether orbit may run its native verifier when no listed provider can run it, and recommends no (Ranked providers). Validate checks each entry against the capabilities result, with search for a named model. It refuses a repeated provider and an inherit before the last entry, keeps a trailing inherit it found, and accepts an entry that falls after the third outside the session's family. It names that entry as tried only when an earlier entry fails a seat's checks. The write goes to ~/.claude/rules/orbit-models.md with no frontmatter, one header line and a Models table in rules.md's format. setup-pstack overwrites its whole file. Orbit's write replaces only the Models table and keeps every line outside it byte for byte. It also writes a verifier row when the provider list is not empty, with Model other-family, inherit after a yes to the second question and other-family after a no. An existing other-family row reads as current: no native fallback with the question unanswered, because setup before 0.60.0 wrote that row without asking.
  • Why. The user's goal, 2026-11-16, is one install through Claude Code's /plugin lines, then one command in T3 that saves which providers orbit uses, user-wide, with no per-provider installs. Claude Code has no per-spawn speed or budget knob, and the user caps effort at high, so the budget question has nothing to set. Roles other than other-family already live in the project's table (Model per role). Orbit's other opt-in skills keep disable-model-invocation, and setup writes a user file, so the user types it. Setup once linked ~/.codex/skills/orbit to orbit's folder, checked what Grok loaded and offered an always-on rules line for each, so either could lead. Those steps left with the other leads (Claude is the only lead). Setup once needed T3 Code and stopped without it, so a plain Claude Code user had no way to find a missing tool before a flow failed on it. The doctor runs on every host and checks the tools that orbit's flows call (production-readiness program, P11, 2026-11-17). A verifier saw a lead run bun run check in the user's project before any yes, so setup reads the files that name the Check command and never runs it (verifier, 2026-11-17). Only plugin/ ships, so the template moved into the setup skill, where setup can read it on an installed copy (AGENTS.md). A table-only write is as idempotent as a whole-file overwrite and keeps the user's own lines (inferred).

Effort ceiling

  • pstack. setup-pstack asks for a budget, large, medium or small. "large keeps" each default's effort, "medium lowers it one step, and small lowers it two steps", and "No role runs above xhigh" (skills/setup-pstack/SKILL.md). poteto-mode's Subagents section defaults "Code, prose, and judgment" to claude-opus-5-5-xhigh-fast and panels to "claude-fable-5-2-high, claude-opus-5-5-high-fast, and gemini-4-neon-xhigh". "Raise any other role one step, up to xhigh, for the hardest or subtlest work, lower it one step for judgment, and two or more steps for routine work." "Opus 5.5 always runs its -fast slug." "Fable 5.2 is an exception. It runs outside a panel only when the user named it for this task or two Opus 5.5 xhigh runs of the same brief failed its check." If the tool rejects a slug, "never pass it again", fall back through the role's line or default, and "Say so." (poteto-mode/SKILL.md Subagents)
  • orbit. No budget setting and no starting level to step from. rules.md's "Match the model to the job" has the lead pick high for hard and judgment work, medium for a code writer even on a small change, low only for an edit that writes no logic (a typo fix or one fixed line), and medium or low for other routine work. It passes xhigh or max only when a step, a Models row or the user names it. A spawn that runs on Fable gets medium or high, never low. The verifier's frontmatter runs at high. If the Agent tool rejects a level, the lead tries no other level, uses the row's level or the agent's default, and says so, as pstack does. rules.md Delegation keeps the de8ee15 Subagents text with orbit's edits. It names no -fast slug, no xhigh default and no limit on Fable. Its Writing the reply section stays whole, plus one link bullet (File links) and less the bullet that Final reply cut. Comments moved to rules-shared.md (Shared rules).
  • Why. The user found xhigh not worth its tokens, 2026-11-07, and said it again on 2026-11-11, "do not use xhigh use max high when u need it". pstack's ladder starts every role at xhigh, so orbit names the levels directly instead of steps from it. The Models table already lets a project name xhigh where it pays off, so a budget knob adds nothing. The Fable floor is the user's rule, "dont use low fable" (2026-11-11). e1cc031's Opus-first routing (poteto-mode hunk 2) starts code, prose and judgment at xhigh, which breaks that ceiling. It also runs code on Opus 5.5 at xhigh, where the user said "in most cases: for coding opus 5.5 medium is good enough" (2026-11-11). Its Fable exception would bar the advisor, which runs on Fable at every plan gate (Plan gate). The same hunk cut Writing the reply to one paragraph and removed Comments, which orbit's rules.md keeps, so the hunk stays out whole (P13 review, 2026-11-17). "Medium or low for routine work" let Claude leads pass low to every code delegate in the live matrix at 34fdaae (code-child, foreground and parallel-units lanes), so a code writer now gets medium per the user's line. At cfc882d the Codex parallel-units lead still passed low to both implementation children, because it read a small new module (min.mjs or max.mjs with a node:test test) as a trivial mechanical edit. So low now covers only an edit that writes no logic, such as the typo fix in autopilot-owners or the one fixed line in code-child and foreground (#71).

File links

  • pstack. Writing the reply names no link form. "Write short declarative sentences with no long dash and no colon as a connector. Lead with what changes for the user. Give each claim its evidence or a label (measured, inferred, or guess). Never hand the human a check you could run." (poteto-mode/SKILL.md)
  • orbit. rules.md Writing the reply adds one bullet after "Never fabricate", "Embed images, video and audio with Markdown image syntax and an absolute path. Link every other file you cite or produce by its absolute path, as in [http.ts:42](/abs/path/http.ts:42)." It holds on every host.
  • Why. T3 asks for that form in every thread. Its runtime prompt says "You can embed images, video, and audio using Markdown image syntax with absolute file paths. Link every other file you cite or produce by its absolute path, as in http.ts:42, so the user can open it in T3 Code's files viewer." (runtimeInstructions.ts:23 in pingdotgg/t3code at c2eb8f3). rules.md holds one rule for every host, so a plain Claude Code reply carries the same links.

Final reply

  • pstack. Writing the reply is one paragraph. "Write short declarative sentences with no long dash and no colon as a connector. Lead with what changes for the user. Give each claim its evidence or a label (measured, inferred, or guess). Never hand the human a check you could run." (poteto-mode/SKILL.md) pstack has no rule that keeps every section a playbook's reply names, and no fixed shape for the final reply. Each playbook's Reply: lists what its reply holds.
  • orbit. rules.md Task End holds a Final reply paragraph. The final reply has four parts, in order. They are the outcome in one or two sentences, the closed task list for a multistep plan, an always-present Heads-up: list, and the Next: line. The outcome restates the goal, says whether it is met, and gives the PR link or the landed commit. Checks that passed get one clause there. Heads-up: lists, worst first, a part of the goal not done, a skipped or waived step, a check that failed, did not run, passed with parts unverified or ran on a fallback, an unasked behavior change or accepted tradeoff, anything left behind, a problem outside the goal or a dismissed finding, and a reversible call made in the user's place. With none it reads Heads-up: nothing skipped, failed or left behind. What ran as planned stays out of the reply, and under Land pr the PR body holds it. When no PR opens, what a playbook or Non-negotiables sends to the PR body goes between the outcome and Heads-up:. A Reply: item that is the result itself, such as an answer, a number, a path, a plan or a status per PR, goes there too. Any other Reply: item that ran as planned goes in the PR body, or in that slot when no PR opens. Writing the reply drops orbit's "Terse is not an excuse to drop content." bullet, which kept every section a playbook's reply named. Its last sentence now says each playbook's Reply: names what the task reports, and Final reply says where each part goes. The principles that shaped a decision go in the PR body's ## Tradeoffs, or in the reply when no PR opens. opening-a-pr.md and agents/gitops.md widen ## Tradeoffs from only rejected alternatives to also hold those principles. /orbit:start step 3 gives each task list line only the task and its state. The feature, bug and shipping Reply: lines say which item goes in the outcome, which in Heads-up:, and which in the PR body. Bug's repro output goes in a PR comment or file that ## Verification links, per opening-a-pr's log rule. Shipping lists each verdict other than a plain PASS with its notes. docs/harness/t3-seats.md and t3-code.md name a seat's model only when it fell back.
  • Why. The final reply joined the feature, Opening a PR and Shipping Reply: lists, and the Terse bullet forbade cutting any of them. On a PR of UI fixes the final reply ran about 30 lines, with a goal restatement, a detailed checklist, "How it was checked", "Process notes" and "Cleanup". The user called it noise and said "it should show important stuff: what it didnt do, anything important, info that user should know, nothing should fail silently" (user, 2026-11-20). The Heads-up: line is always present, so a skip, a failure or a fallback never drops out silently. The PR body already holds the detail for a reviewer.

poteto-agent model

  • pstack. model: claude-opus-5-5-xhigh-fast in the poteto-agent frontmatter (agents/poteto-agent.md).
  • orbit. agents/poteto-agent.md has no model key and sets effort: medium. Each delegate runs on the model its work type or role resolves (rules.md Workflow Defaults, Models), at the effort the lead picks per "Match the model to the job".
  • Why. The user caps effort at high (Effort ceiling), and an xhigh -fast slug in the frontmatter would win over a missed pick. Orbit's Models roles, not one fixed slug, choose each delegate's model.

Agent call defaults

  • pstack. "run_in_background: true, agent mode (readonly strips MCP), file pointers not inlined context" (poteto-mode/SKILL.md Subagents).
  • orbit. rules.md Delegation keeps agent mode and file pointers. Agent mode is general-purpose or an orbit: agent, not Explore. pstack's run_in_background: true drops out. When any mcp__t3-code__ tool is in the tool list, every Agent call passes run_in_background: false, and parallel spawns go as several calls in one message. On other hosts the call passes no run_in_background. The T3 adapter's Task row says the same (T3 Code host). Models follow Model per role.
  • Why. The adapter maps readonly: false to general-purpose, which keeps the session's MCP servers, and readonly: true to Explore. It omits run_in_background: true because subagents run in the background by default. T3 forbids that default. Its system prompt says "Subagents: use your native tool when the child uses your provider, a model it offers and no settings beyond yours (Claude Agent, run_in_background:false; Codex spawn_agent, then wait). Use delegate_task for another provider's model, user-asked settings, a separate checkout (isolation:"worktree"), or delegate_task by name. A native type on another provider's model counts too. Background agent: delegate_task, never a background Agent. Workflow only when asked." (orchestrationInstructions.ts:9 in pingdotgg/t3code at c2eb8f3). The rule sits in rules.md, not only in the adapter, because rules.md is in context before the adapter is read, so a T3 session's first spawn follows rules.md alone. The rule holds only in T3, because the lead waits for every call in a foreground batch before it can act again. In plain Claude Code that wait would stop autopilot-full's root from firing its /loop tick, its code-ready swarm and a stuck-owner replacement while owners build. In T3, a child that needs its own checkout or runs while the lead keeps working is an async delegate_task child, so rolling starts, the code-ready swarm and the tick hold there too (Own-checkout children).

Own-checkout children

  • pstack. Children that need their own checkout or run beside the lead are Cursor cloud agents. Swarm spawns its workers "with subagent_type: generalPurpose, environment: "cloud", run_in_background: true" (skills/swarm/SKILL.md). In autopilot-full, "Each owner is a Cursor cloud agent" (playbooks/autopilot-full.md step 2). Arena gives each candidate "a git worktree where possible" and spawns them all "with run_in_background: true" (skills/arena/SKILL.md). The Claude Code adapter maps environment: "cloud" to isolation: "worktree" (docs/harness/claude-code.md).
  • orbit. The T3 adapter's Where a child runs table (plugin/docs/harness/t3-code.md) picks how each child runs, by what the child needs. Its three columns are a T3 lead with delegate_task, T3 otherwise (the agent is a child or a subagent, or delegate_task is off), and not T3. A child that shares the lead's checkout is a foreground Agent with no worktree in all three columns. That row holds the read-only children, such as the how explainer, the advisor, judges on the session's family, audit and verify lanes, and swarm workers that only read, plus gitops, serial delegates, small review fixes, comment-sicko, and an owner's fix, rebase and merge rounds, which work in the owner's worktree. A read-only lane reads a SHA through git show or a git archive -o export, never through a checkout of its own. A child that needs its own checkout is a parallel delegate, an arena runner, an interrogate adversary, a swarm worker that writes, or the native verifier. Under a T3 lead with delegate_task, it is a same-provider delegate_task child. In T3 otherwise, its units run one at a time in the agent's own checkout, never as an Agent with isolation: "worktree" and never in a worktree made in the shell. Outside T3, Claude Code runs it as an Agent with isolation: "worktree", where the delegate commits its own unit and gitops cherry-picks it, as in T3. A child that runs while the lead keeps working is an autopilot owner's build round. Under a T3 lead with delegate_task, it is a same-provider delegate_task child too. In T3 otherwise, owners run one at a time in the foreground, and the reply says the tick cannot fire while one runs. Outside T3, owners stay Agent calls with isolation: "worktree", rolling under the Parallel cap. Panel seats and the verifier seat on another family keep Seats on another family. No T3 lane calls Agent with isolation: "worktree". The lead calls orchestrator_capabilities once per thread before the first delegate_task, and probes delegate_task, task_status, task_cancel and t3_thread_organize. Each call passes a target with the lead's inheritedProviderInstanceId, the model the spawn's Models role resolves and its effort as the model's effort option, else options: []. It also passes isolation: "worktree", mode: "async", a role (implementation for writers and owners, review for adversaries, test for the verifier), a title that names the skill and the unit, and no runtimeMode. Its clientRequestId is <skill>-<unit>-<short base sha>-try<n>. A retry of the same call after a tool error or a lost response reuses the id, and a new try or round takes a new one. Before the spawn, the lead commits what the child needs on the task branch. Each brief names the start SHA, the task head, or for an owner or other work off trunk the SHA of origin/<trunk> after a fetch, or for an owner stacked on another PR that PR's tip. It also names the lead's checkout and the project root. The child's first command is git rev-parse --show-toplevel, and when it prints either path the child stops and reports without moving HEAD. Next it runs git reset --hard <start sha>. A verifier or adversary checks out the SHAs its brief names instead. A brief to an orbit: agent names the agent file, agents/<name>.md, and the plugin folder, and states the agent's tools limit. A general-purpose child, such as an owner, a swarm worker or an adversary, gets the plugin folder and the playbook SKILL.md path instead. Every brief says "You are a subagent of this thread. Start no child thread." An owner's build round is its only child. Its brief allows native foreground subagents and drops the babysit loop and the merge-ready stop. Under Land pr the owner pushes, opens its PR, reads its state once with watch-pr --once, and ends with PR <url>, head <sha>, checks and reviews <state>. The owner never watches a PR, and the root runs babysit on it in drive mode. The child commits its unit by path in its own worktree and reports its pwd, branch and commit SHA. The lead neither waits nor polls, works on while other work is left, and ends the turn when none is left. The child's completion brings the wake. With a turn running, the wake arrives inside that turn, beside the next tool result. With no turn running, the wake is a new run after the turn ends. A wake that arrives in the middle of a step, such as a review or another child's cherry-pick, waits until that step is done, and the lead handles each wake once. On the wake, the lead reads task_status. A workState other than result_available means the child still runs, so the lead neither reads nor settles it and waits for its wake. At result_available the lead checks git merge-base --is-ancestor <start sha> <sha>, and reviews git show <sha> from its own checkout. A commit that does not descend from the start SHA is a failed try, never cherry-picked. gitops runs git cherry-pick <sha> in the task worktree. On a conflict, gitops runs git cherry-pick --abort and reports, and the lead reruns the unit serially on the new task head as a native orbit:poteto-agent. Then the lead settles the child with t3_thread_organize and runs git worktree list. The lead, not gitops, removes a child worktree that remains with git worktree remove <path>, and its branch with git branch -D <branch> when its tip is the picked commit. A fix round after the cherry-pick is a native orbit:poteto-agent in the task worktree. Only a full redo of the unit is a new delegate_task, with a new id, and it counts one failed try. A stuck child gets task_cancel before any replacement, and "run fewer" or "no delegate" cancels the extras and starts none. Until a child's wake, the tick judges it by its trail and its git side effects, never by task_status. The lead settles an owner's build child and keeps its worktree. Each later round of the role, a fix, a rebase or the merge round, is a foreground Agent in the lead's thread with no isolation and no EnterWorktree, briefed with the owner's worktree path and branch. It is an orbit:poteto-agent on the judgment model for code, or orbit:gitops for git and forge work. Only when git worktree list no longer shows that worktree is the round a fresh child, whose brief runs the same guard, then git switch -C <branch> <head sha>, and stops and reports, never forces, when another worktree holds the branch. Inside a child, units that need their own checkout run one at a time.
  • Why. T3's system prompt for every thread (orchestrationInstructions.ts in pingdotgg/t3code at c2eb8f3, read 2026-11-17) sets five rules for children. Line 9 says "Subagents: use your native tool when the child uses your provider, a model it offers and no settings beyond yours (Claude Agent, run_in_background:false; Codex spawn_agent, then wait). Use delegate_task for another provider's model, user-asked settings, a separate checkout (isolation:"worktree"), or delegate_task by name. A native type on another provider's model counts too. Background agent: delegate_task, never a background Agent. Workflow only when asked." Line 10 says "Call orchestrator_capabilities once per thread, before the first delegate_task. Again only after an error or a user-named provider change. Settings go in target.options. Provider or model unavailable: say so. Never switch unasked or fall back to native tools, Workflow or CLIs. Never make a child's checkout in the shell or in task." Line 11 says "Every new delegate review or re-check is a new delegate_task (brief, findings, objections), never a t3_thread_send. Fix small review findings yourself; start no delegate for them. When told to proceed without a delegate, or to run fewer, task_cancel the extras. Start no replacement." Line 12 says "Follow a running delegate's next. Don't poll it (task_status, sleep, watchers, Monitor, ScheduleWakeup). Stop a delegate run you replace or no longer need with task_cancel, never t3_thread_interrupt on a childThreadId." Line 13 says "As a subagent or child, do the work yourself. Start no subagents unless your task says to." An Agent with isolation: "worktree" is a separate checkout, and an owner that runs while the root works is a background agent, so line 9 sends both to delegate_task. Line 10 rules out a brief that has the child make its own worktree in the shell. Line 11 keeps small fixes native, so an owner's fix, rebase and merge rounds run in the lead's thread and start no delegate. Line 13 keeps a child from starting its own child thread. T3's runtime prompt (runtimeInstructions.ts in pingdotgg/t3code at c2eb8f3) adds "Delegated children never watch, even if the brief says babysit", "For PR waits, no sleep, loops" and "After PR work, a child's last line is: PR , head , checks and reviews ." So the build child reads its PR once and ends on that line, and the root, which stays in the thread, runs babysit. The operator wants as few threads as the rules allow, because each thread costs attention, so only a child that needs its own checkout or runs long becomes one (operator directive, 2026-11-17). The prod-ready program ran this way. Each owner's build round was a delegate_task child, and each fix, rebase and merge round ran in the root's thread as a foreground orbit:poteto-agent or orbit:gitops pointed at the owner's worktree (prod-ready program, 2026-11-17). T3's orchestrator MCP doc (docs/orchestration-v2/orchestrator-mcp-server.md in pingdotgg/t3code at c2eb8f3, read 2026-11-17) says to "use isolation: "worktree" for a separate prepared checkout from the parent's commit", and "Uncommitted parent edits are not copied." So the lead commits first. The parent's commit there is HEAD of the parent thread's bound worktree, else of the project root, and delegate_task takes no base ref (OrchestratorMcpService.ts in pingdotgg/t3code, about lines 2809-2836, read 2026-11-20). EnterWorktree does not move T3's binding. In three child-base --root lanes at 7686e86 (2026-11-20), all six children of a thread opened on the project root started at the root's commit, without the lead's committed lib/round.mjs (#88). The adapter had said "The child's checkout starts from your commit." Leads coped three ways. One reran its round after the children stopped, one brief happened to say git merge --ff-only <sha>, and in one the children fast-forwarded on their own. So every brief now pins the start SHA. T3 makes a worktree only when isolation: "worktree" is passed. Without it the child runs in the thread's bound checkout, which for a thread on the project root is the user's own checkout, where the reset would move the user's branch and drop their edits. So the child first checks that its checkout is neither the lead's nor the project root (diff review of #89, 2026-11-20). The child resets its own fresh branch there, because git merge --ff-only fails when the start is not behind the task head (inferred), and because a detached checkout would leave the branch at T3's start, while the lead deletes a child's branch only when its tip is the picked SHA. A child commit off another base would carry that base's history into the review, so it is a failed try. The same doc says "When the result includes next, completion wakes the parent: do not wait on the task or poll it; continue other work, and end the turn when none is left." So the root starts the next owner as one finishes and fires its code-ready swarm and its tick while owners build, which a foreground batch blocked (Agent call defaults). Under a Claude lead, T3 used to deliver the wake only as a new run after the turn ended. pingdotgg/t3code#39528, merged 2026-11-20, changes only ClaudeAdapterV2.ts and its test, and reports one notice in the running turn and no second run. It shipped in T3 nightly 0.1.11-nightly.20261120.4979. A live probe in a Claude lead on that build on 2026-11-20 started an async delegate_task child on Haiku that replied PROBE_CHILD_DONE. The lead ran one Read, and the notice "Delegated task (probe mid-turn delivery) in child thread [completed]: PROBE_CHILD_DONE" arrived beside that Read's result in the same turn. task_status then showed workState result_available with the same summary, and the settle succeeded. The mid-step wait and the rule to handle each wake once are orbit's own reading, so a wake never cuts into a review or a cherry-pick and a handled child is never read again. Two cases are unknown. No run has shown whether a child's pending question arrives mid-turn. A wake while the lead is blocked in a foreground Agent call is inferred to land at the tool boundary when that call returns, and is unprobed. A wake can still find the task unsettled. In pingdotgg/t3code at 966e422 (read 2026-11-20), the task_status description in apps/server/src/mcp/toolkits/orchestrator/tools.ts says "Do not call it on a running task before its completion wakes you.", and the test "finalizes a child whose run ended before %s settled" in apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts (about line 5744) keeps the parent's task open after the child's run ends until the child's background command or nested subagent settles. So a state other than result_available gets no read, settle or poll, and the lead waits for the wake. No live run has shown that state on a wake. The doc also says clientRequestId "derives stable command, thread, and message IDs within the provider session. Retrying the same call returns the same durable work." The id carries the base SHA so that a second run of the same skill and unit in one session starts new work instead of returning the first run's (advisor plan gate, 2026-11-17). A prototype on 2026-11-17 ran a same-provider delegate_task child with isolation: "worktree" on claude-haiku-5-5 from parent commit 1956d10. The child's git rev-parse --git-common-dir was the main checkout's .git, and its tree was clean, without the parent's uncommitted edits. The child committed 024650f, and the parent's git cat-file -t 024650f returned commit, so the lead can cherry-pick it from the shared .git. After the settle, the worktree and the branch were gone (prod-ready plan, Appendix A). The advisor plan gate of 2026-11-17 still made the cleanup idempotent, with git worktree list after the settle and removal of what remains, so the step converges whether or not a settle removes the worktree (P7 trail). Outside T3 the Delegate gate once had gitops commit each kept unit inside the child's isolation: "worktree" worktree. Claude Code 2.1.326's worktree guard refuses that write, " is isolated in the worktree , so its writes are limited to that folder. This path is in a different worktree ()." A headless parallel-units run at 34fdaae worked only because the lead had each child commit its own unit and gitops cherry-pick by SHA, as T3 does, so every host now runs that way (#70). The P7 parallel-units lane on 2026-11-17 needed it. After each settle, the lead's git worktree list still listed the child's worktree, and the lead removed it and the child's branch. In the same lane gitops ran git cherry-pick <sha> in the task worktree for both units with no refusal (tests/t3/fixtures/claude-parallel-units.json). The child commits in its own working directory, and the lead reviews and cherry-picks by SHA from its own checkout, because Claude Code's worktree guard refused git -C into a delegate's worktree (docs/trails/pstack-harm-audit.tsv, 2026-11-10). A fix round runs native because line 11 says to fix small findings without a delegate. The prod-ready root did so for P2, with a native orbit:poteto-agent in the owner's worktree (prod-ready trail, 2026-11-17). The owners' worktrees for feat/t3-seat-selection, feat/t3-pr-waits and feat/t3-delegate-children stayed under ~/.t3/worktrees/orbit/ after their build children returned (git worktree list, 2026-11-17), so a later round finds the worktree there. The prototype above saw a settle remove a unit child's worktree, so the lead checks git worktree list before a later round and falls back to a fresh child only when the worktree is gone. Autopilot step 4 lanes read the code-ready SHA from git archive -o <scratch>/head.tar <sha>, unpacked with tar -xf. Orbit reads line 10 as a ban on a child's checkout, and an export is a folder of files, not a checkout, so a read-only lane needs no thread (orbit's reading, P7 plan, 2026-11-17). The shipping verifier checks out the head SHA and moves HEAD, so it is a child with its own checkout. Interrogate adversaries keep their repros in their own checkout, so in T3 each one is a child too, one thread per adversary (P7 plan, 2026-11-17). The prod-ready plan rejected keeping every child a native Agent with isolation: "worktree", because "it breaks T3's rule that a separate checkout or background work goes through delegate_task" (plan Appendix B row 1). The root applied the advisor's verdict, owners as delegate_task, because the operator said to use the advisor for decisions (prod-ready trail, 2026-11-17). The same row says "If the operator prefers fewer threads over T3 conformance, P7 drops out and the clash goes into docs/pstack-differences.md as a recorded divergence." An operator who asks for no threads reverts this default. The cost is threads. Under a T3 lead with delegate_task, exactly these children become child threads in T3's sidebar: a parallel delegate, an arena runner, an interrogate adversary, a swarm worker that writes, the native verifier, an autopilot owner's build round, and a panel seat or the verifier seat on another family. Every other child is a foreground Agent that shows as a nested node. That covers an owner's fix, rebase and merge rounds, verify and audit lanes, workers that only read, judges on the session's family, the advisor, the how explainer, gitops, serial delegates and comment-sicko. The lead settles each child thread at result_available.

Fresh subagents

  • pstack. "Resume an existing subagent only when the work needs state that lives in it and is costly to move" (poteto-mode/SKILL.md Subagents). de8ee15 said "Resume, message, or queue a follow-up on an existing subagent only when the new work strictly needs state that lives in that agent and is costly to move".
  • orbit. The de8ee15 paragraph in rules.md Delegation, plus one sentence. It stays because poteto-mode hunk 2 stays out (Effort ceiling). A resume means a new agent with the earlier result pasted into its brief. A fresh agent that takes a returned owner's next round first enters the prior worktree (Autopilot-full). Under a T3 lead with delegate_task, that round is a foreground Agent in the lead's thread that works in the owner's worktree by its path, with no EnterWorktree (Own-checkout children).
  • Why. The adapter maps resume to spawning a new agent and pasting the earlier result into its brief. That agent starts in its parent's working directory, not the prior agent's worktree.

Parallel cap

  • pstack. No cap. Swarm says "Spawn all N workers in one message" with environment: "cloud" (skills/swarm/SKILL.md), and autopilot-full says "Run owners in parallel off trunk" (playbooks/autopilot-full.md step 3).
  • orbit. rules.md Workflow Defaults item 5. At most 4 agents that build, test or run the app run at once, and read-only agents don't count. Swarm spawns up to the cap in one message and starts the next as one finishes. Autopilot owners, parallel delegate units and hillclimb, figure-it-out and arena fan-out run under it. Under a T3 lead with delegate_task, they run as same-provider delegate_task children and still count (Own-checkout children).
  • Why. pstack's workers run on cloud VMs, so their count costs the user's machine nothing. Here every agent runs on the user's laptop. The user said "too many parallel agents i told u laptop is heating up bro" and "use 4-5 max" (transcript audit, 2026-11-10). The default takes the low end of that range. A configurable Parallel: key and rules for counting nested agents were tried and dropped on 2026-11-10, because pstack has no such machinery. A project that needs fewer agents says so in its own AGENTS.md.

Machine line

  • pstack. Workers run on cloud VMs. Swarm uses environment: "local" "only when the worker needs access to something on the user's computer" (skills/swarm/SKILL.md).
  • orbit. Every Delegate gate brief and every swarm brief carries one line verbatim, "You run on the user's machine, not a VM. Run the app headless or windowless when the project allows it, and never open a window that takes focus or plays sound unless the user agreed." agents/verifier.md carries the same line.
  • Why. pstack's prose assumes a VM, where a window or a sound reaches no one. Here a launched app takes the user's screen. The user said "stop spawning fullscreen game instances its shifting my screen" (transcript audit, 2026-11-10).

Opus session

  • pstack. Arena's defaults name three runners, Fable, Opus and Gemini, and a judge "never from the parent's vendor" (skills/arena/SKILL.md). interrogate reviewers defaults to the same three slugs (skills/setup-pstack/SKILL.md).
  • orbit. When the Models table resolves code and judgment to the same model, as an Opus session does under the defaults, both interrogate adversaries and both arena runners run on that model. Arena then skips the judge, because no model other than the parent's is left (Arena judge). Panels name their roles, so a work type never changes their model. Under T3 Code with a roster, arena's judge and the other seats on another family run on the roster, so an Opus session keeps a second family unless every listed entry fails (Seats on another family). Without one, the text above holds.
  • Why. This follows the adapter's grok mapping (Model per role). Without a roster, the panel loses its model diversity in that case, and orbit accepts that to stay on the adapter. A project that wants diversity there adds a code row with a different model.

Fable lead

  • pstack. No Fable lead. Its defaults name claude-opus-5-5-xhigh-fast for code, prose and judgment, and Fable "runs outside a panel only when the user named it for this task or two Opus 5.5 xhigh runs of the same brief failed its check" (poteto-mode/SKILL.md Subagents).
  • orbit. The guide's "Run the lead on Fable" (docs/guide/08-make-it-fit.md) runs the session on Fable at high or medium and adds code, judgment and verifier rows on opus with empty Effort cells. Spawns then run on Opus, and the lead still picks their level. The advisor stays on Fable. A variant puts judgment on fable at high to keep a second model in the panels.
  • Why. Orbit's own recipe, from the user's ask on 2026-11-11 to use Fable where it pays off. Anthropic's Fable 5.2 migration guide says early testers had good results with Fable "as the planner and orchestrator for other models", and that "subagents can be a large part of a session's cost". Fable 5.2 costs $8 and $40 per million input and output tokens, and Opus 5.5 costs $4 and $20 (Anthropic's model table, cached 2026-11-03). Empty Effort cells keep the lead's per-unit pick, because a row's effort is exact.

Panel seats

  • pstack. "For panel roles (arena runners, interrogate reviewers) the value is a list, and one subagent runs per entry, alias entries included, so the list length sets the count." The arena judge comes from the arena cross-judge pool list (skills/setup-pstack/SKILL.md). "Pick the runners from the arena runners line ..., by default claude-fable-5-2-high, claude-opus-5-5-high-fast, and gemini-4-neon-xhigh." (skills/arena/SKILL.md)
  • orbit. One list cell, the other-family Model. Interrogate runs arena's default seats as its two adversaries, one on judgment and one on code. Arena, and the arena architect runs for a large or contested design, default to two runners, one on each role. Arena still spawns more runners for several design directions, and every runner runs on judgment or code. Under T3 Code with a roster, each panel gets one seat on another family, the other-family role (Seats on another family). Its list orders the providers to try for that one seat, as pstack's arena cross-judge pool orders the judge's, so its length never sets a count. The seat tries at most three of them (Ranked providers). Without a roster, the judge runs on the first of the two models that differs from the parent's, and arena skips it when neither differs.
  • Why. Every other Models cell holds one model. The other-family list is a preference order, so a seat whose first provider fails or shares the lead's family moves to the user's next pick, not to a provider the user never chose. When every pick fails, the seat is skipped, as pstack's arena skips its judge, unless the list ends with inherit. The adapter maps each default list to opus and the session model, which are the judgment and code defaults, so two seats keep pstack's default panels. A project changes a panel's models through those two rows. pstack's default arena runners list holds three slugs since bf0c7cd, two Claude and one Gemini. Orbit keeps two runners on judgment and code, because every runner already runs on a Models role and a third default runner on Fable or a -fast slug has no role to map to (P13 plan gate, 2026-11-17). The one roster seat stands where pstack's non-Claude slug stands.

Seats on another family

  • pstack. Each seat below holds a non-Claude slug in its setup-pstack default list. arena cross-judge pool: claude-opus-5-5-high-fast, gemini-4-neon-xhigh and interrogate reviewers: claude-fable-5-2-high, claude-opus-5-5-high-fast, gemini-4-neon-xhigh. The trail reviewer runs "on another vendor's model than the one that did the work" (skills/show-me-your-work/SKILL.md). At e1cc031 how spawns one explainer, and why and reflect spawn nothing. de8ee15 put a grok slug on these seats and on how explorer, reflect tooling, why investigators and swarm workers.
  • orbit. Under T3 Code with a roster, four seats move to the roster (T3 Code host). They are arena's judge, interrogate's second adversary, the show-me-your-work trail reviewer and autopilot-full's audit seat, one per full swarm. Each panel fills one roster seat, and only the agent whose turn end returns to the user fills it. A subagent or a child, such as an autopilot owner, takes the absent column. delegate_task gets options: [] when the model lists no matching effort, and the lead settles the child by its childThreadId. Each seat brief says "You are a subagent of this thread." Each delegate_task call passes a clientRequestId that differs per seat, provider and round and stays the same on a retry of that call. t3_thread_send only answers or steers a running child, and every re-check or new round is a new call. When every listed candidate fails, the skill reports the skip line where the seat's result would go, and a skipped trail reviewer leaves the Attention section's first line as not reviewed: seat on another family skipped. When the result holds next, the lead neither waits nor polls, works on, and ends the turn when no work is left. The seat's wake comes inside a running turn under a Claude lead, else as a new run, as Own-checkout children says. A child question reported by hasPendingQuestion gets an answer through t3_pending_request on the childThreadId, or goes to the user. The lead reads the result and settles the child only at workState result_available. The reply names another thread by the link its result carries. When every verifier candidate fails, the lead sends the per-entry <entry> unavailable: <reason> lines with send_to_user when it is present, before the question.
  • Why. A Grok child loads orbit from Claude Code's copy and may load the rules skill, which stops a subagent, so the brief names the child a subagent and it never acts as a lead (advisor, 2026-11-16). These are the seats where pstack runs another vendor and that only read or review. One seat per panel stands where pstack's one non-Claude slug per default list stands, and it caps the non-Claude children a run spends. A subagent's turn end returns to its parent, and a delegate_task child's wake lands on the lead's thread, not the subagent's, so a subagent never sees its seat finish (advisor, 2026-11-16). delegate_task merges a given options value over the inherited ones and clears them on [], so omitting options would run the lead's options, not the provider default. T3's orchestrator MCP doc (c2eb8f3, read 2026-11-16, re-checked 2026-11-17) sets the rest. Each review round is a new delegate_task call with a distinct clientRequestId, stable across retries, and a call without one creates new work on retry. "When the result includes next, completion wakes the parent: do not wait on the task or poll it." A child question goes to the parent, which answers with t3_pending_request or asks the user, because "Users rarely watch child threads". A link never goes stale when the user renames a thread, as an id or title would. task_status says "A finished turn with live child work is not done" (tool description, 2026-11-16). A fallback to another provider is a different call, so it takes a new clientRequestId, or the retry key would return the failed task (inferred). T3's system prompt rules out a re-check through t3_thread_send (Ranked providers). A Claude lead in the live matrix wrote one summary sentence before its AskUserQuestion in place of the per-entry lines. T3's runtime prompt says text before a tool call may reach the user only as a one-line summary, and to use send_to_user for content the user must read in full mid-turn (#72).

Trail reviewer

  • pstack. "spawn a subagent on another vendor's model than the one that did the work" (skills/show-me-your-work/SKILL.md). de8ee15 read "a different model family from".
  • orbit. Keeps "a different model family from". Under T3 Code with a roster, the reviewer is the roster seat (Seats on another family). Otherwise it is an Agent call with model set to a different Claude tier, Sonnet under Opus, else Opus. The Attention header reads reviewed by <model>, as pstack's does, with the provider when the roster seat ran. When every listed entry fails, the seat is skipped and the section opens with not reviewed: seat on another family skipped, and the lead never reviews its own trail in the reviewer's place.
  • Why. The roster seat is another vendor, as pstack asks. Without a roster only Claude models run, so "another vendor" cannot hold, and the different Claude tier is the closest reviewer. Inheriting the session model would make the reviewer the same model as the worker, so this spawn keeps an explicit tier. Orbit's header once added (same family: no other available), and the user kept running into that caveat ("keep hitting Attention. Reviewed by Sonnet", transcript audit, 2026-11-10), so the header matches pstack again.

Review

  • pstack. interrogate runs "Phase A steps 3 and 4 and Phase B of the arena skill", reads "the interrogate reviewers line in place of arena runners", and spawns "each adversary as generalPurpose". "A finding survives only when a run proves it." It never applies fixes (skills/interrogate/SKILL.md).
  • orbit. /orbit:interrogate reads arena's SKILL.md by path and runs those steps with arena's default seats. Its two adversaries are general-purpose agents, one with model: "opus" (the judgment model) and one on the code model, each with effort: "high". Under T3 Code with a roster, the second adversary is the roster seat instead, spawned with delegate_task isolation: "worktree", at the effort the adapter's effort rule maps. Its brief holds the commit to check out and the patch file's path, and it reports its worktree's absolute path and starting branch with each finding. Verify reruns each command in that worktree, and cleanup settles its thread and removes the worktree and that branch. Under a T3 lead with delegate_task, an adversary that is not the roster seat runs as a same-provider delegate_task child in the same way, because it keeps its repros in its own checkout (Own-checkout children). Inside a child, or without delegate_task, the adversaries run one at a time in the agent's own checkout. Feature step 7 runs it when the design is contested. Known issues get fixed before the adversaries spawn (Fix before audit).
  • Why. Orbit has no interrogate reviewers line, and the adapter maps a non-Claude slug to the session model, the code default, so arena's default seats keep pstack's default panel. pstack's default interrogate reviewers list has a Gemini entry, so with a roster that seat goes to another family. It is the one roster seat that runs code, so it gets a worktree, which delegate_task starts at HEAD of the thread's bound checkout (Own-checkout children) and the seat reports back (T3-3 lane 1, 2026-11-16). T3 starts that worktree on a new branch, and a seat that checks out a commit detaches from it, so the lead deleted nothing and the branch stayed (T3-3 lane 1, 2026-11-16). Arena's step 3 names orbit:poteto-agent, so interrogate overrides it with general-purpose, the adapter's mapping for generalPurpose. An adversary reasons about how code fails, which is judgment work, and rules.md picks high for that.

Arena judge

  • pstack. The judge comes from the arena cross-judge pool line, "by default claude-opus-5-5-high-fast, gemini-4-neon-xhigh. The judge is never from the parent's vendor, and Fable counts as Claude for that check". "If the Task tool rejects a slug, use the nearest valid slug of the same family, then the next such entry, or skip the judge, and say so." (skills/arena/SKILL.md)
  • orbit. Under T3 Code with a roster, the judge is the seat on another family in any session, briefed with the rubric and each candidate's absolute path (Seats on another family). Without one, the judge's model comes from the judgment and code models and is never the parent's model, so a different model stands in for a different family. It runs on the first of them that differs. When both resolve to the parent's model, as in an Opus session under the defaults, arena skips the judge, Claude picks the base alone, and the synthesis note says so. If the Agent tool rejects the model, arena also skips the judge and says so. With the parent's model unknown, it uses the judgment model and says the model check did not run. A session-family judge is a foreground Agent, so it returns before Phase D's read starts. Only the roster seat, an async delegate_task, scores while the lead reads.
  • Why. With a roster, pstack's "The judge is never from the parent's family" holds again. Without one only Claude models run, so a literal copy of that line would skip the judge in every session. A different Claude model is the closest stand-in and the fallback, as the Trail reviewer takes a different tier. A judge on the parent's own model would share its blind spots, so arena skips it rather than run one (inferred). Trying judgment first is orbit's choice. pstack's default pool names a -fast slug and Gemini, which map to no Models role, so the judge stays on the roster seat or the first of judgment and code that differs. Arena Phase C's "While you read in Phase D, the judge scores each candidate" assumed a background judge, and T3 allows "Background agent: delegate_task, never a background Agent." (orchestrationInstructions.ts:9 in pingdotgg/t3code at c2eb8f3), so only the roster seat reads in parallel with the lead (T3 clash audit, 2026-11-17).

Adversary worktrees

  • pstack. "Copy the scope's uncommitted changes into each worktree." Verify reruns each finding's command. The scope runs "through the working tree" (skills/interrogate/SKILL.md).
  • orbit. The scope includes untracked files (git status --short). The lead names the commit each adversary checks out and saves the scope's uncommitted changes, untracked files included, as a patch in a fresh mktemp file that the adversary applies first. Verify reruns each command in that adversary's own worktree, whose path the Agent result or the child's report returns. Then the lead removes every adversary worktree with git worktree remove --force <path>, deletes its branch and deletes the patch file.
  • Why. Claude Code creates an isolation: "worktree" worktree only when the agent spawns, so the lead can't copy files into it beforehand. A worktree with changes stays after its agent returns, at its own path, so the repro files are there for the rerun and nothing removes them unless the lead does. Removing a worktree leaves its worktree-agent-* branch, and a fixed patch path would collide between sessions (both seen in a live run). A plain git diff leaves out untracked files, which are part of the working tree (inferred).

Review briefs

  • pstack. No rule. An adversary gets "the scope, the intent, and this brief" (skills/interrogate/SKILL.md), and project context comes from the harness.
  • orbit. rules.md's Review line passes the Workflow block's "Review also checks" sources and the Before code entries for the changed paths to /orbit:interrogate. Its Fan out puts them in each adversary's brief.
  • Why. The rule started when interrogate's reviewers were Explore agents, which don't load CLAUDE.md. Adversaries are general-purpose now, so that reason no longer holds. The sources stay in the brief for the reason in Project sources in briefs. A path-scoped source reaches the agent by name, not through AGENTS.md pointers.

Fix before audit

  • pstack. No such step. Interrogate says "Report the findings. Do not apply fixes." (skills/interrogate/SKILL.md).
  • orbit. /orbit:interrogate has a Fix first step between Frame and Fan out. It fixes open PR review comments that hold up against the code, confirmed bugs and Check failures. A fresh orbit:poteto-agent makes each fix under the Delegate gate and gitops commits it. Then the Check runs, and the adversaries check out the commit after the fixes. A suspicion the user wants tested stays for the audit. The step skips code the user plans to replace, a design or plan with no code, a branch this session does not write, and a scope with uncommitted changes. Interrogate still never fixes its own findings, and its Output reports the fixes or why the step was skipped.
  • Why. tstack's council skill (t3dotgg/tstack skills/council/SKILL.md) says "Before an audit, address outstanding PR comments, fix known issues, and run relevant checks. Give council the updated implementation; do not defer known fixes until reviews return." Without the step, adversaries spend a run re-proving known bugs (inferred). The user asked for it on 2026-11-16, with the rule that a reviewer never writes code and the code agent never reviews, so poteto makes the fixes. Babysit already routes fixes through the Delegate gate (playbooks/babysit.md). Only comments that hold up get fixed, because rules.md asks for skeptical triage. Suspicions stay for the audit. The step skips a dirty scope because gitops commits by path and would sweep the user's uncommitted work into a fix commit (advisor plan gate, 2026-11-16). It skips a branch this session does not write because an autopilot owner is its branch's only writer.

Project sources in briefs

  • pstack. No rule. Delegates rely on the harness loading AGENTS.md.
  • orbit. skills/setup/workflow-block.md defines a Before code line of path-scoped entries, each a file or a skill-load command. The Delegate gate copies the matching entries verbatim into each code delegate's brief. agents/poteto-agent.md reads each file whole, runs each command and follows any "read X first" pointer.
  • Why. Orbit's choice. Path-scoped guidance, such as a library's agent guide, reaches each delegate by name, so no delegate depends on finding it through AGENTS.md pointers.

Task end

  • pstack. No handoff line. Feature says "Stack follow-ups" (playbooks/feature.md step 6), and Autonomy proceeds on reversible work (poteto-mode/SKILL.md).
  • orbit. Autonomy's four paragraphs sit in rules.md Task End, after "finish every follow-up inside the goal yourself" and "List anything outside the goal. Don't build it." It ends with one Next: status line. A change that waits on the user's review gets a line that names the review and gives /orbit:ship as its own step after it. Landing a held change never folds into an /orbit:start follow-up.
  • Why. Orbit has no Autonomy section, so its lines sit with the other task-end rules. The user's global CLAUDE.md asks for the Next: line. The goal rules are orbit's choice. They finish work inside the goal and list scope creep instead of building it. A follow-up line that bundled "push and merge" started a merge the user had held for review (transcript audit, 2026-11-10), so landing stays a separate step the user runs.

Code Quality

  • pstack. No such section.
  • orbit. rules-shared.md Code Quality items 1 to 6, kept from orbit's team config (6af3e88). Item 5 keeps only its first sentence, "Fix the cause, not the symptom."
  • Why. User-authored config that predates the port, kept as written. Item 5's second sentence, "No workarounds without asking", conflicted with never-block-on-the-human, so review cut it (49e6804).

Files

  • pstack. No such section.
  • orbit. rules-shared.md Files keeps .md files out of a repo root, puts working notes in auto memory, and puts permanent docs in docs/.
  • Why. User-authored in 6af3e88. Notes moved from .claude/ to auto memory because Claude Code prompts on every .claude/ write.

Check default

  • pstack. No such default. CI on the PR gates landing.
  • orbit. rules.md Workflow Defaults sets Check to vpr check, then vpr build and vpr test if those scripts exist. The flows' verify steps run it, and under Land main Shipping runs it in place of CI.
  • Why. User-authored in 6af3e88. Under Land main no PR opens, so no CI runs.

Goal restatement

  • pstack. Interrogate's Frame says "State the intent with the in-your-own-words skill". That skill is one sentence, "Restate in your own words what you think the user's goals are and what problem they're trying to solve." (skills/in-your-own-words/SKILL.md) poteto-mode's Non-negotiables also open with "First message → restate the user's goal and the smallest change that meets it, then proceed." (poteto-mode/SKILL.md). de8ee15 opened them with "Your first message on a task → tell the user, in your own words, their goal", added in upstream commit ab1f702.
  • orbit. Interrogate's Frame inlines the sentence, as "State the intent by restating in your own words what you think the user's goals are and what problem they're trying to solve". rules.md's Remaining triggers open with the de8ee15 rule, copied as pstack worded it (Trigger list).
  • Why. Orbit doesn't ship in-your-own-words, and one sentence carries it, as ketchup inlines bro's tone. poteto-mode's rule says "in your own words" in plain text and names no skill, so it needs no inlining. It was left for an upstream bump (docs/trails/pstack-parity.tsv), and the de8ee15 pin brought it in.

Land default

  • pstack. Every change lands through a PR. Opening a PR is "Invoked at the end of every other playbook" (playbooks/opening-a-pr.md).
  • orbit. With no Land line, Land is main (opening-a-pr.md Land, skills/setup/workflow-block.md). Opening a PR then pushes nothing and opens no PR. Babysit says there is no PR and stops. Shipping fast-forwards main bottom-up after the verifier and the Check line pass. A stack is a chain of unpushed task branches, and measurements go in the reply. rules.md's "per-PR verdict" then means one verdict per task branch.
  • Why. The user's product call. A solo repo needs no PR. Land pr keeps pstack's PR path for projects that want it.

Ship by default

  • pstack. A task ends at Opening a PR. "Opening a PR does not start a babysit" (playbooks/opening-a-pr.md), and "Babysitting never authorizes merging" (playbooks/babysit.md, last bullet).
  • orbit. A change task ships once the verifier passes it. It runs Opening a PR, then Babysit drive under Land pr, then Shipping (opening-a-pr.md Ship by default). "don't ship", "I'll land it" or "stack them, don't ship" stops it at the PR or branch. Ship by default grants a multi-phase plan landing authority, so the plan runs autopilot-full (Multi-phase plan). The opt-out withholds that authority, so the plan's go runs autopilot-stack. rules.md's Babysit trigger keeps "Never triggered by merely opening a PR".
  • Why. User preference, 2026-10-29: "ill be writing more ship it when verified. than if it was dont ship until i say so". Where the Babysit trigger and Ship by default meet, the recorded preference wins. The standing request starts Babysit, not the PR.

Pausing

  • pstack. "for irreversible writes: force-push to shared branches, deploys, data deletion, customer messages" (poteto-mode/SKILL.md Autonomy).
  • orbit. The same list in rules.md Task End. A product call goes to the advisor first, and the lead pauses only when the advisor's pick drops or changes what the user asked for (Test before asking). It adds "Pushing, merging and opening PRs are not irreversible."
  • Why. A change to the goal is the one call that neither an experiment nor the advisor can make for the user. The old line paused for every product call, and the lead asked the user calls the advisor could make (Test before asking). Ship by default pushes and merges, so the rule says those don't pause.

Broken skill mid-task

  • pstack. e1cc031 has no such trigger. de8ee15 said "fix it in its own PR. Don't block." (poteto-mode/SKILL.md)
  • orbit. In orbit's own repo, a broken orbit skill is fixed in its own PR. Under Land main, that is its own worktree and branch, with its own Opening a PR run (rules.md Non-negotiables). From any other repo, the lead files an issue on orbit's repo (gh issue create --repo aayushbtw/orbit) with what broke, the session and a verbatim quote, then keeps going. It doesn't edit orbit from there.
  • Why. Under Land main no PR opens, so a separate branch keeps the fix out of the task's change. Orbit can fix only the skills in its own repo (inferred). From another project, an edit lands in the installed plugin cache or pulls the session out of its task (inferred), and the user said "dont edit orbit just open issue" (transcript audit, 2026-11-10).

PR owner checks

  • pstack. e1cc031 cut the subagent paragraph from playbooks/opening-a-pr.md. Autopilot-full step 2 still says "The code is ready only after the slop-strip ... and the /no-comments pass".
  • orbit. Opening a PR's Ship by default says a subagent that opens a PR returns without babysitting, and an autopilot owner babysits and stops where its brief says. The owner's code-ready trail row lives in autopilot-full step 2. The same paragraph says no child watches a PR, and a child that did PR work ends with the PR line, per babysit's Host watcher. In T3 Code, an owner's build round reads its PR once with watch-pr --once and returns with its PR line, and the root babysits (Own-checkout children). There a child, meaning any subagent, autopilot owner, gitops agent or delegate_task child, never watches, even when its brief says babysit. In T3 it runs one --once read per push, acts on BLOCKER and returns on any other verdict. Its last line is PR <full URL>, head <SHA>, checks and reviews <state>.
  • Why. A subagent reports once, so code-ready is a trail row (Autopilot-full). T3 hides watch_pull_request and unwatch_pull_request from subagents (McpInvocationContext.hiddenFromSubagents in T3's pr-tools.ts at c2eb8f3). T3's source-control doc says "Subagents cannot watch pull requests; the thread that delegated to them does." T3's runtime rule (runtimeInstructions.ts line 3) says "Delegated children never watch, even if the brief says babysit. After PR work, a child's last line is: PR , head , checks and reviews ." So the child rule wins over a brief that says babysit to green.

Independent verifier

  • pstack. "One verifier per PR, each a Cursor cloud agent, runs the change the way a user would" with the matching control skill, parent against head, and posts its verdict on the PR (playbooks/shipping.md step 1).
  • orbit. agents/verifier.md, a fresh orbit:verifier that shipping step 1 (/orbit:ship) or the autopilot-full root spawns with isolation: "worktree". Shipping spawns it with the verifier row's model and effort, not the code model (Model per role). It checks out the head SHA detached, runs parent against head, and returns its verdict. gitops posts it with gh pr comment, with the SHA and the patch-id. It has Write but no Edit tool, so scratch scripts go to /tmp instead of a Bash heredoc, which the worktree guard refuses (rules-shared.md "One plain command per Bash call"). It drives prompt changes with claude -p --plugin-dir in a scratch repo. Its prompt carries the Machine line. Its tools add ToolSearch and two named T3 read tools, list_thread_pull_requests and t3_thread_read. It has no preview_* tool, and its body says never to verify through T3's preview browser, so it drives a UI through the control skill's own headless browser. Shipping step 7 removes its worktree once the branch lands. Under a T3 lead with delegate_task, the native verifier is a same-provider delegate_task child with isolation: "worktree" and the same brief, plus the agent file and its tools limit (Own-checkout children). Before any verifier spawns, the advisor reviews the diff (Diff review). Under T3 Code with a roster and a verifier row of other-family or other-family, inherit, the lead spawns each PR's verifier as a seat on another family through delegate_task with isolation: "worktree", one child thread per PR, under the Parallel cap. Autopilot owners and swarm lanes stay on the lead's provider. The brief names agents/verifier.md to read first, states its tools limit, carries the SHAs, intent, changed paths and skill path, and asks for the worktree's path and starting branch so the lead can remove them once it settles the child. A child that cannot run the change replies BLOCKED: <reason>, and the lead names that entry unavailable in the reply and tries the next candidate. When none is left, the native verifier runs only if the verifier Model is other-family, inherit. Otherwise the lead writes one <entry> unavailable: <reason> line per entry before any question or hold. Then it asks the user before a native verifier runs, with the native verifier offered but not marked recommended, and with no user to ask it holds the PR. A FAIL stands. The lead settles each child thread after reading its verdict.
  • Why. The adapter maps a cloud agent to isolation: "worktree". A subagent returns its verdict as text, and gitops runs every forge write. A prompt change has no app to run, so a headless session drives it. A cloud agent's VM goes away on its own, and a local worktree stays until something removes it. Before it had T3 tools, the verifier saw none in a T3 session, because its tools list allowed only Read, Grep, Glob, Bash and Write (T3-native plan, Appendix A). With T3 tools allowed, the verifier loaded and called t3_preview_list in the T3 probe lane on 2026-11-16. T3 then ruled preview out for this job. Its system prompt says "Never use preview_* unasked to verify or show your own edit." (orchestrationInstructions.ts:24 in pingdotgg/t3code at c2eb8f3) and "When browser work was asked, preview_* is the browser you share with the user" (line 36). A verifier is never asked for browser work by the user, so the preview tools left its list. The rule also sits in its body, because a seat on another family reads the file by hand and a hand-read tools list binds nothing (Seats on another family). A verifier only judges, so it gets no T3 write. The list once held the wildcard mcp__t3-code__*. Under a stub t3-code server, a verifier with it loaded t3_project_delete, delegate_task, t3_thread_launch, schedule_task and unlink_pull_request through ToolSearch, and gitops's named list blocked the same probe (interrogate rerun, 2026-11-16). So the verifier's list names each tool too. The seat follows the operator's directive and the advisor plan gate of 2026-11-16 (Model per role). pstack's verifier runs on the swarm workers model. At de8ee15 that was a grok slug by default, so another family checked a Claude author's change. e1cc031 moved the default to claude-opus-5-5-high-fast. A child thread loads no orbit agent, so the brief names the file and states its limit, as Where a child runs step 5 says (Own-checkout children). Another provider can lack the project's toolchain or claude -p, and a FAIL there would hold a correct change, so BLOCKED hands the run on instead (inferred). T3 forbids a fallback to native tools unasked, and without a verifier nothing lands, so the lead asks, and a trailing inherit records the user's yes (Ranked providers). Only the verifier row's inherit counts. Setup writes it only after a yes to its second question, and a user can end the other-family list with inherit and still answer no (advisor, 2026-11-17). In the live verifier-all-fail lane at 31ee0b3, the lead merged both entries' reasons into one question sentence, wrote no per-entry line, and marked the native verifier recommended, which the verifier row had withheld. So the adapter and shipping step 1 now spell out both rules. A subagent never sees its child's wake, and a child starts no child thread (orchestrationInstructions.ts:13), so owners and lanes take no seat on another family (Seats on another family).

Diff review

  • pstack. No diff review. Shipping step 1 says "One verifier per PR, each a Cursor cloud agent, runs the change the way a user would" (playbooks/shipping.md). "Verification always runs on the swarm workers model, claude-opus-5-5-high-fast by default." (poteto-mode/SKILL.md Subagents)
  • orbit. Shipping step 1 briefs orbit:advisor for a diff review of each PR before any verifier spawns, on Fable from its frontmatter or the advisor row. The brief holds git diff <parent>..<head>, the intent paragraph and the Plan gate's project sources for the changed paths. It asks for blocking findings, meaning bugs, broken project rules and missed cases. The lead checks each blocking finding against the code and dismisses one that doesn't hold, with its reason. Each one that holds gets a fix round through the Delegate gate. Under Land pr, gitops pushes the fix, and Babysit brings the PR and every PR stacked above it back to merge-ready before any verifier spawns. The review covers the patch it read. It runs again, on git diff <reviewed-sha>..<head>, only when step 3 finds that patch changed, or after a fix for a FAIL. Step 3's "fresh checks and a review" becomes "fresh checks and step 1's diff review". Non-blocking findings and the model that reviewed the diff go in the reply. The review is not a verdict and never replaces the verifier. Under T3 Code the advisor is a foreground Agent. Only the agent whose turn end returns to the user runs the review, so an autopilot owner or swarm lane never does. Autopilot has no diff review, because its merge round runs only shipping steps 3, 4 and 7 (skills/playbook/playbooks/autopilot-full.md step 5). This is a known gap. agents/verifier.md still names no model.
  • Why. The verifier runs on the session model, so in an Opus session it is the same model as the code's Opus author. The user asked for a Fable code review by hand 6 times (transcript audit, 2026-11-20). Fable's read-only diff reviews then found real bugs that the verifier had passed, traced from the code, not from a run. A model: fable line in agents/verifier.md would not close the gap under T3, because there the verifier runs as a child thread that loads no agent frontmatter (Own-checkout children). The advisor already runs as a foreground Agent on every host, on Fable. The advisor reads code and never runs it, so the lead checks a finding before it spends a fix round on it. A verdict on an unpushed fix would not describe the head that lands, so the fix is pushed and the stack made merge-ready first (inferred). A fix round before the verifier keeps a verifier off a head the review already blocked (inferred). A second review of an unchanged patch would read the same code again, so it reruns only on what changed.

Verifier intent

  • pstack. Step 1 gives the verifier no written brief.
  • orbit. Shipping step 1 writes the change's intent in one paragraph from the goal and the code. The verifier's brief holds it, the head and parent SHAs, the changed paths and the verify or control skill path.
  • Why. Orbit-only. A fresh subagent sees only its brief, so the intent tells it what a user should see.

PR merges

  • pstack. Merge "with origin pr merge <pr> or gh pr merge <pr> --squash", then read back state,mergedAt,baseRefName. A child moves onto the merge result and pushes "with --force-with-lease" (playbooks/shipping.md step 4).
  • orbit. gitops merges with --delete-branch and the Land line's method, --squash by default, and reads back the same fields. It moves the child with git rebase --onto origin/<trunk> <tip>, where <tip> is the merged PR's headRefOid.
  • Why. The merge method is the project's choice in its Workflow block (skills/setup/workflow-block.md). After a squash, a plain rebase replays the parent's commits and conflicts.

Force-push

  • pstack. "Force-push only your own branch, with --force-with-lease pinned to the SHA you last pushed or took over" (playbooks/autopilot-full.md step 2). The owner rebase in that step and shipping step 4 push with a bare --force-with-lease.
  • orbit. gitops makes every force-push as git push --force-with-lease=<branch>:<sha>, with the SHA the lead passes. It rewrites pushed history only on a task branch the session pushed or took over, and stops if the remote tip differs (agents/gitops.md).
  • Why. A bare --force-with-lease checks the remote-tracking ref, which any fetch moves, so it can overwrite a push nobody saw. gitops starts fresh each time, so only the lead knows the SHA.

Opening a PR

  • pstack. playbooks/opening-a-pr.md, three paragraphs. "Work from a git worktree off trunk, and keep unrelated work out of it. Rebase into small, landable commits. Run /deslop from cursor-team-kit over the diff before commit." PRs open "through the run's PR tool with draft: false. Without one, use gh pr create without --draft, or origin pr create --status open when Origin's CLI resolves the repository."
  • orbit. skills/playbook/playbooks/opening-a-pr.md, the last step of every change flow (Opening a PR gate). A Land paragraph decides whether a PR opens (Land default). gitops commits each reviewed unit by path and runs the rebase, with fixup and autosquash (Commits). It keeps "/orbit:no-comments before review", which upstream cut. The Body sentence adds that evidence logs, run histories and long tables go in a file or a PR comment that the body links to. gh is the only forge. gitops opens the PR with gh pr create without --draft, then links it to the session's thread per the host adapter, and skips the link where link_pull_request is absent. Under Land main a stack is a chain of unpushed task branches. A Ship by default paragraph and a Reply: line follow.
  • Why. Origin and Graphite are not vendored. pstack's adapter maps a built-in PR tool to the forge command. Orbit's T3 adapter maps it to gh pr create, then link_pull_request with the PR URL (T3 Code host). Orbit's no-comments skill says Opening a PR runs it before review, and autopilot-full step 2, orbit's and upstream's, gates the code-ready head on the /no-comments pass, so the clause stays. e1cc031 moved the rule that evidence goes in a linked artifact, not the body, from opening-a-pr.md into worker.md, which orbit does not ship (Trigger list), so orbit keeps the rule in Opening a PR.

Babysit

  • pstack. playbooks/babysit.md, six bullets. "Use gh by default, or origin pr when Origin's CLI resolves the repository. Never require Graphite (gt)." Modes are drive, threads-only and check. "Never rebase, retarget, or force-push." It says nothing about a host's own PR watcher, and the Cursor-only features table in pstack's Claude Code adapter (pstack/docs/harness/claude-code.md) lists only Cursor Automations, Bugbot, cloud agents and the built-in PR tool. Its watcher reads empty checks as a retryable checks-unavailable error (scripts/watch-pr/github.ts) and, after five query errors, stops at BLOCKER: status-query, so it never reports READY on a repository with no CI. Both still hold at e1cc031.
  • orbit. skills/playbook/playbooks/babysit.md. The stance line adds that a request to land or ship is Shipping (/orbit:ship). A paragraph after it says the user's request or Ship by default starts it, in drive, even for a small PR. Under Land main it says there is no PR and stops. Fixes go through the Delegate gate. The forge bullet keeps "Use gh by default." and drops the Origin and Graphite clauses. Bugbot replies go through gitops with the gh api command, with the payload written by the Write tool. The last bullet adds orbit's standing ship default. The watcher is pstack's watch-pr in skills/playbook/scripts/, with three fixes. First, when both check sources are empty, it asks GitHub whether the repository runs checks. With no workflow on the PR head or the base branch that runs on a pull_request* event or on a push that can reach a PR branch, no check on an earlier commit of the PR, no check on one of the repository's 10 most recently updated pull requests, and no protection rule or ruleset that requires checks, the read is no-ci and the PR can reach READY. Second, under --status-only a query error returns the status-query blocker at once, with no retry. Third, --once makes one classifying read and never sleeps. READY and BLOCKER come as usual. A pending PR ends at TIMEOUT with reason pending-checks, which names its frontier, or queued-stack with --queued-stack, exit 5. A retryable query error ends at TIMEOUT with reason status-unavailable, even under --max-query-errors 1, and a non-retryable one at the status-query blocker. That timeout's pr names the PR whose read failed. A gh error that says the PR or repository does not exist, or that the branch has no PR, is the non-retryable not-found. The queued-stack timeout says in waitingOn whether its frontier waits on pending-checks, review-required or only the merge. The watcher reads reviewRequests, so a READY gate and a review-required wait name the requested reviewers. --once conflicts with --status-only. A **Host watcher.** bullet sets the lead's wait by host. The session is in T3 when any mcp__t3-code__ tool is in the tool list. In T3 with watch_pull_request present, the lead pushes any branch update first, and reads once with --once. When the verdict waits on checks, it calls watch_pull_request on the PR the verdict names and ends the turn. That is a pending-checks timeout's frontier, a status-unavailable timeout's pr when its failure.kind is checks-unavailable, or a queued-stack timeout's frontier when its waitingOn is pending-checks or review-required. Any other status-unavailable failure gets no watch, so the lead reports it, hands back and reads again with --once on its next turn. When a merge was asked for, a READY with reviewDecision REVIEW_REQUIRED or a changes-requested blocker waits on a review, so the lead names the reviewers, watches and ends the turn. A wait only on a merge someone else holds, such as a merge queue, auto-merge or a person, gets a watch, and the lead says what the PR waits on and ends the turn. Every watch passes until. It is "merged" when a machine holds the merge, such as a merge queue or auto-merge, or when a merge was asked for and the PR waits on checks or a named reviewer. It is "checks" on every other wait, such as a merge a person holds or a review with no reviewer requested. In Shipping step 5 under T3, a frontier that waits on the lead's own next step-4 merge is no handback, so the lead runs that merge and reads again. On a wake it reads again with --once, watches a new frontier the same way, and calls watch_pull_request again only after T3 says it stopped watching a PR that is still open and still waited on. A tool error takes the tool-off path. In T3 with the tool off, the lead reads once per turn and hands back, with no sleep, loop, gh --watch, Monitor or ScheduleWakeup. Outside T3, drive runs the bare watcher under /loop with no interval, per the adapter's /loop row. A handback is a READY that waits on nothing, a conflict report, a question to the user, the ceiling or a stop. Before one, the lead calls unwatch_pull_request on each PR it watches. The bullet's second paragraph says no child watches a PR (PR owner checks). Shipping step 5 waits per Host watcher, and step 6 unwatches at the ceiling. A Reply: line names the mode, the verdict, each thread, what a wait waits on and each PR unwatched. rules.md's Babysit trigger drops the clause about Cursor's built-in babysit skill. The mode bullet keeps de8ee15's request-to-mode mapping, which e1cc031 cut. "Check on X", "is it green" and "anything outstanding" ask for check, "babysit this", "get it green" and "wait on CI" ask for drive, "address the review comments" asks for threads-only, and an undeclared mode is drive. rules.md's Babysit trigger says the playbook's first bullet owns that mapping. The forge bullet names the watcher's command form, watch-pr --owner <owner> --repo <repo> --pr <n>, with --stack for a stack and --status-only for one read.
  • Why. Claude Code has no built-in babysit skill, and Origin is not vendored. The bold **Host watcher.** lead-in keeps a citable anchor, because upstream's bullets have no step numbers and shipping step 5 and the T3 adapter cite the rule. gitops runs every forge write and can write a file only through the shell. Shipping needs the watcher's terminal verdict, so a small PR still runs drive. pstack's watcher never reaches a verdict on a repository with no CI and stops at BLOCKER: status-query, and orbit's own repository runs no CI. A push workflow attaches checks to a same-repository PR branch, so it counts unless its branches filter names only the base branch or it runs only on tags. A workflow that runs only on push to the base branch, such as a deploy, never attaches a check to a PR, and it sets the base branch head's rollup, so neither its file nor that rollup counts. A status-only read promises one table and an exit, but pstack's ran the full retry schedule on a query error, about 12 minutes on one PR. A host PR watcher such as T3 Code's watch_pull_request wakes only on events. On a PR with no CI and no reviewer, an agent that armed it in place of the watcher waited on nothing. T3 now wakes a GitHub watch once 15 minutes pass with no check (PULL_REQUEST_WATCH_NO_CHECKS_MS in apps/server/src/orchestration-v2/pullRequestWatch.ts at 6d05c5f), and never off GitHub. So the --once read comes before the watch. T3's runtime rule for every thread (runtimeInstructions.ts line 3 in pingdotgg/t3code at c2eb8f3) says "Call watch_pull_request when asked to monitor or babysit, or when work you were asked to do, such as a merge, still waits on checks or reviews, even after an earlier unwatch. Finish any needed branch update and push first, then watch and end your turn. Otherwise act now or hand back. Delegated children never watch, even if the brief says babysit. After PR work, a child's last line is: PR , head , checks and reviews . Links and watches persist across pushes. For PR waits, no sleep, loops, gh --watch, Monitor or ScheduleWakeup. Before handback, call unwatch_pull_request on any PR you watch." The old --timeout 120 wait slept between polls, which that rule bans. The tool's own description in T3's pr-tools.ts says "After this call, end your turn. The watch stays on after each wake, so do not call this again on a wake. A wake is not a merge decision. Check readiness yourself." --status-only could not be the one read. runSimple in policy.ts returns STATUS with reason status-only before it classifies the PR, so it never reports READY or BLOCKER. --timeout 0 turns the deadline off, so the watcher polls forever. So --once makes the deadline pass on the first read. A read right after a push often finds no checks yet, a retryable checks-unavailable error. When --once ended every query error at the status-query blocker, that read stopped babysit before it armed a watch (P6 audit, 2026-11-17), so a retryable error ends at a status-unavailable timeout, which arms one. Only checks-unavailable clears when a push's checks register, which wakes a watch. A failed gh call or an unparsable reply is no change to the PR, so a watch on it would never wake (P6 audit, 2026-11-17). --pr 999999 and a branch with no PR came back as retryable command-exit errors, so --once ended them at status-unavailable and babysit would watch a PR that does not exist (P6 verifier, 2026-11-17). They now end at the status-query blocker, as the long-running watcher already did for a branch with no PR. In --stack mode the read that fails can be an upstack PR, so the timeout names it. T3's tool description lists no merge among its wakes. Orbit read that as no wake on a merge, so a lead whose PR waited on someone else's merge handed back. T3's source-control doc says "When the pull request merges or closes, watching ends, and the agent is woken once unless it merged or closed the pull request itself with the host's CLI. A reopened pull request needs a new watch. Watching also ends after 10 wakes in a row that bring only comments, after 8 failed reads in a row, or when you press Stop on the thread." (docs/user/source-control.md:345-348 in pingdotgg/t3code at 6d05c5f). PullRequestWatchReactor.ts skips that wake only for a merge or close command in the thread's own turn, and says "Anything ending later, as a --auto merge does, is news." The merge or close wake fires whatever until says (finished() in apps/server/src/orchestration-v2/PullRequestWatchReactor.ts). until only decides whether the thread shows as Working (packages/shared/src/orchestrationV2PendingBackgroundWork.ts). The tool's text says "Omit it to keep the current value; a new watch starts at "checks". "checks": until checks finish, for a PR you hand to the user. "merged": until it merges or closes or you unwatch it, when you will act on it yourself, such as merging after someone else approves." (apps/server/src/mcp/toolkits/pullRequests/tools.ts). So a wait on someone else's merge keeps a watch and ends the turn. A merge queue or auto-merge holds the thread in Working with "merged". A merge a person holds passes "checks", so the thread returns to the user's inbox and the merge still wakes it. Omitting until would keep an earlier "merged", so every call passes it. The lead re-arms only after T3 ends a watch on a PR that is still open. T3 also wakes when the branch needs a rebase, and when every check passes on a PR with no required checks (apps/server/src/orchestration-v2/pullRequestWatch.ts). The installed T3 Code (Nightly) v0.1.11-nightly.20261119 holds the end message "so T3 Code stopped watching it.", the until text, the tool description, the rebase and all-checks wake messages, the 10-update and 8-read limits and the 15-minute no-checks constant (rg -a on its app.asar, 2026-11-20). A live probe on that build confirmed the merge wake on 2026-11-20. A Claude lead watched aayushbtw/orbit-t3-lane-ci#19 with until: "checks" after its only check had passed, then ended its turn. A detached gh pr merge that the lead had started before ending its turn merged the PR at 05:44:06Z. T3 woke the idle thread by 05:45:11Z with "Pull request #19 (https://github.com/aayushbtw/orbit-t3-lane-ci/pull/19) was merged into main by aayushbtw as ccfef9e, so T3 Code stopped watching it." A wait on a review arms a watch. T3 says "Otherwise act now or hand back", and in Shipping the merge the frontier waits on is the lead's own step 4, so it acts. In --stack mode the PR with pending checks can sit above the one named, so the timeout names its frontier. The host key is any mcp__t3-code__ tool, the same key rules.md uses for run_in_background: false, because T3 can turn watch_pull_request off and leave the rest on. Outside T3 no such rule applies, so the bare watcher under /loop stays (inferred). rules.md routes "check on PR X" and "anything outstanding on X" to Babysit and asks for a mode before any poll, so the flow has to say which mode each request gets. Two headless leads passed the watcher a PR URL and got exit 64, its usage error (P13 audit, 2026-11-17), so the bullet names the flags. In a T3 lane asked to have gitops wait on CI, the lead took check, got TIMEOUT pending-checks from gitops and armed no watch (P6 lane B, 2026-11-17). T3 says "Call watch_pull_request when asked to monitor or babysit, or when work you were asked to do, such as a merge, still waits on checks or reviews", so "wait on CI" asks for drive.

Shipping

  • pstack. playbooks/shipping.md. Verifiers are Cursor cloud agents. PRs land bottom-up with --squash. The forge is gh or Origin. It has six steps and no cleanup. Worktree and simulator cleanup is its own playbook.
  • orbit. skills/playbook/playbooks/shipping.md, run by Ship by default or /orbit:ship. /orbit:ship first runs Opening a PR when the session's todolist has no finished Opening a PR for the branch. Verifiers follow Independent verifier. The patch-id diffs against the PR's base, which is the parent's branch for a stacked PR. Under Land main, steps 4 and 5 become a bottom-up fast-forward of main. gitops rebases each branch onto origin/main, the Check line stands in for CI, the patch-id is compared, and gitops pushes HEAD:main. The playbook index line drops the forge clause. Step 7 cleans up each branch that landed, after a successful HEAD:main push or a MERGED read-back. The session first leaves its own worktree with ExitWorktree and keep, never remove or discard_changes. Then gitops, from the session's restored directory, removes the task's worktree and every verifier and owner worktree made for it with git worktree remove <absolute path>, never --force. A session that never called EnterWorktree skips the exit. When its working directory is the task worktree, as in a T3-bound thread, it keeps that worktree and its branch. A worktree with uncommitted changes stays. Then gitops deletes the local branch with git branch -D only when it holds nothing unlanded. Under Land main that is a fetch and a passing git merge-base --is-ancestor <branch> origin/main, and gitops never switches, merges or fast-forwards the restored checkout. Under Land pr it is a local tip equal to the PR's headRefOid, and step 4's --delete-branch already removed the remote branch. The reply names each worktree and branch that stays. /orbit:worktree-cleanup still prunes abandoned worktrees.
  • Why. Cloud agents and Origin are not here. Under Land main no forge lands the run. A patch-id against origin/main would take in a stacked PR's parent and change once the parent lands. Under Land main nothing pushed is rewritten, so no push needs force. pstack's cloud VMs leave nothing on the user's disk (inferred), and orbit's local worktrees do. The user asked "i have 140 worktrees?" when 126 worktrees held 196 GB and 124 of them had merged, then "branches too, merged prs left branches behind" (transcript audit, 2026-11-10). A squash merge leaves the branch's commits off trunk, so -d refuses them, and the MERGED read-back is what makes -D safe. Ship by default runs Opening a PR first, but a bare /orbit:ship skipped it, and the user asked "why would u skip deslop?" (transcript audit, 2026-11-10). A session that ran EnterWorktree is isolated in its worktree, and so is every subagent it spawns. Claude Code's worktree guard then refuses git that reaches another checkout through cd or -C, "This session is isolated in the worktree

    , but this command redirects git to the shared checkout via -C. Refusing to run it". ExitWorktree with remove refuses a worktree whose branch has a commit the session's starting commit lacks, and every landed branch has one. In real sessions 42 of 53 first remove calls were refused, and leads then passed discard_changes: true without the user. The ship cleanup eval at d840cd4 (tests/ship/cleanup.mjs --ref origin/main, 2026-11-19) reproduced both. While the lead was still isolated, gitops's cd <root> && git worktree remove ... and git -C $R fetch were refused, and the lead's remove was refused. After ExitWorktree with keep, gitops removed the worktree and branch with no refusal. So step 7 exits with keep first, and rules-shared.md's git -C advice ("One plain command per Bash call") names the isolation limit. In three runs of the same eval at 1e187da (2026-11-19), every git branch -d from the restored directory was refused with "error: the branch 'fix/readme-typo' is not fully merged". The HEAD:main push does not move the root checkout's local main, and -d checks a branch with no upstream against that HEAD. The lead or gitops then ran git merge --ff-only origin/main in the user's checkout to get past it. So under Land main gitops deletes with -D once git merge-base --is-ancestor proves the branch is in origin/main, the same shape as the headRefOid rule, and leaves the user's checkout alone. A T3-bound thread works in its worktree without having called EnterWorktree, so ExitWorktree has nothing to leave, git refuses to delete a branch checked out in a worktree, and removing the thread's working directory breaks every later shell call in it. So that thread keeps both (inferred). A session outside the worktree, such as a later /orbit:ship from the main checkout or the T3 merge-round Agent (docs/harness/t3-code.md step 10), skips the exit, and gitops removes the worktree as usual.

Test before asking

  • pstack. "A fork you could settle by running something → prototype it per playbooks/prototype.md instead of asking." (poteto-mode/SKILL.md Non-negotiables). de8ee15 classified the fork and said "Sketch it via the Prototype playbook (playbooks/prototype.md)", with the full-autonomy grant clause and "the Always-pause list in Autonomy".
  • orbit. The de8ee15 rule, grant clause included, in rules.md Non-negotiables (Trigger list). The sketch runs as /orbit:playbook prototype, and the Always-pause list is the one in Task End. The trigger covers AskUserQuestion and a numbered "your call", "your pick" or "(Recommended)" choice in the reply. A fork no run settles goes to orbit:advisor, every open fork in one brief. The lead acts on the advisor's pick and reports it, with what the user could say to change it. It asks the user, with the pick marked recommended, only for an Always-pause item, a gate the user named, or a pick that drops or changes what the user asked for. A skill's own question, such as /orbit:setup's or Shipping's native-verifier consent, goes to the user as the skill says, and an advisor pick never counts as the user's yes to it. The Prototype playbook's step 2, "let the user pick directions before building", stays with the user on purpose. It is a taste call and that playbook's own step. Before it asks, the lead finishes the work that doesn't hang on the answer. An advisor that can't run on Fable retries on Opus, so an outage never sends a fork to the user. Under the grant, the advisor's pick is the default for a call only the operator can make. rules.md Writing the reply adds "Never end on a choice the advisor could make."
  • Why. Orbit has no Autonomy section, so its pause list sits in Task End (Task end). The lead asked the user to make calls as "Your call: 1. ... (recommended) 2. ..." without briefing the advisor. In 4 sessions the user pushed back with "did u check with advisor?", "ise advisor to decide dont ask me", "use advisor for decisions dont be blocked" or "consult" (transcript audit, 2026-11-20). The old trigger named only AskUserQuestion, so a numbered choice in the reply slipped past it (inferred). pstack's Never Block on the Human says "Proceed, present the result, let the human course-correct." (poteto-mode/SKILL.md), and the advisor's pick is what the lead proceeds on. A skill's own question asks for the user's consent or knowledge, which the advisor cannot give. The native-verifier consent is the user's yes to a fallback that T3 forbids unasked (Independent verifier).

Feature flow

  • pstack. Step 4 delegates to "a subagent using your configured feature model" and says "Commit liberally" (playbooks/feature.md). Step 6 rebases into small commits. The closing paragraph says "That owner fans out internally after the blocking phase."
  • orbit. The same steps, with a fresh orbit:poteto-agent per the Delegate gate and gitops committing each reviewed unit. Step 6 keeps the rebase, and gitops runs it (Commits). The single owner fans out one orbit:poteto-agent per unit. Units the throughput checkpoint (step 3) marks independent, with disjoint files, run in parallel under the Parallel cap, each in its own isolation: "worktree" worktree, and count tries as other units do. Under a T3 lead with delegate_task, each parallel unit is a same-provider delegate_task child instead. On every host the delegate commits its unit in its own worktree, and gitops cherry-picks each kept commit by SHA (Own-checkout children). Units that share a file run one at a time. Parent-level fan-out for independent artifacts runs as read-only agents outside the Delegate gate.
  • Why. pstack's step 3 says "Disjoint files, services, or layers parallelize. Shared writes serialize." Orbit's Delegate gate once ran every unit one at a time, and the user asked "why are u not using orbit why are u working without subagents" (transcript audit, 2026-11-10). A delegate works only in the path its brief gives, so a parallel unit needs its own worktree and a way back to the task branch. Artifact slices write no code, so the Delegate gate doesn't apply.

Swarm

  • pstack. skills/swarm/SKILL.md. Workers run on the swarm workers model, claude-opus-5-5-high-fast by default, "with subagent_type: generalPurpose, environment: "cloud", run_in_background: true". environment: "local" is for "access to something on the user's computer". It sets disable-model-invocation: true.
  • orbit. skills/swarm/SKILL.md, vendored at 0b46ec3 (skills.json). Workers run on the code model, with effort per rules.md. Each is a general-purpose Agent call with isolation: "worktree" on a named branch or commit. isolation is omitted only when a worker needs what a fresh worktree lacks. Under a T3 lead with delegate_task, a worker that writes is a same-provider delegate_task child, and a read-only worker is a foreground Agent with no worktree (Own-checkout children). Workers spawn up to the Parallel cap in one message, and the next starts as one finishes. Every brief carries the Machine line. The skill runs through the Skill tool.
  • Why. The adapter maps the default slug to the code model, cloud to isolation: "worktree", local to omitting it, and cloud_base_branch to telling the worker to check out the ref. Every worktree is on the user's machine, so "the user's computer" becomes what a fresh worktree lacks (inferred). For the same reason, the worker count and what each worker opens on screen reach the user.

Architect

  • pstack. Architect traces every system the change touches, sketches two shapes, and picks the one where "each piece of state has one owner, each task has one way to do it, and callers need to know least". "For a large or contested design, run the arena skill instead of sketching alone." (skills/architect/SKILL.md)
  • orbit. The same text as /orbit:architect, routing to /orbit:arena, whose two default runners apply (Panel seats). In an /orbit:playbook flow it reuses the flow's earlier /orbit:how output for the trace. The sketches stay in the lead's reply, and any stub code goes through the playbook's Delegate gate. Arena's runners are orbit:poteto-agent, each with isolation: "worktree" under the Delegate gate's parallel exception. Under a T3 lead with delegate_task, each runner is a same-provider delegate_task child instead (Own-checkout children). The judge is the roster seat under T3 Code, else an Explore agent on the first of the judgment and code models that differs from the parent's, and arena skips it when neither differs (Arena judge). In a playbook flow, each runner commits its candidate in its own checkout, gitops cherry-picks the base's commit, and a fresh orbit:poteto-agent folds in the grafts.
  • Why. A /orbit:how answer from earlier in the flow already traces the affected systems, so a second trace repeats the read (inferred). Architect no longer names runners, a runner prompt or a rationale template, so the absolute-path and two-runner edits went with them. Under the Delegate gate the lead writes no code, so a sketch that turns into stub code needs a delegate. The adapter maps readonly: true to Explore. Arena names no subagent_type, so poteto-mode's poteto-agent rule applies. The parent writes no code under the Delegate gate.

Reflect

  • pstack. "Never edit a skill under plugins/cache/. Before approval, show its destination, .cursor/skills/<skill>/ or ~/.cursor/skills/<skill>/. After approval, copy the skill folder there and edit the copy. Never open a PR or push." Backlog has no destination named. (skills/reflect/SKILL.md)
  • orbit. Reads its transcript by ${CLAUDE_SESSION_ID}, lists Backlog as /orbit:correct <pattern> candidates, hands large edits and description tunes to skill-creator if installed, and edits a plugin skill in its source repo, recording vendored changes in skills.json edits.
  • Why. Claude Code has no .cursor/skills/ override folder, and the plugin cache is overwritten on update. Orbit fixes its own skills in a PR (rules.md Non-negotiables, Broken orbit skill), so "Never open a PR" would clash.

Perf artifacts

  • pstack. Cite the measurement in the PR (playbooks/perf-issue.md step 5).
  • orbit. The measurement goes in the PR body when Land is pr, else in the reply.
  • Why. Under Land main no PR opens.

Hillclimb

  • pstack. Each attempt goes to "a subagent using your configured hillclimb model", and parallel attempts each get their own worktree. "One commit per accepted fix, staging only the files you changed". An unattended run borrows "the wake mechanism from the Autonomous run playbook" (playbooks/hillclimb.md).
  • orbit. skills/playbook/playbooks/hillclimb.md. Each attempt is a fresh orbit:poteto-agent, and gitops commits each accepted fix by path. Parallel attempts follow the Delegate gate's parallel exception, and gitops cherry-picks a kept one onto the task branch. The wake rule is inlined (Wake mechanism).
  • Why. Delegates never commit. A delegate works only in the path its brief gives, so an isolated attempt needs its own worktree and a way back to the task branch. Autonomous run is not ported.

Wake mechanism

  • pstack. Under /loop, "An event to watch (CI, a merge, a ref advancing) gets a watcher subagent that wakes you on the event", with a long heartbeat as fallback (playbooks/autonomous-run.md step 2).
  • orbit. Hillclimb step 5 checks each wake tool on its own, per the host adapter (T3 Code host), and says which it used. The loop and every heartbeat run on schedule_task bound to the thread when that tool is present, else under /loop. A PR event, CI, a review or a merge, gets watch_pull_request when that tool is present, with until as Babysit's Host watcher says. In T3 with that tool off, a wait on a merge takes the heartbeat, one read of the PR per wake. Any other PR event there gets one read per turn and a handback, with no Monitor. Outside T3, a PR event gets a Monitor watcher. Any other event, such as a ref advancing, gets a Monitor watcher. When the run waits on that Monitor's event, its task id goes to t3_background_wait when that tool is present. A background task gets t3_background_wait when that tool is present, else Monitor or its finish notification. An event watcher keeps a long time-based heartbeat as fallback.
  • Why. Orbit's own mapping, since pstack's adapter has no row for a watcher subagent. T3's session runtime instruction "Background work you wait on" says "To wait for a background command or Monitor you started (tests, a build), call t3_background_wait with its task ID before you end your turn." (system text T3 injected into a session, read 2026-11-17). That text is not in the c2eb8f3 repo snapshot. The tool's own description excludes "work left running (dev server, watcher)", so the rule names only a Monitor whose event the run waits on, and a PR event keeps watch_pull_request, because T3 says "For PR waits, no sleep, loops, gh --watch, Monitor or ScheduleWakeup." (runtimeInstructions.ts:3 in pingdotgg/t3code at c2eb8f3). A watch also wakes once when its PR merges or closes, so a merge needs no heartbeat while the watch tool is on (Babysit). With it off, a handback would stall an unattended run on a merge, so the merge keeps the heartbeat. Monitor wakes the session on the event, and no subagent has to poll. In T3, /loop with no interval wakes through ScheduleWakeup, a timer inside the session (T3 probe lane, 2026-11-16). schedule_task is T3's own scheduler, so the adapter prefers it there. A headless lane without T3 tools armed Monitor and added no /loop heartbeat, because the old sentence named /loop the heartbeat tool only for the loop (T3-2 fix-round lane, 2026-11-16). Each tool is checked on its own because T3 can turn one off and leave the rest (T3 Code host).

Autopilot-full

  • pstack. playbooks/autopilot-full.md. Each owner is a Cursor cloud agent that opens its PR early, reports the code-ready head, pushes "each finished unit before you start the next", and merges once the root's swarm verifies it. "Assume the VM dies." Trails go in "the root agent's store". Each tick re-reads the playbook "from trunk".
  • orbit. skills/playbook/playbooks/autopilot-full.md. Each owner is a general-purpose Agent call with model: "opus" (the judgment model) and isolation: "worktree" that runs /orbit:start <item> and returns at merge-ready. Under a T3 lead with delegate_task, only each owner's build round is a same-provider delegate_task child. It never watches a PR, reads its PR once with watch-pr --once and ends with its PR, head and check state, and the root runs babysit on the PR. Until its wake, the tick judges it by its trail and git side effects, never task_status, and a stuck owner gets task_cancel before its replacement. Each later round, a fix, a rebase or the merge round, is a foreground Agent in the root's thread that works in the owner's worktree (Own-checkout children). In T3 without delegate_task, owners run one at a time, and the reply says the tick cannot fire while one runs. The owner reports code-ready as a code-ready <sha> trail row, and each tick starts the swarm at a new code-ready SHA. The PR opens in Opening a PR, after /orbit:deslop and /orbit:no-comments, not early alongside the work. "Assume the owner dies." Owners commit each finished unit before they start the next, instead of pushing it. Trails and agents.tsv go in $TMPDIR/orbit-autopilot/<slug>/. Swarm lanes are swarm workers on the code model, briefed as shipping step 1 briefs a verifier, with the Check line. They read the code-ready SHA from a git archive -o export, so each lane is a foreground Agent with no worktree, and under Land pr gitops posts the root's verdict line on the PR. Owners run in parallel under the Parallel cap. A fresh owner takes each later round, and its brief says to call EnterWorktree with path set to the prior worktree before any other work. The merge round, briefed also with the verifier worktree paths, runs only shipping steps 3, 4 and 7. Under Land main, the merge is gitops pushing HEAD:main, then step 7. Ticks re-read the playbook without "from trunk". Under T3 Code with a roster, the root also spawns one read-only audit seat on another family per full swarm (Seats on another family). It is additive and never required for a clean verdict. Where babysit says to report a rebase, the owner has gitops rebase its own branch and push it with --force-with-lease=<branch>:<sha>, pinned to the SHA it last pushed or took over (Force-push).
  • Why. The adapter maps a cloud agent to isolation: "worktree" and resume to a fresh agent. T3 sends a separate checkout and a background agent to delegate_task, so in T3 an owner's build round is a child thread (Own-checkout children). A fresh agent starts pinned to the root's working directory and can't run git in the prior worktree. Later owner rounds inherited the root's worktree lock and wasted 3 Opus rounds (transcript audit, 2026-11-10). A pinned subagent may switch into a worktree under .claude/worktrees/ of the same repo, so EnterWorktree with path gets it there. Step 7 removes the landed branch and the worktrees made for it (Shipping). A subagent reports once, when it returns, so the code-ready report goes to the trail the root reads. Orbit pushes nothing before Opening a PR, so a dead owner's work stays in its worktree. A subagent returns its verdict as text and gitops runs every forge write (Independent verifier). Full shipping would spawn a second verifier on a verified head. The playbook ships in the plugin, not the project's trunk. The judgment model (Opus by default) for owners is orbit's choice, since each owner runs a whole flow. The lanes stay swarm workers, as pstack's "Verification is the exception and stays on the swarm workers model" says, and swarm workers run on code. pstack's swarm workers default was a grok slug at de8ee15, so its lanes brought another family into the verdict, and the audit seat keeps one there. e1cc031 moved that default to claude-opus-5-5-high-fast. Lanes run the app and write scripts, so they stay on Claude (inferred). A child thread can stall or fail, so a clean verdict doesn't wait on it (inferred).

Autopilot-stack

  • pstack. playbooks/autopilot-stack.md. "Run the Autopilot-full playbook, but do not merge." Owners "stop at verified" in place of step 5 and hand the PRs to the operator. A PR that builds on another is based on "the other PR's branch in place of trunk", each PR "rebases onto its parent PR's branch", and "A new head on the lower PR restacks the PRs above it". The root writes no topology of its own.
  • orbit. skills/playbook/playbooks/autopilot-stack.md. It runs playbooks/autopilot-full.md, named as a file. A dependent owner's brief names the parent's branch and its exact tip SHA as the base, in place of origin/main, and the owner starts its own branch at that SHA before any work.
  • Why. Orbit names playbook files, as its other autopilot edits do. The adapter says "Name the branch or commit the worker checks out." Git won't check out a branch that another worktree holds, so the owner starts its own branch at the SHA.

Multi-phase plan

  • pstack. playbooks/multi-phase-plan.md, five steps. Step 2 says "Ask the operator only about a product or preference call that no run can settle." Step 3 says "Write the plan file", with no location. Step 5 says "Hand back the plan path and stop. Execution starts on the operator's explicit go.", and names no execution playbook. It has no skeleton and no check script (2f87c85 deleted check-plan.mjs and its test).
  • orbit. skills/playbook/playbooks/multi-phase-plan.md, with no gates. Under Land main a PR in the plan is a task branch. Step 2 briefs orbit:advisor on a fork no run settles and asks the operator only where rules.md Non-negotiables says to (Test before asking). Unless the operator names a path, the plan goes under $TMPDIR/orbit-autopilot/<slug>/docs/. Step 5 adds that, per Ship by default, the go runs autopilot-full, or autopilot-stack when the operator said "don't ship" or "I'll land it".
  • Why. rules-shared.md Files keeps working notes out of the repo, and $TMPDIR/orbit-autopilot/<slug>/ is the autopilot store the plan's run uses. Ship by default grants landing authority unless the operator opts out (Ship by default), so orbit still names the run that executes the plan. The de8ee15 skeleton's lane placement table and control-skill paragraph clashed with T3 Code's thread and device rules, and the cut removes both. pstack's step 2 reads as a playbook's own question. rules.md Non-negotiables sends such a question to the user as the skill says, so the line kept a plan's forks from the advisor (advisor diff review, 2026-11-20).

Flow wording

  • pstack. Bug reaches the surface "via the control skill (Non-negotiables)", refactoring "via the relevant control skill", and perf "via the matching control skill". Bug uses "Cursor's /loop command". Investigation re-routes "to Bug fix or Feature", says "No PR, no babysit" and "see Autonomy". Prototype says "Route to Feature".
  • orbit. The control skill is the project's verify-* skill when it has one, else /orbit:control-ui or /orbit:control-cli. Bug uses /loop. Investigation and prototype route through /orbit:start <goal>. Investigation says "No commit, no PR, no babysit" and drops the Autonomy pointer. Delegate steps name a fresh orbit:poteto-agent per the Delegate gate. The Worktree gate names hillclimb and figure-it-out runs by the commit type of what they change.
  • Why. A project's own verify skill knows its app. Orbit commits each unit as it passes review, so investigation rules out a commit too. Orbit has no Autonomy section. Branch names must be commit types.

Waived steps

  • pstack. No waiver rule. Prototype covers "a throwaway sketch to make a design or behavioral decision cheaply" (poteto-mode/SKILL.md Playbooks).
  • orbit. start step 2 keeps a step the user waives ("no commit", "no subagents", "skip e2e", "just testing", "quick check") in the todolist as skip: user waived. "Just testing" or "quick check" waives the commit, the PR and shipping. Step 1's prototype line adds brainstorming or iterating on UI the user isn't sure they'll keep.
  • Why. Orbit adds gates and ships by default, so a full flow runs where pstack's would stop at a PR. The user said "no need to put readme or commit this is just testing" and "when we are brainstorming ui dont go all the way u take forever for small changes" (transcript audit, 2026-11-10). The skip stays in the list, where the user can see it and overrule it.

No matching flow

  • pstack. Route to figure-it-out when no bundled playbook fits, or for large, cross-cutting or step-away work. figure-it-out's Start reads "the Principles section of the poteto-mode skill" (skills/figure-it-out/SKILL.md). e1cc031 deleted Orchestrate, so program-scale work routes to figure-it-out too. At de8ee15 a standing project-scale program "routes to Orchestrate instead".
  • orbit. start routes to /orbit:figure-it-out on the same triggers. Program-scale work routes to /orbit:figure-it-out too, as upstream, unless the goal is already a queue of PRs, which routes to autopilot-full. figure-it-out's Start reads the playbook's Principles, Stack rules and gates, and its last todo is Opening a PR when the run changes code.
  • Why. The gates keep a figure-it-out change on the same worktree, delegate and Opening a PR path as every other change.

Dropped playbooks

  • pstack. poteto-mode indexes Runtime forensics, Trace forensics, Visual parity, Eval, Authoring a skill and Autonomous run (poteto-mode/SKILL.md Playbooks). de8ee15 also indexed Orchestrate.
  • orbit. None of them is vendored (the playbook-playbooks skip list in skills.json). start has no route for them, so such a task falls to /orbit:figure-it-out because no flow fits. Orbit removed Orchestrate on 2026-11-17 by operator decision, after upstream deleted it at e1cc031, and program-scale work routes to /orbit:figure-it-out.
  • Why. Orbit's choice. A playbook is adopted when a task needs it, as unvendored skills are (Vendored subset).

create-skill

  • pstack. e1cc031 has no such trigger. de8ee15 said "Agent-facing prose also follows the create-skill skill (Cursor's built-in for authoring SKILL.md files)." (poteto-mode/SKILL.md Non-negotiables)
  • orbit. Dropped from rules.md Non-negotiables.
  • Why. It is Cursor's built-in and not in pstack's skills/, so there is nothing to vendor.

Playbooks as skills

  • pstack. Pause safely, Session pickup and Worktree and simulator cleanup are poteto-mode playbooks. Pause safely writes its note to "a file like /tmp/<slug>-resume.md".
  • orbit. skills/pause-safely, skills/session-pickup and skills/worktree-cleanup, each with its own skills.json entry. pause-safely has gitops commit the wip: checkpoint and writes the resume note to the memory file resume-<slug>.md, one per paused task slug, as pstack names one per slug. session-pickup reads the note for the slug the user names, else the one whose originSessionId matches the prior transcript. session-pickup keeps disable-model-invocation. When a pause hands the thread back to the user, pause-safely lists the PRs the thread watches and calls unwatch_pull_request on each, when those tools are present. Only the lead unwatches, and a subagent or delegated child skips that part of step 1. Before imminent compaction the lead keeps the watches. Either way the resume note names each watched PR and, under T3 Code, the thread's threadId, and says that a watched PR resumes through babysit. The reply names each PR unwatched. session-pickup sends an open PR whose watch a Stop or pause ended to babysit without a new ask. Babysit's Host watcher waits on it, and arms the watch while checks are pending. Pickup reads each PR's state with gh pr view <pr> --json state. When the note records the prior threadId, pickup calls list_thread_pull_requests on that thread and skips a PR it still watches. It also skips a PR the trail unwatched at a handback other than a pause, and never calls watch_pull_request itself. The adapter's Stop row holds both rules (T3 Code host).
  • Why. Each runs outside a task flow, so each needs its own command. A model-invocable pause-safely runs on "pause" or before compaction. rules-shared.md Files puts working notes in auto memory, not the repo, so only the folder differs from pstack. Orbit once wrote one shared resume.md, and a pause in another session overwrote it ("the resume.md was overwritten what work do we have left here?", transcript audit, 2026-11-10). T3's runtime prompt says "Before handback, call unwatch_pull_request on any PR you watch." and "Call watch_pull_request when asked to monitor or babysit, or when work you were asked to do, such as a merge, still waits on checks or reviews, even after an earlier unwatch." (runtimeInstructions.ts:3 in pingdotgg/t3code at c2eb8f3). A compaction keeps the session working, so it is no handback. T3's feature-lifecycles doc says "A Stop also holds the queue, ends the thread's pull request watches, and drops wakes its delegated tasks still owe, so nothing automatic restarts the thread." (docs/orchestration-v2/feature-lifecycles.md:254). So the PR work a Stop or pause cut off is work the user asked for that still waits, and resuming it is the ask. Babysit already waits on the PR per Host watcher, so pickup routes there instead of arming its own. list_thread_pull_requests takes "Thread. Default: this thread." (pr-tools.ts:313 in pingdotgg/t3code at c2eb8f3), and pickup runs in a new session, so a call with no threadId finds none of the prior thread's PRs. The resume note records the prior threadId for that call. A PR the prior thread still watches already wakes that thread, so pickup leaves it there (inferred). A PR the lead unwatched at an ordinary handback had finished its part, so it stays as the user left it (inferred).

Worktree cleanup

  • pstack. The audit reads transcripts from ~/.cursor/projects/<slug>/agent-transcripts and fetches PRs through Origin's CLI, else gh (poteto-mode/scripts/worktree-audit.sh). The pinned and active chats come "from the user or sidebar". Step 6 also clears Cursor's app state (poteto-mode/playbooks/worktree-cleanup.md).
  • orbit. /orbit:worktree-cleanup. The audit reads ~/.claude/projects/<slug>/**/*.jsonl. A worktree's newest session is one started in it or one of the repo's that names its path. A worktree Claude Code has locked is hold-locked and never removed. PRs come from gh only. The active sessions come from the user. The Subagents and Autonomy pointers and the Cursor app-state reclaimer are dropped.
  • Why. Claude Code stores sessions per start path and locks a live session's worktree. Origin's CLI and the sidebar don't exist here, and Claude Code has no Cursor app state.

Maintain verification skill

  • pstack. A changed run ships "at most one PR of proven corrections" (skills/maintain-verification-skill/SKILL.md).
  • orbit. One change of proven corrections goes through Opening a PR. Clean or blocked runs land nothing.
  • Why. Under Land main, Opening a PR leaves an unpushed task branch, not a PR.

ketchup

  • pstack. skills/ketchup/SKILL.md uses /bro's "voice, not its task" and draws charts with "a chart or diagram from /visualize".
  • orbit. skills/ketchup, vendored at the pin without bro. The voice line is inlined. A chart for a trend or comparison goes as inline HTML through html_preview, then html_render, when both T3 tools are present, per the adapter's proof table row (T3 Code host). Without both, /visualize maps to Mermaid charts (xychart-beta or pie). Diagrams stay Mermaid. Autopilot ticks and replies read it by path.
  • Why. ketchup borrows only bro's tone, so one sentence carries it. Orbit vendors no /visualize, and a Mermaid chart is text a reply can carry. T3's system prompt says "Answer data with a trend or comparison with a chart and show any visual the user asks for here: pass an HTML file path or inline HTML to html_preview, then html_render." (orchestrationInstructions.ts:23 in pingdotgg/t3code at c2eb8f3). Ketchup keeps its turn read-only, so the chart goes as inline HTML, not a file it writes.

Control skills

  • pstack. Flows drive the surface with "the matching control skill", control-ui or control-cli from cursor-team-kit. control-ui creates "before/after evidence for verify-this".
  • orbit. skills/control-ui and skills/control-cli, vendored at the pin. The flows, rules.md and the verifier brief fall back to them when a project has no verify-* skill. verify-this becomes the orbit:verifier agent.
  • Why. Without them, a project with no verify skill has no way to run a change as a user would. Orbit vendors no verify-this, and orbit:verifier does its job.

Vendored subset

  • pstack. 58 skills (pstack/skills/).
  • orbit. The subset in skills.json: all 24 principle leaves, arena, ketchup, and deslop, control-ui and control-cli from cursor-team-kit, among others. Every entry pins 0b46ec3. The playbook scripts come from harness/pstack/claude-code/. They first pinned 1ba91fc there, when the 9580c23 scripts still carried orch/ and a test script that runs it. Upstream removed orch in c742dd6.
  • Why. Unvendored skills are adopted when a flow needs them.