Skip to content

pstack-differences.md

Latest commit

 

History

History
353 lines (235 loc) · 54.4 KB

pstack-differences.md

File metadata and controls

353 lines (235 loc) · 54.4 KB
Raw

Differences from pstack

Orbit copies pstack (pstack/ in cursor/plugins) at commit 9580c23, the SHA that most skills.json entries pin. arena and interrogate pin 6b03002, so the pstack. lines about them quote that commit. Every other pstack. line quotes 9580c23, not newer upstream. For Claude Code tool and path mappings, orbit follows pstack's adapter, pstack/docs/harness/claude-code.md. On a design fork, check pstack first. Record each difference here with its reason.

In the orbit. lines, paths under agents/, hooks/ and skills/, and rules.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. Two SessionStart hooks print rules.md every session, split at # Code Quality (hooks/hooks.json). The first line of rules.md sends a goal with no named skill through /orbit:start. Poteto-mode's Non-negotiables follow it. agents/poteto-agent.md reads rules.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 inlines about 10 KB per hook and shows only a 2 KB preview past that, so one hook would drop the end of rules.md. The two parts arrive in the order the hooks finish. Subagents don't get the SessionStart output.

Orbit-written skills

  • pstack. poteto-mode's SKILL.md holds Non-negotiables, Principles, Autonomy, Subagents, Writing the reply, Comments and the playbook index. It has no gates. pstack ships its own correct.
  • orbit. skills/start, skills/ship, skills/correct and skills/playbook/SKILL.md are orbit's text, with no skills.json entry. 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.

Worktree for the main chat

  • pstack. "Work from a git worktree off main", with no tool named. "Dirty branch with unrelated work: patch out, fresh worktree, apply. Snarled worktree: reset from main, redo minimally." (playbooks/opening-a-pr.md)
  • orbit. The Worktree gate (skills/playbook/SKILL.md) calls EnterWorktree named <type>-<slug>, then runs git branch -m <type>/<slug>. It carries both recovery sentences, and they override its skip-when-in-a-worktree rule. "Reset from main" becomes a fresh worktree. Either case runs ExitWorktree with keep first. The worktree and branch stay after landing, until /orbit:worktree-cleanup runs.
  • 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.
  • 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.

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, Opus at high unless the project's advisor row changes it, read-only) with the plan and the sources, and acts on its verdict.
  • 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.

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 and worktree-cleanup. 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, ${CLAUDE_PLUGIN_ROOT}/skills/<name>/SKILL.md. It gives bugbot-triage.md the bundled path ${CLAUDE_PLUGIN_ROOT}/skills/playbook/references/bugbot-triage.md. 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, how, why, architect 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 through sed, which expands ${CLAUDE_PLUGIN_ROOT} to the plugin root.

Commits

  • pstack. No actor named. "Commit liberally" (playbooks/feature.md step 4). "Rebase into small, ordered commits" (feature.md step 6, 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. Flows name the unit order instead of a rebase. Refactor commits 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. Units are committed in order as they pass review, so there is nothing to rebase.

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

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 whose command holds a Co-Authored-By: Claude trailer and tells the agent to commit again without it. It reads only the command, not 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" (playbooks/feature.md) and "your configured hillclimb model" (playbooks/hillclimb.md). Defaults are "grok-4.7-xhigh-fast for code, claude-opus-5-5-xhigh for prose and judgment", and the hardest changes "go to your strongest judgment model" (poteto-mode/SKILL.md Subagents). A grok slug maps to "Omit model so the agent runs on the session model". "Verification is the exception and stays on the swarm workers model and speed". The adapter's setup step says "Never put the role lines in CLAUDE.md or AGENTS.md."
  • orbit. No setup step and no user-level file. A ### Models table in the project's Workflow block replaces pstack-models.md, with | Task | Use for | Model | Effort | rows (rules.md Workflow Defaults, Models). 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) and the rest on the code role, and the lead's reply names each unit no work type fit. Five Task names are orbit's roles. 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, the how explainer, the why synthesizer and reflect's judgment reviewer, divergent reviewer and synthesizer. 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, swarm workers, how explorers, why investigators, reflect's tooling reviewer, multi-phase-plan explorers 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, the trail reviewer and multi-phase-plan's live lanes at high. 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, hillclimb and multi-phase-plan playbooks keep pstack's line minus speed, as "Pick each subagent's reasoning level for the job, per the Delegation section of rules.md." 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, why, reflect and show-me-your-work drop it. 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: high 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.
  • Why. The adapter's setup defaults map 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 hold only those two values by default, so two roles, judgment and code, carry every default. The how explainer, the why synthesizer, reflect's judgment, divergent and synthesizer lines, and "prose and judgment" all default to claude-opus-5-5-xhigh, so they take judgment. A user-level file gives every project one mapping and needs a setup step. 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. That is orbit's answer to the adapter's rule. 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. 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. 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.

Effort ceiling

  • pstack. setup-pstack defaults to budget large, which puts every slug at xhigh. "unlimited, large, medium, and small set the effort token of every real slug ... to max, xhigh, high, or medium", and "large keeps both defaults" (skills/setup-pstack/SKILL.md). "The /setup-pstack budget sets each role's starting level, xhigh by default. Raise it one step, up to max, for the hardest or subtlest work. Lower it one step for judgment and two or more steps for routine work." If the tool rejects the slug, "do not try another adjusted slug. Use 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, and medium or low for routine work. It passes xhigh or max only when a step, a Models row or the user names it. The verifier's frontmatter and multi-phase-plan's live lanes run 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.
  • Why. The user found xhigh not worth its tokens, 2026-11-07. 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.

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. It drops run_in_background. 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.

Fresh subagents

  • pstack. "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" (poteto-mode/SKILL.md Subagents).
  • orbit. The same paragraph in rules.md Delegation, plus one sentence. A resume means a new agent with the earlier result pasted into its brief.
  • Why. The adapter maps resume to spawning a new agent and pasting the earlier result into its brief.

Opus session

  • pstack. Defaults pair Opus with Grok for interrogate adversaries and arena runners. The arena judge "is never from the parent's family", and "With the default pool, a Claude parent gets grok-4.7-xhigh-fast." (skills/arena/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.
  • Why. This follows the adapter's grok mapping (Model per role). The panel loses its model diversity in that case, and orbit accepts that to stay on the adapter. A project that wants diversity adds a code row with a different model.

Panel seats

  • pstack. "For panel roles (arena runners, architect 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). Each default list holds one Claude slug and one grok slug.
  • orbit. No list cells. Interrogate runs arena's default seats as its two adversaries, one on judgment and one on code. Arena and architect's arena 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. The judge runs on the first of the two models that differs from the parent's, and arena skips it when neither differs.
  • Why. A Models cell holds one model. 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.

Trail reviewer

  • pstack. "spawn a subagent on a different model family from the one that did the work" (skills/show-me-your-work/SKILL.md).
  • orbit. The reviewer is an Agent call with model set to a different Claude tier, Sonnet under Opus, else Opus. The Attention header reads reviewed by <model> (same family: no other available).
  • Why. Only Claude models run here. Inheriting the session model would make the reviewer the same model as the worker, so this spawn keeps an explicit tier.

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". Feature step 7 runs it when the design is contested.
  • Why. Orbit has no interrogate reviewers line, and the adapter maps a grok slug to the code model, so arena's default seats keep pstack's default panel. 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. "The judge is never from the parent's family", and "With the default pool, a Claude parent gets grok-4.7-xhigh-fast." "If none of those runs, skip the judge, pick the base alone in Phase D, and say so." (skills/arena/SKILL.md)
  • orbit. 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.
  • Why. Only Claude models run here, so a literal copy of "never from the parent's family" would skip the judge in every session. A different Claude model is the closest stand-in, 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.

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

Project sources in briefs

  • pstack. No rule. Delegates rely on the harness loading AGENTS.md.
  • orbit. templates/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.
  • 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.

Code Quality

  • pstack. No such section.
  • orbit. rules.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.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. At 6b03002, 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) The 9580c23 poteto-mode has no such rule. Upstream commit ab1f702 adds one to restate the user's goal first.
  • 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". poteto-mode's rule is not ported.
  • Why. Orbit doesn't ship in-your-own-words, and one sentence carries it, as ketchup inlines bro's tone. The playbook files track 9580c23, so poteto-mode's rule waits for their bump (docs/trails/pstack-parity.tsv).

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, templates/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 step 9).
  • 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 picks its flow by the rule at the end of autopilot-stack.md (Multi-phase plan). The opt-out withholds that authority, so the plan picks 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, plus "Also pause for a product call that's the user's." It adds "Pushing, merging and opening PRs are not irreversible."
  • Why. A product call is the one fork no experiment can settle. Ship by default pushes and merges, so the rule says those don't pause.

Broken skill mid-task

  • pstack. "fix it in its own PR. Don't block." (poteto-mode/SKILL.md)
  • orbit. A broken orbit skill is fixed in its own PR. Under Land main, that is its own worktree and branch in orbit's repo, with its own Opening a PR run (rules.md Non-negotiables).
  • 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).

PR owner checks

  • pstack. At 9580c23, "A subagent that opens a PR runs interrogate, /deslop, and /no-comments, and posts the URL." The owner "starts the loop after its code-ready report, reports merge-ready or STACK-READY per its playbook" (playbooks/opening-a-pr.md). At 6b03002 the subagent "runs /deslop and /no-comments", and the owner "reports merge-ready".
  • orbit. The subagent runs /orbit:deslop and /orbit:no-comments. The owner writes its code-ready trail row, starts the loop once its PR is open, and reports merge-ready or STACK-READY per its playbook.
  • Why. A subagent reports once, so code-ready is a trail row (Autopilot-full). The PR opens only in Opening a PR, so the loop starts once it is open. Orbit's interrogate pins 6b03002, so the interrogate removal from that commit is ported ahead of the playbook files (skills.json playbook-playbooks). STACK-READY stays until those files move to 6b03002.

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.md "One plain command per Bash call"). It drives prompt changes with claude -p --plugin-dir in a scratch repo.
  • 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.

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 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 (templates/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). Babysit and shipping 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. "Subagents inherit it", or git reset --hard between Task calls. The forge is gh or Origin, never Graphite. A built-in PR tool does every PR write when the run has one. The perf line links "the arena or swarm directory".
  • 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). Parallel delegates get their own worktree per the Delegate gate. gh is the only forge, and the built-in PR tool paragraph is dropped. The perf line links the arena directory. The squash note holds only under a squash merge. A Reply: names the PR URL, or the worktree and branch, and the Next: line.
  • Why. Origin and Graphite are not vendored. The adapter maps a built-in PR tool to the forge command. A swarm returns its report in chat (skills/swarm/SKILL.md Phase D), so there is no swarm directory to link.

Babysit

  • pstack. playbooks/babysit.md. It replaces Cursor's built-in babysit skill. The forge is gh or Origin, each with its own stop conditions. Step 4 bans a "stack-wide submit". Step 6 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 on pstack's main at bb68f23.
  • orbit. skills/playbook/playbooks/babysit.md. 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. gh only. Step 4 drops the stack-wide submit, and an owner's rebase goes through gitops with a pinned lease. Bugbot replies go through gitops, with the payload written by the Write tool. The watcher is pstack's watch-pr in skills/playbook/scripts/, with two 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. Step 6 runs the bare watcher before any host PR watcher and arms the host watcher only on a TIMEOUT whose reason is pending-checks, or queued-stack in queued mode. Shipping step 5 points at that rule. rules.md's Babysit trigger drops the clause about Cursor's built-in babysit skill.
  • Why. Claude Code has no built-in babysit skill, and Origin is not vendored. A stack-wide submit is a Graphite or Origin action (inferred). A bare lease can overwrite a push nobody saw (Force-push). 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, so on a PR with no CI and no reviewer it never fires, and an agent under a host that bans loops armed it and waited on nothing.

Shipping

  • pstack. playbooks/shipping.md. Verifiers are Cursor cloud agents. PRs land bottom-up with --squash. The forge is gh or Origin.
  • orbit. skills/playbook/playbooks/shipping.md, run by Ship by default or /orbit:ship. 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.
  • 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.

Test before asking

  • pstack. Classify a fork and "Sketch it via the Prototype playbook (playbooks/prototype.md)", with the full-autonomy grant clause and "the Always-pause list in Autonomy" (poteto-mode/SKILL.md Non-negotiables).
  • orbit. The same rule, grant clause included, in rules.md Non-negotiables. The sketch runs as /orbit:playbook prototype, and the Always-pause list is the one in Task End.
  • Why. Orbit has no Autonomy section, so its pause list sits in Task End (Task end).

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 drops the rebase. The single owner fans out one orbit:poteto-agent per unit. Parent-level fan-out for independent artifacts runs as read-only agents outside the Delegate gate.
  • Why. Units are committed in order as they pass review (Commits). 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, grok-4.7-xhigh-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 9580c23 (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. The skill runs through the Skill tool.
  • Why. The adapter maps a grok 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).

Architect runners

  • pstack. Phase B runs the arena skill with runners from the architect runners line, claude-opus-5-5-xhigh and grok-4.7-xhigh-fast by default (skills/architect/SKILL.md). Arena spawns "one readonly judge subagent" (skills/arena/SKILL.md).
  • orbit. Phase B runs /orbit:arena. Its runners are orbit:poteto-agent, one on model: "opus" (the judgment model) and one on the code model, each with isolation: "worktree" under the Delegate gate's parallel exception. Each brief carries absolute paths to architect's SKILL.md, references and principle leaves. The judge is 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, gitops commits the base candidate and cherry-picks it, and a fresh orbit:poteto-agent folds in the grafts.
  • Why. The adapter maps the grok runner to the code model and 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. runner-prompt.md reads architect's files at the brief's paths.

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 runs the loop under /loop. An event gets a Monitor watcher with a long time-based heartbeat as fallback.
  • Why. Orbit's own mapping, since the adapter has no row for a watcher subagent. Monitor wakes the session on the event, and no subagent has to poll.

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 unit, 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. It 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 after every unit worth keeping 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, and under Land pr gitops posts the root's verdict line on the PR. A fresh owner takes each later round, and the merge round runs only shipping steps 3 and 4. Under Land main, the merge is gitops pushing HEAD:main. Ticks re-read the playbook without "from trunk".
  • Why. The adapter maps a cloud agent to isolation: "worktree" and resume to a fresh agent. 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.

Autopilot-stack

  • pstack. playbooks/autopilot-stack.md. "You own the stack, never the landing." Owners report STACK-READY, never rebase, and branch from a dependency's branch. The root is the chain's one writer, absorbs drift, and appends each PR with origin pr edit or gh pr edit. Each tick re-reads both playbooks from trunk. A closing paragraph chooses between the autopilots.
  • orbit. skills/playbook/playbooks/autopilot-stack.md. Owners report STACK-READY as a stack-ready <sha> <parent-branch> trail row, and each tip and its intended parent as trail rows. A dependent owner's brief names the parent's branch and its exact tip SHA as the base, and the owner starts its own branch at that SHA. gitops runs the root's rebases, retargets and pushes in the worktree that holds the link's branch, with --force-with-lease pinned to the SHA last pushed or taken over. gh is the only forge. Ticks re-read both playbooks without "from trunk".
  • Why. A subagent reports once, so STACK-READY goes to the trail the root reads, as code-ready does (Autopilot-full). 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, and gitops works in the worktree that holds the link. A bare lease can overwrite a push nobody saw (Force-push). Origin is not vendored. The playbooks ship in the plugin, not the project's trunk.

Multi-phase plan

  • pstack. playbooks/multi-phase-plan.md. Explorers are poteto-agent with "an explicit model per the Subagents section". The plan goes under "the agent store's docs/" and passes node pstack/skills/poteto-mode/scripts/check-plan.mjs. The skeleton reads its files "from trunk", resolves the forge to gh or Origin, and boots each live lane "on its own cloud VM". The owner "squash-merges".
  • orbit. skills/playbook/playbooks/multi-phase-plan.md, with no gates. Explorers are orbit:poteto-agent on the code model. The plan goes under $TMPDIR/orbit-autopilot/<slug>/docs/ and passes the vendored scripts/check-plan.mjs. The template's <swarm workers model> becomes <code model>, and the script's Verify, live error names it. The plan picks autopilot-full or autopilot-stack by the rule at the end of autopilot-stack.md, and per Ship by default the run may merge unless the operator opts out. The orchestrate.md sentence is dropped. Skeleton paths start with <orbit playbook dir>, and only the control skill reads from trunk. gh is the only forge. Each live lane is a swarm worker on the code model in its own worktree, on ports no other lane uses. The gates lane re-runs the Check line. The boot recipe checks out the head SHA without git fetch origin <head-branch>. The review gate posts media paths, and the owner merges with the Land line's method.
  • Why. Orchestrate is not vendored, and Origin and cloud VMs are not here. Orbit has no swarm workers line, so the placeholder names the code role that swarm workers run on. Explorers read and report, so they take the code role, as how explorers do. Orbit's playbooks ship in the plugin, not the project's trunk. All lanes share one machine and the repo's objects. The Check line is the Workflow block's name for the repo's gates. Under Land main the head branch is never pushed, so the fetch would fail. A Claude Code reply is text, so it can't carry the media. Ship by default grants landing authority unless the operator opts out (Ship by default).

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.

No matching flow

  • pstack. Route to figure-it-out when no bundled playbook fits, or for large, cross-cutting or step-away work. A standing project-scale program "routes to Orchestrate instead". figure-it-out's Start reads "the Principles section of the poteto-mode skill" (skills/figure-it-out/SKILL.md).
  • orbit. start routes to /orbit:figure-it-out on the same triggers. A standing project-scale program routes to multi-phase-plan. 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. Orchestrate is not ported, so multi-phase-plan takes the standing program. 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 or modifying a skill, Autonomous run and Orchestrate (poteto-mode/SKILL.md Playbooks).
  • orbit. Not 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.
  • Why. Orbit's choice. A playbook is adopted when a task needs it, as unvendored skills are (Vendored subset).

create-skill

  • pstack. "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.md. session-pickup keeps disable-model-invocation.
  • 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.md Files puts working notes in auto memory, not the repo.

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, and /visualize maps to Mermaid charts (xychart-beta or pie). 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.

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 9580c23 except arena and interrogate, which pin 6b03002, and the playbook scripts, which pin 1ba91fc from harness/pstack/claude-code/. At 9580c23 the scripts still carry orch/ and a test script that runs it, and upstream removed orch in c742dd6.
  • Why. Unvendored skills are adopted when a flow needs them.