@coreplane/switchboard 1.226.1 → 1.227.0

package/dist/cli.js

@@ -689,6 +689,13 @@ var init_policy = __esm({
       // List-shaped `runs.*`: the grant admits the command; the store predicate narrows the rows.
       { action: "runs:read", resource: "command", when: [grant("runs:read")] },
       { action: "runs:write", resource: "command", when: [grant("runs:write")] },
+      // ── conversations ────────────────────────────────────────────────────────
+      // Who may point the bot at another thread (record 0037). Asked for a
+      // pointing actor (`pointingActor`: one membership, the origin channel, no
+      // grants), so `member-of` reads: a public channel from anywhere, a private
+      // channel only from inside it, an admin's `all` not consulted. The row has
+      // no caller until the references dispatch step lands behind its flag.
+      { action: "conversation:read", resource: "channel", when: [MEMBER_OF] },
       // ── review ───────────────────────────────────────────────────────────────
       // `review abridge` spends one Opus-class call and rewrites a stored record:
       // the grant admits the command (admins through `all`, operators by name;
@@ -872,8 +879,8 @@ function principalOf(actor) {
   while (current.onBehalfOf) current = current.onBehalfOf;
   return current;
 }
-function deny(reason) {
-  return { allow: false, reason };
+function deny(reason2) {
+  return { allow: false, reason: reason2 };
 }
 function isKnownActorKind(kind) {
   return ACTOR_KINDS.includes(kind);
@@ -909,13 +916,13 @@ function authorizeWith(rules, actor, action, resource) {
   if (forOrigin.length === 0) return deny("origin-visibility");
   const grants = effectiveGrants(actor);
   const selfId = principalOf(actor).id;
-  let reason;
+  let reason2;
   for (const rule of forOrigin) {
     const failed = rule.when.find((condition) => !evaluateCondition(condition, grants, selfId, attributes));
     if (!failed) return ALLOW;
-    reason ??= FAILURE_REASON[failed.kind];
+    reason2 ??= FAILURE_REASON[failed.kind];
   }
-  return deny(reason ?? "no-rule");
+  return deny(reason2 ?? "no-rule");
 }
 function authorize(actor, action, resource) {
   return authorizeWith(POLICY, actor, action, resource);
@@ -2856,6 +2863,7 @@ function validateConfig(cfg) {
   if (cfg.ship !== void 0) validateShip(cfg.ship);
   if (cfg.spawn !== void 0) validateSpawn(cfg.spawn);
   if (cfg.routing !== void 0) validateRouting(cfg.routing, cfg.providers);
+  if (cfg.references !== void 0) validateReferences(cfg.references);
   if (cfg.artifacts !== void 0) validateArtifacts(cfg.artifacts);
   if (cfg.harness !== void 0) validateHarness(cfg.harness);
   if (cfg.pi !== void 0) validatePi(cfg.pi);
@@ -2885,6 +2893,14 @@ function validateHarness(harness) {
       throw new Error(`config.yaml: harness.${preset} must be one of ${HARNESSES.join(", ")}`);
   }
 }
+function validateReferences(references) {
+  if (typeof references !== "object" || references === null || Array.isArray(references))
+    throw new Error("config.yaml: references must be a mapping");
+  for (const key of unknownKeys2(references, REFERENCES_KEYS))
+    throw new Error(`config.yaml: references.${key} is not a known key`);
+  if (references.enabled !== void 0 && typeof references.enabled !== "boolean")
+    throw new Error("config.yaml: references.enabled must be true or false");
+}
 function validateRouting(routing, providers) {
   if (typeof routing !== "object" || routing === null || Array.isArray(routing))
     throw new Error("config.yaml: routing must be a mapping");
@@ -2993,7 +3009,7 @@ function validateRuntimeOverrides(ro) {
     }
   }
 }
-var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, PI_KEYS, PI_COMPACTION_KEYS, ROUTE_ANSWER_MODES, ROUTING_KEYS, SHIP_KEYS, SPAWN_KEYS;
+var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, PI_KEYS, PI_COMPACTION_KEYS, ROUTE_ANSWER_MODES, REFERENCES_KEYS, ROUTING_KEYS, SHIP_KEYS, SPAWN_KEYS;
 var init_validate = __esm({
   "../../src/config/validate.ts"() {
     "use strict";
@@ -3027,6 +3043,7 @@ var init_validate = __esm({
       ship: true,
       spawn: true,
       routing: true,
+      references: true,
       harness: true,
       pi: true,
       slack: true,
@@ -3046,6 +3063,7 @@ var init_validate = __esm({
     PI_KEYS = { compaction: true };
     PI_COMPACTION_KEYS = { reserveTokens: true, keepRecentTokens: true };
     ROUTE_ANSWER_MODES = ["tool", "text"];
+    REFERENCES_KEYS = { enabled: true };
     ROUTING_KEYS = { auto: true, model: true, answer: true };
     SHIP_KEYS = { maxRounds: true, maxMinutes: true };
     SPAWN_KEYS = { maxChildren: true };
@@ -4117,6 +4135,7 @@ var init_residentSteps = __esm({
       "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",
@@ -5543,10 +5562,10 @@ function describeBase(base, code) {
       return "none";
   }
 }
-function markdownReason(reason) {
-  if (reason.startsWith("unsure:"))
-    return reason.replace(/(unclassified path |import )(\S+)/, (_m, pre, p) => `${pre}\`${p}\``);
-  return reason.replace(/^(\S+?)(?=$| \(imported by |: (production )?dependencies)/, "`$1`").replace(/\(imported by (\S+)\)/, "(imported by `$1`)");
+function markdownReason(reason2) {
+  if (reason2.startsWith("unsure:"))
+    return reason2.replace(/(unclassified path |import )(\S+)/, (_m, pre, p) => `${pre}\`${p}\``);
+  return reason2.replace(/^(\S+?)(?=$| \(imported by |: (production )?dependencies)/, "`$1`").replace(/\(imported by (\S+)\)/, "(imported by `$1`)");
 }
 function capped(reasons, render3, sep) {
   const shown = reasons.slice(0, REASONS_SHOWN).map(render3);
@@ -5670,19 +5689,19 @@ function servedCommit(body) {
   return typeof c === "string" && c !== "" ? c : void 0;
 }
 function decideReady(body, elapsedMs, deadlineMs, identify) {
-  let reason;
+  let reason2;
   if (!body) {
-    reason = "/healthz not answering with JSON (container restarting, or unreachable)";
+    reason2 = "/healthz not answering with JSON (container restarting, or unreachable)";
   } else {
     const verdict = identify(body);
     if (verdict.live) return { kind: "live", ...verdict.identity };
     if (body.draining === true && !verdict.sameIdentity) {
       const n2 = typeof body.inFlight === "number" ? body.inFlight : "?";
       const since = typeof body.drainStartedAt === "string" ? ` since ${body.drainStartedAt}` : "";
-      reason = `old container still draining \u2014 ${n2} run(s) in flight${since}`;
-    } else reason = verdict.reason;
+      reason2 = `old container still draining \u2014 ${n2} run(s) in flight${since}`;
+    } else reason2 = verdict.reason;
   }
-  return elapsedMs >= deadlineMs ? { kind: "timeout", reason } : { kind: "waiting", reason };
+  return elapsedMs >= deadlineMs ? { kind: "timeout", reason: reason2 } : { kind: "waiting", reason: reason2 };
 }
 function sameCommit(a, b) {
   const x = a.trim();
@@ -6289,7 +6308,7 @@ var init_sandboxLiveGate = __esm({
     PROBE_COMMAND = "echo ok";
     PROBE_TIMEOUT_MS = 6e4;
     CONTAINER_STARTING = /Container is starting/i;
-    waiting = (reason) => ({ kind: "waiting", reason });
+    waiting = (reason2) => ({ kind: "waiting", reason: reason2 });
     isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     ANSI_SEQUENCE2 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
     SECTION_GUTTER = /^[\s│├╭╰|]+/;
@@ -7346,10 +7365,7 @@ async function transferImage(copy, account2, credential, io = {}) {
   } catch (err2) {
     if (err2 instanceof TransferProblem)
       return { ok: false, problem: err2.message, ...err2.unauthorized ? { unauthorized: true } : {} };
-    return {
-      ok: false,
-      problem: `copying ${copy.source} failed \u2014 ${err2 instanceof Error ? err2.message : String(err2)}`
-    };
+    return { ok: false, problem: `copying ${copy.source} failed \u2014 ${reason(err2)}` };
   }
 }
 async function transfer(copy, account2, credential, io) {
@@ -7433,16 +7449,19 @@ async function transfer(copy, account2, credential, io) {
     if (started.status !== 202 || !startedAt)
       throw await refused(`starting the upload of ${short2(blob.digest)} to ${targetName} failed`, started);
     let location = resolveLocation(startedAt, `${targetBase}/blobs/uploads/`);
-    const source2 = await fromSource(
-      `reading ${short2(blob.digest)} from ${copy.source}`,
-      `${sourceBase}/v2/${repository}/blobs/${blob.digest}`,
-      { signal: AbortSignal.timeout(LONG_MS) }
+    const blobUrl = `${sourceBase}/v2/${repository}/blobs/${blob.digest}`;
+    const chunks = sourceBytes(
+      blob,
+      copy.source,
+      log,
+      (from) => fromSource(`reading ${short2(blob.digest)} from ${copy.source}`, blobUrl, {
+        headers: from > 0 ? { range: `bytes=${from}-` } : {},
+        signal: AbortSignal.timeout(LONG_MS)
+      })
     );
-    if (!source2.ok || !source2.body)
-      throw new TransferProblem(`reading ${short2(blob.digest)} from ${copy.source} failed \u2014 ${await said(source2)}`);
     const hash = createHash2("sha256");
     let index = 0;
-    for await (const { part, bytes: partBytesBuffer } of partsOf(source2.body, parts, hash, blob, copy.source)) {
+    for await (const { part, bytes: partBytesBuffer } of partsOf(chunks, parts, hash, blob, copy.source)) {
       index++;
       const label = `part ${index}/${parts.length} (${contentRange(part)})`;
       const patch = () => doFetch(location, {
@@ -7513,6 +7532,41 @@ function asBody(bytes) {
 function sha256(bytes) {
   return `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
 }
+async function* sourceBytes(blob, source2, log, open2) {
+  let consumed = 0;
+  let resumes = 0;
+  for (; ; ) {
+    const res = await open2(consumed);
+    const what = consumed === 0 ? `reading ${short2(blob.digest)} from ${source2}` : `resuming ${short2(blob.digest)} from ${source2} at byte ${consumed}`;
+    if (consumed === 0 ? !res.ok : res.status !== 206) {
+      const words = consumed > 0 && res.status === 200 ? "HTTP 200 where 206 was expected (the source ignored the Range)" : await said(res);
+      void res.body?.cancel().catch(() => {
+      });
+      throw new TransferProblem(`${what} failed \u2014 ${words}`);
+    }
+    const contentRange2 = res.headers.get("content-range");
+    if (consumed > 0 && !contentRange2?.startsWith(`bytes ${consumed}-`))
+      throw new TransferProblem(`${what} failed \u2014 the source answered Content-Range ${contentRange2 ?? "none"}`);
+    if (!res.body) throw new TransferProblem(`${what} failed \u2014 no body`);
+    try {
+      for await (const chunk of res.body) {
+        consumed += chunk.byteLength;
+        yield chunk;
+      }
+      return;
+    } catch (err2) {
+      if (consumed >= blob.size) return;
+      if (resumes >= RESUMES)
+        throw new TransferProblem(
+          `reading ${short2(blob.digest)} from ${source2} broke at byte ${consumed} of ${blob.size} after ${resumes} resumes \u2014 ${reason(err2)}`
+        );
+      resumes++;
+      log(
+        `[images]   ${short2(blob.digest)} broke at ${mib(consumed)} of ${mib(blob.size)} (${reason(err2)}) \u2014 resuming from there, ${resumes} of ${RESUMES}`
+      );
+    }
+  }
+}
 async function* partsOf(body, parts, hash, blob, source2) {
   let i = 0;
   let buffer = parts.length > 0 ? Buffer.allocUnsafe(parts[0].end - parts[0].start) : Buffer.alloc(0);
@@ -7542,7 +7596,7 @@ async function* partsOf(body, parts, hash, blob, source2) {
       `${short2(blob.digest)} from ${source2} ended after ${parts[i].start + filled} of its ${blob.size} bytes`
     );
 }
-var REGISTRY_ENDPOINTS, SHORT_MS, LONG_MS, TransferProblem, refused, said, MiB, mib, short2;
+var REGISTRY_ENDPOINTS, SHORT_MS, LONG_MS, RESUMES, TransferProblem, refused, said, reason, MiB, mib, short2;
 var init_registryTransferHost = __esm({
   "../../src/deploy/registryTransferHost.ts"() {
     "use strict";
@@ -7555,6 +7609,7 @@ var init_registryTransferHost = __esm({
     };
     SHORT_MS = 6e4;
     LONG_MS = 30 * 6e4;
+    RESUMES = 3;
     TransferProblem = class extends Error {
       constructor(message3, unauthorized = false) {
         super(message3);
@@ -7567,6 +7622,11 @@ var init_registryTransferHost = __esm({
       const text = (await res.text().catch(() => "")).trim();
       return `HTTP ${res.status}${text ? `: ${text}` : ""}`;
     };
+    reason = (err2) => {
+      if (!(err2 instanceof Error)) return String(err2);
+      const cause = err2.cause instanceof Error ? err2.cause.message : void 0;
+      return cause && cause !== err2.message ? `${err2.message} (${cause})` : err2.message;
+    };
     MiB = 1024 * 1024;
     mib = (n2) => `${(n2 / MiB).toFixed(n2 >= 10 * MiB ? 0 : 1)} MiB`;
     short2 = (digest) => digest.slice(0, 19);
@@ -7590,9 +7650,9 @@ function imagesHostIO(options = {}) {
   const transferIO = { ...options.transferIO ?? {}, ...options.log ? { log: options.log } : {} };
   const credentials = /* @__PURE__ */ new Map();
   const credential = async (account2, replace = false) => {
-    const held = credentials.get(account2);
-    if (held && !replace && now() - held.mintedAt < CREDENTIAL_MINUTES * 6e4 - RENEW_BEFORE_MS)
-      return { ok: true, credential: held.credential };
+    const held2 = credentials.get(account2);
+    if (held2 && !replace && now() - held2.mintedAt < CREDENTIAL_MINUTES * 6e4 - RENEW_BEFORE_MS)
+      return { ok: true, credential: held2.credential };
     const token2 = env[API_TOKEN_ENV];
     if (!token2) return { ok: false, problem: apiTokenMissingProblem() };
     const minted = await transfer2.mint(account2, token2, transferIO);
@@ -7994,7 +8054,7 @@ function isHeadMaterial(event) {
     case "route":
       return true;
     case "run_note":
-      return event.kind === "mcp_unavailable" || event.kind === "spans_dropped" || event.kind === "cold_sandbox";
+      return event.kind === "mcp_unavailable" || event.kind === "spans_dropped" || event.kind === "cold_sandbox" || event.kind === "rebind_refused";
     case "span_start":
       return event.name === "request" || event.name === "slack.receive" || event.name.startsWith("dispatch.");
     case "span_end":
@@ -8060,6 +8120,7 @@ var init_runEvents = __esm({
       "seed",
       "description_turn",
       "cold_sandbox",
+      "rebind_refused",
       "pr_not_opened",
       "review_not_posted",
       "compacted",
@@ -9163,12 +9224,12 @@ ${parts}`);
 });
 
 // ../../src/execution/residentState.ts
-function degradedIsServiceable(reason) {
-  return SERVICEABLE_DEGRADED_REASON.test(reason ?? "");
+function degradedIsServiceable(reason2) {
+  return SERVICEABLE_DEGRADED_REASON.test(reason2 ?? "");
 }
-function isServiceable(state, reason) {
+function isServiceable(state, reason2) {
   if (!SERVICEABLE_STATES.has(state)) return false;
-  return state !== "degraded" || degradedIsServiceable(reason);
+  return state !== "degraded" || degradedIsServiceable(reason2);
 }
 var SERVICEABLE_STATES, SERVICEABLE_DEGRADED_REASON;
 var init_residentState = __esm({
@@ -9280,8 +9341,8 @@ function wakeDecision(probe) {
   }
   return { wait: false, why: `the resident is ${seen}, which no wake recovers from; not waiting` };
 }
-function describeState(state, reason) {
-  return reason ? `${state} (${reason})` : state;
+function describeState(state, reason2) {
+  return reason2 ? `${state} (${reason2})` : state;
 }
 function describeProbe(probe) {
   return probe.kind === "status" ? describeState(probe.state, probe.reason) : `unreachable (${probe.error})`;
@@ -9381,8 +9442,8 @@ var init_residentAdmin = __esm({
     init_secrets2();
     RESIDENTS_OFF_MESSAGE = "Resident repo environments aren't configured \u2014 set `execution.resident.baseUrl` in config.yaml.";
     NullResidentAdminClient = class {
-      constructor(reason = RESIDENTS_OFF_MESSAGE) {
-        this.reason = reason;
+      constructor(reason2 = RESIDENTS_OFF_MESSAGE) {
+        this.reason = reason2;
       }
       reason;
       answer() {
@@ -9431,6 +9492,20 @@ function wakePause(ms, signal2) {
     signal2?.addEventListener("abort", onAbort, { once: true });
   });
 }
+function reboundOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const v = value;
+  if (typeof v.from !== "string" || typeof v.to !== "string" || typeof v.pr !== "number") return void 0;
+  if (!v.from || !v.to || !Number.isSafeInteger(v.pr) || v.pr <= 0) return void 0;
+  return { from: v.from, to: v.to, pr: v.pr };
+}
+function rebindRefusedOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const v = value;
+  if (typeof v.to !== "string" || typeof v.pr !== "number" || typeof v.reason !== "string") return void 0;
+  if (!v.to || !v.reason || !Number.isSafeInteger(v.pr) || v.pr <= 0) return void 0;
+  return { to: v.to, pr: v.pr, reason: v.reason, why: typeof v.why === "string" ? v.why : "" };
+}
 async function parseResidentBody(res) {
   const text = await res.text();
   let data = {};
@@ -9620,10 +9695,12 @@ var init_resident = __esm({
       }
       /** Bind/reuse this thread's worktree. Legible errors for every named
        *  refusal the service can answer with. Answers the binding the resident
-       *  reported: the bound ref (authoritative — a differing refHint is ignored)
-       *  and the sha the worktree is at. A 200 without both fields is a
-       *  malformed resident (the attach contract always carries them) and is an
-       *  error, never a half-bound executor. */
+       *  reported: the bound ref — the resident's word, not the hint's: a differing
+       *  refHint is ignored unless `ownPr` names it as the thread's own pull
+       *  request and the resident moves a default-bound thread onto it (item 16;
+       *  `rebound` / `rebindRefused` say which) — and the sha the worktree is at. A
+       *  200 without both fields is a malformed resident (the attach contract
+       *  always carries them) and is an error, never a half-bound executor. */
       async attach(span) {
         const answer = await this.attachOnce(span);
         if (answer.ok) return answer.binding;
@@ -9640,6 +9717,8 @@ var init_resident = __esm({
         if (this.opts.readonly) body.readonly = true;
         if (this.opts.sha) body.sha = this.opts.sha;
         if (this.opts.reuse) body.reuse = true;
+        if (this.opts.ownPr) body.ownPr = this.opts.ownPr;
+        if (this.opts.refByDefault) body.refByDefault = true;
         const answered = await this.call("/attach", body, timeoutMs, void 0, span);
         const data = answered.data;
         const status3 = answered.status === 200 && typeof data.error === "string" && typeof data.status === "number" ? data.status : answered.status;
@@ -9648,6 +9727,8 @@ var init_resident = __esm({
           throw new Error(`resident attach: malformed answer for ${this.opts.resource} (missing ref/sha)`);
         }
         const trace = sanitizeGraftedSteps(data.trace);
+        const rebound = reboundOf(data.rebound);
+        const rebindRefused = rebindRefusedOf(data.rebindRefused);
         this.lastBinding = {
           ref: data.ref,
           sha: data.sha,
@@ -9655,7 +9736,9 @@ var init_resident = __esm({
           ...typeof data.user === "string" && data.user ? { user: data.user } : {},
           ...typeof data.container === "string" && data.container ? { container: data.container } : {},
           ...trace.length > 0 ? { trace } : {},
-          ...typeof data.attachMs === "number" && Number.isFinite(data.attachMs) ? { attachMs: data.attachMs } : {}
+          ...typeof data.attachMs === "number" && Number.isFinite(data.attachMs) ? { attachMs: data.attachMs } : {},
+          ...rebound !== void 0 ? { rebound } : {},
+          ...rebindRefused !== void 0 ? { rebindRefused } : {}
         };
         return { ok: true, binding: this.lastBinding };
       }
@@ -10086,7 +10169,8 @@ async function makeExecutor(opts, ctx, span) {
             threadKey: ctx.threadKey,
             refHint: ctx.ref,
             readonly,
-            sha: ctx.headSha
+            sha: ctx.headSha,
+            ...ctx.ownPr !== void 0 ? { ownPr: ctx.ownPr } : {}
           },
           nonWarm,
           span
@@ -10174,7 +10258,7 @@ async function openResident(opts, nonWarm, span) {
   } catch (err2) {
     if (!(err2 instanceof ResidentNeedsRefError) || !err2.defaultRef) throw err2;
     byDefault = true;
-    executor = new ResidentExecutor({ ...opts, refHint: err2.defaultRef });
+    executor = new ResidentExecutor({ ...opts, refHint: err2.defaultRef, refByDefault: true });
     try {
       binding = await executor.attach(span);
     } catch (again) {
@@ -10189,6 +10273,7 @@ async function openResident(opts, nonWarm, span) {
   }
   const where = `${opts.resource.replace(/^repo:/, "")} \xB7 ${binding.ref}@${binding.sha.slice(0, 7)}`;
   const why = byDefault ? " (repo default \u2014 no branch named)" : "";
+  const moved = rebindLabel(binding);
   return {
     executor,
     resident: true,
@@ -10196,9 +10281,17 @@ async function openResident(opts, nonWarm, span) {
     ...binding.trace ? { trace: binding.trace } : {},
     ...binding.attachMs !== void 0 ? { attachMs: binding.attachMs } : {},
     binding,
-    note: nonWarm ? `resident ${nonWarm} \xB7 ${where}${why} \u2014 attached to the last snapshot` : `resident \xB7 ${where}${why}`
+    note: nonWarm ? `resident ${nonWarm} \xB7 ${where}${why}${moved} \u2014 attached to the last snapshot` : `resident \xB7 ${where}${why}${moved}`
   };
 }
+function rebindLabel(binding) {
+  if (binding.rebound) return ` \xB7 rebound to ${binding.rebound.to} (this thread's PR #${binding.rebound.pr})`;
+  if (binding.rebindRefused) {
+    const r = binding.rebindRefused;
+    return ` \xB7 rebind to ${r.to} (this thread's PR #${r.pr}) refused: ${r.reason}`;
+  }
+  return "";
+}
 function residentOnboardedProbe(cfg, secrets = processSecrets) {
   const token2 = cfg?.baseUrl ? secrets.named(cfg.tokenEnv ?? "RESIDENT_OPERATOR_TOKEN") : void 0;
   if (!cfg?.baseUrl || !token2) return void 0;
@@ -12461,9 +12554,12 @@ function describeIssue(issue, root) {
 function wrapUntrusted(text) {
   return `${UNTRUSTED_PREAMBLE}
 ${UNTRUSTED_OPEN}
-${text}
+${breakFenceMarkers(text)}
 ${UNTRUSTED_CLOSE}`;
 }
+function breakFenceMarkers(text) {
+  return text.replaceAll(UNTRUSTED_CLOSE, "UNTRUSTED>> >").replaceAll(UNTRUSTED_OPEN, "<< <UNTRUSTED");
+}
 function renderText(cmd, output, opts = {}) {
   if (opts.surface === "chat" && cmd.renderChat) return cmd.renderChat(output);
   return cmd.render ? cmd.render(output) : renderCompact(cmd.id, output, opts);
@@ -12588,14 +12684,14 @@ var init_commandRegistry = __esm({
           });
           return fail("not_found", `unknown command: ${id}`);
         }
-        const done = (res, reason) => {
+        const done = (res, reason2) => {
           this.audit({
             commandId: cmd.id,
             callerKind: caller.kind,
             callerId: caller.id,
             effect: cmd.effect,
             outcome: res.ok ? "ok" : res.error,
-            ...reason === void 0 ? {} : { reason }
+            ...reason2 === void 0 ? {} : { reason: reason2 }
           });
           return res;
         };
@@ -14389,6 +14485,38 @@ function prOfEvents(events) {
   for (const e of events) if (e.type === "pr_opened") pr = { number: e.number, url: e.url };
   return pr;
 }
+function routeOfEvents(events) {
+  const meta = events.find((e) => e.type === "run_meta");
+  if (meta?.type !== "run_meta" || meta.agentSource !== "route") return void 0;
+  const r = events.find((e) => e.type === "route");
+  if (r?.type !== "route") return void 0;
+  return {
+    preset: r.preset,
+    reason: r.reason,
+    model: r.model,
+    ...r.parts ? { parts: r.parts.map((p) => ({ preset: p.preset, text: p.text })) } : {},
+    ...r.collapsed ? { collapsed: { presets: [...r.collapsed.presets] } } : {}
+  };
+}
+function isRunRouteShape(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const r = v;
+  if (typeof r.preset !== "string" || typeof r.reason !== "string" || typeof r.model !== "string") return false;
+  if (r.parts !== void 0) {
+    if (!Array.isArray(r.parts)) return false;
+    for (const p of r.parts) {
+      if (typeof p !== "object" || p === null) return false;
+      const part = p;
+      if (typeof part.preset !== "string" || typeof part.text !== "string") return false;
+    }
+  }
+  if (r.collapsed !== void 0) {
+    const c = r.collapsed;
+    if (typeof c !== "object" || c === null) return false;
+    if (!Array.isArray(c.presets) || !c.presets.every((p) => typeof p === "string")) return false;
+  }
+  return true;
+}
 function isRunPullRequestShape(v) {
   if (typeof v !== "object" || v === null) return false;
   const p = v;
@@ -14551,6 +14679,7 @@ function isRunRecord(v) {
     return false;
   if (r.dispositions !== void 0 && !isFindingDispositionsShape(r.dispositions)) return false;
   if (r.reviewPost !== void 0 && !isReviewPostShape(r.reviewPost)) return false;
+  if (r.route !== void 0 && !isRunRouteShape(r.route)) return false;
   if (r.profile !== void 0 && !isRunProfileRecord(r.profile)) return false;
   if (r.pr !== void 0 && !isRunPullRequestShape(r.pr)) return false;
   if (r.parentRunId !== void 0 && (typeof r.parentRunId !== "string" || !RUN_ID_PATTERN.test(r.parentRunId)))
@@ -17473,13 +17602,13 @@ function bridgeMcpTools(server, client, tools, opts) {
           const bytes = Buffer.byteLength(text, "utf8");
           const wrapped = wrapUntrusted(clipped);
           if (!ok2) {
-            const refused5 = classifyError(new Error(`MCP ${server.name}/${t.name} reported an error:
+            const refused6 = classifyError(new Error(`MCP ${server.name}/${t.name} reported an error:
 ${wrapped}`), {
               kind: "refused"
             });
-            span?.fail(refused5);
+            span?.fail(refused6);
             span?.end("error", { ok: ok2, bytes });
-            throw refused5;
+            throw refused6;
           }
           span?.end("ok", { ok: ok2, bytes });
           return wrapped;
@@ -17598,9 +17727,9 @@ var init_source = __esm({
               tools: bridgeMcpTools(server, client, tools, { budget })
             };
           } catch (err2) {
-            const reason = redactAndCap(err2 instanceof Error ? err2.message : String(err2), 160);
+            const reason2 = redactAndCap(err2 instanceof Error ? err2.message : String(err2), 160);
             return {
-              outcome: { server: server.name, unavailable: reason },
+              outcome: { server: server.name, unavailable: reason2 },
               tools: []
             };
           }
@@ -19725,12 +19854,12 @@ function renderResidentList(data) {
     const live = obj(rec2.live);
     const slug = String(rec2.resource ?? "").replace(/^repo:/, "");
     const state = String(live.state ?? "unknown");
-    const reason = String(live.reason ?? "");
+    const reason2 = String(live.reason ?? "");
     const sha = typeof live.sha === "string" && live.sha ? ` \xB7 sha \`${live.sha.slice(0, 8)}\`` : "";
     const refreshed = typeof live.lastRefreshAt === "string" && live.lastRefreshAt ? ` \xB7 refreshed ${live.lastRefreshAt}` : "";
     const d = obj(live.disk);
     const disk = typeof d.usedKiB === "number" && typeof d.totalKiB === "number" ? ` \xB7 disk ${formatDiskGauge({ usedKiB: d.usedKiB, totalKiB: d.totalKiB })}` : "";
-    return `\u2022 \`${slug}\` \u2014 *${state}*${reason ? ` (${reason})` : ""} \xB7 ref \`${String(rec2.defaultRef ?? "?")}\`${sha}${refreshed}${disk}`;
+    return `\u2022 \`${slug}\` \u2014 *${state}*${reason2 ? ` (${reason2})` : ""} \xB7 ref \`${String(rec2.defaultRef ?? "?")}\`${sha}${refreshed}${disk}`;
   });
   const out = [`*Resident repos* (${n(data.count)}/${n(data.cap)}):`, ...lines];
   const t = data.testOverrides;
@@ -19754,7 +19883,7 @@ function listWords(words) {
 async function settleProvisioning(deps, slug) {
   const sleep2 = deps.repo.sleep ?? ((ms) => new Promise((resolve12) => setTimeout(resolve12, ms)));
   const resource = repoResourceId(slug);
-  const hint = (reason) => /provision-failed at (install|build|test)\b/.test(reason) ? `Fix the command table with \`repo reconfigure ${slug} --install "\u2026" --build "\u2026" --test "\u2026"\`, then \`repo rebuild ${slug}\`.` : `Not a command-table failure \u2014 retry with \`repo rebuild ${slug}\`; if it recurs, the resident or Cloudflare side is at fault (\`repo list\` shows the live state).`;
+  const hint = (reason2) => /provision-failed at (install|build|test)\b/.test(reason2) ? `Fix the command table with \`repo reconfigure ${slug} --install "\u2026" --build "\u2026" --test "\u2026"\`, then \`repo rebuild ${slug}\`.` : `Not a command-table failure \u2014 retry with \`repo rebuild ${slug}\`; if it recurs, the resident or Cloudflare side is at fault (\`repo list\` shows the live state).`;
   for (let elapsed2 = 0; elapsed2 <= SETTLE_MAX_MS; elapsed2 += SETTLE_POLL_MS) {
     if (elapsed2 > 0) await sleep2(SETTLE_POLL_MS);
     const api = await deps.repo.admin();
@@ -19780,9 +19909,9 @@ async function settleProvisioning(deps, slug) {
     if (state === "onboarding") continue;
     if (state === "warm") return { ok: true, text: `\u2705 \`${slug}\` is warm \u2014 provisioned and attach-ready.` };
     if (state === "down") {
-      const reason = str4(r.data.reason ?? "no reason recorded");
-      return { ok: false, text: `\u274C \`${slug}\` failed to provision: ${reason}
-${hint(reason)}` };
+      const reason2 = str4(r.data.reason ?? "no reason recorded");
+      return { ok: false, text: `\u274C \`${slug}\` failed to provision: ${reason2}
+${hint(reason2)}` };
     }
     return {
       ok: true,
@@ -20708,6 +20837,7 @@ function ledgerView(row, events) {
     ...m.sourceUrl !== void 0 ? { sourceUrl: m.sourceUrl } : {},
     ...m.userName !== void 0 ? { userName: m.userName } : {},
     ...m.parentRunId !== void 0 ? { parentRunId: m.parentRunId } : {},
+    ...m.route !== void 0 ? { route: m.route } : {},
     ...m.parentInstanceId !== void 0 ? { parentInstanceId: m.parentInstanceId } : {},
     ...m.idempotencyKey !== void 0 ? { idempotencyKey: m.idempotencyKey } : {},
     ...row.stop ? { stop: { mode: row.stop, state: "stopping" } } : {},
@@ -22944,6 +23074,7 @@ function reclaimedRunRecord(input) {
     // included); a row from before profiles existed leaves the record without one.
     ...row.meta.profile && row.meta.agent ? { profile: { preset: row.meta.agent, ...row.meta.profile } } : {},
     ...row.meta.parentRunId !== void 0 ? { parentRunId: row.meta.parentRunId } : {},
+    ...row.meta.route !== void 0 ? { route: row.meta.route } : {},
     ...row.meta.seed !== void 0 ? { seed: row.meta.seed } : {},
     // The row's place in its session log (item 53): the range stays open on a
     // record closed here, since the closer has no turn count to end it with.
@@ -22979,6 +23110,7 @@ function assembleRunRecord(input) {
   const atFinish = snap?.events ?? [];
   const events = seal && seal.events.length > 0 ? [...atFinish, ...seal.events] : atFinish;
   const pr = prOfEvents(events);
+  const route3 = input.route ?? routeOfEvents(events);
   const fitted = fitRecordToBudget({
     id: run2.id,
     ...run2.label !== void 0 ? { label: run2.label } : {},
@@ -23015,6 +23147,7 @@ function assembleRunRecord(input) {
     ...input.reviewHead !== void 0 ? { reviewHead: input.reviewHead } : {},
     ...input.dispositions !== void 0 ? { dispositions: redactDispositions(input.dispositions) } : {},
     ...input.reviewPost !== void 0 ? { reviewPost: redactReviewPost(input.reviewPost) } : {},
+    ...route3 !== void 0 ? { route: route3 } : {},
     ...input.profile !== void 0 ? { profile: input.profile } : {},
     ...input.parentRunId !== void 0 ? { parentRunId: input.parentRunId } : {},
     ...coordinatorFields(input.coordinator),
@@ -23038,6 +23171,7 @@ function writeTombstone(deps, ctx) {
     run: run2,
     registry,
     resume,
+    route: route3,
     parentRunId,
     coordinator,
     seed
@@ -23055,6 +23189,7 @@ function writeTombstone(deps, ctx) {
           channelVisibility,
           repo: repoCtx.repo,
           profile: profileRecordOf(agent, profile),
+          ...route3 !== void 0 ? { route: route3 } : {},
           ...parentRunId !== void 0 ? { parentRunId } : {},
           ...coordinator !== void 0 ? { coordinator } : {},
           ...seed !== void 0 ? { seed } : {},
@@ -23091,6 +23226,7 @@ function registerFinishRecord(deps, ctx) {
     reviewHead,
     dispositions,
     reviewPost,
+    route: route3,
     parentRunId,
     coordinator,
     seed
@@ -23117,6 +23253,7 @@ function registerFinishRecord(deps, ctx) {
         ...reviewHead !== void 0 ? { reviewHead } : {},
         ...dispositions !== void 0 ? { dispositions } : {},
         ...reviewPost !== void 0 ? { reviewPost } : {},
+        ...route3 !== void 0 ? { route: route3 } : {},
         ...parentRunId !== void 0 ? { parentRunId } : {},
         ...coordinator !== void 0 ? { coordinator } : {},
         ...seed !== void 0 ? { seed } : {}
@@ -23666,8 +23803,8 @@ async function mergePullRequest(pr, opts) {
     return { ok: true, sha };
   }
   if (res.status === 405 || res.status === 409 || res.status === 422) {
-    const reason = typeof body?.message === "string" && body.message ? body.message : redactAndCap(text, 300);
-    return { ok: false, status: res.status, reason };
+    const reason2 = typeof body?.message === "string" && body.message ? body.message : redactAndCap(text, 300);
+    return { ok: false, status: res.status, reason: reason2 };
   }
   throw new Error(`merge failed for ${pr.repo}#${pr.number}: HTTP ${res.status} ${redactAndCap(text, 300)}`);
 }
@@ -23980,9 +24117,12 @@ async function resolveRepoContext(msg, history = [], probe, residentSlugs, recor
         if (head.base) out.baseRef = head.base;
         if (head.size) out.prSize = head.size;
         if (head.facts) out.prDescription = head.facts;
-        if (inherited.source === "record" && !ref && head.ref) {
-          out.ref = head.ref;
-          out.refFromPr = true;
+        if (inherited.source === "record") {
+          out.prFromRecord = true;
+          if (!ref && head.ref) {
+            out.ref = head.ref;
+            out.refFromPr = true;
+          }
         }
       } else {
         out.prUnpostable = { number: inherited.number, reason: head.reason };
@@ -23991,6 +24131,10 @@ async function resolveRepoContext(msg, history = [], probe, residentSlugs, recor
   }
   return out;
 }
+function ownPrOf(ctx) {
+  if (!ctx.prFromRecord || !ctx.refFromPr || ctx.pr === void 0 || ctx.ref === void 0) return void 0;
+  return { number: ctx.pr, ref: ctx.ref };
+}
 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;
   const record2 = records?.pr && records.pr.repo === repo ? { repo, number: records.pr.number, source: "record", at: records.pr.at } : void 0;
@@ -25591,9 +25735,9 @@ var init_diffDigest2 = __esm({
         const listing = `git diff --numstat ${range} && echo ${NAME_STATUS_MARK} && git diff --name-status ${range}`;
         let raw = await ctx.executor.exec(listing);
         const incomplete = () => {
-          const reason = "the file listing exceeded the executor's output cap";
-          ctx.onDigest?.({ complete: false, base: baseName, reason });
-          return `diff_digest: ${reason} \u2014 the digest cannot state totals for this change (base \`${baseName}\`). Read the diff file by file (\`git diff --name-only ${baseName}...HEAD\`).`;
+          const reason2 = "the file listing exceeded the executor's output cap";
+          ctx.onDigest?.({ complete: false, base: baseName, reason: reason2 });
+          return `diff_digest: ${reason2} \u2014 the digest cannot state totals for this change (base \`${baseName}\`). Read the diff file by file (\`git diff --name-only ${baseName}...HEAD\`).`;
         };
         if (OUTPUT_CUT_RE.test(raw)) return incomplete();
         let marker = NAME_STATUS_MARK_LINE.exec(raw);
@@ -25896,8 +26040,8 @@ ${clip2(c.body.trim(), 2e3)}`).join("\n\n")}` : "";
       async run(input, ctx) {
         const repo = repoOf(input);
         if (typeof repo !== "string") return `github_issue_create: ${repo.error}`;
-        const refused5 = writeGate("github_issue_create", ctx, repo);
-        if (refused5) return refused5;
+        const refused6 = writeGate("github_issue_create", ctx, repo);
+        if (refused6) return refused6;
         const title = String(input.title ?? "").trim();
         if (!title) return "github_issue_create: title is required.";
         try {
@@ -25933,8 +26077,8 @@ ${issue.url}`;
       async run(input, ctx) {
         const repo = repoOf(input);
         if (typeof repo !== "string") return `github_issue_update: ${repo.error}`;
-        const refused5 = writeGate("github_issue_update", ctx, repo);
-        if (refused5) return refused5;
+        const refused6 = writeGate("github_issue_update", ctx, repo);
+        if (refused6) return refused6;
         const number = numberOf(input);
         if (typeof number !== "number") return `github_issue_update: ${number.error}`;
         const patch = {
@@ -25970,8 +26114,8 @@ ${issue.url}`;
       async run(input, ctx) {
         const repo = repoOf(input);
         if (typeof repo !== "string") return `github_issue_comment: ${repo.error}`;
-        const refused5 = writeGate("github_issue_comment", ctx, repo);
-        if (refused5) return refused5;
+        const refused6 = writeGate("github_issue_comment", ctx, repo);
+        if (refused6) return refused6;
         const number = numberOf(input);
         if (typeof number !== "number") return `github_issue_comment: ${number.error}`;
         const body = String(input.body ?? "").trim();
@@ -25999,8 +26143,8 @@ ${url}`;
       async run(input, ctx) {
         const repo = repoOf(input);
         if (typeof repo !== "string") return `github_issue_delete: ${repo.error}`;
-        const refused5 = writeGate("github_issue_delete", ctx, repo);
-        if (refused5) return refused5;
+        const refused6 = writeGate("github_issue_delete", ctx, repo);
+        if (refused6) return refused6;
         const number = numberOf(input);
         if (typeof number !== "number") return `github_issue_delete: ${number.error}`;
         try {
@@ -26172,22 +26316,22 @@ function watchedChild(io, on) {
   return watched2;
 }
 async function spawnChild(deps, parent, request) {
-  const refused5 = (reason2, message3) => ({ kind: "refused", reason: reason2, message: message3 });
+  const refused6 = (reason3, message3) => ({ kind: "refused", reason: reason3, message: message3 });
   if (parent.depth >= MAX_SPAWN_DEPTH) {
-    return refused5(
+    return refused6(
       "spawn_depth",
       `a child run cannot spawn: this run is itself a child, and a tree is ${MAX_SPAWN_DEPTH} level deep \u2014 the run that started it is the one to ask`
     );
   }
   if (AGENTS[request.preset]?.identity === "write") {
-    return refused5(
+    return refused6(
       "spawn_identity",
       `\`${request.preset}\` runs as a \`write\` identity \u2014 it pushes branches and opens pull requests \u2014 and a spawned child never writes: it reads this conversation and reports; the person who asked starts that work by hand with \`agent:${request.preset}\``
     );
   }
   const minutesLeft = Math.floor(parent.remainingMs / 6e4);
   if (minutesLeft < MIN_BOUNDARY_MINUTES) {
-    return refused5(
+    return refused6(
       "spawn_budget",
       `this run has under ${MIN_BOUNDARY_MINUTES} minutes left \u2014 too little to hand a child, which could never run a command in it; wrap up instead`
     );
@@ -26195,13 +26339,13 @@ async function spawnChild(deps, parent, request) {
   const live = deps.registry.listActive().filter((s) => !s.finished && s.parentRunId === parent.runId).length;
   const cap = maxChildrenOf(deps.core.config.config.spawn);
   if (live >= cap) {
-    return refused5(
+    return refused6(
       "spawn_fanout",
       `${live} child run${live === 1 ? " is" : "s are"} live already \u2014 the cap is ${cap} (\`spawn.maxChildren\`); wait for one to finish before spawning another`
     );
   }
   if (!parent.io.openThread) {
-    return refused5(
+    return refused6(
       "spawn_unsupported",
       `the ${platformOf(parent.msg.channelId)} channel cannot open a thread of its own, so a child run cannot be spawned from it`
     );
@@ -26210,7 +26354,7 @@ async function spawnChild(deps, parent, request) {
   try {
     opened = await parent.io.openThread(childThreadLead(parent, request));
   } catch (err2) {
-    return refused5("spawn_failed", `the channel could not open the child's thread: ${describe3(err2)}`);
+    return refused6("spawn_failed", `the channel could not open the child's thread: ${describe3(err2)}`);
   }
   const child = {
     channelId: parent.msg.channelId,
@@ -26265,10 +26409,10 @@ async function spawnChild(deps, parent, request) {
       ...opened.thread.sourceUrl !== void 0 ? { url: opened.thread.sourceUrl } : {}
     };
   }
-  if (first.kind === "threw") return refused5("spawn_failed", describe3(first.err));
-  const reason = first.outcome.refusal ?? "spawn_failed";
-  console.log(`[spawn] ${parent.msg.threadKey} run ${parent.runId}: ${request.preset} child not started (${reason})`);
-  return refused5(reason, lastReply ?? `the child ended (${first.outcome.status}) before it started`);
+  if (first.kind === "threw") return refused6("spawn_failed", describe3(first.err));
+  const reason2 = first.outcome.refusal ?? "spawn_failed";
+  console.log(`[spawn] ${parent.msg.threadKey} run ${parent.runId}: ${request.preset} child not started (${reason2})`);
+  return refused6(reason2, lastReply ?? `the child ended (${first.outcome.status}) before it started`);
 }
 function spawnCapabilityFor(deps, parent) {
   const outcomes = /* @__PURE__ */ new Map();
@@ -28169,8 +28313,8 @@ function attachRule(attachers) {
     "A request that asks for a file, a screenshot, a recording or an attachment to be posted, attached or sent back routes there too, however read-only the rest of it sounds; a read-only preset can describe a file but never post one."
   ].join(" ");
 }
-function tidyReason(reason) {
-  const line3 = oneLine(redactAndCap(reason, ROUTE_REASON_CAP));
+function tidyReason(reason2) {
+  const line3 = oneLine(redactAndCap(reason2, ROUTE_REASON_CAP));
   return line3.length > 0 ? line3 : "no reason given";
 }
 function parseRouteAnswer(raw, allowed2, compound) {
@@ -28183,21 +28327,21 @@ function parseRouteAnswer(raw, allowed2, compound) {
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
     return { preset: void 0, reason: `not a single JSON object: ${tidyReason(trimmed)}` };
-  const { preset: named, reason, parts } = parsed;
+  const { preset: named, reason: reason2, parts } = parsed;
   const preset = typeof named === "string" ? named : Array.isArray(parts) ? COMPOUND_PRESET : void 0;
   const inferred = typeof named !== "string" && preset === COMPOUND_PRESET;
   if (preset === void 0)
     return { preset: void 0, reason: `missing preset in the router's answer: ${tidyReason(trimmed)}` };
   const partsAnswer = preset === COMPOUND_PRESET && Array.isArray(parts);
-  if (typeof reason !== "string" && !partsAnswer)
+  if (typeof reason2 !== "string" && !partsAnswer)
     return { preset: void 0, reason: `missing reason in the router's answer: ${tidyReason(trimmed)}` };
-  const tidy = typeof reason === "string" ? tidyReason(reason) : inferred ? "compound inferred from parts" : "no reason given";
+  const tidy = typeof reason2 === "string" ? tidyReason(reason2) : inferred ? "compound inferred from parts" : "no reason given";
   if (preset === COMPOUND_PRESET) return parseCompound(parts, tidy, allowed2, compound);
   if (!allowed2.includes(preset))
     return { preset: void 0, reason: `router said "${tidyReason(preset)}", not a preset the requester may run` };
   return { preset, reason: tidy };
 }
-function parseCompound(parts, reason, allowed2, offer) {
+function parseCompound(parts, reason2, allowed2, offer) {
   const rejected = (why) => ({
     preset: void 0,
     reason: `compound_rejected: ${why}`,
@@ -28221,8 +28365,8 @@ function parseCompound(parts, reason, allowed2, offer) {
     out.push({ preset, text: tidy });
   }
   const writer = out.find((p) => identityOf(p.preset) === "write");
-  if (writer) return { preset: writer.preset, reason, collapsed: { presets: out.map((p) => p.preset) } };
-  return { preset: COMPOUND_PRESET, reason, parts: out };
+  if (writer) return { preset: writer.preset, reason: reason2, collapsed: { presets: out.map((p) => p.preset) } };
+  return { preset: COMPOUND_PRESET, reason: reason2, parts: out };
 }
 async function route(input, model, opts = {}) {
   const { compound: offer, ...rest } = input;
@@ -28342,8 +28486,8 @@ async function routeRequest(deps, ctx) {
     }
   };
 }
-function routedLabel(reason, collapsed) {
-  return `${ROUTED_LABEL_PREFIX} ${reason}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}`;
+function routedLabel(reason2, collapsed) {
+  return `${ROUTED_LABEL_PREFIX} ${reason2}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}`;
 }
 function routedPartLines(parts) {
   return parts.map((p) => {
@@ -29269,6 +29413,7 @@ async function attachRoundWorkspace(input) {
       repo: input.round.repo,
       ref: input.round.ref,
       headSha: input.round.headSha,
+      ...input.round.ownPr !== void 0 ? { ownPr: input.round.ownPr } : {},
       ...input.round.reattach !== void 0 ? { reattach: input.round.reattach } : {}
     },
     input.span
@@ -29541,11 +29686,11 @@ ${carriedFooter(carried)}` : buildReviewPostBody(input.answer, verdict);
     try {
       await input.post(target, body);
     } catch (err2) {
-      const reason = err2 instanceof Error ? err2.message : String(err2);
-      console.error(`[review-post] ${logKey} failed for ${where}: ${reason}`);
-      await input.reply(`\u2139\uFE0F Review not posted to ${where}: ${reason} \u2014 this verdict is Slack-only.`).catch(() => {
+      const reason2 = err2 instanceof Error ? err2.message : String(err2);
+      console.error(`[review-post] ${logKey} failed for ${where}: ${reason2}`);
+      await input.reply(`\u2139\uFE0F Review not posted to ${where}: ${reason2} \u2014 this verdict is Slack-only.`).catch(() => {
       });
-      return record2({ posted: false, reason });
+      return record2({ posted: false, reason: reason2 });
     }
     console.log(
       `[review-post] ${logKey} \u2192 ${where} (${verdict?.verdict ?? "no verdict"})${carried ? ` carried ${carried.reviewed.slice(0, 7)} \u2192 ${pinned.slice(0, 7)}` : ""}`
@@ -30600,6 +30745,7 @@ async function reserveRun(deps, ctx) {
 }
 async function attachWorkspace(deps, ctx) {
   const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock3, agent, profile, repoCtx, root, reattach } = ctx;
+  const ownPr = ownPrOf(repoCtx);
   let round2;
   try {
     round2 = await root.span("dispatch.workspace.attach", async (span) => {
@@ -30625,6 +30771,9 @@ async function attachWorkspace(deps, ctx) {
             repo: repoCtx.repo,
             ref: repoCtx.ref,
             headSha: repoCtx.headSha,
+            // The thread's own pull request, when the ref is its head (resident-
+            // repos item 16): the one reason the resident may move a binding.
+            ...ownPr !== void 0 ? { ownPr } : {},
             ...reattach !== void 0 ? { reattach } : {}
           },
           logKey: msg.threadKey,
@@ -30804,6 +30953,7 @@ var init_provision = __esm({
     init_selfDescription();
     init_customInstructions();
     init_reviewRound();
+    init_repoContext();
     init_runEvents();
     init_runRecord();
     init_inboxMessage();
@@ -32021,10 +32171,10 @@ var init_bridge2 = __esm({
         return this.openTools.has(callId);
       }
       /** End whatever tool spans a stopped pi left open, so no span outlives the run. */
-      closeOpenSpans(reason) {
+      closeOpenSpans(reason2) {
         for (const [callId, open2] of this.openTools) {
           open2.span?.end("error", { callId, ok: false });
-          this.emit({ type: "tool_result", tool: open2.tool, ok: false, callId, summary: redactAndCap(reason) });
+          this.emit({ type: "tool_result", tool: open2.tool, ok: false, callId, summary: redactAndCap(reason2) });
         }
         this.openTools.clear();
         this.vetted.clear();
@@ -32535,7 +32685,7 @@ async function runPiHarnessOpen(deps, run2) {
       run2.saveFacts?.(facts2);
     }
   };
-  const held = () => {
+  const held2 = () => {
     if (transport) mirrored = transport.consumedOffset;
     save();
   };
@@ -32812,9 +32962,9 @@ ${stagedLine}` : prompt,
           if (!continuing) mirror.expectSeedEcho();
         }
       }
-      if (obs.message && await mirror.onMessage(obs.message, bridge.turns)) held();
+      if (obs.message && await mirror.onMessage(obs.message, bridge.turns)) held2();
       if (obs.compaction) {
-        if (await mirror.onCompaction(obs.compaction, bridge.turns)) held();
+        if (await mirror.onCompaction(obs.compaction, bridge.turns)) held2();
         if (!writeUp && !hardStopped && !catchingUp) {
           let notepad;
           let unavailable = false;
@@ -32994,8 +33144,8 @@ var init_harness = __esm({
     CALL_SEEN_TICK_MS = 50;
     CONTINUE_PROMPT = "Continue where you left off: the bot restarted mid-run, so re-check the effects of your last command before relying on them.";
     PromptRefused = class extends Error {
-      constructor(reason) {
-        super(`pi refused the prompt: ${reason}`);
+      constructor(reason2) {
+        super(`pi refused the prompt: ${reason2}`);
         this.name = "PromptRefused";
       }
     };
@@ -33466,9 +33616,9 @@ async function runCodingPrPostStep(input) {
       });
       return opened.created ? `\u{1F500} PR opened: ${opened.htmlUrl} (\`${branch2}\` \u2192 \`${base}\`)` : `\u{1F500} PR updated: ${opened.htmlUrl} \u2014 body re-rendered at \`${headSha.slice(0, 7)}\``;
     } catch (err2) {
-      const reason = err2 instanceof Error ? err2.message : String(err2);
-      console.error(`[pr-post] ${logKey} open/edit failed for ${repo} ${branch2}: ${reason}`);
-      return `\u26A0\uFE0F The branch \`${branch2}\` is pushed but the PR could not be opened: ${reason} \u2014 compare & open manually: ${compareUrl}`;
+      const reason2 = err2 instanceof Error ? err2.message : String(err2);
+      console.error(`[pr-post] ${logKey} open/edit failed for ${repo} ${branch2}: ${reason2}`);
+      return `\u26A0\uFE0F The branch \`${branch2}\` is pushed but the PR could not be opened: ${reason2} \u2014 compare & open manually: ${compareUrl}`;
     }
   }
   if (prDescription && pushedBranch && !base) {
@@ -33722,6 +33872,7 @@ async function runLoop2(deps, ctx) {
     steer,
     wait,
     session,
+    route: route3,
     parentRunId,
     coordinator,
     seed
@@ -34246,6 +34397,7 @@ async function runLoop2(deps, ctx) {
       ...reviewHead !== void 0 ? { reviewHead } : {},
       ...dispositions !== void 0 ? { dispositions } : {},
       ...reviewPost !== void 0 ? { reviewPost } : {},
+      ...route3 !== void 0 ? { route: route3 } : {},
       ...parentRunId !== void 0 ? { parentRunId } : {},
       ...coordinator !== void 0 ? { coordinator } : {},
       ...seed !== void 0 ? { seed } : {}
@@ -34373,8 +34525,8 @@ async function shipPreflight(input) {
   }
   const info = await input.repoInfo(repo).catch(() => void 0);
   if (info?.allowAutoMerge !== false) {
-    const reason = 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} ${reason}`);
+    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") {
@@ -35808,6 +35960,13 @@ function stickyAgentOf(runs, onPi) {
   if (newest === void 0 || !continuable(newest) || !onPi(newest.agent)) return void 0;
   return newest.agent;
 }
+function threadRouteOf(runs, agent) {
+  const newest = runs[0];
+  if (newest === void 0 || !continuable(newest) || newest.agent !== agent || newest.route === void 0)
+    return void 0;
+  const { preset, reason: reason2, model } = newest.route;
+  return { preset, reason: reason2, model };
+}
 function previousRunOf(runs, agent) {
   const run2 = runs.find((r) => r.agent === agent && continuable(r));
   if (run2 === void 0) return void 0;
@@ -36042,9 +36201,9 @@ async function dispatch(deps, msg, io, opts = {}) {
   const receivedAt = trace.receivedAt;
   const queuedBeforeMs = msg.originAt !== void 0 ? Math.max(0, receivedAt - msg.originAt) : void 0;
   const queued = queuedCaption("behind", opts.queuedBehindMs) ?? queuedCaption("before", queuedBeforeMs);
-  let refused5 = false;
+  let refused6 = false;
   const refuse3 = (outcome, fn) => {
-    refused5 = true;
+    refused6 = true;
     ended.refusal ??= outcome;
     return root.span("dispatch.refuse", fn, { attrs: { outcome } });
   };
@@ -36131,6 +36290,8 @@ async function dispatch(deps, msg, io, opts = {}) {
       agentSource = "route";
     }
     const routeEvent = routing.kind === "routed" ? routing.route : routing.rejected;
+    if (routing.kind === "unrouted" && stickyAgent !== void 0 && agentSource === "sticky" && thread)
+      route3 = threadRouteOf(thread, resolved.agentName);
     if (resume?.row.meta.route) route3 = resume.row.meta.route;
     if ((await authorizeAgent(deps, { msg, io, refuse: refuse3, agentName: resolved.agentName })).kind === "refused")
       return ended;
@@ -36481,6 +36642,12 @@ async function dispatch(deps, msg, io, opts = {}) {
     if (note) shell.setLabel(`${shell.label} \xB7 ${oneLine(note)}`);
     if (note && !resident)
       registry.publish(run2.id, { type: "run_note", kind: "cold_sandbox", summary: oneLine(note), at: clock3() });
+    const bound = round2.selection.binding;
+    const kept = bound?.rebindRefused;
+    if (bound && kept) {
+      const summary = `kept on ${bound.ref} \u2014 rebind to ${kept.to} (this thread's PR #${kept.pr}) refused: ${kept.reason}${kept.why ? ` \u2014 ${kept.why}` : ""}`;
+      registry.publish(run2.id, { type: "run_note", kind: "rebind_refused", summary: oneLine(summary), at: clock3() });
+    }
     console.log(`[run] ${msg.threadKey} user=${msg.userId} agent=${agent.name} model=${resolved.modelRef}`);
     setupCard = void 0;
     clearInterval(setupHeartbeat);
@@ -36502,6 +36669,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       run: run2,
       registry,
       resume,
+      ...route3 !== void 0 ? { route: route3 } : {},
       parentRunId,
       coordinator,
       seed
@@ -36592,6 +36760,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       steer,
       wait,
       ...sessionTools ? { session: sessionTools } : {},
+      ...route3 !== void 0 ? { route: route3 } : {},
       parentRunId,
       coordinator,
       seed,
@@ -36675,7 +36844,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     const settled = settleThread(deps, { msg, admitted, runLoopStarted, control: registered?.control });
     if (settled.kind === "dropped") await tellDropped(root, settled.pending);
     const stopMode = settled.kind === "handed-on" ? void 0 : settled.stopMode;
-    ended.status = caught ? "failed" : refused5 ? "refused" : stopMode ? "stopped" : "completed";
+    ended.status = caught ? "failed" : refused6 ? "refused" : stopMode ? "stopped" : "completed";
     root.end(caught ? "error" : "ok", { status: ended.status });
     if (restartRequest) {
       const pending2 = settled.kind === "handed-on" ? settled.pending : [];
@@ -37340,14 +37509,14 @@ function createLedgerWriteThrough(opts) {
       return !this.detached;
     }
     /** One warning, then silence: the run continues untracked. */
-    detach(reason) {
+    detach(reason2) {
       if (this.detached) return;
       this.detached = true;
       this.broken = true;
-      warn(`[ledger] ${this.threadKey} run ${this.runId} detached: ${reason} \u2014 this run is not resumable`);
+      warn(`[ledger] ${this.threadKey} run ${this.runId} detached: ${reason2} \u2014 this run is not resumable`);
       this.stopHeartbeat();
       live.delete(this);
-      if (reason.includes("(fenced)")) {
+      if (reason2.includes("(fenced)")) {
         this.fencedOut = true;
         if (this.onFenced && !this.fencedTold) {
           this.fencedTold = true;
@@ -38447,6 +38616,35 @@ var init_invokedAsScript = __esm({
   }
 });
 
+// ../../src/channels/slack/threadTurns.ts
+function threadTurns(messages, opts) {
+  const kept = [];
+  for (const mm of messages) {
+    if (opts.skipTs !== void 0 && mm.ts === opts.skipTs) continue;
+    const raw = mm.text ?? "";
+    const text = opts.botUserId ? raw.replaceAll(`<@${opts.botUserId}>`, "").trim() : raw;
+    if (STATUS_PREFIXES.some((p) => text.startsWith(p))) continue;
+    const files = mm.bot_id ? void 0 : mm.files;
+    if (!text && !files?.length) continue;
+    const at = mm.ts !== void 0 && Number.isFinite(Number(mm.ts)) ? Math.round(Number(mm.ts) * 1e3) : void 0;
+    kept.push({
+      role: mm.bot_id ? "assistant" : "user",
+      text,
+      ...at !== void 0 ? { at } : {},
+      ...mm.user !== void 0 ? { user: mm.user } : {},
+      ...mm.bot_id !== void 0 ? { botId: mm.bot_id } : {},
+      files
+    });
+  }
+  return kept;
+}
+var init_threadTurns = __esm({
+  "../../src/channels/slack/threadTurns.ts"() {
+    "use strict";
+    init_reply();
+  }
+});
+
 // ../../src/core/statusBudget.ts
 function createStatusBudget(opts) {
   const now = opts.now ?? Date.now;
@@ -39587,7 +39785,7 @@ var init_slack = __esm({
   "../../src/channels/slack.ts"() {
     "use strict";
     init_dispatcher();
-    init_reply();
+    init_threadTurns();
     init_statusBudget();
     init_requestTrace();
     init_clock();
@@ -39810,18 +40008,7 @@ ${file.text}`));
             ts: this.ev.threadTs,
             limit: 50
           })).messages ?? [];
-          const kept = [];
-          for (const m of thread) {
-            const mm = m;
-            if (mm.ts === this.ev.ts) continue;
-            const raw = mm.text ?? "";
-            const text = this.ev.botUserId ? raw.replaceAll(`<@${this.ev.botUserId}>`, "").trim() : raw;
-            if (STATUS_PREFIXES.some((p) => text.startsWith(p))) continue;
-            const files = mm.bot_id ? void 0 : mm.files;
-            if (!text && !files?.length) continue;
-            const at = mm.ts !== void 0 && Number.isFinite(Number(mm.ts)) ? Math.round(Number(mm.ts) * 1e3) : void 0;
-            kept.push({ role: mm.bot_id ? "assistant" : "user", text, ...at !== void 0 ? { at } : {}, files });
-          }
+          const kept = threadTurns(thread, { skipTs: this.ev.ts, botUserId: this.ev.botUserId });
           const imagesByIndex = [];
           const documentsByIndex = [];
           let imagesLeft = MAX_HISTORY_IMAGES;
@@ -41340,15 +41527,15 @@ function createResidentsViewHandler(client, shell, trace) {
     };
     bound.residents().then((r) => {
       if (r.status !== 200) {
-        const reason = (typeof r.data.error === "string" ? r.data.error : JSON.stringify(r.data)).slice(
+        const reason2 = (typeof r.data.error === "string" ? r.data.error : JSON.stringify(r.data)).slice(
           0,
           UPSTREAM_REASON_MAX
         );
         if (r.status === 503) {
-          plainEnd(503, reason);
+          plainEnd(503, reason2);
           return;
         }
-        plainEnd(502, `resident Worker answered ${r.status} to /residents: ${reason}`);
+        plainEnd(502, `resident Worker answered ${r.status} to /residents: ${reason2}`);
         return;
       }
       const residents = Array.isArray(r.data.residents) ? r.data.residents : [];
@@ -41430,8 +41617,8 @@ function createCostsViewHandler(service, shell) {
       res.writeHead(200, WEB_HTML_HEADERS);
       res.end(shell(`${report2.label} spend`, { page: "costs", report: report2, groups }));
     }).catch((err2) => {
-      const reason = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX2);
-      plain2(res, 502, `cost sources unavailable: ${reason}`);
+      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX2);
+      plain2(res, 502, `cost sources unavailable: ${reason2}`);
     });
     return true;
   };
@@ -41512,8 +41699,8 @@ function createDeliveryViewHandler(deps, shell) {
       res.writeHead(200, WEB_HTML_HEADERS);
       res.end(html);
     }).catch((err2) => {
-      const reason = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX3);
-      plain3(res, 502, `delivery sources unavailable: ${reason}`);
+      const reason2 = (err2 instanceof Error ? err2.message : String(err2)).slice(0, UPSTREAM_REASON_MAX3);
+      plain3(res, 502, `delivery sources unavailable: ${reason2}`);
     });
     return true;
   };
@@ -42797,6 +42984,11 @@ async function launchResumes(deps, resumable, opts) {
   });
   const dispatchFn = opts.dispatchFn ?? (await Promise.resolve().then(() => (init_dispatcher(), dispatcher_exports))).dispatch;
   const outcome = { launched: [], closed: [] };
+  const start3 = (row, dispatched, failure2) => {
+    void dispatched.catch(
+      (err2) => warn(`[resume] ${row.runId} ${row.threadKey}: ${failure2}: ${err2 instanceof Error ? err2.message : String(err2)}`)
+    ).finally(() => opts.onDone?.(row.runId));
+  };
   for (const run2 of resumable) {
     const { row } = run2;
     const agent = opts.agentFor(row.meta.agent);
@@ -42819,11 +43011,7 @@ async function launchResumes(deps, resumable, opts) {
         `[resume] ${row.runId} ${row.threadKey}: restarting from its request (killed while attaching; ${run2.inbox.length} follow-up(s) pending)`
       );
       outcome.launched.push(row.runId);
-      void dispatchFn(deps, restored.msg, io2, { restart: { row, inbox: run2.inbox } }).catch(
-        (err2) => warn(
-          `[resume] ${row.runId} ${row.threadKey}: restart dispatch failed: ${err2 instanceof Error ? err2.message : String(err2)}`
-        )
-      );
+      start3(row, dispatchFn(deps, restored.msg, io2, { restart: { row, inbox: run2.inbox } }), "restart dispatch failed");
       continue;
     }
     const plan3 = planResume({ transcript: run2.transcript, lastStep: run2.lastStep, tools: knownToolsFor(agent) });
@@ -42850,11 +43038,7 @@ async function launchResumes(deps, resumable, opts) {
       plan3.kind === "finish" ? `[resume] ${row.runId} ${row.threadKey}: finishing (the model had answered at step ${plan3.step}; running the post-steps with its answer)` : `[resume] ${row.runId} ${row.threadKey}: resuming (${plan3.stepRecorded ? "settling" : "running fresh"} step ${plan3.step}, ${plan3.settlements.length} call(s), ${Math.round(plan3.remainingMs / 6e4)} min left)`
     );
     outcome.launched.push(row.runId);
-    void dispatchFn(deps, resumeMessage(row, inputTextOf(run2.events)), io, { resume: ctx }).catch(
-      (err2) => warn(
-        `[resume] ${row.runId} ${row.threadKey}: dispatch failed: ${err2 instanceof Error ? err2.message : String(err2)}`
-      )
-    );
+    start3(row, dispatchFn(deps, resumeMessage(row, inputTextOf(run2.events)), io, { resume: ctx }), "dispatch failed");
   }
   return outcome;
   async function closeWith(run2, why) {
@@ -42864,6 +43048,7 @@ async function launchResumes(deps, resumable, opts) {
     } catch (err2) {
       warn(`[resume] ${run2.row.runId}: could not close: ${err2 instanceof Error ? err2.message : String(err2)}`);
     }
+    opts.onDone?.(run2.row.runId);
   }
 }
 var init_resumeLaunch = __esm({
@@ -42875,6 +43060,60 @@ var init_resumeLaunch = __esm({
   }
 });
 
+// ../../src/core/runLedger/takeover.ts
+var LedgerTakeover;
+var init_takeover = __esm({
+  "../../src/core/runLedger/takeover.ts"() {
+    "use strict";
+    LedgerTakeover = class {
+      listed = false;
+      waiters = [];
+      /** Handed to the launcher; each leaves when `done` names it. */
+      resuming = /* @__PURE__ */ new Set();
+      /** The latest listing's rows under another generation's lease. */
+      elsewhere = /* @__PURE__ */ new Set();
+      get settled() {
+        return this.listed;
+      }
+      /** No ledger to take over from: settled with nothing pending. */
+      settle() {
+        this.listed = true;
+        for (const wake2 of this.waiters.splice(0)) wake2();
+      }
+      /** One reclaim pass's outcome: its resumable runs join the pending set (until
+       *  `done`), its listing of rows live elsewhere replaces the previous one, and
+       *  the takeover counts as settled. */
+      take(outcome) {
+        for (const r of outcome.resumable) this.resuming.add(r.row.runId);
+        this.elsewhere = new Set(outcome.liveElsewhere.map((r) => r.runId));
+        this.settle();
+      }
+      /** The run's resume is over — its dispatch settled or the launcher closed it. */
+      done(runId3) {
+        this.resuming.delete(runId3);
+      }
+      pending(runId3) {
+        return this.resuming.has(runId3) || this.elsewhere.has(runId3);
+      }
+      whenSettled(withinMs) {
+        if (this.listed) return Promise.resolve(true);
+        return new Promise((resolve12) => {
+          const timer = setTimeout(() => {
+            const at = this.waiters.indexOf(wake2);
+            if (at >= 0) this.waiters.splice(at, 1);
+            resolve12(false);
+          }, withinMs);
+          const wake2 = () => {
+            clearTimeout(timer);
+            resolve12(true);
+          };
+          this.waiters.push(wake2);
+        });
+      }
+    };
+  }
+});
+
 // ../../src/core/nullChannelIo.ts
 function nullChannelIO(logKey, log = console.log) {
   let children = 0;
@@ -42954,18 +43193,18 @@ function presentedBearer(headers) {
   return apiKey ? apiKey : void 0;
 }
 function decideDoor(method, path, headers, bearers) {
-  const refused5 = (shape2, status3, code, message3, runId3) => ({
+  const refused6 = (shape2, status3, code, message3, runId3) => ({
     ok: false,
     code,
     response: refusalResponse(shape2, status3, code, message3),
     ...runId3 !== void 0 ? { runId: runId3 } : {}
   });
   const shape = proxyShapeOf(path);
-  if (!shape) return refused5(void 0, 404, "not_found", "no model proxy at this path");
-  if ((method ?? "GET").toUpperCase() !== "POST") return refused5(shape, 405, "method_not_allowed", "POST only");
+  if (!shape) return refused6(void 0, 404, "not_found", "no model proxy at this path");
+  if ((method ?? "GET").toUpperCase() !== "POST") return refused6(shape, 405, "method_not_allowed", "POST only");
   const presented = presentedBearer(headers);
   if (presented === void 0) {
-    return refused5(
+    return refused6(
       shape,
       401,
       "missing_bearer",
@@ -42976,15 +43215,15 @@ function decideDoor(method, path, headers, bearers) {
   if (verdict.ok) return { ok: true, shape, grant: verdict.grant, turns: verdict.turns };
   switch (verdict.reason) {
     case "malformed":
-      return refused5(shape, 401, "malformed_bearer", "the bearer is not a run bearer");
+      return refused6(shape, 401, "malformed_bearer", "the bearer is not a run bearer");
     case "unknown_run":
-      return refused5(shape, 404, "unknown_run", "the bearer names a run this bot does not hold", verdict.runId);
+      return refused6(shape, 404, "unknown_run", "the bearer names a run this bot does not hold", verdict.runId);
     case "unknown_bearer":
-      return refused5(shape, 401, "unknown_bearer", "the bearer was not minted for its run", verdict.runId);
+      return refused6(shape, 401, "unknown_bearer", "the bearer was not minted for its run", verdict.runId);
     case "expired":
-      return refused5(shape, 403, "expired", "the bearer expired with the run's budget", verdict.runId);
+      return refused6(shape, 403, "expired", "the bearer expired with the run's budget", verdict.runId);
     case "revoked":
-      return refused5(shape, 403, "revoked", "the run ended and its bearer with it", verdict.runId);
+      return refused6(shape, 403, "revoked", "the run ended and its bearer with it", verdict.runId);
   }
 }
 function pinRequest(shape, body, grant2) {
@@ -43125,9 +43364,9 @@ function meteredStream(source2, hooks) {
         controller.error(err2);
       }
     },
-    cancel(reason) {
-      settle2(() => hooks.onError(reason ?? new Error("cancelled")));
-      void reader.cancel(reason).catch(() => {
+    cancel(reason2) {
+      settle2(() => hooks.onError(reason2 ?? new Error("cancelled")));
+      void reader.cancel(reason2).catch(() => {
       });
     }
   });
@@ -43579,8 +43818,8 @@ var init_toolRules = __esm({
     READ_REACH = /* @__PURE__ */ new Set(["shell", "files", "web", "search", "github-read", "verdict"]);
     NONE_REACH = /* @__PURE__ */ new Set();
     allowed = { verdict: "allowed" };
-    refused4 = (reason) => ({ verdict: "refused", reason });
-    outside = (reason) => ({ verdict: "outside-profile", reason });
+    refused4 = (reason2) => ({ verdict: "refused", reason: reason2 });
+    outside = (reason2) => ({ verdict: "outside-profile", reason: reason2 });
     isRecord5 = (v) => typeof v === "object" && v !== null;
     CREDENTIAL_FILE = /(^|[\s/'"`])(\.git\/)?(github-credentials|\.git-credentials)($|[\s'"`|;&])/;
     ENV_DUMP = /(^|[;&|(]\s*)((printenv|env)(\s+-[A-Za-z0-9-]+)*|export\s+-p|declare\s+-[a-zA-Z]*[px][a-zA-Z]*|set)\s*($|[|;&>)])|\/proc\/(self|\d+)\/environ|process\.env(?![.[\w])/;
@@ -43618,13 +43857,13 @@ function relayedToolDefinitions(harness) {
 function authorizeToolCall(harness, ask) {
   harness.gateSaw(ask.toolCallId);
   const blocked = harness.toolsBlocked();
-  const refuse3 = (reason) => {
+  const refuse3 = (reason2) => {
     harness.emit({
       type: "run_note",
       kind: "tool_refused",
-      summary: redactAndCap(`${ask.tool} refused: ${reason}`, 300)
+      summary: redactAndCap(`${ask.tool} refused: ${reason2}`, 300)
     });
-    return { allow: false, reason };
+    return { allow: false, reason: reason2 };
   };
   if (blocked !== void 0) return refuse3(blocked);
   if (harness.tools.some((t) => t.name === ask.tool)) return { allow: true };
@@ -43756,19 +43995,42 @@ function bearerOf(headers) {
   const m = value ? /^Bearer\s+(\S+)$/i.exec(value.trim()) : null;
   return m ? m[1] : void 0;
 }
-function admitHarnessRequest(deps, headers) {
-  const presented = bearerOf(headers);
-  if (!presented) return { ok: false, response: { status: 401, body: { error: "missing_bearer" } } };
+function judge2(deps, presented) {
   const verdict = deps.bearers.verify(presented);
   if (!verdict.ok) {
     const status3 = verdict.reason === "unknown_run" ? 404 : verdict.reason === "malformed" ? 401 : verdict.reason === "unknown_bearer" ? 401 : 403;
-    return { ok: false, response: { status: status3, body: { error: verdict.reason } } };
+    return {
+      ok: false,
+      status: status3,
+      reason: verdict.reason,
+      ...verdict.reason === "malformed" ? {} : { runId: verdict.runId }
+    };
   }
   const runId3 = verdict.grant.runId;
-  if (!deps.harnesses.get(runId3))
-    return { ok: false, response: { status: 404, body: { error: "run_not_on_harness" } } };
+  if (!deps.harnesses.get(runId3)) return { ok: false, status: 404, reason: "run_not_on_harness", runId: runId3 };
   return { ok: true, runId: runId3 };
 }
+function held(path, reason2, runId3) {
+  const response = path === HARNESS_TOOL_PATH ? { status: 202, body: { pending: true, reason: reason2 } } : { status: 503, body: { error: reason2 }, headers: { "retry-after": String(HELD_RETRY_AFTER_S) } };
+  return { ok: false, response, held: { reason: reason2, ...runId3 !== void 0 ? { runId: runId3 } : {} } };
+}
+async function admitHarnessRequest(deps, headers, path) {
+  const presented = bearerOf(headers);
+  if (!presented) return { ok: false, response: { status: 401, body: { error: "missing_bearer" } } };
+  let verdict = judge2(deps, presented);
+  if (verdict.ok) return verdict;
+  if (!RESUME_CAN_OPEN.has(verdict.reason)) return refused5(verdict);
+  if (!deps.takeover.settled) {
+    await deps.takeover.whenSettled(DOOR_HOLD_MS);
+    verdict = judge2(deps, presented);
+    if (verdict.ok) return verdict;
+    if (!RESUME_CAN_OPEN.has(verdict.reason)) return refused5(verdict);
+    if (!deps.takeover.settled) return held(path, "reclaim_pending", verdict.runId);
+  }
+  if (verdict.runId !== void 0 && deps.takeover.pending(verdict.runId))
+    return held(path, "run_resuming", verdict.runId);
+  return refused5(verdict);
+}
 function askOf(body) {
   if (typeof body !== "object" || body === null) return void 0;
   const b = body;
@@ -43780,7 +44042,7 @@ async function handleHarnessRequest(deps, req) {
   const wantsGet = req.path === HARNESS_TOOLS_PATH;
   if ((req.method ?? "GET") !== (wantsGet ? "GET" : "POST"))
     return { status: 405, body: { error: "method_not_allowed" } };
-  const door = admitHarnessRequest(deps, req.headers);
+  const door = await admitHarnessRequest(deps, req.headers, req.path);
   if (!door.ok) return door.response;
   const harness = deps.harnesses.get(door.runId);
   if (wantsGet) return { status: 200, body: { tools: relayedToolDefinitions(harness) } };
@@ -43807,14 +44069,17 @@ function createHarnessRoutesHandler(deps) {
   const log = deps.log ?? ((line3) => console.log(line3));
   return (req, res) => {
     const json2 = (r) => {
-      res.writeHead(r.status, { "content-type": "application/json", "cache-control": "no-store" });
+      res.writeHead(r.status, { ...r.headers, "content-type": "application/json", "cache-control": "no-store" });
       res.end(JSON.stringify(r.body));
     };
     void (async () => {
       const path = (req.url ?? "/").split("?")[0];
-      const door = admitHarnessRequest({ ...deps, log }, req.headers);
+      const door = await admitHarnessRequest({ ...deps, log }, req.headers, path);
       if (!door.ok) {
-        log(`[harness] ${door.response.status} ${ROUTE_WORD[path] ?? "other"} \u2014 ${String(door.response.body.error)}`);
+        const word = ROUTE_WORD[path] ?? "other";
+        log(
+          door.held ? `[harness] ${door.response.status} ${word} \u2014 held (${door.held.reason})${door.held.runId ? ` run=${door.held.runId}` : ""}` : `[harness] ${door.response.status} ${word} \u2014 ${String(door.response.body.error)}`
+        );
         json2(door.response);
         req.resume();
         return;
@@ -43840,22 +44105,30 @@ function createHarnessRoutesHandler(deps) {
     });
   };
 }
-var HARNESS_TOOLS_PATH, HARNESS_AUTHORIZE_PATH, HARNESS_TOOL_PATH, HARNESS_PATHS, MAX_HARNESS_BODY_BYTES, ROUTE_WORD;
+var HARNESS_TOOLS_PATH, HARNESS_AUTHORIZE_PATH, HARNESS_TOOL_PATH, HARNESS_PATHS, MAX_HARNESS_BODY_BYTES, DOOR_HOLD_MS, HELD_RETRY_AFTER_S, ROUTE_WORD, RESUME_CAN_OPEN, refused5;
 var init_harnessRoutes = __esm({
   "../../src/channels/harnessRoutes.ts"() {
     "use strict";
     init_relay();
+    init_drain();
     init_http();
     HARNESS_TOOLS_PATH = "/harness/tools";
     HARNESS_AUTHORIZE_PATH = "/harness/authorize";
     HARNESS_TOOL_PATH = "/harness/tool";
     HARNESS_PATHS = [HARNESS_TOOLS_PATH, HARNESS_AUTHORIZE_PATH, HARNESS_TOOL_PATH];
     MAX_HARNESS_BODY_BYTES = 4 * 1024 * 1024;
+    DOOR_HOLD_MS = HANDOFF_BUDGET_MS + 4e3;
+    HELD_RETRY_AFTER_S = 2;
     ROUTE_WORD = {
       [HARNESS_TOOLS_PATH]: "tools",
       [HARNESS_AUTHORIZE_PATH]: "authorize",
       [HARNESS_TOOL_PATH]: "tool"
     };
+    RESUME_CAN_OPEN = /* @__PURE__ */ new Set(["unknown_run", "unknown_bearer", "run_not_on_harness"]);
+    refused5 = (j) => ({
+      ok: false,
+      response: { status: j.status, body: { error: j.reason } }
+    });
   }
 });
 
@@ -44714,7 +44987,7 @@ async function merge(body, deps, subject2) {
   const headSha = normalizeHead(body.headSha);
   if (headSha === void 0) return json(400, { ok: false, error: "headSha must be the approved head (7 to 40 hex)" });
   const at = (deps.clock ?? systemClock)();
-  const refused5 = (reason) => json(200, { ok: true, outcome: "refused", reason, at });
+  const refused6 = (reason2) => json(200, { ok: true, outcome: "refused", reason: reason2, at });
   const instance = await deps.instances.get(id.value);
   if (!instance) return json(404, { ok: false, error: "unknown_instance" });
   const unit = await unitRowOf(deps, instance, body.unit);
@@ -44723,12 +44996,12 @@ async function merge(body, deps, subject2) {
   const log = deps.log ?? console.log;
   const actor = resolveActor({ surface: "http", subjectId: subject2 }, deps.grantsFor);
   if (!authorize(actor, PLAN_MERGE_ACTION, { type: "command", id: "coordinator.merge" }).allow)
-    return refused5(
+    return refused6(
       `the runner holds no ${PLAN_MERGE_ACTION} grant (grants["http:${subject2}"] in config.yaml) \u2014 a person merges`
     );
   const planBranch = parsePlanBranch(row.branch);
   if (instance.plan === void 0 || planBranch === void 0 || planBranch.planId !== instance.plan.id)
-    return refused5(
+    return refused6(
       `\`${row.branch}\` is not a branch of plan \`${instance.plan?.id ?? "(none)"}\` \u2014 waits for a person's merge`
     );
   const pr = { repo: instance.repo, number: body.prNumber };
@@ -44742,12 +45015,12 @@ async function merge(body, deps, subject2) {
   if (facts2 === void 0)
     return json(502, { ok: false, error: "github_unavailable", message: `${where} could not be read`, at });
   if (isReleasePullRequest(facts2))
-    return refused5(`${where} is the release pull request \u2014 always a person's merge, never the runner's`);
-  if (facts2.state !== "open") return refused5(`${where} is ${facts2.state}`);
+    return refused6(`${where} is the release pull request \u2014 always a person's merge, never the runner's`);
+  if (facts2.state !== "open") return refused6(`${where} is ${facts2.state}`);
   if (facts2.headRef !== row.branch)
-    return refused5(`${where} heads \`${facts2.headRef ?? "?"}\`, not the unit's branch \`${row.branch}\``);
+    return refused6(`${where} heads \`${facts2.headRef ?? "?"}\`, not the unit's branch \`${row.branch}\``);
   if (facts2.headSha === void 0 || !sameCommit2(facts2.headSha, headSha))
-    return refused5(
+    return refused6(
       `the head of ${where} moved: \`${facts2.headSha?.slice(0, 7) ?? "?"}\` is not the approved \`${headSha.slice(0, 7)}\``
     );
   const approved = await reviewPostedAt(deps, pr, "approve", headSha);
@@ -44758,7 +45031,7 @@ async function merge(body, deps, subject2) {
       message: `the reviews of ${where} could not be read`,
       at
     });
-  if (!approved) return refused5(`no approving review by the bot stands on ${where} at \`${headSha.slice(0, 7)}\``);
+  if (!approved) return refused6(`no approving review by the bot stands on ${where} at \`${headSha.slice(0, 7)}\``);
   const checks = await deps.fetchCommitChecks(instance.repo, headSha).catch(() => void 0);
   if (checks === void 0)
     return json(502, {
@@ -44767,7 +45040,7 @@ async function merge(body, deps, subject2) {
       message: `the checks at ${headSha.slice(0, 7)} could not be read`,
       at
     });
-  if (checks.failed.length > 0) return refused5(`CI is red at \`${headSha.slice(0, 7)}\`: ${checks.failed.join(", ")}`);
+  if (checks.failed.length > 0) return refused6(`CI is red at \`${headSha.slice(0, 7)}\`: ${checks.failed.join(", ")}`);
   if (checks.total === 0)
     return json(200, {
       ok: true,
@@ -44795,7 +45068,7 @@ async function merge(body, deps, subject2) {
     log(
       `[coordinator] ${instance.id} ${row.unit}: GitHub refused the merge of ${where} (HTTP ${merged.status}): ${merged.reason}`
     );
-    return refused5(`GitHub refused the merge of ${where} (HTTP ${merged.status}): ${merged.reason}`);
+    return refused6(`GitHub refused the merge of ${where} (HTTP ${merged.status}): ${merged.reason}`);
   }
   log(
     `[coordinator] ${instance.id} ${row.unit}: merged ${where} at ${headSha.slice(0, 7)} \u2192 ${merged.sha.slice(0, 7)}`
@@ -45376,6 +45649,7 @@ async function runBot() {
     );
   }
   const threadsElsewhere = new ThreadsElsewhere();
+  const takeover = new LedgerTakeover();
   const residentAdmin = capabilities.residents ? residentAdminFromConfig(config, processSecrets) : new NullResidentAdminClient();
   const residentAdminClient = "unavailable" in residentAdmin ? new NullResidentAdminClient(residentAdmin.unavailable) : residentAdmin;
   const spanLog = createSpanLog();
@@ -45486,7 +45760,7 @@ async function runBot() {
       secrets: processSecrets,
       clock: systemClock
     });
-    const harnessRoutes = createHarnessRoutesHandler({ bearers: runBearers, harnesses });
+    const harnessRoutes = createHarnessRoutesHandler({ bearers: runBearers, harnesses, takeover });
     const coordinatorAdmin = createAdminCoordinatorHandler({
       tokens: processSecrets.get("SWITCHBOARD_INGRESS_TOKENS"),
       grantsFor: (id) => config.grantsFor(id),
@@ -45764,6 +46038,7 @@ async function runBot() {
           `[resume] ${run2.row.runId} ${run2.row.threadKey} closed interrupted (${why})${closed.ok ? "" : ` \u2014 finish refused (${closed.reason})`}`
         );
       },
+      onDone: (runId3) => takeover.done(runId3),
       log: (l) => console.log(l),
       warn: (w) => console.warn(w)
     });
@@ -45776,11 +46051,14 @@ async function runBot() {
       log: (l) => console.log(l),
       warn: (w) => console.warn(w)
     });
+    takeover.take(bootReclaim);
     await guardCards(bootReclaim);
     const client = ledgerReclaim.client;
     setForeignLiveCardsSource(
       async () => (await client.listLive()).filter((r) => r.ownerGen !== generation && r.leaseUntil > systemClock()).flatMap((r) => r.card ? [r.card] : [])
     );
+  } else {
+    takeover.settle();
   }
   await app.start();
   if (ledgerReclaim && bootReclaim) {
@@ -45791,6 +46069,7 @@ async function runBot() {
       log: (l) => console.log(l),
       warn: (w) => console.warn(w),
       onOutcome: async (outcome) => {
+        takeover.take(outcome);
         await guardCards(outcome);
         await launch(outcome);
       }
@@ -45903,6 +46182,7 @@ var init_index = __esm({
     init_boot();
     init_resumeLaunch();
     init_threadsElsewhere();
+    init_takeover();
     init_nullChannelIo();
     init_registry();
     init_trace();