@coreplane/switchboard 1.231.1 → 1.232.0

package/dist/assets/deploy/cloudflare-resident/worker.ts

@@ -1110,9 +1110,12 @@ const NO_REF_HINT_REASON: RefHintReason = { ownPr: null, refByDefault: false };
 type RebindOutcome =
   | { kind: "none"; binding: ThreadBinding }
   | { kind: "refuse"; refused: RebindRefused }
-  /** `note`: the move was the record alone — a dirty tree already on the
-   *  branch, no checkout run — in the verdict's words, for the log line. */
-  | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound; note?: string };
+  | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound; keepTree: false }
+  /** The move was the record alone — a dirty tree already on the branch, no
+   *  checkout run — with the verdict's `note` for the log line. The attach
+   *  that follows must keep that tree (`keepTree`, the worktree step's word
+   *  for it): the promise the note makes is the attach's to keep. */
+  | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound; keepTree: true; note: string };
 
 /** Result of one /op test/build execution. `ok` is the command's
  *  verdict — a failing test run is a RESULT with ok:false, never an error. */
@@ -4570,6 +4573,7 @@ export class ResidentDO extends Sandbox<Env> {
         refHint,
         wantSha,
         reuse,
+        keepTree: rebind.keepTree === true,
         slug,
         t0,
         facts,
@@ -4595,16 +4599,32 @@ export class ResidentDO extends Sandbox<Env> {
    *  mirror mutex so no other attach of the thread touches the tree meanwhile.
    *  The rest of the attach then runs on the moved ref: the mirror fetch for
    *  the PR head (item 51) and item 17's stale check, which keeps a tree whose
-   *  HEAD is the ref's tip or a descendant of it. The binding records the move
-   *  (`rebound`); the answer carries it, or the named refusal, so the bot can
-   *  say where the follow-up runs and why. A refusal never fails the attach. */
+   *  HEAD is the ref's tip or a descendant of it. When the verdict moved the
+   *  record alone — a dirty tree with the branch already checked out — the
+   *  answer says so (`keepTree`) and the worktree step keeps that tree, dirt
+   *  included, instead of item 17's dirty wipe: the promise not to touch it is
+   *  the whole attach's. The binding records the move (`rebound`); the answer
+   *  carries it, or the named refusal, so the bot can say where the follow-up
+   *  runs and why. A refusal never fails the attach. */
   private async rebindToOwnPr(
     prior: ThreadBinding | undefined,
     ownPr: OwnPr | null,
     reuse: boolean,
     defaultRef: string,
     slug: string,
-  ): Promise<{ binding: ThreadBinding | undefined; rebound?: Rebound; rebindRefused?: RebindRefused } | ThreadErr> {
+  ): Promise<
+    | {
+        binding: ThreadBinding | undefined;
+        rebound?: Rebound;
+        rebindRefused?: RebindRefused;
+        /** The move was the record alone — the tree is dirty with the branch
+         *  already checked out — and the attach must keep that tree as it
+         *  stands: the worktree step's item 17 wipe of a dirty tree would
+         *  destroy the very work the rebind declined to touch. */
+        keepTree?: true;
+      }
+    | ThreadErr
+  > {
     const plan = rebindPlan({ ownPr, reuse, binding: prior, defaultRef });
     if (plan.kind === "none" || prior === undefined) return { binding: prior };
     if (plan.kind === "refuse") return { binding: prior, rebindRefused: plan.refused };
@@ -4704,8 +4724,8 @@ export class ResidentDO extends Sandbox<Env> {
           const moved: ThreadBinding = { ...current, ref: again.to, rebound };
           await this.ctx.storage.put(key, moved);
           return verdict.checkout
-            ? { kind: "rebound", moved, rebound }
-            : { kind: "rebound", moved, rebound, note: verdict.note };
+            ? { kind: "rebound", moved, rebound, keepTree: false }
+            : { kind: "rebound", moved, rebound, keepTree: true, note: verdict.note };
         }, ATTACH_MUTEX_WAIT_MS)
       ).value;
     } catch (err) {
@@ -4723,10 +4743,16 @@ export class ResidentDO extends Sandbox<Env> {
       return { binding: prior, rebindRefused: outcome.refused };
     }
     const { moved, rebound } = outcome;
+    if (!outcome.keepTree) {
+      console.log(
+        `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr})`,
+      );
+      return { binding: moved, rebound };
+    }
     console.log(
-      `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr})${outcome.note ? ` — ${outcome.note}` : ""}`,
+      `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr}) — ${outcome.note}`,
     );
-    return { binding: moved, rebound };
+    return { binding: moved, rebound, keepTree: true };
   }
 
   /** The move when the thread's tree is gone (item 16): the binding's ref
@@ -4781,7 +4807,7 @@ export class ResidentDO extends Sandbox<Env> {
     };
     const moved: ThreadBinding = { ...current, ref: plan.to, rebound };
     await this.ctx.storage.put(threadBindingKey(current.threadKey), moved);
-    return { kind: "rebound", moved, rebound };
+    return { kind: "rebound", moved, rebound, keepTree: false };
   }
 
   /** The release's word on what the run pushed (`/detach` `pushed`, item
@@ -4809,6 +4835,10 @@ export class ResidentDO extends Sandbox<Env> {
     refHint: string | null;
     wantSha: string | null;
     reuse: boolean;
+    /** The rebind moved the record alone over a dirty tree already on the
+     *  branch (item 16) and promised not to touch it: the worktree step keeps
+     *  the tree as it stands instead of item 17's dirty wipe. */
+    keepTree: boolean;
     slug: string;
     t0: number;
     facts: RepoFacts;
@@ -4820,7 +4850,7 @@ export class ResidentDO extends Sandbox<Env> {
     rebound?: Rebound;
     rebindRefused?: RebindRefused;
   }): Promise<AttachOk | ThreadErr> {
-    const { threadKey, refHint, wantSha, reuse, slug, t0, facts, record, binding, mode, rollback } = input;
+    const { threadKey, refHint, wantSha, reuse, keepTree, slug, t0, facts, record, binding, mode, rollback } = input;
     const { rebound, rebindRefused } = input;
 
     // Command-level token mint — before the lock so mint latency
@@ -4899,6 +4929,7 @@ export class ResidentDO extends Sandbox<Env> {
         const recreated = await this.ensureThreadWorktree(binding, sha, mode.originUrl, mode.modeSwitch, {
           detached: target.kind === "sha",
           reuse,
+          keepTree,
         });
         return { sha, threadLockKey, recreated };
       }, ATTACH_MUTEX_WAIT_MS);
@@ -5003,10 +5034,13 @@ export class ResidentDO extends Sandbox<Env> {
    *  trees; a reusing attach (`opts.reuse`, item 66) keeps a readable tree
    *  exactly as it stands (the dirt and the HEAD are the resumed run's own
    *  work) and throws `ReuseRefusedError` for one it cannot keep, touching
-   *  nothing. The decision is the pure `decideWorktree`; this method measures
-   *  the facts and runs the verdict. Returns true when the tree was
-   *  (re)created. MUST be called holding the mirror mutex: the clone reads
-   *  the mirror.
+   *  nothing; a provisioning attach whose own rebind moved the record alone
+   *  over a dirty tree already on the branch (`opts.keepTree`, item 16) keeps
+   *  that tree as it stands too — the dirt is why the rebind declined to touch
+   *  it — and provisions one that turns out not to be there. The decision is
+   *  the pure `decideWorktree`; this method measures the facts and runs the
+   *  verdict. Returns true when the tree was (re)created. MUST be called
+   *  holding the mirror mutex: the clone reads the mirror.
    *
    *  "Dirty" is tracked-file dirt (`status --porcelain -uno`): untracked
    *  scratch files are the thread's own state and survive re-attach.
@@ -5029,8 +5063,11 @@ export class ResidentDO extends Sandbox<Env> {
     /** `detached`: the bound ref is gone from the mirror and `sha` is the
      *  expected commit it still holds (item 51) — the tree is checked out at
      *  that commit, detached, instead of at a branch. `reuse`: a resumed
-     *  run's attach (item 66): keep the tree as it stands, or refuse. */
-    opts: { detached: boolean; reuse: boolean } = { detached: false, reuse: false },
+     *  run's attach (item 66): keep the tree as it stands, or refuse.
+     *  `keepTree`: this attach's rebind moved the record alone over a dirty
+     *  tree already on the branch (item 16): keep a readable tree as it
+     *  stands, provision one that is not there. */
+    opts: { detached: boolean; reuse: boolean; keepTree: boolean } = { detached: false, reuse: false, keepTree: false },
   ): Promise<boolean> {
     const wt = binding.worktreePath;
     const threadDir = parentDir(wt);
@@ -5067,7 +5104,14 @@ export class ResidentDO extends Sandbox<Env> {
         }
       }
     }
-    const decision = decideWorktree({ reuse: opts.reuse, modeSwitch, sha, worktreePath: wt, facts });
+    const decision = decideWorktree({
+      reuse: opts.reuse,
+      keepTree: opts.keepTree,
+      modeSwitch,
+      sha,
+      worktreePath: wt,
+      facts,
+    });
     if (decision.kind === "refuse") throw new ReuseRefusedError(decision.why);
     if (decision.kind === "reuse") return false;
 

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.231.1",
+  "version": "1.232.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.231.1",
+      "version": "1.232.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20032,7 +20032,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.231.1",
+      "version": "1.232.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.231.1",
+  "version": "1.232.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.231.1",
-  "commit": "a22b34899cfe2b3f7d343e46b38c50ea75ebfa3e",
-  "builtAt": "2026-09-16T00:35:27.645Z"
+  "version": "1.232.0",
+  "commit": "d61cfe3bf51e3ff2a69387412add020b4182875d",
+  "builtAt": "2026-09-16T15:02:34.038Z"
 }

package/dist/assets/src/core/coordinator/driver.ts

@@ -44,6 +44,7 @@ import {
   settleUnit,
   startUnit,
   type ChildFacts,
+  type MergeReadyFacts,
   type CoordinatorAction,
   type PlanGraph,
   type PlanUnitNode,
@@ -278,7 +279,13 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
     return {
       type: "pr-check",
       step,
-      pr: { state: "open", prNumber, url, ...(typeof headSha === "string" ? { headSha } : {}) },
+      pr: {
+        state: "open",
+        prNumber,
+        url,
+        ...(typeof headSha === "string" ? { headSha } : {}),
+        ...(typeof a.body.autoMergeEnabled === "boolean" ? { autoMergeEnabled: a.body.autoMergeEnabled } : {}),
+      },
       at,
     };
   // A merged pull request is read whole or not at all: the merge commit and
@@ -448,12 +455,36 @@ async function runUnit(
         const body = { ...tag, index: note.index, agent: note.agent, outcome: note.outcome };
         await step.do(`${unit}/note/${++notes}`, STEP_CONFIG, () => call(bot, "round", body));
       } else {
+        // A merge_ready ending names the pull request as it is at the APPROVED
+        // head (agent-ship item 9): one more pr-check reads the facts fresh —
+        // auto-merge may have been switched on since the round's check, or it
+        // may already have fired, in which case the answer is `merged` and the
+        // report says so rather than naming a gate that has passed. An
+        // unreadable answer just leaves the facts out.
+        let endFacts: MergeReadyFacts | undefined;
+        if (note.ending.kind === "merge_ready") {
+          try {
+            const check = prCheckReturn(
+              `${unit}/end/pr-facts`,
+              answerOf(
+                "pr-check",
+                await step.do(`${unit}/end/pr-facts`, STEP_CONFIG, () => call(bot, "pr-check", tag)),
+              ),
+            );
+            if (check.type === "pr-check" && check.pr.state === "merged")
+              endFacts = { merged: { sha: check.pr.sha, mergedAt: check.pr.mergedAt } };
+            else if (check.type === "pr-check" && check.pr.state === "open" && check.pr.autoMergeEnabled !== undefined)
+              endFacts = { autoMergeEnabled: check.pr.autoMergeEnabled };
+          } catch {
+            // the report simply omits the fact
+          }
+        }
         // The last coding child's run is named so the bot can put its handoff
         // — the deviations it recorded — on the unit's board issue beside the
         // ending (agent-ship item 14).
         const body = {
           ...tag,
-          ending: { kind: note.ending.kind, report: renderUnitReport(state) },
+          ending: { kind: note.ending.kind, report: renderUnitReport(state, endFacts) },
           ...(state.pr !== undefined ? { pr: state.pr } : {}),
           ...(state.lastCodingRunId !== undefined ? { codingRunId: state.lastCodingRunId } : {}),
         };

package/dist/assets/src/core/ship/coordinator.ts

@@ -443,7 +443,7 @@ export type ChildFacts =
  *  with no open one — a merged one, `sha` the merge commit on the base. */
 export type PrCheck =
   | { state: "none" }
-  | { state: "open"; prNumber: number; url: string; headSha?: string }
+  | { state: "open"; prNumber: number; url: string; headSha?: string; autoMergeEnabled?: boolean }
   | { state: "merged"; prNumber: number; url: string; sha: string; mergedAt: string };
 
 /** What a step answered. Every bot answer carries `at`, the bot's clock — the machine's time. */
@@ -1159,7 +1159,17 @@ function splitReport(s: UnitPipelineState): string {
 
 /** The thread's report for a unit's ending — the ship pipeline's own words
  *  for the endings it has, and the merge's for the ones it gains. */
-export function renderUnitReport(s: UnitPipelineState): string {
+/** What the driver read at the approved head when it composed a `merge_ready`
+ *  ending (agent-ship item 9): the pull request's own auto-merge fact, or the
+ *  merge that already happened — auto-merge or a person can merge between the
+ *  approval and the ending, and the report must describe the pull request as
+ *  it is, never a gate that has already passed. */
+export interface MergeReadyFacts {
+  autoMergeEnabled?: boolean;
+  merged?: { sha: string; mergedAt: string };
+}
+
+export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts): string {
   const e = s.ending;
   if (!e) return "";
   const rounds = `${e.reviewRounds} review round${e.reviewRounds === 1 ? "" : "s"}`;
@@ -1189,7 +1199,14 @@ export function renderUnitReport(s: UnitPipelineState): string {
         `✅ Merge-ready after ${rounds}: ${e.pr.url}`,
         verdictLine,
         declinedLine,
-        "Remaining gate: a person's merge — the runner merges only when the instance's `merge` field says runner, and ship never approves.",
+        // What the driver read at the approved head when it composed this
+        // ending (agent-ship item 9): a merge that already happened is named
+        // as such, else the pull request's own auto-merge fact, else the gate.
+        facts?.merged
+          ? `Already merged: ${e.pr.url} (merge commit \`${facts.merged.sha.slice(0, 7)}\`, merged ${facts.merged.mergedAt}) — auto-merge or a person merged it after the approval; the runner merged nothing.`
+          : facts?.autoMergeEnabled
+            ? "Auto-merge is on for this pull request: the approval merges it once checks pass."
+            : "Remaining gate: a person's merge — the runner merges only when the instance's `merge` field says runner, and ship never approves.",
       ].join("\n");
     case "merge_refused":
       return join([

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

@@ -16,7 +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. */
+ *  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. */
 
 export type ParsedReuse = { reuse: boolean } | { error: string };
 
@@ -58,6 +62,15 @@ 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. */
@@ -65,7 +78,7 @@ export function decideWorktree(input: {
   worktreePath: string;
   facts: WorktreeFacts;
 }): WorktreeDecision {
-  const { reuse, modeSwitch, sha, worktreePath, facts } = input;
+  const { reuse, keepTree = false, modeSwitch, sha, worktreePath, facts } = input;
   if (modeSwitch) {
     return reuse
       ? {
@@ -92,7 +105,9 @@ 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" };
-  if (facts.dirty) return { kind: "recreate", why: "dirty" };
+  // 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.head !== sha && facts.descendsFromTip !== true) return { kind: "recreate", why: "stale" };
   return { kind: "reuse" };
 }

package/dist/cli.js

@@ -9369,6 +9369,13 @@ function wakeWaitBudget(commandBudgetMs) {
   if (commandBudgetMs === void 0 || !Number.isFinite(commandBudgetMs)) return WAKE_WAIT_MAX_MS;
   return Math.max(0, Math.min(WAKE_WAIT_MAX_MS, Math.trunc(commandBudgetMs)));
 }
+function saysContainerGone(data) {
+  if (data.reason === "runtime-replaced") return true;
+  return data.needs === "attach" && typeof data.error === "string" && data.error.startsWith("worktree-missing:");
+}
+function containerGoneMessage(error) {
+  return `${error.trim()}; the command was not run again`;
+}
 function sandboxRestartedMessage(woke) {
   const secs2 = Math.round(woke.waitedMs / 1e3);
   return `the resident container exited under a rollout and woke from its snapshot after ${secs2}s; the worktree was recreated at ${woke.ref}@${woke.sha.slice(0, 7)}, so uncommitted changes and unpushed commits from earlier in this run are gone`;
@@ -9629,10 +9636,11 @@ var init_resident = __esm({
         this.opts = opts;
       }
       opts;
-      /** Consecutive `runtime-replaced` outcomes with no successful op between
-       *  them. One is a deploy that swapped the resident isolate under a command
-       *  (routine, recoverable); two in a row is a flapping resident and becomes
-       *  infra so the runner's fail-fast still has teeth. */
+      /** Consecutive `runtime-replaced` answers on the idempotent routes (/read,
+       *  /write) with no successful op between them. One is a deploy that swapped
+       *  the resident isolate under a call (routine: re-attach and re-issue); two
+       *  in a row is a flapping resident and becomes infra. /exec never counts
+       *  here: its `runtime-replaced` is the typed restart (`opWithReattach`). */
       runtimeReplacedStreak = 0;
       lastBinding;
       /** The thread's binding as the resident answered it on the most recent
@@ -9807,15 +9815,20 @@ var init_resident = __esm({
           return { released: false, reason: err2 instanceof Error ? err2.message : String(err2) };
         }
       }
-      /** Run a route; on needs:"attach" (evicted/recycled worktree, in-body for
+      /** Run a route; on needs:"attach" for an evicted worktree (in-body for
        *  /exec, 409 for /read //write) re-attach ONCE and retry, then fail legibly.
        *
-       *  A `reason:"runtime-replaced"` answer (the resident isolate was swapped by
-       *  a deploy while the op ran) also re-attaches once — proving the new isolate
-       *  serves this thread — but the op is re-issued only for the idempotent
-       *  routes (/read, /write). /exec is handed back to the caller as-is: the
-       *  command may have started, so it is never blind-retried. Two such answers
-       *  with no success between them are infra (a flapping resident).
+       *  An answer saying the container under the thread is gone
+       *  (`saysContainerGone`: `reason:"runtime-replaced"`, the isolate was swapped
+       *  by a deploy while the op ran; `worktree-missing`, the container disk was
+       *  recycled since the last attach) is, on /exec, the typed
+       *  `ExecSandboxRestartedError` at once — the word the pi harness keys on
+       *  (harness-pi item 16) — before any recovery, so nothing the recovery
+       *  meets can hide it; the command may have started and is never re-issued.
+       *  On the idempotent routes (/read, /write) a `runtime-replaced` re-attaches
+       *  once — proving the new isolate serves this thread — and re-issues the op;
+       *  two such answers with no success between them are infra (a flapping
+       *  resident).
        *
        *  A refusal naming a container that just exited (item 65) waits for the
        *  wake first (`awaitWake`): the refusal came before the command started, so
@@ -9834,6 +9847,10 @@ var init_resident = __esm({
           ),
           { kind: "infra", code: "attach" }
         );
+        const goneUnderThread = (data) => {
+          if (route3 === "/exec" && saysContainerGone(data))
+            throw new ExecSandboxRestartedError(containerGoneMessage(String(data.error)), 0);
+        };
         let r = await this.call(route3, body, callTimeoutMs, signal2, span);
         if (isContainerRolling(r.data.error)) {
           const woke = await this.awaitWake(route3, String(r.data.error), { signal: signal2, budgetMs: opts.waitBudgetMs, span });
@@ -9848,19 +9865,19 @@ var init_resident = __esm({
             );
           }
         }
+        goneUnderThread(r.data);
         if (r.data.needs === "attach") {
           await this.attach(span);
           r = await this.call(route3, body, callTimeoutMs, signal2, span);
+          goneUnderThread(r.data);
           if (r.data.needs === "attach") throw stillGone(r.data);
         }
         if (r.data.reason === "runtime-replaced") {
           this.noteRuntimeReplaced(route3, r.data);
           await this.attach(span);
-          if (route3 === "/read" || route3 === "/write") {
-            r = await this.call(route3, body, callTimeoutMs, signal2, span);
-            if (r.data.reason === "runtime-replaced") this.noteRuntimeReplaced(route3, r.data);
-            if (r.data.needs === "attach") throw stillGone(r.data);
-          }
+          r = await this.call(route3, body, callTimeoutMs, signal2, span);
+          if (r.data.reason === "runtime-replaced") this.noteRuntimeReplaced(route3, r.data);
+          if (r.data.needs === "attach") throw stillGone(r.data);
         }
         if (typeof r.data.error !== "string" || !r.data.error) this.runtimeReplacedStreak = 0;
         return r;
@@ -9944,10 +9961,6 @@ var init_resident = __esm({
         if (status3 === 400 && typeof data.error === "string" && data.error && data.needs === void 0) {
           throw new Error(`resident /exec: ${data.error}`);
         }
-        if (data.reason === "runtime-replaced") {
-          return `${String(data.error)}
-The command may have started; re-check its effects (e.g. git status, the files it writes) before re-running it.`;
-        }
         if (typeof data.error === "string" && data.error) {
           throw classifyError(new ExecInfraError(`resident /exec: ${data.error}`), { kind: "infra" });
         }
@@ -25072,7 +25085,8 @@ async function findOpenPrByHead(repo, branch2) {
   return {
     number: first.number,
     htmlUrl: first.html_url,
-    ...first.head?.sha ? { headSha: first.head.sha } : {}
+    ...first.head?.sha ? { headSha: first.head.sha } : {},
+    ..."auto_merge" in first ? { autoMergeEnabled: first.auto_merge !== null } : {}
   };
 }
 async function findMergedPrByHead(repo, branch2) {
@@ -25182,7 +25196,6 @@ async function fetchRepoShipInfo(repo) {
   const data = await res.json().catch(() => null);
   if (!data || typeof data !== "object") return void 0;
   return {
-    ...typeof data.allow_auto_merge === "boolean" ? { allowAutoMerge: data.allow_auto_merge } : {},
     ...typeof data.default_branch === "string" && data.default_branch ? { defaultBranch: data.default_branch } : {}
   };
 }
@@ -25247,7 +25260,8 @@ async function fetchPullRequestFacts(pr) {
     sameRepoHead,
     ...typeof data.base?.ref === "string" && data.base.ref ? { baseRef: data.base.ref } : {},
     ...typeof data.html_url === "string" ? { htmlUrl: data.html_url } : {},
-    ...typeof data.title === "string" && data.title ? { title: data.title } : {}
+    ...typeof data.title === "string" && data.title ? { title: data.title } : {},
+    ..."auto_merge" in data ? { autoMergeEnabled: data.auto_merge !== null } : {}
   };
 }
 async function mergePullRequest(pr, opts) {
@@ -25584,7 +25598,7 @@ async function resolveRepoContext(msg, history = [], probe, residentSlugs, recor
     const inherited = inheritedPr(thread, records, repo);
     if (inherited) {
       const head = await openPrHeadSha(inherited);
-      if ("sha" in head) {
+      if (!("reason" in head)) {
         out.pr = inherited.number;
         out.headSha = head.sha;
         if (head.base) out.baseRef = head.base;
@@ -25599,6 +25613,9 @@ async function resolveRepoContext(msg, history = [], probe, residentSlugs, recor
         }
       } else {
         out.prUnpostable = { number: inherited.number, reason: head.reason };
+        if (inherited.source === "record" && head.reason === "closed" && head.sha !== void 0) {
+          out.closedRecordPr = { number: inherited.number, headSha: head.sha, merged: head.merged };
+        }
       }
     }
   }
@@ -25609,8 +25626,14 @@ function ownPrOf(ctx) {
   return { number: ctx.pr, ref: ctx.ref };
 }
 function recordPrOf(ctx) {
-  if (!ctx.prFromRecord || ctx.pr === void 0 || ctx.headSha === void 0) return void 0;
-  return { number: ctx.pr, headSha: ctx.headSha };
+  if (ctx.prFromRecord && ctx.pr !== void 0 && ctx.headSha !== void 0) {
+    return { number: ctx.pr, headSha: ctx.headSha, state: "open" };
+  }
+  if (ctx.closedRecordPr !== void 0) {
+    const { number, headSha, merged } = ctx.closedRecordPr;
+    return { number, headSha, state: merged ? "merged" : "closed" };
+  }
+  return void 0;
 }
 function inheritedPr(thread, records, repo) {
   const turn = thread.pr && thread.pr.repo === repo ? { repo, number: thread.pr.number, source: "turn", at: thread.prAt } : void 0;
@@ -25620,7 +25643,8 @@ function inheritedPr(thread, records, repo) {
 }
 async function openPrHeadSha(pr) {
   const head = await prHead(pr).catch(() => void 0);
-  if (head?.state === "closed") return { reason: "closed" };
+  if (head?.state === "closed")
+    return { reason: "closed", ...head.sha ? { sha: head.sha } : {}, merged: head.merged };
   if (head?.state === "open" && head.sha) {
     return {
       sha: head.sha,
@@ -25686,9 +25710,17 @@ async function prHead(pr) {
   const headRepo = data.head?.repo?.full_name?.toLowerCase();
   const ref = data.head?.ref && headRepo === pr.repo ? validRef(data.head.ref) : void 0;
   const state = data.state === "open" || data.state === "closed" ? data.state : void 0;
-  const sha = ref !== void 0 ? preferRefTip(`${pr.repo}#${pr.number}`, prSha, await headRefTipSha(pr.repo, ref, headers), ref) : prSha;
+  const sha = ref !== void 0 && state !== "closed" ? preferRefTip(`${pr.repo}#${pr.number}`, prSha, await headRefTipSha(pr.repo, ref, headers), ref) : prSha;
   const size = sha === prSha ? prSizeOf(data) : void 0;
-  return { ref, sha, base, ...size ? { size } : {}, state, ...facts2 ? { facts: facts2 } : {} };
+  return {
+    ref,
+    sha,
+    base,
+    ...size ? { size } : {},
+    state,
+    merged: data.merged === true,
+    ...facts2 ? { facts: facts2 } : {}
+  };
 }
 function prSizeOf(data) {
   const n2 = (x) => typeof x === "number" && Number.isInteger(x) && x >= 0;
@@ -32445,13 +32477,13 @@ function removeScript(dir) {
   return `rm -rf ${shellQuote(dir)}`;
 }
 function stdoutOf(operation, out) {
-  const exit = parseExitPrefix(out);
-  if (exit.failed || RUNTIME_WORD.test(out)) throw new PiContainerError(operation, out);
+  if (RUNTIME_WORD.test(out)) throw new PiContainerRuntimeReplacedError(operation, out);
+  if (parseExitPrefix(out).failed) throw new PiContainerError(operation, out);
   const cut = out.indexOf(STDERR_MARK);
   const stdout = cut >= 0 ? out.slice(0, cut) : out;
   return stdout === "(no output)" ? "" : stdout;
 }
-var PiContainerError, WRITE_CHUNK_CHARS, INLINE_LINE_CHARS, LOG_READ_BYTES, MESSAGE_UPDATE_MARK, LOG_FILTER, IDENTITY_WORD, STDERR_MARK, RUNTIME_WORD, OP_TIMEOUT_MS, ExecPiContainer;
+var PiContainerError, WRITE_CHUNK_CHARS, INLINE_LINE_CHARS, LOG_READ_BYTES, MESSAGE_UPDATE_MARK, LOG_FILTER, IDENTITY_WORD, STDERR_MARK, RUNTIME_WORD, PiContainerRuntimeReplacedError, OP_TIMEOUT_MS, ExecPiContainer;
 var init_container = __esm({
   "../../src/core/harness/pi/container.ts"() {
     "use strict";
@@ -32473,7 +32505,13 @@ var init_container = __esm({
     LOG_FILTER = `grep --line-buffered -v ${shellQuote(MESSAGE_UPDATE_MARK)}`;
     IDENTITY_WORD = /^[A-Za-z0-9-]{1,64}$/;
     STDERR_MARK = "\n--- stderr ---\n";
-    RUNTIME_WORD = /^(?:runtime-unreachable:|runtime-replaced)/;
+    RUNTIME_WORD = /\bruntime-(?:unreachable|replaced)\b/;
+    PiContainerRuntimeReplacedError = class extends PiContainerError {
+      constructor(operation, detail) {
+        super(operation, detail);
+        this.name = "PiContainerRuntimeReplacedError";
+      }
+    };
     OP_TIMEOUT_MS = 6e4;
     ExecPiContainer = class {
       constructor(executor) {
@@ -33614,10 +33652,8 @@ function settlementAnswer(s) {
   return { content: [{ type: "text", text: settlementText(s) }], isError: true };
 }
 function saysContainerReplaced(err2) {
-  if (err2 instanceof ExecSandboxRestartedError) return true;
-  if (!(err2 instanceof Error)) return false;
-  const text = err2.message.replace(/^pi container: [a-z]+ failed — /, "").replace(/^exit \d+: /, "");
-  return /^(?:runtime-unreachable:|runtime-replaced)/.test(text);
+  if (err2 instanceof ExecSandboxRestartedError || err2 instanceof PiContainerRuntimeReplacedError) return true;
+  return err2 instanceof Error && RUNTIME_WORD.test(err2.message);
 }
 function replacedCallNote(tool) {
   return `The container running pi was replaced while this ${tool} call was in flight; its result was lost \u2014 re-check its effects before re-running it.`;
@@ -34254,6 +34290,7 @@ var init_harness = __esm({
     init_runEvents();
     init_threadAdmission();
     init_bridge2();
+    init_container();
     init_mirror();
     init_process();
     init_protocol();
@@ -34719,14 +34756,30 @@ async function runCodingPrPostStep(input) {
   const candidates = [target.baseRef, target.bindingRef, target.resolvedRef];
   const base = prDescription ? await resolveBaseRefLazy(candidates, repo, input.fetchRepoInfo) : resolveBaseRef(candidates, void 0);
   const pushedBranch = branch2 !== void 0 && branch2 !== base && pushed;
-  if (prDescription && branch2 !== void 0 && branch2 === base && target.ownPr !== void 0) {
-    const { number, headSha: prHead2 } = target.ownPr;
+  const ownPr = target.ownPr;
+  const pushedPastOwnPr = ownPr !== void 0 && pushed && headSha !== void 0 && !sameCommit2(headSha, ownPr.headSha) ? headSha : void 0;
+  if (prDescription && ownPr !== void 0 && ownPr.state !== "open" && pushedPastOwnPr !== void 0 && branch2 !== void 0) {
+    const url = `https://github.com/${repo}/pull/${ownPr.number}`;
+    console.log(
+      `[pr-post] ${logKey} skipped: ${branchLog} was pushed past the thread's ${ownPr.state} ${repo}#${ownPr.number} (its head ${ownPr.headSha.slice(0, 7)}, the workspace at ${pushedPastOwnPr.slice(0, 7)}) \u2014 a new PR is needed`
+    );
+    input.publish({
+      type: "run_note",
+      kind: "pr_not_opened",
+      summary: `no PR opened: ${branch2} was pushed past the thread's ${ownPr.state} pull request #${ownPr.number}; the new commits need a new pull request`,
+      at: systemClock()
+    });
+    return `\u26A0\uFE0F A PR description was submitted and \`${branch2}\`${branchNote} was pushed to \`${pushedPastOwnPr.slice(0, 7)}\`, but this thread's pull request ${url} is ${ownPr.state} and that branch is its head \u2014 the new commits need a new pull request, so nothing was edited: compare & open manually: ${compareUrl}`;
+  }
+  if (prDescription && ownPr !== void 0 && (branch2 === base || ownPr.state !== "open")) {
+    const { number, headSha: prHead2, state } = ownPr;
     const url = `https://github.com/${repo}/pull/${number}`;
+    const standing = state === "open" ? "" : ` (${state})`;
     try {
       const body = renderPrDescriptionMarkdown(prDescription, { repo, headSha: prHead2 });
       await input.updatePullRequest(repo, number, { title: prDescription.title, body });
       console.log(
-        `[pr-post] ${logKey} updated ${repo}#${number} \u2014 the thread's own pull request, nothing pushed (workspace on ${branchLog}; rendered at its head ${prHead2.slice(0, 7)})`
+        `[pr-post] ${logKey} updated ${repo}#${number} \u2014 the thread's own pull request${standing}, nothing pushed past its head (workspace on ${branchLog}; rendered at its head ${prHead2.slice(0, 7)})`
       );
       input.publish({ type: "pr_opened", url, number, created: false, at: systemClock() });
       input.publish({
@@ -34734,7 +34787,7 @@ async function runCodingPrPostStep(input) {
         ...submittedPrDescriptionArtifact(prDescription, { repo, pr: number, headSha: prHead2, body }),
         at: systemClock()
       });
-      return `\u{1F500} PR updated: ${url} \u2014 body re-rendered at \`${prHead2.slice(0, 7)}\``;
+      return state === "open" ? `\u{1F500} PR updated: ${url} \u2014 body re-rendered at \`${prHead2.slice(0, 7)}\`` : `\u{1F500} PR updated: ${url} \u2014 body re-rendered at \`${prHead2.slice(0, 7)}\` (the pull request is ${state}; its description was edited in place)`;
     } catch (err2) {
       const reason2 = err2 instanceof Error ? err2.message : String(err2);
       console.error(`[pr-post] ${logKey} update failed for ${repo}#${number}: ${reason2}`);
@@ -35677,151 +35730,6 @@ var init_runLoop = __esm({
   }
 });
 
-// ../../src/core/ship/preflight.ts
-function shipTaskText(requestText, repo) {
-  let t = requestText.replace(/<((?:https?):\/\/[^|>\s]+)(?:\|[^>]*)?>/gi, " $1 ");
-  t = t.replace(/https?:\/\/\S+/gi, " ");
-  const slug = repo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  t = t.replace(new RegExp(`\\bin\\s+${slug}\\s*:?`, "gi"), " ");
-  t = t.replace(new RegExp(`\\b${slug}(#\\d+)?\\b`, "gi"), " ");
-  t = t.replace(/\b[a-z0-9][\w.-]*\/[\w.-]+#\d+\b/gi, " ");
-  return t.replace(/\s+/g, " ").trim().replace(/^[:,\-—.\s]+/, "").trim();
-}
-async function shipPreflight(input) {
-  const { repoCtx } = input;
-  if (!input.channelId.startsWith("slack:") && !input.channelId.startsWith("cli:")) {
-    const base = input.runsBase?.trim();
-    const page2 = base ? `${base.replace(/\/+$/, "")}/runs` : "the bot's /runs page";
-    return refuse2(
-      "channel",
-      "not started (Slack/CLI only)",
-      `\u{1F6AB} \`agent:ship\` runs only from Slack or the CLI \u2014 this adapter is single-shot and cannot hold a pipeline-length run. Start it there instead, and watch pipelines on the run page (${page2}).`
-    );
-  }
-  const missing = ["ship", "coding", "review"].filter((a) => !input.gates.canRunAgent(a));
-  if (missing.length > 0) {
-    return refuse2(
-      `permission (${missing.join(", ")})`,
-      "not started (permissions)",
-      `\u{1F6AB} Running \`ship\` drives \`coding\` and \`review\` child rounds, and you're not on the allowlist for ${missing.map((a) => `\`${a}\``).join(", ")}. Ask ${input.gates.adminsHint()} for access.`
-    );
-  }
-  const repo = repoCtx.repo;
-  if (!repo) {
-    return refuse2(
-      "no repo",
-      "not started (no repository)",
-      "\u{1F6AB} `agent:ship` needs a target repository \u2014 name it in the request, e.g. `agent:ship in owner/repo: <task>`."
-    );
-  }
-  const info = await input.repoInfo(repo).catch(() => void 0);
-  if (info?.allowAutoMerge !== false) {
-    const reason2 = info?.allowAutoMerge === true ? `auto-merge is enabled on \`${repo}\` \u2014 ship's approving LGTM triggers the org auto-approve workflow, and with auto-merge on the PR would merge with no human. Disable auto-merge on the repo to use ship.` : `could not verify that auto-merge is disabled on \`${repo}\` (the repository lookup failed or answered without the setting) \u2014 refusing fail-closed.`;
-    return refuse2("auto-merge", "not started (auto-merge)", `\u{1F6AB} ${reason2}`);
-  }
-  const task = shipTaskText(input.requestText, repo);
-  if (repoCtx.prUnpostable?.reason === "unreachable") {
-    return refuse2(
-      "thread PR unreachable",
-      "not started (PR unverifiable)",
-      `\u{1F6AB} This thread names PR ${repo}#${repoCtx.prUnpostable.number} but it could not be fetched to run ship's entry checks \u2014 refusing fail-closed. Retry in a moment, or check the PR on GitHub.`
-    );
-  }
-  if (repoCtx.pr !== void 0) {
-    const where = `${repo}#${repoCtx.pr}`;
-    const facts2 = await input.prFacts({ repo, number: repoCtx.pr }).catch(() => void 0);
-    const fallThrough = !facts2 && task !== "" && repoCtx.prFromMessage === true;
-    if (!facts2 && !fallThrough) {
-      return refuse2(
-        "PR facts unavailable",
-        "not started (PR unverifiable)",
-        `\u{1F6AB} Could not fetch ${where} to run ship's entry checks (open? bot-authored? same-repo head?) \u2014 refusing fail-closed. Retry in a moment.`
-      );
-    }
-    if (facts2) {
-      const self = facts2.state === "open" ? await input.selfIdentity().catch(() => void 0) : void 0;
-      if (facts2.state === "open" && !self) {
-        return refuse2(
-          "own identity unavailable",
-          "not started (identity unverifiable)",
-          `\u{1F6AB} Could not resolve the GitHub identity this bot acts as, so whether ${where} is ship's to drive cannot be judged \u2014 refusing fail-closed. Retry in a moment.`
-        );
-      }
-      const author = facts2.author;
-      const shipAuthored = self !== void 0 && author?.login === self.login && author?.id === self.id;
-      if (facts2.state === "open" && !(task && !shipAuthored)) {
-        if (task) {
-          return refuse2(
-            "new task over open PR",
-            "not started (open PR)",
-            `\u{1F6AB} This thread's PR ${where} is still open \u2014 a new task over it is refused. Re-issue \`agent:ship\` with only the PR URL to resume its review loop, or finish/close ${where} and start the new task in a fresh thread.`
-          );
-        }
-        if (!shipAuthored) {
-          return refuse2(
-            "human-authored PR",
-            "not started (not ship's PR)",
-            `\u{1F6AB} ${where} was not authored by \`${self.login}\` (this bot) \u2014 it is not ship's to drive. Use \`agent:review\` for a one-off review, or drive the loop manually.`
-          );
-        }
-        if (!facts2.sameRepoHead) {
-          return refuse2(
-            "fork-head PR",
-            "not started (fork head)",
-            `\u{1F6AB} ${where}'s head branch lives on a fork, not on \`${repo}\` \u2014 ship cannot drive it.`
-          );
-        }
-        const branch2 = facts2.headRef ?? repoCtx.ref;
-        if (!branch2) {
-          return refuse2(
-            "head branch unknown",
-            "not started (head branch unknown)",
-            `\u{1F6AB} Could not determine ${where}'s head branch, so ship cannot bind the thread's worktree to it \u2014 refusing fail-closed.`
-          );
-        }
-        return {
-          ok: true,
-          entry: {
-            repo,
-            branch: branch2,
-            // The PR's OWN base wins on resume: a ship PR opened against a
-            // non-default base must not run its re-reviews (or re-open a closed
-            // PR) against the default branch. repoCtx.baseRef carries the same
-            // fact when the thread context resolved the PR; the default branch
-            // is the last resort.
-            base: resolveBaseRef([facts2.baseRef, repoCtx.baseRef], info.defaultBranch),
-            resume: {
-              pr: repoCtx.pr,
-              headSha: facts2.headSha ?? repoCtx.headSha,
-              ...facts2.htmlUrl !== void 0 ? { url: facts2.htmlUrl } : {}
-            }
-          }
-        };
-      }
-    }
-  }
-  if (!task) {
-    return refuse2(
-      "no task",
-      "not started (no task)",
-      `\u{1F6AB} Nothing to ship: give ship a task (\`agent:ship in ${repo}: <task>\`), or name an open ship PR by URL to resume its review loop.`
-    );
-  }
-  const ref = repoCtx.ref && !repoCtx.refFromPr && repoCtx.ref.toLowerCase() !== repo.toLowerCase() ? repoCtx.ref : void 0;
-  return {
-    ok: true,
-    entry: { repo, base: resolveBaseRef([ref], info.defaultBranch) }
-  };
-}
-var refuse2;
-var init_preflight = __esm({
-  "../../src/core/ship/preflight.ts"() {
-    "use strict";
-    init_githubPulls();
-    refuse2 = (where, card, reply) => ({ ok: false, where, card, reply });
-  }
-});
-
 // ../../src/core/ship/coordinator.ts
 function shipInterruptedNote(prUrl2) {
   const stands = prUrl2 ? `Its work stands on GitHub: ${prUrl2}.` : "Whatever it pushed stands on its pipeline branch; no PR was opened yet.";
@@ -36072,6 +35980,142 @@ var init_coordinator = __esm({
   }
 });
 
+// ../../src/core/ship/preflight.ts
+function shipTaskText(requestText, repo) {
+  let t = requestText.replace(/<((?:https?):\/\/[^|>\s]+)(?:\|[^>]*)?>/gi, " $1 ");
+  t = t.replace(/https?:\/\/\S+/gi, " ");
+  const slug = repo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  t = t.replace(new RegExp(`\\bin\\s+${slug}\\s*:?`, "gi"), " ");
+  t = t.replace(new RegExp(`\\b${slug}(#\\d+)?\\b`, "gi"), " ");
+  t = t.replace(/\b[a-z0-9][\w.-]*\/[\w.-]+#\d+\b/gi, " ");
+  return t.replace(/\s+/g, " ").trim().replace(/^[:,\-—.\s]+/, "").trim();
+}
+async function shipPreflight(input) {
+  const { repoCtx } = input;
+  if (!input.channelId.startsWith("slack:") && !input.channelId.startsWith("cli:")) {
+    const base = input.runsBase?.trim();
+    const page2 = base ? `${base.replace(/\/+$/, "")}/runs` : "the bot's /runs page";
+    return refuse2(
+      "channel",
+      "not started (Slack/CLI only)",
+      `\u{1F6AB} \`agent:ship\` runs only from Slack or the CLI \u2014 this adapter is single-shot and cannot hold a pipeline-length run. Start it there instead, and watch pipelines on the run page (${page2}).`
+    );
+  }
+  const missing = ["ship", "coding", "review"].filter((a) => !input.gates.canRunAgent(a));
+  if (missing.length > 0) {
+    return refuse2(
+      `permission (${missing.join(", ")})`,
+      "not started (permissions)",
+      `\u{1F6AB} Running \`ship\` drives \`coding\` and \`review\` child rounds, and you're not on the allowlist for ${missing.map((a) => `\`${a}\``).join(", ")}. Ask ${input.gates.adminsHint()} for access.`
+    );
+  }
+  const repo = repoCtx.repo;
+  if (!repo) {
+    return refuse2(
+      "no repo",
+      "not started (no repository)",
+      "\u{1F6AB} `agent:ship` needs a target repository \u2014 name it in the request, e.g. `agent:ship in owner/repo: <task>`."
+    );
+  }
+  const info = await input.repoInfo(repo).catch(() => void 0);
+  const task = shipTaskText(input.requestText, repo);
+  const seeded = parseShipPlanRequest(task) !== void 0;
+  if (!seeded && repoCtx.prUnpostable?.reason === "unreachable") {
+    return refuse2(
+      "thread PR unreachable",
+      "not started (PR unverifiable)",
+      `\u{1F6AB} This thread names PR ${repo}#${repoCtx.prUnpostable.number} but it could not be fetched to run ship's entry checks \u2014 refusing fail-closed. Retry in a moment, or check the PR on GitHub.`
+    );
+  }
+  if (repoCtx.pr !== void 0 && !seeded) {
+    const where = `${repo}#${repoCtx.pr}`;
+    const contextCase = task !== "" && repoCtx.prFromMessage === true;
+    if (!contextCase) {
+      const facts2 = await input.prFacts({ repo, number: repoCtx.pr }).catch(() => void 0);
+      if (!facts2) {
+        return refuse2(
+          "PR facts unavailable",
+          "not started (PR unverifiable)",
+          `\u{1F6AB} Could not fetch ${where} to run ship's entry checks (open? same-repo head?) \u2014 refusing fail-closed. Retry in a moment.`
+        );
+      }
+      if (facts2.state === "open") {
+        if (!facts2.sameRepoHead) {
+          return refuse2(
+            "fork-head PR",
+            "not started (fork head)",
+            `\u{1F6AB} ${where}'s head branch lives on a fork, not on \`${repo}\` \u2014 ship cannot drive it.`
+          );
+        }
+        const branch2 = facts2.headRef ?? repoCtx.ref;
+        if (!branch2) {
+          return refuse2(
+            "head branch unknown",
+            "not started (head branch unknown)",
+            `\u{1F6AB} Could not determine ${where}'s head branch, so ship cannot bind the thread's worktree to it \u2014 refusing fail-closed.`
+          );
+        }
+        const base = resolveBaseRef([facts2.baseRef, repoCtx.baseRef], info?.defaultBranch);
+        const autoMerge = facts2.autoMergeEnabled !== void 0 ? { autoMergeEnabled: facts2.autoMergeEnabled } : {};
+        if (task) {
+          return {
+            ok: true,
+            entry: {
+              repo,
+              branch: branch2,
+              base,
+              adopt: { pr: repoCtx.pr, ...facts2.htmlUrl !== void 0 ? { url: facts2.htmlUrl } : {} },
+              ...autoMerge
+            }
+          };
+        }
+        return {
+          ok: true,
+          entry: {
+            repo,
+            branch: branch2,
+            base,
+            resume: {
+              pr: repoCtx.pr,
+              headSha: facts2.headSha ?? repoCtx.headSha,
+              ...facts2.htmlUrl !== void 0 ? { url: facts2.htmlUrl } : {}
+            },
+            ...autoMerge
+          }
+        };
+      }
+      if (!task) {
+        return refuse2(
+          "closed resume target",
+          "not started (PR closed)",
+          `\u{1F6AB} ${where} is closed \u2014 there is no review loop to resume. Give ship a task to start fresh work.`
+        );
+      }
+    }
+  }
+  if (!task) {
+    return refuse2(
+      "no task",
+      "not started (no task)",
+      `\u{1F6AB} Nothing to ship: give ship a task (\`agent:ship in ${repo}: <task>\`), or name an open ship PR by URL to resume its review loop.`
+    );
+  }
+  const ref = repoCtx.ref && !repoCtx.refFromPr && repoCtx.ref.toLowerCase() !== repo.toLowerCase() ? repoCtx.ref : void 0;
+  return {
+    ok: true,
+    entry: { repo, base: resolveBaseRef([ref], info?.defaultBranch) }
+  };
+}
+var refuse2;
+var init_preflight = __esm({
+  "../../src/core/ship/preflight.ts"() {
+    "use strict";
+    init_githubPulls();
+    init_coordinator();
+    refuse2 = (where, card, reply) => ({ ok: false, where, card, reply });
+  }
+});
+
 // ../../src/core/coordinator/handOff.ts
 async function plan(deps, input) {
   const { entry, msg } = input;
@@ -36116,7 +36160,9 @@ async function plan(deps, input) {
         identity: identity2,
         merge: "person",
         ...entry.resume !== void 0 ? { resume: entry.resume } : {},
-        ...entry.branch !== void 0 ? { entryBranch: entry.branch } : {}
+        ...entry.adopt !== void 0 ? { adopt: entry.adopt } : {},
+        ...entry.branch !== void 0 ? { entryBranch: entry.branch } : {},
+        ...entry.autoMergeEnabled !== void 0 ? { autoMergeEnabled: entry.autoMergeEnabled } : {}
       }
     };
   }
@@ -36173,9 +36219,10 @@ function planWhere(p, units, mergedBefore) {
   if (p.path !== void 0)
     return `${head} Each unit runs in a thread of its own in this channel under your grants; this card follows the plan and its summary lands in this thread.`;
   const branch2 = units[0]?.branch ?? "";
-  const prUrl2 = p.resume?.url ?? (p.resume !== void 0 ? `https://github.com/${p.identity.repo}/pull/${p.resume.pr}` : void 0);
-  const runs = p.resume !== void 0 ? `the review loop of ${prUrl2} resumes at its next review round on \`${branch2}\` in this thread under your grants \u2014 no new coding round first` : `the unit runs on \`${branch2}\` in this thread under your grants`;
-  return `${head} ${runs}; this card follows it and the report lands here.`;
+  const url = (of) => of?.url ?? (of !== void 0 ? `https://github.com/${p.identity.repo}/pull/${of.pr}` : void 0);
+  const runs = p.resume !== void 0 ? `the review loop of ${url(p.resume)} resumes at its next review round on \`${branch2}\` in this thread under your grants \u2014 no new coding round first` : p.adopt !== void 0 ? `the unit adopts ${url(p.adopt)}: it runs on \`${branch2}\` \u2014 the pull request's own head \u2014 in this thread under your grants, no new branch` : `the unit runs on \`${branch2}\` in this thread under your grants`;
+  const autoMerge = p.autoMergeEnabled ? " Auto-merge is on for this pull request: the approval merges it once checks pass." : "";
+  return `${head} ${runs}; this card follows it and the report lands here.${autoMerge}`;
 }
 async function handOffToCoordinator(deps, input) {
   const log = deps.log ?? console.log;
@@ -36452,7 +36499,6 @@ async function runShipBranch(deps, msg, io, ctx) {
       gates: { canRunAgent: (a) => deps.config.canRunAgent(msg.userId, a), adminsHint: () => deps.config.adminsHint() },
       repoInfo: deps.fetchRepoShipInfo ?? fetchRepoShipInfo,
       prFacts: deps.fetchPrFacts ?? fetchPullRequestFacts,
-      selfIdentity: deps.fetchSelfIdentity ?? resolveGithubIdentity,
       runsBase: process.env.PUBLIC_BASE_URL
     })
   );
@@ -36682,7 +36728,6 @@ var init_ship = __esm({
     "use strict";
     init_trace();
     init_githubPulls();
-    init_githubApp();
     init_secrets2();
     init_handOff();
     init_instancesClient();
@@ -45417,6 +45462,9 @@ async function prCheck(body, deps) {
         prNumber: open2.number,
         url: open2.htmlUrl,
         ...open2.headSha !== void 0 ? { headSha: open2.headSha } : {},
+        // The pull request's own auto-merge fact (agent-ship item 9), so a
+        // merge_ready ending can name it at the approved head.
+        ...open2.autoMergeEnabled !== void 0 ? { autoMergeEnabled: open2.autoMergeEnabled } : {},
         at
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreplane/switchboard",
-  "version": "1.231.1",
+  "version": "1.232.0",
   "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",
   "homepage": "https://openswitchboard.dev",