@coreplane/switchboard 1.233.0 → 1.234.0

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.233.0",
+  "version": "1.234.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.233.0",
+      "version": "1.234.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20032,7 +20032,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.233.0",
+      "version": "1.234.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@earendil-works/pi-ai": "0.85.1",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.233.0",
+  "version": "1.234.0",
   "private": true,
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.233.0",
-  "commit": "4c96f69d476e76e2bc768a9eb6d505b683fddd36",
-  "builtAt": "2026-09-16T15:18:25.322Z"
+  "version": "1.234.0",
+  "commit": "0c5f8c5e4657cd12a9bbf85177bee69b61505ac3",
+  "builtAt": "2026-09-16T16:44:55.183Z"
 }

package/dist/assets/src/agents/registry.ts

@@ -96,9 +96,10 @@ export interface AgentDef {
    *  router's table is rendered from this registry. `false` keeps a preset
    *  out of the table — structurally: it is absent from the table the model
    *  is shown and refused as a single route even if the model names it.
-   *  `ship` (it holds the merge grant) opts out for good; `conductor` (it
-   *  starts other runs) opts out of the table and is reached through the
-   *  router's compound form alone, with its parts named. */
+   *  `coding` (a bare write ask deserves the review loop, so `ship` holds its
+   *  seat) opts out; `conductor` (it starts other runs) opts out of the table
+   *  and is reached through the router's compound form alone, with its parts
+   *  named. */
   routable?: false;
   /** System prompt variant for resident-repo runs (docs/reference/specs/resident-repos.md):
    *  the workspace is a ready worktree — no cloning, no installs, no repo
@@ -535,6 +536,11 @@ const WORK_PRESETS = {
     // `config set channel efforts.coding=…`, or `effort:` per request).
     machine: "repo-resident",
     identity: "write", // pushes branches and opens pull requests
+    // Never routed: a plain write ask deserves the coding → review loop, so
+    // the router's table offers `ship` in coding's seat — a routed ship runs
+    // a generated one-unit plan whose merge is a person's, never the runner's.
+    // A request that wants a bare coding run names it — `agent:coding`.
+    routable: false,
   },
   review: {
     name: "review",
@@ -568,10 +574,10 @@ const WORK_PRESETS = {
     toolset: "full",
     machine: "repo-resident",
     identity: "write",
-    // Never routed: ship is the plan runner and holds the merge grant, so a
-    // wrong route into it is code landing on main, not a stray pull request.
-    // A request that wants it names it — `agent:ship`.
-    routable: false,
+    // Routable: a routed ship runs a generated one-unit plan whose merge is a
+    // person's (`merge: person`) and never a seeded plan (the hand-off refuses
+    // a routed `plan <path>.md` naming `agent:ship`), so a wrong route costs a
+    // reviewed pull request, never code landing on main.
     maxTurns: 1,
     maxTokens: 16000,
     maxMinutes: 120,

package/dist/assets/src/core/provider.ts

@@ -38,12 +38,15 @@ export interface CompletionRequest {
   system?: string;
   messages: ChatMessage[];
   tools?: ToolDef[];
-  /** Force one of `tools`: the model must answer by calling the named tool,
-   *  so the call's input IS the answer and prose cannot occur (the request
-   *  router's shape, routing-and-config item 21). Anthropic: `tool_choice:
-   *  {type: "tool", name}`; Chat Completions: `tool_choice: {type: "function",
-   *  function: {name}}`. Absent → the model chooses. */
-  toolChoice?: { type: "tool"; name: string };
+  /** Force tool calling (the request router's shape, routing-and-config item
+   *  21). `{type: "tool", name}` forces the named tool — Anthropic:
+   *  `tool_choice: {type: "tool", name}`; Chat Completions: `tool_choice:
+   *  {type: "function", function: {name}}` — so the call's input IS the answer
+   *  and prose cannot occur. `{type: "any"}` forces one call to some tool of
+   *  `tools` — spelled `"any"` on Anthropic's Messages API and `"required"` on
+   *  Chat Completions, with parallel tool calls switched off on the wire so
+   *  the answer is exactly one call. Absent → the model chooses. */
+  toolChoice?: { type: "tool"; name: string } | { type: "any" };
   maxTokens: number;
   /** model effort hint; providers apply it only where the model supports it */
   effort?: Effort;

package/dist/assets/src/core/runEvents.ts

@@ -137,6 +137,14 @@ export type RunNoteKind =
    *  attach, before the first turn, so the run page explains a follow-up that
    *  runs on the default instead of on its thread's PR. */
   | "rebind_refused"
+  /** The run ended with uncommitted changes or unpushed commits in its
+   *  workspace, and they do not outlive it: a run starts from a clean tree
+   *  (docs/reference/specs/resident-repos.md item 17), so the release that
+   *  follows the reply discards them. The summary names both counts and what
+   *  to do instead (commit and push). Read off the workspace by the run loop
+   *  after the model's last turn — the release itself runs after the record
+   *  is sealed — and set on the card's label too, so the loss is never silent. */
+  | "work_left_behind"
   /** A coding run submitted a PR description but the post-step opened no
    *  pull request because the branch it observed IS the base the pull
    *  request would target (docs/reference/specs/pr-description.md item 5) —
@@ -201,6 +209,7 @@ export const RUN_NOTE_KINDS = [
   "verdict_turn",
   "cold_sandbox",
   "rebind_refused",
+  "work_left_behind",
   "pr_not_opened",
   "review_not_posted",
   "compacted",
@@ -483,11 +492,20 @@ export type RunEvent =
       model?: string;
       /** The request's trace id (docs/reference/specs/tracing.md), once the root exists. */
       traceId?: string;
+      /** The harness the run is driven by (`Harness.name`; docs/reference/specs/harness.md
+       *  item 8): `pi` today. Absent on a command run, which starts no process,
+       *  and on a record written before the seam existed. Additive. */
+      harness?: string;
       effort?: string;
       repo?: string;
       ref?: string;
       pr?: number;
       headSha?: string;
+      /** The plan runner instance whose story this record is (agent-ship item
+       *  17): written on the pipeline's own record alone, so its page can list
+       *  the instance's units. A child's instance rides the record's
+       *  `parentInstanceId`, never here. */
+      instanceId?: string;
       seq?: number;
       at?: number;
     }

package/dist/assets/src/execution/residentCleanliness.ts

@@ -5,7 +5,7 @@
  *  shipped code.
  *
  *  Background: the check used to be three sequential container spawns per
- *  binding (`test -d`, `su … git status --porcelain`, `su … git rev-list
+ *  binding (`test -d`, `su … git status --porcelain -uno`, `su … git rev-list
  *  --count HEAD --not --remotes`), and `isIdle()` ran it serially per live
  *  binding — every refresh cycle's idle gate paid 3×N process round-trips.
  *  The three probes fold into one `sh -c` script; the DECISION semantics are
@@ -42,7 +42,7 @@ export function worktreeCleanlinessScript(worktreePath: string, user: string): s
   const inner = [
     `t=$(mktemp) || { echo gitrc=1; echo 'giterr=mktemp failed'; exit 0; }`,
     `cd ${wt} 2>"$t" || { echo gitrc=1; printf 'giterr=%s\\n' "$(grep -m 1 . "$t" || echo 'cd failed')"; rm -f "$t"; exit 0; }`,
-    `s_out=$(git status --porcelain 2>"$t"); s_rc=$?; s_err=$(grep -m 1 . "$t" || true)`,
+    `s_out=$(git status --porcelain -uno 2>"$t"); s_rc=$?; s_err=$(grep -m 1 . "$t" || true)`,
     `a_out=$(git rev-list --count HEAD --not --remotes 2>"$t"); a_rc=$?; a_err=$(grep -m 1 . "$t" || true)`,
     `rm -f "$t"`,
     `if [ "$s_rc" -ne 0 ] || [ "$a_rc" -ne 0 ]; then`,
@@ -66,6 +66,40 @@ export function worktreeCleanlinessScript(worktreePath: string, user: string): s
 export interface WorktreeCleanliness {
   clean: boolean;
   reason?: string;
+  /** What the probes counted, when they ran: the tracked files `git status
+   *  --porcelain -uno` listed as changed — item 17's definition of dirt, the
+   *  same the run loop counts for its note, so the card and the release log
+   *  name one number; untracked scratch is the thread's own and not work —
+   *  and the commits on no remote branch. Absent when the tree is missing or
+   *  a probe failed. */
+  changes?: number;
+  unpushed?: number;
+}
+
+/** What a release discards (docs/reference/specs/resident-repos.md item 16a):
+ *  the counts a run left in its tree, named in the detach answer and the
+ *  bot's log so the loss is never silent. */
+export interface LeftBehind {
+  uncommittedChanges: number;
+  unpushedCommits: number;
+}
+
+/** The counts the probes measured, as what a release leaves behind: nothing
+ *  when the probes could not run (a tree that is gone or unreadable) and
+ *  nothing when both are zero — the answer names only a loss. */
+export function leftBehindOf(measured: WorktreeCleanliness): LeftBehind | undefined {
+  if (measured.changes === undefined || measured.unpushed === undefined) return undefined;
+  if (measured.changes === 0 && measured.unpushed === 0) return undefined;
+  return { uncommittedChanges: measured.changes, unpushedCommits: measured.unpushed };
+}
+
+/** The bot's word for a discarded tree, in the release log and the run's
+ *  record: what was left, why it is gone, what to do instead. */
+export function leftBehindSentence(left: LeftBehind): string {
+  return (
+    `${left.uncommittedChanges} uncommitted change(s) and ${left.unpushedCommits} unpushed commit(s) were left in the worktree; ` +
+    "a run starts from a clean tree, so they were discarded — commit and push what must be kept"
+  );
 }
 
 /** Decide from the script's tagged output. Unknown (missing/failed tags,
@@ -89,7 +123,13 @@ export function parseWorktreeCleanliness(r: {
   }
   const changes = Number(tags.get("changes")) || 0;
   const unpushed = Number(tags.get("unpushed")) || 0;
-  if (changes > 0 || unpushed > 0)
-    return { clean: false, reason: `dirty: ${changes} uncommitted change(s), ${unpushed} unpushed commit(s)` };
-  return { clean: true };
+  if (changes > 0 || unpushed > 0) {
+    return {
+      clean: false,
+      reason: `dirty: ${changes} uncommitted change(s), ${unpushed} unpushed commit(s)`,
+      changes,
+      unpushed,
+    };
+  }
+  return { clean: true, changes, unpushed };
 }

package/dist/assets/src/execution/residentRebind.ts

@@ -16,21 +16,34 @@
  *
  *  Shape: the caller names the reason for its hint (`ownPr`: the pull request
  *  the thread's own run opened and its head branch — never a PR a person
- *  named). The resident moves the binding only when all of these hold:
+ *  named). The move is a decision about the BINDING alone; the tree is the
+ *  attach's business afterwards (item 17: a run starts from a clean tree at
+ *  the bound ref, so the attach provisions the tree at the moved ref as it
+ *  provisions any other). The resident moves the binding only when all of
+ *  these hold:
  *  - the binding was made by default (the first message named no branch), read
  *    off `boundBy`, or, for a binding made before that field, off whether the
  *    ref is the default branch — a ref a person named is never moved;
- *  - the thread was not rebound before — a thread moves once;
- *  - the branch is a local branch of the thread's OWN worktree — the physical
- *    fact that this thread's run created it; a branch the tree never made is
- *    refused whatever the caller says;
- *  - the tree has no uncommitted tracked changes — never at the cost of work —
- *    unless its HEAD is already the branch: the run made the branch in this
- *    tree and left an edit after pushing, so the record alone moves and no
- *    git command touches the tree.
- *  The move is a `git checkout` inside the existing tree: same path, same pool
- *  user, deps and snapshot lineage untouched. Every refusal is named in the
- *  attach answer so the bot can say why the follow-up runs where it does. */
+ *  - the thread was not rebound before, or its earlier move was returned (the
+ *    second movement below) — a thread moves once per pull request;
+ *  - the branch is the thread's own: remembered from a release (`ownBranches`,
+ *    the branches its runs pushed), or, when nothing was remembered, a local
+ *    branch of the thread's surviving tree — the physical fact that this
+ *    thread's run created it. A branch neither remembered nor local is
+ *    refused whatever the caller says; so is one the mirror does not hold
+ *    even after a fetch (the Worker's check: the tree is cloned from it).
+ *  Every refusal is named in the attach answer so the bot can say why the
+ *  follow-up runs where it does.
+ *
+ *  The second movement: a rebound binding names a branch that can die — the
+ *  pull request merges and the branch is deleted. A binding left on it would
+ *  fail every later attach (`unknown-ref`) for the thread's whole life. So a
+ *  binding a rebind moved, whose branch the mirror no longer holds after a
+ *  fetch, goes back to the default it was bound to (`canReturnToDefault`,
+ *  `returnToDefault`); the attach provisions the tree there, clean, and the
+ *  thread is default-bound again, so a later own pull request may move it once
+ *  more. A ref a person named that vanished keeps the `unknown-ref` refusal:
+ *  that branch is the person's to sort out. */
 
 /** The pull request the thread's own run opened, and its head branch — the
  *  reason a caller's refHint is that branch. */
@@ -145,15 +158,29 @@ export function boundByOf(binding: { ref: string; boundBy?: BoundBy }, defaultRe
   return binding.boundBy ?? (binding.ref === defaultRef ? "default" : "name");
 }
 
-/** The record a rebind leaves on the binding and in the attach answer. */
+/** The record a rebind leaves on the binding and in the attach answer: from
+ *  which ref, onto which branch, for which pull request, when. `returnedAt`:
+ *  that branch was gone from the mirror at a later attach and the binding
+ *  went back to the default (the second movement) — a returned move no
+ *  longer counts as the thread's one move. */
 export interface Rebound {
   from: string;
   to: string;
   pr: number;
   at: string;
+  returnedAt?: string;
+}
+
+/** The move back, in the attach answer: from the branch that is gone, to the
+ *  default, for the pull request whose branch it was, when. */
+export interface Returned {
+  from: string;
+  to: string;
+  pr: number;
+  at: string;
 }
 
-export type RebindRefusal = "named-ref" | "already-rebound" | "branch-absent" | "dirty" | "checkout-failed";
+export type RebindRefusal = "named-ref" | "already-rebound" | "branch-absent";
 
 /** Why the binding stood, in the attach answer: the branch it was asked to
  *  move to, the pull request, the reason and its sentence. */
@@ -182,9 +209,10 @@ export type RebindPlan =
   | { kind: "none" }
   /** The binding alone rules it out; nothing on disk is consulted. */
   | { kind: "refuse"; refused: RebindRefused }
-  /** The binding allows it and has a live tree; the tree decides
-   *  (`rebindVerdict`). `own`: the thread's own runs pushed the branch, so a
-   *  tree that turns out missing may still be recreated at it. */
+  /** The binding allows it and has a live tree. `own`: the thread's own runs
+   *  pushed the branch, as the binding remembers it — the fact that decides;
+   *  when nothing was remembered, the tree's local branch is the fallback
+   *  evidence (`rebindVerdict`). */
   | { kind: "measure"; from: string; to: string; pr: number; own: boolean }
   /** The binding allows it, its tree was evicted, and the thread's own runs
    *  pushed the branch: the binding moves and the attach recreates the tree
@@ -217,7 +245,10 @@ export function rebindPlan(input: {
       ),
     };
   }
-  if (binding.rebound) {
+  // A move that was returned (its branch gone, the binding back on the
+  // default) no longer stands in the way: the thread may follow its next
+  // pull request as it followed the first.
+  if (binding.rebound && binding.rebound.returnedAt === undefined) {
     const r = binding.rebound;
     return {
       kind: "refuse",
@@ -243,42 +274,30 @@ export function rebindPlan(input: {
   return { kind: "measure", from: binding.ref, ...plan, own };
 }
 
-/** What the attach measured about the thread's tree, as the thread user. Each
- *  probe past `exists` is measured only when the tree is there. */
+/** What the attach measured about the thread's tree, as the thread user —
+ *  only when the binding remembers no push of the branch: the tree is then
+ *  the only place the branch's origin can be read. */
 export interface RebindTreeFacts {
   /** `<worktree>/.git` is a directory. */
   exists: boolean;
-  /** `git rev-parse --verify --quiet refs/heads/<to>` succeeded in the tree. */
+  /** `git rev-parse --verify --quiet refs/heads/<to>` succeeded in the tree;
+   *  false for a branch the tree never made and for a tree git cannot read
+   *  (neither verifies anything). */
   branchExists?: boolean;
-  /** `git status --porcelain -uno` ran: false is a tree git cannot read
-   *  (corrupt, or owned by an earlier pool user), where nothing is verifiable. */
-  readable?: boolean;
-  /** `git status --porcelain -uno` listed a tracked change (untracked scratch
-   *  files are the thread's own state and survive a checkout). */
-  dirty?: boolean;
-  /** `git rev-parse --abbrev-ref HEAD` in the tree — the branch checked out
-   *  (`HEAD` when detached) — measured once the tree is dirty: the one fact
-   *  that tells a dirty tree already on the branch from one elsewhere. */
-  head?: string;
 }
 
 export type RebindVerdict =
-  /** Move the binding. `checkout: true`: check the branch out in the existing
-   *  tree. `checkout: false`: the tree is dirty but its HEAD is already the
-   *  branch — the run made it here and left an edit after pushing — so only
-   *  the record moves; no checkout, no fetch, no reset, the tree not touched
-   *  by the rebind (`note` says so for the log). */
-  | { kind: "rebind"; checkout: true }
-  | { kind: "rebind"; checkout: false; note: string }
-  /** The tree is gone (a slept container) and the thread's own runs pushed the
-   *  branch: move the binding and let the attach recreate the tree at it. */
-  | { kind: "recreate" }
-  | { kind: "refuse"; refused: RebindRefused };
+  /** The branch is the thread's own: move the binding. The tree is not this
+   *  verdict's concern — the attach provisions it at the moved ref (item 17),
+   *  once the Worker has seen the mirror hold the branch. */
+  { kind: "rebind" } | { kind: "refuse"; refused: RebindRefused };
 
-/** The tree's verdict on a measured plan. */
+/** Whether the branch is the thread's own, for a measured plan: the memory of
+ *  a release decides by itself; without it, the surviving tree must hold the
+ *  branch as a local branch. */
 export function rebindVerdict(plan: { to: string; pr: number; own?: boolean }, tree: RebindTreeFacts): RebindVerdict {
+  if (plan.own === true) return { kind: "rebind" };
   if (!tree.exists) {
-    if (plan.own === true) return { kind: "recreate" };
     return {
       kind: "refuse",
       refused: rebindRefused(
@@ -288,46 +307,42 @@ export function rebindVerdict(plan: { to: string; pr: number; own?: boolean }, t
       ),
     };
   }
-  if (tree.readable === false) {
-    return {
-      kind: "refuse",
-      refused: rebindRefused(
-        plan,
-        "branch-absent",
-        "the thread's worktree cannot be read; the branch cannot be verified there",
-      ),
-    };
-  }
   if (tree.branchExists !== true) {
     return {
       kind: "refuse",
       refused: rebindRefused(
         plan,
         "branch-absent",
-        `${JSON.stringify(plan.to)} is not a local branch of the thread's worktree; only a branch this thread's own run made moves it`,
+        `${JSON.stringify(plan.to)} is not a local branch of the thread's worktree and none of its runs pushed it; only a branch this thread's own run made moves it`,
       ),
     };
   }
-  if (tree.dirty === true) {
-    // A dirty tree whose HEAD is the branch has nothing a checkout could
-    // cost: the run created the branch in this very tree and left the edit
-    // after pushing, and only the record still names the old ref. Moving
-    // the record is the whole move. Any other HEAD keeps the guard.
-    if (tree.head === plan.to) {
-      return {
-        kind: "rebind",
-        checkout: false,
-        note: `the worktree is dirty but its HEAD is already ${JSON.stringify(plan.to)} (the run made the branch here); the binding moves, the tree is not touched`,
-      };
-    }
-    return {
-      kind: "refuse",
-      refused: rebindRefused(
-        plan,
-        "dirty",
-        "the worktree has uncommitted changes on the bound branch; the binding stands until they are committed or discarded",
-      ),
-    };
-  }
-  return { kind: "rebind", checkout: true };
+  return { kind: "rebind" };
+}
+
+/** Whether a binding whose ref the mirror no longer holds goes back to the
+ *  default branch (the second movement): only a binding a rebind moved onto
+ *  its own pull request's branch — bound by default in the first place, still
+ *  on that branch, the move not yet returned. Anything else keeps the
+ *  attach's `unknown-ref` refusal: a ref a person named is that person's to
+ *  sort out, and a binding on the default cannot lose its ref. */
+export function canReturnToDefault(
+  binding: { ref: string; boundBy?: BoundBy; rebound?: Rebound },
+  defaultRef: string,
+): boolean {
+  const r = binding.rebound;
+  if (r === undefined || r.returnedAt !== undefined || binding.ref !== r.to) return false;
+  return binding.ref !== defaultRef && boundByOf(binding, defaultRef) === "default";
+}
+
+/** The move back: the binding's ref becomes the default and the move that
+ *  brought it here is stamped returned, so the thread may move again. Only
+ *  ever applied to a binding `canReturnToDefault` admitted. */
+export function returnToDefault<B extends { ref: string; rebound?: Rebound }>(
+  binding: B & { rebound: Rebound },
+  defaultRef: string,
+  at: string,
+): { binding: B; returned: Returned } {
+  const returned: Returned = { from: binding.ref, to: defaultRef, pr: binding.rebound.pr, at };
+  return { binding: { ...binding, ref: defaultRef, rebound: { ...binding.rebound, returnedAt: at } }, returned };
 }

package/dist/assets/src/execution/residentReuse.ts

@@ -16,11 +16,11 @@
  *  PROVISIONS (a fresh one). A reusing attach keeps a readable tree exactly
  *  as it stands, dirt and stale HEAD included, and refuses by name a tree it
  *  cannot keep (gone, unreadable, built for the other mode) without touching
- *  it. A provisioning attach keeps the dirty/stale discipline byte for byte —
- *  with one exception it is told about (`keepTree`): when its own rebind onto
- *  the thread's pull request branch found the tree dirty with that branch
- *  already checked out and moved the record alone, the dirt is the thread's
- *  own work and the tree is kept as it stands. */
+ *  it. A provisioning attach keeps the dirty/stale discipline byte for byte:
+ *  a run starts from a clean tree at the bound ref's tip, and what a run
+ *  wants kept it commits and pushes (docs/reference/specs/resident-repos.md
+ *  item 17) — so a tree left dirty, or on a branch the binding has since
+ *  moved away from, is recreated, never repaired. */
 
 export type ParsedReuse = { reuse: boolean } | { error: string };
 
@@ -62,15 +62,6 @@ export type WorktreeDecision =
 export function decideWorktree(input: {
   /** True for a resumed run's attach: keep the tree, never wipe it. */
   reuse: boolean;
-  /** True when this attach's rebind moved the binding onto the branch the
-   *  tree already had checked out, dirty, and promised not to touch it
-   *  (residentRebind.ts, the `checkout: false` verdict): the dirt is the
-   *  thread's own uncommitted work on its own pull request branch, so a
-   *  readable tree is kept as it stands — dirt and HEAD included, like a
-   *  resumed run's — while a tree that turns out missing, unreadable or built
-   *  for the other mode has nothing to keep and is provisioned like any fresh
-   *  attach's. Absent on every attach that did not make that move. */
-  keepTree?: boolean;
   /** The tree was built for the other mode (read-only against writable). */
   modeSwitch: boolean;
   /** The commit a provisioning attach checks out: the ref's tip, or the expected head. */
@@ -78,7 +69,7 @@ export function decideWorktree(input: {
   worktreePath: string;
   facts: WorktreeFacts;
 }): WorktreeDecision {
-  const { reuse, keepTree = false, modeSwitch, sha, worktreePath, facts } = input;
+  const { reuse, modeSwitch, sha, worktreePath, facts } = input;
   if (modeSwitch) {
     return reuse
       ? {
@@ -105,9 +96,7 @@ export function decideWorktree(input: {
   }
   // A reusing attach judges nothing past readability: the dirt and the HEAD are the run's own state.
   if (reuse) return { kind: "reuse" };
-  // The rebind promised a dirty tree on its own branch would not be touched;
-  // the dirt is the reason it made that promise, so it is not a reason to wipe.
-  if (facts.dirty) return keepTree ? { kind: "reuse" } : { kind: "recreate", why: "dirty" };
+  if (facts.dirty) return { kind: "recreate", why: "dirty" };
   if (facts.head !== sha && facts.descendsFromTip !== true) return { kind: "recreate", why: "stale" };
   return { kind: "reuse" };
 }

package/dist/assets/src/execution/residentSteps.ts

@@ -18,7 +18,6 @@ export const RESIDENT_STEP_LABELS = {
   "for-each-ref": "listing the branches",
   checkout: "checking out the branch",
   "checkout-update": "updating the checkout",
-  "rebind-checkout": "checking out the thread's own branch",
   "rev-parse": "reading the commit",
   "cat-file": "checking the mirror for the commit",
   "show-ref": "reading the branch tip",