@coreplane/switchboard 1.220.0 → 1.221.0

package/dist/cli.js

@@ -408,8 +408,11 @@ var init_store = __esm({
         const res = await this.fetchImpl(signed);
         if (res.status === 404) return null;
         if (!res.ok) throw new Error(`artifact store: HEAD ${key} answered HTTP ${res.status}`);
-        const size = Number(res.headers.get("content-length"));
-        if (!Number.isFinite(size) || size < 0) throw new Error(`artifact store: HEAD ${key} answered without a length`);
+        const length = res.headers.get("content-length");
+        const size = length === null ? Number.NaN : Number(length);
+        if (!Number.isFinite(size) || size < 0) {
+          throw new Error(`artifact store: HEAD ${key} answered HTTP ${res.status} without a length`);
+        }
         return { size, contentType: res.headers.get("content-type") ?? "application/octet-stream" };
       }
       async get(key) {
@@ -4136,6 +4139,7 @@ var init_residentSteps = __esm({
       "ops-dir": "preparing a directory",
       "stage-dir": "preparing a directory",
       stat: "checking a file",
+      "boot-id": "reading the container's identity",
       touch: "touching a marker",
       nproc: "counting CPUs",
       mutex_wait: "waiting for the workspace",
@@ -7993,6 +7997,9 @@ function parseExitPrefix(output) {
   if (!m) return { failed: false, exitCode: 0 };
   return /^\d+$/.test(m[1]) ? { failed: true, exitCode: Number(m[1]) } : { failed: true };
 }
+function toolTextFailed(output) {
+  return /^\s*error:/i.test(stripAnsi(output));
+}
 function capClean(clean) {
   const text = clean.trim();
   if (text.length <= TOOL_OUTPUT_CAP) return text;
@@ -9413,7 +9420,7 @@ async function parseResidentBody(res) {
   }
   return sanitizeResidentBody(data);
 }
-var DETACH_TIMEOUT_MS, ResidentNeedsRefError, ResidentOperations, ResidentExecutor;
+var DETACH_TIMEOUT_MS, ResidentNeedsRefError, ResidentReuseRefusedError, ResidentOperations, ResidentExecutor;
 var init_resident = __esm({
   "../../src/execution/resident.ts"() {
     "use strict";
@@ -9445,6 +9452,16 @@ var init_resident = __esm({
       defaultRef;
       needs = "ref";
     };
+    ResidentReuseRefusedError = class extends Error {
+      constructor(resource, why) {
+        super(`resident attach: ${resource} cannot reuse this thread's worktree (${why})`);
+        this.resource = resource;
+        this.why = why;
+        this.name = "ResidentReuseRefusedError";
+      }
+      resource;
+      why;
+    };
     ResidentOperations = class {
       constructor(opts) {
         this.opts = opts;
@@ -9602,6 +9619,7 @@ var init_resident = __esm({
         if (this.opts.refHint) body.refHint = this.opts.refHint;
         if (this.opts.readonly) body.readonly = true;
         if (this.opts.sha) body.sha = this.opts.sha;
+        if (this.opts.reuse) body.reuse = 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;
@@ -9615,6 +9633,7 @@ var init_resident = __esm({
           sha: data.sha,
           ...typeof data.workspace === "string" && data.workspace ? { workspace: data.workspace } : {},
           ...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 } : {}
         };
@@ -9634,6 +9653,8 @@ var init_resident = __esm({
           const defaultRef = typeof data.defaultRef === "string" && data.defaultRef ? data.defaultRef : void 0;
           return traced(new ResidentNeedsRefError(this.opts.resource, defaultRef));
         }
+        if (status3 === 409 && data.needs === "recreate")
+          return traced(new ResidentReuseRefusedError(this.opts.resource, err2));
         if (status3 === 404) return traced(new Error(`resident attach: ${this.opts.resource} is not onboarded (${err2})`));
         return traced(new Error(`resident attach failed for ${this.opts.resource}: ${err2}`));
       }
@@ -9988,11 +10009,33 @@ var init_githubApp = __esm({
 // ../../src/execution/factory.ts
 import { resolve as resolve7 } from "node:path";
 import { mkdirSync as mkdirSync7 } from "node:fs";
+function workspaceBindingOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const v = value;
+  if (typeof v.backend !== "string" || !BACKENDS.includes(v.backend)) return void 0;
+  return {
+    backend: v.backend,
+    ...typeof v.workspace === "string" && v.workspace ? { workspace: v.workspace } : {},
+    ...typeof v.user === "string" && v.user ? { user: v.user } : {},
+    ...typeof v.container === "string" && v.container ? { container: v.container } : {}
+  };
+}
+function workspaceBindingFor(selection, machine = "repo-resident") {
+  if (machine === "none" || selection.backend === void 0) return void 0;
+  const b = selection.binding;
+  return {
+    backend: selection.backend,
+    ...b?.workspace !== void 0 ? { workspace: b.workspace } : {},
+    ...b?.user !== void 0 ? { user: b.user } : {},
+    ...b?.container !== void 0 ? { container: b.container } : {}
+  };
+}
 async function makeExecutor(opts, ctx, span) {
   const machine = ctx.profile.machine;
   if (machine === "none") {
     return { executor: new NullExecutor(ctx.agent.name), backend: "local" };
   }
+  if (ctx.reattach !== void 0) return reattachWorkspace(opts, ctx, ctx.reattach, span);
   if (machine === "blank") {
     return {
       executor: await makePerThreadExecutor(opts, { threadKey: ctx.threadKey, resolveEnvs: async () => ({}) }),
@@ -10050,6 +10093,58 @@ async function makeExecutor(opts, ctx, span) {
     ...failedAttach ? { trace: failedAttach.steps } : {}
   };
 }
+async function reattachWorkspace(opts, ctx, recorded, span) {
+  const refuse3 = (why) => new WorkspaceReattachRefusedError(recorded, oneLine(why));
+  if (recorded.backend !== "resident") {
+    const input = ctx.profile.machine === "blank" ? { threadKey: ctx.threadKey, resolveEnvs: async () => ({}) } : perThreadCheckout(ctx);
+    return { executor: await makePerThreadExecutor(opts, input), backend: perThreadBackend(opts) };
+  }
+  const resident = opts.execution?.resident;
+  if (!resident) throw refuse3("no resident backend is configured in this process");
+  if (!ctx.repo) throw refuse3("the run's row names no repository to re-attach on");
+  const tokenEnv = resident.tokenEnv ?? "RESIDENT_OPERATOR_TOKEN";
+  const token2 = processSecrets.named(tokenEnv);
+  if (!token2) throw new Error(`execution.resident is configured but ${tokenEnv} is not set`);
+  const resource = repoResourceId(ctx.repo);
+  const probe = await probeResident(resident, token2, resource, span);
+  if (probe.kind === "unreachable") throw refuse3(`resident unreachable (${probe.error})`);
+  if (!isServiceable(probe.state, probe.reason))
+    throw refuse3(`resident ${probe.state}${probe.reason ? ` (${probe.reason})` : ""}`);
+  const nonWarm = probe.state === "warm" ? void 0 : oneLine(`${probe.state}${probe.reason ? ` (${probe.reason})` : ""}`);
+  const executor = new ResidentExecutor({
+    baseUrl: resident.baseUrl,
+    token: token2.reveal(),
+    resource,
+    threadKey: ctx.threadKey,
+    refHint: ctx.ref,
+    readonly: ctx.profile.identity === "read" ? true : void 0,
+    sha: ctx.headSha,
+    reuse: true
+  });
+  let binding;
+  try {
+    binding = await executor.attach(span);
+  } catch (err2) {
+    throw refuse3(err2 instanceof Error ? err2.message : String(err2));
+  }
+  const same = (recordedValue, answered) => recordedValue === void 0 || answered === void 0 || recordedValue === answered;
+  if (!same(recorded.workspace, binding.workspace) || !same(recorded.user, binding.user)) {
+    const name = (workspace, user) => `${workspace ?? "(unnamed)"} as ${user ?? "(unnamed)"}`;
+    throw refuse3(
+      `the resident's worktree for this thread is ${name(binding.workspace, binding.user)}, not the run's recorded ${name(recorded.workspace, recorded.user)}`
+    );
+  }
+  const where = `${resource.replace(/^repo:/, "")} \xB7 ${binding.ref}@${binding.sha.slice(0, 7)}`;
+  return {
+    executor,
+    resident: true,
+    backend: "resident",
+    ...binding.trace ? { trace: binding.trace } : {},
+    ...binding.attachMs !== void 0 ? { attachMs: binding.attachMs } : {},
+    binding,
+    note: nonWarm ? `resident ${nonWarm} \xB7 ${where} \xB7 re-attached to the run's worktree` : `resident \xB7 ${where} \xB7 re-attached to the run's worktree`
+  };
+}
 async function openResident(opts, nonWarm, span) {
   let executor = new ResidentExecutor(opts);
   let binding;
@@ -10200,7 +10295,7 @@ function perThreadBackend(opts) {
   const type = opts.execution?.type ?? "local";
   return type === "e2b" ? "e2b" : type === "cloudflare" ? "sandbox" : "local";
 }
-var PROBE_OUTAGE_WINDOW_MS, probeOutage, NullExecutor;
+var BACKENDS, WorkspaceReattachRefusedError, PROBE_OUTAGE_WINDOW_MS, probeOutage, NullExecutor;
 var init_factory = __esm({
   "../../src/execution/factory.ts"() {
     "use strict";
@@ -10215,6 +10310,17 @@ var init_factory = __esm({
     init_residentState();
     init_clock();
     init_secrets2();
+    BACKENDS = ["local", "resident", "sandbox", "e2b"];
+    WorkspaceReattachRefusedError = class extends Error {
+      constructor(recorded, why) {
+        super(`the run's workspace on the ${recorded.backend} backend could not be re-attached: ${why}`);
+        this.recorded = recorded;
+        this.why = why;
+        this.name = "WorkspaceReattachRefusedError";
+      }
+      recorded;
+      why;
+    };
     PROBE_OUTAGE_WINDOW_MS = 3e4;
     NullExecutor = class {
       constructor(agentName) {
@@ -20502,7 +20608,7 @@ function createRunsService(deps) {
   const analyze = deps.analyze ?? ((events, opts) => analyzeRunFriction(events, opts));
   const clock3 = deps.clock ?? systemClock;
   const warn = deps.warn ?? ((m) => console.warn(m));
-  const describe11 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+  const describe12 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   let listing;
   const liveRows = () => {
     if (!ledger) return null;
@@ -20522,7 +20628,7 @@ function createRunsService(deps) {
     try {
       rows = await pending2;
     } catch (err2) {
-      warn(`[runs] run ledger list failed \u2014 showing this process's runs only: ${describe11(err2)}`);
+      warn(`[runs] run ledger list failed \u2014 showing this process's runs only: ${describe12(err2)}`);
       return [];
     }
     const foreign = rows.filter((row) => !registry.getById(row.runId));
@@ -20532,7 +20638,7 @@ function createRunsService(deps) {
         try {
           events = await ledger.readEvents(row.runId);
         } catch (err2) {
-          warn(`[runs] run ledger events read failed for ${row.runId}: ${describe11(err2)}`);
+          warn(`[runs] run ledger events read failed for ${row.runId}: ${describe12(err2)}`);
         }
         return ledgerView(row, events);
       })
@@ -20546,7 +20652,7 @@ function createRunsService(deps) {
       if (!row) return null;
       return { row, events: await ledger.readEvents(id) };
     } catch (err2) {
-      warn(`[runs] run ledger read failed for ${id}: ${describe11(err2)}`);
+      warn(`[runs] run ledger read failed for ${id}: ${describe12(err2)}`);
       return null;
     }
   };
@@ -20564,7 +20670,7 @@ function createRunsService(deps) {
       row = await storeSummary(id);
     } catch (err2) {
       warn(
-        `[runs] history store read failed for ${id} \u2014 serving the registry row without its record: ${describe11(err2)}`
+        `[runs] history store read failed for ${id} \u2014 serving the registry row without its record: ${describe12(err2)}`
       );
       return {};
     }
@@ -20735,7 +20841,7 @@ function createRunsService(deps) {
           const r = await ledger.requestStop(id, mode);
           if (r.ok) return { ok: true, value: { id, mode, state: "stopping" } };
         } catch (err2) {
-          warn(`[runs] run ledger stop failed for ${id}: ${describe11(err2)}`);
+          warn(`[runs] run ledger stop failed for ${id}: ${describe12(err2)}`);
         }
       }
       return await storeSummary(id) ? conflict : notFound;
@@ -25933,7 +26039,11 @@ function fileNameOf2(path) {
   return segments2[segments2.length - 1] ?? path;
 }
 function putCommandFor(path, contentType, url) {
-  return `curl -fsS -T ${shellQuote(path)} -H ${shellQuote(`Content-Type: ${contentType}`)} ${shellQuote(url)}`;
+  return `curl -fsS -T ${shellQuote(path)} -H ${shellQuote(`Content-Type: ${contentType}`)} -o /dev/null -w ${shellQuote(PUT_REPORT_FORMAT)} ${shellQuote(url)}`;
+}
+function parsePutReport(output) {
+  const m = /(\d{3}) (\d{1,15})\s*$/.exec(output);
+  return m ? { httpCode: Number(m[1]), sentBytes: Number(m[2]) } : null;
 }
 function postCommandFor(path, url) {
   return `curl -fsS --upload-file ${shellQuote(path)} -X POST ${shellQuote(url)}`;
@@ -25968,11 +26078,14 @@ async function attachThroughStore(path, name, lead, artifacts, ctx) {
   if (parseExitPrefix(putOut).failed) {
     return `error: the upload of ${name} to the artifact store failed: ${putOut.trim()}`;
   }
+  const report2 = parsePutReport(putOut);
+  const curlSaid = report2 ? `; curl reported HTTP ${report2.httpCode} after sending ${report2.sentBytes} bytes` : "";
   const head = await artifacts.store.head(key);
-  if (!head)
-    return `error: the artifact store holds nothing under ${key} after the upload of ${name} \u2014 nothing was posted`;
+  if (!head) {
+    return `error: the artifact store holds nothing under ${key} after the upload of ${name}${curlSaid} \u2014 nothing was posted`;
+  }
   if (head.size !== size) {
-    return `error: the artifact store holds ${head.size} bytes for ${name}, not the ${size} measured \u2014 nothing was posted`;
+    return `error: the artifact store holds ${head.size} bytes for ${name}, not the ${size} measured${curlSaid} \u2014 nothing was posted`;
   }
   ctx.publish?.({ type: "artifact", direction: "out", key, name, size, contentType });
   if (!ctx.uploadTicket) {
@@ -26000,7 +26113,7 @@ async function attachThroughStore(path, name, lead, artifacts, ctx) {
   }
   return `attached ${name} (${size} bytes) to the conversation and the run page`;
 }
-var MAX_ARTIFACT_BYTES, TRANSFER_FLOOR_BYTES_PER_MS, TRANSFER_SETUP_MS, STAT_TIMEOUT_MS, describe2, secs, attachFileTool;
+var MAX_ARTIFACT_BYTES, TRANSFER_FLOOR_BYTES_PER_MS, TRANSFER_SETUP_MS, STAT_TIMEOUT_MS, describe2, secs, PUT_REPORT_FORMAT, attachFileTool;
 var init_attach = __esm({
   "../../src/tools/attach.ts"() {
     "use strict";
@@ -26016,8 +26129,10 @@ var init_attach = __esm({
     STAT_TIMEOUT_MS = 3e4;
     describe2 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     secs = (ms) => Math.max(0, Math.round(ms / 1e3));
+    PUT_REPORT_FORMAT = "\\n%{http_code} %{size_upload}";
     attachFileTool = {
       name: "attach_file",
+      failsInText: true,
       description: `Post a file from the workspace into the conversation so the person sees it inline \u2014 a screenshot (e.g. from \`playwright screenshot\`), a rendered PDF, a recording, a log. Use it whenever you produce an image worth showing: a link to a file is not a picture. Whole files only: up to ${MAX_ARTIFACT_BYTES} bytes (1 GiB) where the artifact store is configured, ${MAX_READ_BYTES} bytes otherwise \u2014 the result says which.`,
       inputSchema: {
         type: "object",
@@ -26557,6 +26672,7 @@ var init_runs2 = __esm({
     CHILDREN_PAGES_MAX = 25;
     spawnRunTool = {
       name: "spawn_run",
+      failsInText: true,
       description: `Start a child run as the person who asked you: an ordinary Switchboard run of the named preset, in a thread of its own in this channel, under their permissions \u2014 what they could start by hand with \`agent:<preset>\`. The child is a reader of this conversation: it starts from this conversation's text so far (every user and assistant turn, never your tool calls or their results) plus \`prompt\`, its one new turn \u2014 so say what it should do. Presets a child can run: ${CHILD_PRESETS().join(", ")}; a preset that writes (${WRITE_PRESETS().join(", ")}) is refused \`spawn_identity\`. \`repo\` (owner/name) for a preset that works in a repository (${REPO_PRESETS().join(", ")}); \`budget\` narrows the child's wall clock in whole minutes (at least 2; it is also capped by what is left of yours). Returns the child's run id, its thread and a link, or a refusal by name: a preset or repository the requester may not use, a boundary the child's profile exceeds, the fan-out cap, or a channel that cannot open a thread. A child cannot spawn children.`,
       inputSchema: {
         type: "object",
@@ -26589,9 +26705,10 @@ var init_runs2 = __esm({
           request.budget = budget;
         }
         const spawn7 = ctx.spawn ?? nullSpawnCapability;
+        const conversation = ctx.conversation ? await ctx.conversation() : void 0;
         const out = await spawn7.spawn(request, {
           remainingMs: ctx.remainingMs?.() ?? Number.POSITIVE_INFINITY,
-          ...ctx.conversation ? { conversation: ctx.conversation() } : {}
+          ...conversation ? { conversation } : {}
         });
         if (out.kind === "refused") return `spawn refused (${out.reason}): ${out.message}`;
         return `spawned a ${preset} run: ${out.runId} in thread ${out.threadKey}${out.url ? ` (${out.url})` : ""} \u2014 it runs on its own; await_runs waits for it and returns its reply; get_run_status ${out.runId} answers its progress meanwhile.`;
@@ -26599,6 +26716,7 @@ var init_runs2 = __esm({
     };
     sendToRunTool = {
       name: "send_to_run",
+      failsInText: true,
       description: "Steer one of your live children: `text` reaches it as a follow-up at its next step, the way a reply in its thread would \u2014 sent as the person who asked you, and recorded on the child's run page as coming from this run. Use it when the request changed or a child is heading the wrong way. Refused by name: `not_found` (an unknown id, or a run the requester may not read), `not_child` (a run you did not spawn), `not_live` (it already ended \u2014 its status is given, nothing is sent; get_run_status has its reply), or the child's agent's allowlist. A child that finishes before its next step never reads it.",
       inputSchema: {
         type: "object",
@@ -26638,6 +26756,7 @@ var init_runs2 = __esm({
     AWAIT_IDS_MAX = 50;
     awaitRunsTool = {
       name: "await_runs",
+      failsInText: true,
       description: "Wait for runs \u2014 normally your children \u2014 to end, and get each one's end as data: its terminal status (completed, failed, refused, stopped_soft, stopped_hard, interrupted) with its final reply wrapped as untrusted content; `running` for one still live when the wait was cut; `not_found` for an unknown id or one the requester may not read. The wait ends at the first of: every named run ended; `timeoutMinutes` (optional, whole minutes); the edge of your own budget (a minute before your clock runs out \u2014 write up what came back and name what is still running, which keeps running); a stop; a follow-up landing in this thread (it rides your next turn). `ended` says which. An interrupted child is reported, never restarted. A child is its thread: when a person's reply in a child's thread started a later run there, the child's row follows that run \u2014 `continuedBy` names it, and `status` and `finalReply` are its \u2014 never the child's first reply alone.",
       inputSchema: {
         type: "object",
@@ -26768,6 +26887,252 @@ var init_runs2 = __esm({
   }
 });
 
+// ../../src/core/dispatch/staging.ts
+function stagedBasename(index, name) {
+  return `${index}-${safeBasename(name)}`;
+}
+function pullCommandFor(url, basename4) {
+  return `mkdir -p ${ATTACHMENTS_DIR} && curl -fsS -o ${shellQuote(`${ATTACHMENTS_DIR}/${basename4}`)} ${shellQuote(url)}`;
+}
+function excludeCommand() {
+  const entry = shellQuote(`${ATTACHMENTS_DIR}/`);
+  return `mkdir -p .git/info && { grep -qxF ${entry} .git/info/exclude 2>/dev/null || echo ${entry} >> .git/info/exclude; }`;
+}
+function formatSize(bytes) {
+  if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+  if (bytes >= 1e6) return `${Math.round(bytes / 1e6)} MB`;
+  if (bytes >= 1e3) return `${Math.round(bytes / 1e3)} KB`;
+  return `${bytes} B`;
+}
+function attachmentsLine(outcomes) {
+  const landed = outcomes.filter((o) => o.error === void 0);
+  const failed = outcomes.filter((o) => o.error !== void 0);
+  const parts = [];
+  if (landed.length > 0) {
+    parts.push(
+      `Attached files are in ./${ATTACHMENTS_DIR}/: ${landed.map(
+        (o) => `${o.basename} (${formatSize(o.file.size)}, ${o.file.type}${o.earlier ? ", from earlier in the thread" : ""})`
+      ).join(", ")}`
+    );
+  }
+  for (const o of failed) parts.push(`${o.file.name} could not be staged: ${o.error}`);
+  return parts.join(". ");
+}
+function noWorkspaceLine(files) {
+  return files.map(
+    (f) => `this agent has no workspace for ${f.name} (${formatSize(f.size)}, ${f.type}); ask \`agent:coding\` to work with it`
+  ).join(". ");
+}
+function stagingIndex() {
+  let n2 = 0;
+  return () => ++n2;
+}
+async function copyStaged(files, deps) {
+  return Promise.all(
+    files.map(async (file) => {
+      const index = deps.nextIndex();
+      const basename4 = stagedBasename(index, file.name);
+      const key = inboundKey(deps.threadKey, file.messageId, index, file.name);
+      try {
+        await deps.store.copyFromUrl({ url: file.url, size: file.size, key });
+        deps.publish?.({
+          type: "artifact",
+          direction: "in",
+          key,
+          name: file.name,
+          size: file.size,
+          contentType: file.type
+        });
+        return { file, basename: basename4, key };
+      } catch (err2) {
+        return { file, basename: basename4, key, error: `the copy into the store failed: ${describe4(err2)}` };
+      }
+    })
+  );
+}
+async function pullStaged(outcomes, deps) {
+  const landed = outcomes.filter((o) => o.error === void 0);
+  if (landed.length === 0) return [...outcomes];
+  const timeoutMs = deps.timeoutMs ?? BASH_TIMEOUT_MAX_MS;
+  const opts = { timeoutMs, ...deps.signal ? { signal: deps.signal } : {} };
+  if (deps.resident) await deps.executor.exec(excludeCommand(), opts);
+  const pulled = /* @__PURE__ */ new Map();
+  for (const o of landed) {
+    const url = await deps.store.presignGet(o.key);
+    const out = await deps.executor.exec(pullCommandFor(url, o.basename), opts);
+    pulled.set(o.key, parseExitPrefix(out).failed ? `the pull into the workspace failed: ${out.trim()}` : void 0);
+  }
+  return outcomes.map((o) => {
+    const error = o.error ?? pulled.get(o.key);
+    if (error !== void 0) return { ...o, error };
+    const { error: _dropped, ...landedOutcome } = o;
+    return landedOutcome;
+  });
+}
+function stageThreadArtifacts(artifacts, deps) {
+  const outcomes = [];
+  for (const a of artifacts) {
+    const file = { name: a.name, size: a.size, type: a.contentType };
+    if (a.held === void 0) {
+      outcomes.push({
+        file,
+        basename: safeBasename(a.name),
+        key: a.key,
+        earlier: true,
+        error: "the store could not be asked whether it still holds it"
+      });
+      continue;
+    }
+    if (!a.held) {
+      outcomes.push({
+        file,
+        basename: safeBasename(a.name),
+        key: a.key,
+        earlier: true,
+        error: "the store no longer holds it (its retention passed)"
+      });
+      continue;
+    }
+    const basename4 = stagedBasename(deps.nextIndex(), a.name);
+    deps.publish?.({
+      type: "artifact",
+      direction: "in",
+      key: a.key,
+      name: a.name,
+      size: a.size,
+      contentType: a.contentType
+    });
+    outcomes.push({ file, basename: basename4, key: a.key, earlier: true });
+  }
+  return outcomes;
+}
+async function stageIntoWorkspace(files, deps) {
+  const outcomes = await pullStaged(await copyStaged(files, deps), deps);
+  return { line: attachmentsLine(outcomes), outcomes };
+}
+var ATTACHMENTS_DIR, WorkspaceFiles, describe4;
+var init_staging = __esm({
+  "../../src/core/dispatch/staging.ts"() {
+    "use strict";
+    init_keys();
+    init_bashTimeout();
+    init_shellQuote();
+    init_runEvents();
+    ATTACHMENTS_DIR = "attachments";
+    WorkspaceFiles = class {
+      paths = /* @__PURE__ */ new Map();
+      /** Every outcome that landed: its key now names a workspace path. */
+      record(outcomes) {
+        for (const o of outcomes) if (o.error === void 0) this.paths.set(o.key, `${ATTACHMENTS_DIR}/${o.basename}`);
+      }
+      pathOf(key) {
+        return this.paths.get(key);
+      }
+    };
+    describe4 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+  }
+});
+
+// ../../src/core/dispatch/threadAssets.ts
+function threadAssetsOf(runsOldestFirst) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const run2 of runsOldestFirst) {
+    for (const e of run2.events) {
+      if (e.type !== "artifact" || seen.has(e.key)) continue;
+      seen.add(e.key);
+      out.push({
+        key: e.key,
+        name: e.name,
+        size: e.size,
+        contentType: e.contentType,
+        direction: e.direction,
+        runId: run2.id,
+        ...e.seq !== void 0 ? { seq: e.seq } : {}
+      });
+    }
+  }
+  return out;
+}
+async function readThreadAssets(deps, threadKey, warn = (line3) => console.warn(line3)) {
+  const runs = [];
+  let before;
+  try {
+    for (; ; ) {
+      const page2 = await deps.runs.listRuns({
+        status: "all",
+        visibleTo: { kind: "all" },
+        threadKey,
+        limit: THREAD_ASSETS_PAGE,
+        ...before !== void 0 ? { before: before.finishedAt, beforeId: before.id } : {}
+      });
+      runs.push(...page2.runs);
+      if (page2.storeUnavailable) {
+        warn(
+          `[thread] ${threadKey}: listing its runs for their files answered live rows only after ${runs.length} run(s) \u2014 the run store was unavailable`
+        );
+        break;
+      }
+      if (page2.nextBefore === void 0) break;
+      before = page2.nextBefore;
+    }
+  } catch (err2) {
+    warn(
+      `[thread] ${threadKey}: listing its runs for their files stopped after ${runs.length} run(s) \u2014 ${describe5(err2)}`
+    );
+  }
+  const perRun = [];
+  for (const run2 of runs.reverse()) {
+    const events = [];
+    let afterSeq;
+    try {
+      for (; ; ) {
+        const r = await deps.runs.getRunEvents(run2.id, afterSeq === void 0 ? {} : { afterSeq });
+        if (!r.ok) {
+          warn(`[thread] ${run2.id}: reading its files stopped after ${events.length} event(s) \u2014 ${r.error}`);
+          break;
+        }
+        events.push(...r.value.events);
+        if (r.value.nextAfterSeq === void 0) break;
+        afterSeq = r.value.nextAfterSeq;
+      }
+    } catch (err2) {
+      warn(`[thread] ${run2.id}: reading its files failed after ${events.length} event(s) \u2014 ${describe5(err2)}`);
+    }
+    perRun.push({ id: run2.id, events });
+  }
+  return Promise.all(
+    threadAssetsOf(perRun).map(async (asset) => {
+      try {
+        return { ...asset, held: await deps.store.head(asset.key) !== null };
+      } catch (err2) {
+        warn(`[thread] ${asset.key}: the store could not be asked whether it holds it \u2014 ${describe5(err2)}`);
+        return asset;
+      }
+    })
+  );
+}
+function describeAsset(asset, path) {
+  const what = `${asset.name} (${formatSize(asset.size)}, ${asset.contentType})`;
+  const origin = asset.direction === "in" ? "received on this thread" : `produced by run ${asset.runId}`;
+  return `${what} \u2014 ${origin}; ${whereIs(asset, path)}`;
+}
+function whereIs(asset, path) {
+  if (path !== void 0) return `in this workspace at ./${path}`;
+  if (asset.held === false) return "no longer in the store (its retention passed)";
+  if (asset.held === void 0) return "the store could not be asked whether it still holds it";
+  return asset.direction === "out" ? "on that run's page, not in this workspace" : "in the store, not in this workspace";
+}
+var THREAD_ASSETS_PAGE, describe5;
+var init_threadAssets = __esm({
+  "../../src/core/dispatch/threadAssets.ts"() {
+    "use strict";
+    init_staging();
+    THREAD_ASSETS_PAGE = 50;
+    describe5 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+  }
+});
+
 // ../../src/core/runLedger/sessionLog.ts
 function sessionKey(threadKey, agent) {
   return `${threadKey}:${agent ?? "-"}`;
@@ -26789,31 +27154,50 @@ var init_sessionLog = __esm({
 });
 
 // ../../src/tools/session.ts
-function sessionCapabilityFor(run2, ledger) {
+function sessionCapabilityFor(run2, ledger, assets) {
   const session = run2?.session;
   if (!session) return void 0;
   return {
     session,
     search: (query, limit) => ledger.searchSession(session.key, query, limit),
     readTurn: async (idx) => (await ledger.readSession(session.key, idx, idx)).messages[0],
+    readConversation: async () => (await ledger.readSession(session.key, session.seedFrom)).messages,
     readNotepad: () => ledger.readNotepad(session.key),
-    writeNotepad: (text) => ledger.writeNotepad(session.key, text)
+    writeNotepad: (text) => ledger.writeNotepad(session.key, text),
+    ...assets ? { assets: assets.read, workspacePathOf: assets.pathOf } : {}
+  };
+}
+function assetView(asset, path) {
+  return {
+    name: asset.name,
+    size: asset.size,
+    type: asset.contentType,
+    [asset.direction === "in" ? "received" : "produced"]: `run ${asset.runId}`,
+    key: asset.key,
+    where: whereIs(asset, path)
   };
 }
+function filesNamedIn(text, catalogue) {
+  return catalogue.filter((a) => [a.name, safeBasename(a.name)].some((n2) => nameAt2(n2).test(text)));
+}
 async function mayRead(ctx) {
   if (!ctx.runs?.runId) return false;
   const res = await ctx.runs.service.getRun(ctx.runs.runId);
   return res.ok && authorize(ctx.runs.actor, "runs:read", runResource(res.value)).allow;
 }
-var UNAVAILABLE3, DEFAULT_HITS, MAX_HITS, SNIPPET_CHARS, snippetOf, recallTool, notesTool, SESSION_TOOLS;
+var FILE_BEARING, nameAt2, UNAVAILABLE3, DEFAULT_HITS, MAX_HITS, SNIPPET_CHARS, snippetOf, recallTool, notesTool, SESSION_TOOLS;
 var init_session = __esm({
   "../../src/tools/session.ts"() {
     "use strict";
+    init_keys();
     init_authorize();
+    init_threadAssets();
     init_runEvents();
     init_sessionLog();
     init_runRecord();
     init_runsService();
+    FILE_BEARING = /attachments\/|attach_file|attached files/i;
+    nameAt2 = (name) => new RegExp(`(?<![A-Za-z0-9._])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![A-Za-z0-9._-])`);
     UNAVAILABLE3 = "the session tools are not available in this context: this run has no session log.";
     DEFAULT_HITS = 5;
     MAX_HITS = 50;
@@ -26824,7 +27208,7 @@ var init_session = __esm({
     };
     recallTool = {
       name: "recall",
-      description: "Search this conversation's whole log \u2014 every turn of this thread on this agent, earlier runs' included and everything a compaction removed from your window \u2014 for words, and get the matching turns in relevance order with their turn numbers and a snippet; or pass `turn` to read one turn whole (a tool result, a command, a message). Use it when you need something said or seen earlier that is not in front of you: a failing test's name, a command's output, a decision. `limit` defaults to 5 (at most 50).",
+      description: "Search this conversation's whole log \u2014 every turn of this thread on this agent, earlier runs' included and everything a compaction removed from your window \u2014 for words, and get the matching turns in relevance order with their turn numbers and a snippet; or pass `turn` to read one turn whole (a tool result, a command, a message). Use it when you need something said or seen earlier that is not in front of you: a failing test's name, a command's output, a decision. `limit` defaults to 5 (at most 50). A hit that names a file of this thread carries the file's key and where it is for this run; `assets: true` lists every file the thread received or its runs produced instead of searching.",
       inputSchema: {
         type: "object",
         properties: {
@@ -26833,6 +27217,10 @@ var init_session = __esm({
           turn: {
             type: "integer",
             description: "A turn number from an earlier recall: returns that turn whole instead of searching"
+          },
+          assets: {
+            type: "boolean",
+            description: "List the thread's files \u2014 received on its messages or produced by its runs \u2014 with their keys and where each is for this run, instead of searching"
           }
         }
       },
@@ -26841,13 +27229,30 @@ var init_session = __esm({
         if (!ctx.session) return UNAVAILABLE3;
         const turn = typeof input.turn === "number" ? Math.trunc(input.turn) : void 0;
         const query = typeof input.query === "string" ? input.query.trim() : "";
-        if (turn === void 0 && query.length === 0) return "recall needs a query or a turn number.";
-        if (!await mayRead(ctx)) return JSON.stringify(turn !== void 0 ? { turn, content: null } : { hits: [] });
+        const listAssets = input.assets === true;
+        if (turn === void 0 && query.length === 0 && !listAssets)
+          return "recall needs a query, a turn number or assets: true.";
+        if (!await mayRead(ctx)) {
+          return JSON.stringify(turn !== void 0 ? { turn, content: null } : listAssets ? { assets: [] } : { hits: [] });
+        }
         if (turn !== void 0) {
           const message3 = turn >= 0 ? await ctx.session.readTurn(turn) : void 0;
           if (!message3) return `no turn ${turn} in this session's log.`;
           return JSON.stringify({ turn, role: message3.role, content: message3.content });
         }
+        if (listAssets) {
+          if (!ctx.session.assets) {
+            return JSON.stringify({
+              assets: [],
+              note: "this deployment has no artifact store: the thread's files are not catalogued"
+            });
+          }
+          const assets = await ctx.session.assets();
+          return JSON.stringify({
+            assets: assets.map((a) => assetView(a, ctx.session.workspacePathOf?.(a.key))),
+            ...assets.length === 0 ? { note: "no run of this thread has received or produced a file" } : {}
+          });
+        }
         const limit = Math.min(
           MAX_HITS,
           Math.max(1, typeof input.limit === "number" ? Math.trunc(input.limit) : DEFAULT_HITS)
@@ -26857,12 +27262,17 @@ var init_session = __esm({
         if (hits.length === 0)
           notes.push("no turn of this session's log matches; your notes (notes {}) may hold what you look for");
         if (ctx.session.session.seedFrom === 0) notes.push("this is the first run of its session: the log begins with it");
+        const catalogue = ctx.session.assets && hits.some((h) => FILE_BEARING.test(h.text)) ? await ctx.session.assets() : [];
         return JSON.stringify({
-          hits: hits.map((h) => ({
-            turn: h.idx,
-            ...h.role !== void 0 ? { role: h.role } : {},
-            snippet: snippetOf(h.text)
-          })),
+          hits: hits.map((h) => {
+            const files = filesNamedIn(h.text, catalogue);
+            return {
+              turn: h.idx,
+              ...h.role !== void 0 ? { role: h.role } : {},
+              snippet: snippetOf(h.text),
+              ...files.length > 0 ? { files: files.map((a) => assetView(a, ctx.session.workspacePathOf?.(a.key))) } : {}
+            };
+          }),
           ...gaps.length ? {
             gaps: `the log has a gap at ${gaps.map((g) => `turn ${g}`).join(", ")}: a run before it detached from the ledger, so turns it saw after that point are not here`
           } : {},
@@ -27037,6 +27447,7 @@ ${raw.trim()}`;
     };
     submitVerdictTool = {
       name: "submit_verdict",
+      failsInText: true,
       description: "Record your review verdict. REQUIRED before your final message when reviewing a PR: `approve` when there are no blocking issues (nits alone are not blocking), `request_changes` otherwise. Switchboard writes the verdict as the first line of the GitHub comment itself (`LGTM:` only for approve); a review with no submitted verdict is posted as NOT approving. Call it once, after your analysis; a later call replaces the earlier one. `head` is the commit you reviewed \u2014 run `git rev-parse HEAD` in the checkout you read and tested and pass its output; Switchboard posts to the PR only if that commit IS the PR's head, so a review of the wrong branch can never land on a PR. Enumerate EVERY issue you report in `findings` with STABLE ids assigned in order (F1, F2, \u2026) \u2014 a fix round references findings by these ids, so never renumber them. Severity is exactly one of blocking|major|minor|nit; the entry carries the file (plus line when it points at one) and a one-line title, while the full explanation stays in your review text keyed by the same ids. An `approve` carrying a `blocking` finding is downgraded to `request_changes` \u2014 approve only when nothing blocking remains.",
       inputSchema: {
         type: "object",
@@ -27087,6 +27498,7 @@ ${raw.trim()}`;
     };
     submitDispositionsTool = {
       name: "submit_dispositions",
+      failsInText: true,
       description: "Record one disposition per review finding after addressing them: `fixed` (the finding is addressed in your pushed code) or `declined` (deliberately not doing it \u2014 the note says why). `findingId` is the finding's stable id from the review (F1, F2, \u2026) \u2014 use exactly those ids; an id the review never issued answers nothing and is dropped when the plan runner reads your record. Every finding gets exactly one entry, every severity included (nits too). Call it once with the complete set after your last push; a later call replaces the earlier one. The set rides this run's record, where the plan runner reads it for the re-review.",
       inputSchema: {
         type: "object",
@@ -27118,6 +27530,7 @@ ${raw.trim()}`;
     };
     submitPrDescriptionTool = {
       name: "submit_pr_description",
+      failsInText: true,
       description: "Submit the PR description as a typed object. REQUIRED after pushing your branch: Switchboard renders the GitHub PR body from this object at the pushed head and opens (or updates) the pull request itself \u2014 never open a PR yourself. Fields map 1:1 to the rendered sections; `title` becomes the PR's title; tour anchors are (path, from, to) line ranges at your pushed head. Call it after your last push; if you push again afterwards, call it again \u2014 the last valid call wins. An invalid object returns an error naming the field to fix; correct it and resubmit.",
       inputSchema: {
         type: "object",
@@ -27211,6 +27624,7 @@ ${raw.trim()}`;
     });
     submitHandoffTool = {
       name: "submit_handoff",
+      failsInText: true,
       description: "Submit the unit handoff as a typed object \u2014 REQUIRED when your first user turn carries a `## Contract` block: once, after submit_pr_description and before your final message. `deviations`: where you departed from the unit as written (from, to, why); `followUps`: what you found and did not do, and where it belongs (what, where); `unproven`: which of the unit's test scenarios or criteria you could not prove, and why (criterion, why). Switchboard records it on the run and posts it to the unit's board issue, where a person decides each row. Submit empty lists when there is nothing to say \u2014 never skip it. A later call replaces the earlier one; an invalid object returns an error naming the field to fix.",
       inputSchema: {
         type: "object",
@@ -27523,7 +27937,11 @@ function imperativeRule(writers) {
 }
 function attachRule(attachers) {
   const names = attachers.map((a) => `\`${a}\``).join(" or ");
-  return `Only ${names} can attach or post a file into the thread (the \`attach_file\` tool). A request that asks for a file, a screenshot, a recording or an attachment to be posted, attached or sent back \u2014 or that names attach_file \u2014 routes there, however read-only the rest of it sounds; a read-only preset can describe a file but never post one.`;
+  return [
+    `Only ${names} can attach or post a file into the thread (the \`attach_file\` tool).`,
+    `A request that names attach_file routes to ${names}, whatever it asks the tool to do \u2014 a probe, a test or a diagnostic of the tool is still a call to it.`,
+    "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));
@@ -27994,17 +28412,17 @@ ${stagedLine}` : prompt }];
       try {
         const output = await untilHardStop(tool.run(tu.input ?? {}, ctx));
         const text2 = toolResultText(output);
-        const exit = tu.name === "bash" ? parseExitPrefix(text2) : void 0;
+        const exit = tu.name === "bash" ? parseExitPrefix(text2) : { failed: tool.failsInText === true && toolTextFailed(text2) };
         emit({
           type: "tool_result",
           tool: tu.name,
-          ok: !exit?.failed,
+          ok: !exit.failed,
           callId: tu.id,
-          ...exit?.exitCode !== void 0 ? { exitCode: exit.exitCode } : {},
+          ...exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {},
           ...prepareToolResult(text2),
           ...spanId
         });
-        settle2(!exit?.failed, exit?.exitCode !== void 0 ? { exitCode: exit.exitCode } : {});
+        settle2(!exit.failed, exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {});
         return { type: "tool_result", toolUseId: tu.id, content: capToolResultContent(output) };
       } catch (err2) {
         if (err2 instanceof HardStopError) throw err2;
@@ -28591,7 +29009,8 @@ async function attachRoundWorkspace(input) {
       profile,
       repo: input.round.repo,
       ref: input.round.ref,
-      headSha: input.round.headSha
+      headSha: input.round.headSha,
+      ...input.round.reattach !== void 0 ? { reattach: input.round.reattach } : {}
     },
     input.span
   );
@@ -29218,157 +29637,6 @@ var init_messages = __esm({
   }
 });
 
-// ../../src/core/dispatch/staging.ts
-function stagedBasename(index, name) {
-  return `${index}-${safeBasename(name)}`;
-}
-function pullCommandFor(url, basename4) {
-  return `mkdir -p ${ATTACHMENTS_DIR} && curl -fsS -o ${shellQuote(`${ATTACHMENTS_DIR}/${basename4}`)} ${shellQuote(url)}`;
-}
-function excludeCommand() {
-  const entry = shellQuote(`${ATTACHMENTS_DIR}/`);
-  return `mkdir -p .git/info && { grep -qxF ${entry} .git/info/exclude 2>/dev/null || echo ${entry} >> .git/info/exclude; }`;
-}
-function formatSize(bytes) {
-  if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
-  if (bytes >= 1e6) return `${Math.round(bytes / 1e6)} MB`;
-  if (bytes >= 1e3) return `${Math.round(bytes / 1e3)} KB`;
-  return `${bytes} B`;
-}
-function attachmentsLine(outcomes) {
-  const landed = outcomes.filter((o) => o.error === void 0);
-  const failed = outcomes.filter((o) => o.error !== void 0);
-  const parts = [];
-  if (landed.length > 0) {
-    parts.push(
-      `Attached files are in ./${ATTACHMENTS_DIR}/: ${landed.map(
-        (o) => `${o.basename} (${formatSize(o.file.size)}, ${o.file.type}${o.earlier ? ", from earlier in the thread" : ""})`
-      ).join(", ")}`
-    );
-  }
-  for (const o of failed) parts.push(`${o.file.name} could not be staged: ${o.error}`);
-  return parts.join(". ");
-}
-function noWorkspaceLine(files) {
-  return files.map(
-    (f) => `this agent has no workspace for ${f.name} (${formatSize(f.size)}, ${f.type}); ask \`agent:coding\` to work with it`
-  ).join(". ");
-}
-function stagingIndex() {
-  let n2 = 0;
-  return () => ++n2;
-}
-async function copyStaged(files, deps) {
-  return Promise.all(
-    files.map(async (file) => {
-      const index = deps.nextIndex();
-      const basename4 = stagedBasename(index, file.name);
-      const key = inboundKey(deps.threadKey, file.messageId, index, file.name);
-      try {
-        await deps.store.copyFromUrl({ url: file.url, size: file.size, key });
-        deps.publish?.({
-          type: "artifact",
-          direction: "in",
-          key,
-          name: file.name,
-          size: file.size,
-          contentType: file.type
-        });
-        return { file, basename: basename4, key };
-      } catch (err2) {
-        return { file, basename: basename4, key, error: `the copy into the store failed: ${describe4(err2)}` };
-      }
-    })
-  );
-}
-async function pullStaged(outcomes, deps) {
-  const landed = outcomes.filter((o) => o.error === void 0);
-  if (landed.length === 0) return [...outcomes];
-  const timeoutMs = deps.timeoutMs ?? BASH_TIMEOUT_MAX_MS;
-  const opts = { timeoutMs, ...deps.signal ? { signal: deps.signal } : {} };
-  if (deps.resident) await deps.executor.exec(excludeCommand(), opts);
-  const pulled = /* @__PURE__ */ new Map();
-  for (const o of landed) {
-    const url = await deps.store.presignGet(o.key);
-    const out = await deps.executor.exec(pullCommandFor(url, o.basename), opts);
-    pulled.set(o.key, parseExitPrefix(out).failed ? `the pull into the workspace failed: ${out.trim()}` : void 0);
-  }
-  return outcomes.map((o) => {
-    const error = o.error ?? pulled.get(o.key);
-    if (error !== void 0) return { ...o, error };
-    const { error: _dropped, ...landedOutcome } = o;
-    return landedOutcome;
-  });
-}
-function threadInboundArtifacts(runsOldestFirst) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const events of runsOldestFirst) {
-    for (const e of events) {
-      if (e.type !== "artifact" || e.direction !== "in" || seen.has(e.key)) continue;
-      seen.add(e.key);
-      out.push({ key: e.key, name: e.name, size: e.size, contentType: e.contentType });
-    }
-  }
-  return out;
-}
-async function stageThreadArtifacts(artifacts, deps) {
-  const outcomes = [];
-  for (const a of artifacts) {
-    const file = { name: a.name, size: a.size, type: a.contentType };
-    let held;
-    try {
-      held = await deps.store.head(a.key) !== null;
-    } catch (err2) {
-      outcomes.push({
-        file,
-        basename: safeBasename(a.name),
-        key: a.key,
-        earlier: true,
-        error: `the store could not be asked: ${describe4(err2)}`
-      });
-      continue;
-    }
-    if (!held) {
-      outcomes.push({
-        file,
-        basename: safeBasename(a.name),
-        key: a.key,
-        earlier: true,
-        error: "the store no longer holds it (its retention passed)"
-      });
-      continue;
-    }
-    const basename4 = stagedBasename(deps.nextIndex(), a.name);
-    deps.publish?.({
-      type: "artifact",
-      direction: "in",
-      key: a.key,
-      name: a.name,
-      size: a.size,
-      contentType: a.contentType
-    });
-    outcomes.push({ file, basename: basename4, key: a.key, earlier: true });
-  }
-  return outcomes;
-}
-async function stageIntoWorkspace(files, deps) {
-  const outcomes = await pullStaged(await copyStaged(files, deps), deps);
-  return { line: attachmentsLine(outcomes), outcomes };
-}
-var ATTACHMENTS_DIR, describe4;
-var init_staging = __esm({
-  "../../src/core/dispatch/staging.ts"() {
-    "use strict";
-    init_keys();
-    init_bashTimeout();
-    init_shellQuote();
-    init_runEvents();
-    ATTACHMENTS_DIR = "attachments";
-    describe4 = (err2) => err2 instanceof Error ? err2.message : String(err2);
-  }
-});
-
 // ../../src/core/modelProxy/runBearers.ts
 import { createHash as createHash4, randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function token(runId3, secret2) {
@@ -30071,7 +30339,7 @@ async function reserveRun(deps, ctx) {
   return void 0;
 }
 async function attachWorkspace(deps, ctx) {
-  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock3, agent, profile, repoCtx, root } = ctx;
+  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock3, agent, profile, repoCtx, root, reattach } = ctx;
   let round2;
   try {
     round2 = await root.span("dispatch.workspace.attach", async (span) => {
@@ -30096,7 +30364,8 @@ async function attachWorkspace(deps, ctx) {
             profile,
             repo: repoCtx.repo,
             ref: repoCtx.ref,
-            headSha: repoCtx.headSha
+            headSha: repoCtx.headSha,
+            ...reattach !== void 0 ? { reattach } : {}
           },
           logKey: msg.threadKey,
           span
@@ -30123,6 +30392,7 @@ async function attachWorkspace(deps, ctx) {
       });
       return { kind: "refused", reason: "which_branch" };
     }
+    if (err2 instanceof WorkspaceReattachRefusedError) return { kind: "reattach_refused", why: err2.why };
     throw err2;
   }
   return { kind: "attached", round: round2 };
@@ -30159,6 +30429,10 @@ function sessionNotesBlock(session) {
     parts.push(
       "SUMMARY OF THE EARLIER CONVERSATION (written when the context was compacted; every earlier turn is still reachable with `recall`):\n" + summary
     );
+  if (session.files && session.files.length > 0)
+    parts.push(
+      "FILES OF THIS THREAD (received on its messages or produced by its runs, as their records name them; `recall {assets: true}` lists them with their keys):\n" + session.files.map((line3) => `- ${line3}`).join("\n")
+    );
   return parts.length ? parts.join("\n\n") : void 0;
 }
 async function composePrompt(deps, ctx) {
@@ -30258,6 +30532,7 @@ var init_provision = __esm({
     init_contract3();
     init_registry();
     init_profile();
+    init_factory();
     init_residentTrace();
     init_resident();
     init_memory();
@@ -30311,6 +30586,7 @@ async function claimRun(deps, ctx) {
   } = ctx;
   const { resident, binding } = selection;
   let ledgerRun = ctx.ledgerRun;
+  const workspaceBinding = workspaceBindingFor(selection, profile.machine);
   if (!resume && reserved) {
     const ledger = deps.runLedger;
     const opened = await root.span(
@@ -30344,6 +30620,7 @@ async function claimRun(deps, ctx) {
           ...requestRow !== void 0 ? { request: requestRow } : {}
         },
         card: card.handle ?? null,
+        ...workspaceBinding !== void 0 ? { state: { binding: workspaceBinding } } : {},
         // The row reserved before the attach (item 42), promoted in place;
         // its hooks (a stop, a fence) were wired at the reservation and stay.
         reservation: reserved,
@@ -30400,6 +30677,7 @@ var init_run2 = __esm({
     init_workspace();
     init_web();
     init_githubApi();
+    init_factory();
     init_runRegistry();
     init_secrets2();
     webCapability = () => sharedWeb ??= makeWebCapability(processSecrets);
@@ -30432,6 +30710,17 @@ const URL_ENV = "SWITCHBOARD_HARNESS_URL";
 /** How long the tool_call hook keeps asking an unreachable bot before it blocks. */
 const AUTHORIZE_WAIT_MS = 90_000;
 const AUTHORIZE_RETRY_MS = 2_000;
+/** How long one request for a relayed tool's result may take before it is asked
+ *  again: over the bot's window (30 s, after which it answers that the call is
+ *  still running), under this runtime's own five-minute header timeout on a
+ *  fetch, so a hung connection costs a minute of the wait, not five. */
+const TOOL_REQUEST_TIMEOUT_MS = 60_000;
+/** How long a relayed call keeps asking a bot it cannot reach before it fails; the cadence is the hook's. */
+const TOOL_WAIT_MS = 90_000;
+/** A bot that says a call is still running is asked again after the window it
+ *  held the request for; one that answered sooner is asked again no sooner
+ *  than this, so a misbehaving bot is never asked in a hot loop. */
+const TOOL_REASK_FLOOR_MS = 1_000;
 
 function settings() {
   const url = process.env[URL_ENV];
@@ -30505,6 +30794,49 @@ async function authorize(event) {
   }
 }
 
+/** pi's abort signal for the call, with this request's own timeout beside it
+ *  where the runtime can combine the two; pi's alone where it cannot. */
+function requestSignal(signal) {
+  const timeout = typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(TOOL_REQUEST_TIMEOUT_MS) : undefined;
+  if (!timeout) return signal;
+  if (!signal) return timeout;
+  return typeof AbortSignal.any === "function" ? AbortSignal.any([signal, timeout]) : signal;
+}
+
+/** A relayed tool's result. The call is posted with its id; a bot that answers
+ *  that the call is still running (a wait on other runs can take minutes) is
+ *  asked again with the same id until it answers: the bot runs the call once
+ *  and every later ask joins it. A bot that cannot be reached or is failing (a
+ *  network error, a timed-out request, a 5xx) is asked again every two seconds
+ *  until the wait is up, then the call fails naming why; a refusal at the door
+ *  (a 4xx) fails it at once; an abort from pi ends the asking. */
+async function relay(toolCallId, tool, input, signal) {
+  let lastAnswered = Date.now();
+  let lastError = "";
+  for (;;) {
+    if (signal && signal.aborted) throw new Error("switchboard harness: " + tool + " was aborted before the bot answered");
+    const asked = Date.now();
+    let answer;
+    try {
+      answer = await call("POST", "/harness/tool", { toolCallId, tool, input }, requestSignal(signal));
+    } catch (err) {
+      if (signal && signal.aborted) throw err;
+      const status = err instanceof HarnessAnswerError ? err.status : undefined;
+      if (status !== undefined && status >= 400 && status < 500) throw err;
+      lastError = err instanceof Error ? err.message : String(err);
+      if (Date.now() - lastAnswered >= TOOL_WAIT_MS) {
+        throw new Error("switchboard harness: the bot did not answer " + tool + " for 90 s (" + lastError + ")");
+      }
+      await sleep(AUTHORIZE_RETRY_MS);
+      continue;
+    }
+    lastAnswered = Date.now();
+    if (!answer.pending) return answer;
+    const held = Date.now() - asked;
+    if (held < TOOL_REASK_FLOOR_MS) await sleep(TOOL_REASK_FLOOR_MS - held);
+  }
+}
+
 function relayTool(def) {
   return {
     name: def.name,
@@ -30512,7 +30844,7 @@ function relayTool(def) {
     description: def.description,
     parameters: def.inputSchema,
     async execute(toolCallId, params, signal) {
-      const answer = await call("POST", "/harness/tool", { toolCallId, tool: def.name, input: params }, signal);
+      const answer = await relay(toolCallId, def.name, params, signal);
       if (answer.isError) throw new Error(answer.content.map((c) => (c.type === "text" ? c.text : "")).join("\\n"));
       return { content: answer.content, details: {} };
     },
@@ -30711,6 +31043,9 @@ function readLogScript(path, offset, maxBytes) {
 function aliveScript(pid) {
   return `kill -0 ${pid} 2>/dev/null && echo alive || echo dead`;
 }
+function identityScript() {
+  return "cat /proc/sys/kernel/random/boot_id 2>/dev/null || true";
+}
 function killScript(pid) {
   return `kill -TERM -- -${pid} 2>/dev/null; kill -TERM ${pid} 2>/dev/null; sleep 1; kill -KILL -- -${pid} 2>/dev/null; kill -KILL ${pid} 2>/dev/null; true`;
 }
@@ -30727,7 +31062,7 @@ function stdoutOf(operation, out) {
   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, STDERR_MARK, OP_TIMEOUT_MS, ExecPiContainer;
+var PiContainerError, WRITE_CHUNK_CHARS, INLINE_LINE_CHARS, LOG_READ_BYTES, MESSAGE_UPDATE_MARK, LOG_FILTER, IDENTITY_WORD, STDERR_MARK, OP_TIMEOUT_MS, ExecPiContainer;
 var init_container = __esm({
   "../../src/core/harness/pi/container.ts"() {
     "use strict";
@@ -30747,6 +31082,7 @@ var init_container = __esm({
     LOG_READ_BYTES = 48 * 1024;
     MESSAGE_UPDATE_MARK = '"type":"message_update"';
     LOG_FILTER = `grep --line-buffered -v ${shellQuote(MESSAGE_UPDATE_MARK)}`;
+    IDENTITY_WORD = /^[A-Za-z0-9-]{1,64}$/;
     STDERR_MARK = "\n--- stderr ---\n";
     OP_TIMEOUT_MS = 6e4;
     ExecPiContainer = class {
@@ -30760,6 +31096,12 @@ var init_container = __esm({
       async makeRoot(runId3) {
         return piRunPaths(runId3);
       }
+      /** The start script never changes directory, so pi runs where the executor
+       *  runs every command: the thread's checkout, which the harness names (a
+       *  resident's `/exec` runs in the thread's worktree). No command runs here. */
+      cwd(_paths, checkout) {
+        return checkout;
+      }
       async writeFile(path, content) {
         for (const script of writeFileScripts(path, content)) stdoutOf("write", await this.exec(script));
       }
@@ -30785,6 +31127,16 @@ var init_container = __esm({
       async alive(pid) {
         return stdoutOf("alive", await this.exec(aliveScript(pid))).trim() === "alive";
       }
+      /** One word or nothing: an empty answer, a malformed one or a command the
+       *  executor could not run is no identity: a judgement never rests on a guess. */
+      async identity() {
+        try {
+          const word = stdoutOf("identity", await this.exec(identityScript())).trim();
+          return IDENTITY_WORD.test(word) ? word : void 0;
+        } catch {
+          return void 0;
+        }
+      }
       async kill(pid) {
         stdoutOf("kill", await this.exec(killScript(pid)));
       }
@@ -30916,6 +31268,14 @@ var init_botHostContainer = __esm({
           throw new PiContainerError("root", message2(err2));
         }
       }
+      /** The run's own root: `start` spawns pi in it, so that is the directory a
+       *  session written for this root names, present on this host in this
+       *  generation. The checkout the harness names is a container path this host
+       *  does not have (a `none` run has no workspace), and the previous
+       *  generation's root is gone with its pi: neither is where pi runs. */
+      cwd(paths, _checkout) {
+        return paths.dir;
+      }
       /** Parents at 700, the file at 600, exact bytes, created and never
        *  replaced: under a root this container made nothing is there before the
        *  harness writes it, so a path already present is a named failure, never
@@ -31036,6 +31396,12 @@ var init_botHostContainer = __esm({
         const child = this.byPid.get(pid);
         return child !== void 0 && !child.exited;
       }
+      /** The bot host names no container: its pi is a child of one bot generation
+       *  and never outlives it, so a resume judges it by its pid alone (`alive`
+       *  answers no for a pid this container did not start). */
+      async identity() {
+        return void 0;
+      }
       /** The group first (pi leads it), then pi itself: TERM, the grace, KILL;
        *  a pid this container never started, or one already ended, is nothing to end. */
       async kill(pid) {
@@ -31289,7 +31655,7 @@ var init_bridge2 = __esm({
         const tool = open2?.tool ?? str5(event.toolName);
         const isError = event.isError === true;
         const text = piResultText(event.result);
-        const exit = tool === "bash" ? piBashExit(text, isError) : { failed: isError, ...isError ? {} : {} };
+        const exit = tool === "bash" ? piBashExit(text, isError) : { failed: isError || this.deps.textFailing?.has(tool) === true && toolTextFailed(text) };
         const ok2 = !exit.failed;
         this.emit({
           type: "tool_result",
@@ -31361,6 +31727,11 @@ var init_bridge2 = __esm({
       openSpan(callId) {
         return this.openTools.get(callId)?.span;
       }
+      /** Whether the bridge has read the call's start off the log and not yet its
+       *  end: what a relayed request that arrived ahead of the poll waits for. */
+      callOpen(callId) {
+        return this.openTools.has(callId);
+      }
       /** End whatever tool spans a stopped pi left open, so no span outlives the run. */
       closeOpenSpans(reason) {
         for (const [callId, open2] of this.openTools) {
@@ -31682,7 +32053,8 @@ function piHarnessFactsOf(value) {
     logOffset: v.logOffset,
     ...typeof v.sessionFile === "string" ? { sessionFile: v.sessionFile } : {},
     ...typeof v.bearerHash === "string" ? { bearerHash: v.bearerHash } : {},
-    ...typeof v.root === "string" ? { root: v.root } : {}
+    ...typeof v.root === "string" ? { root: v.root } : {},
+    ...typeof v.container === "string" ? { container: v.container } : {}
   };
 }
 function relayedTools(tools) {
@@ -31739,12 +32111,36 @@ async function runPiHarness(deps, run2) {
     run2.onProgress?.(summary);
     emit({ type: "run_note", kind, summary, ...mode ? { mode } : {} });
   };
-  const bridge = new PiBridge({ emit, onProgress: run2.onProgress, agentSpan, clock: clock3 });
+  const bridge = new PiBridge({
+    emit,
+    onProgress: run2.onProgress,
+    agentSpan,
+    clock: clock3,
+    textFailing: new Set(run2.tools.filter((t) => t.failsInText).map((t) => t.name))
+  });
   let paths;
   const remainingMs = run2.resume?.remainingMs ?? run2.agent.maxMinutes * 6e4;
   const deadline = now() + remainingMs;
   const warnAt = deadline - Math.min(3 * 6e4, run2.agent.maxMinutes * 15e3);
   run2.toolContext.remainingMs = () => deadline - now();
+  if (run2.conversation) {
+    const readConversation = run2.conversation;
+    run2.toolContext.conversation = async () => {
+      try {
+        return await readConversation();
+      } catch (err2) {
+        emit({
+          type: "run_note",
+          kind: "seed",
+          summary: redactAndCap(
+            `the conversation could not be read from the session log for a child's seed (${err2 instanceof Error ? err2.message : String(err2)}); a child spawned now starts from its own thread`,
+            300
+          )
+        });
+        return void 0;
+      }
+    };
+  }
   bridge.turns = run2.resume?.turn ?? 0;
   const mirror = new PiMirror({
     onStep: run2.onStep,
@@ -31774,7 +32170,11 @@ async function runPiHarness(deps, run2) {
     emit,
     toolSpan: (callId) => bridge.openSpan(callId),
     gateSaw: (callId) => bridge.gateSaw(callId),
-    toolsBlocked
+    toolsBlocked,
+    callSeen: async (callId) => {
+      for (let waited = 0; !bridge.callOpen(callId) && waited < CALL_SEEN_WAIT_MS; waited += CALL_SEEN_TICK_MS)
+        await deps.sleep(CALL_SEEN_TICK_MS);
+    }
   };
   const forget = deps.registry.register(live);
   let pid;
@@ -31791,21 +32191,27 @@ async function runPiHarness(deps, run2) {
     const recorded = run2.resume?.facts;
     let reattached = false;
     let ended;
+    let elsewhere;
+    const here = await container.identity();
     const honoured = (hash) => hash !== void 0 && (deps.bearers === void 0 || deps.bearers.adopt(run2.runId, hash));
     if (recorded !== void 0) {
-      const alive = await container.alive(recorded.pid);
-      if (alive && recorded.root !== void 0 && honoured(recorded.bearerHash)) {
-        reattached = true;
-        paths = piRunPathsAt(recorded.root);
-      } else if (alive) {
-        ended = recorded.root === void 0 ? "named no directory for its pi" : "carried no bearer this generation could honour for its pi";
-        await container.kill(recorded.pid).catch(() => {
-        });
+      if (recorded.container !== void 0 && here !== void 0 && recorded.container !== here) {
+        elsewhere = `pi is elsewhere: the row's pi (pid ${recorded.pid}) ran in container ${recorded.container}, not the one this run was handed (${here}), so it was neither probed nor ended here`;
+      } else {
+        const alive = await container.alive(recorded.pid);
+        if (alive && recorded.root !== void 0 && honoured(recorded.bearerHash)) {
+          reattached = true;
+          paths = piRunPathsAt(recorded.root);
+        } else if (alive) {
+          ended = recorded.root === void 0 ? "named no directory for its pi" : "carried no bearer this generation could honour for its pi";
+          await container.kill(recorded.pid).catch(() => {
+          });
+        }
       }
     }
     if (reattached && recorded && paths !== void 0) {
       pid = recorded.pid;
-      facts2 = { ...recorded };
+      facts2 = { ...recorded, ...recorded.container === void 0 && here !== void 0 ? { container: here } : {} };
       transport = new PiRpcTransport({
         container,
         paths,
@@ -31821,7 +32227,7 @@ async function runPiHarness(deps, run2) {
       );
     } else {
       paths = await container.makeRoot(run2.runId);
-      if (recorded?.root !== void 0 && recorded.root !== paths.dir)
+      if (recorded?.root !== void 0 && recorded.root !== paths.dir && elsewhere === void 0)
         await container.remove(piRunPathsAt(recorded.root)).catch(() => {
         });
       const spec = {
@@ -31854,7 +32260,7 @@ async function runPiHarness(deps, run2) {
           piSessionFile(
             session.messages,
             {
-              cwd: run2.rules.checkout,
+              cwd: container.cwd(paths, run2.rules.checkout),
               model: {
                 provider: run2.model.provider,
                 id: run2.model.id,
@@ -31868,7 +32274,7 @@ async function runPiHarness(deps, run2) {
       }
       if (run2.resume) {
         const lost = run2.resume.settlements.length;
-        const how = ended !== void 0 && recorded !== void 0 ? `the row ${ended} (pid ${recorded.pid}), so it was ended and pi restarted` : "pi restarted";
+        const how = elsewhere !== void 0 ? `${elsewhere}, and pi restarted` : ended !== void 0 && recorded !== void 0 ? `the row ${ended} (pid ${recorded.pid}), so it was ended and pi restarted` : "pi restarted";
         note(
           "resumed",
           `resumed after a restart: ${how} on the mirrored transcript \u2014 ${lost} call(s) were in flight, each answered with a restart note; ${Math.round(remainingMs / 6e4)} min of budget left`
@@ -31878,7 +32284,13 @@ async function runPiHarness(deps, run2) {
       for (const file of piLaunchFiles(launch)) await container.writeFile(file.path, file.content);
       ({ pid } = await container.start({ paths, args: piLaunchArgs(launch), env: piLaunchEnv(launch, deps.bearer) }));
       const bearerHash = bearerHashOf(deps.bearer);
-      facts2 = { pid, logOffset: 0, root: paths.dir, ...bearerHash !== void 0 ? { bearerHash } : {} };
+      facts2 = {
+        pid,
+        logOffset: 0,
+        root: paths.dir,
+        ...bearerHash !== void 0 ? { bearerHash } : {},
+        ...here !== void 0 ? { container: here } : {}
+      };
       save();
       transport = new PiRpcTransport({ container, paths, pid, pollMs: deps.pollMs ?? 750, sleep: deps.sleep });
     }
@@ -32073,7 +32485,7 @@ ${stagedLine}` : prompt,
     agentSpan?.end(hardStopped || bypass ? "error" : "ok");
   }
 }
-var NATIVE_WORKSPACE_TOOLS, FINALE_TIMEOUT_MS2, CONTINUE_PROMPT, PromptRefused, GateBypassed;
+var NATIVE_WORKSPACE_TOOLS, FINALE_TIMEOUT_MS2, CALL_SEEN_WAIT_MS, CALL_SEEN_TICK_MS, CONTINUE_PROMPT, PromptRefused, GateBypassed;
 var init_harness = __esm({
   "../../src/core/harness/pi/harness.ts"() {
     "use strict";
@@ -32088,6 +32500,8 @@ var init_harness = __esm({
     init_transport();
     NATIVE_WORKSPACE_TOOLS = /* @__PURE__ */ new Set(["bash", "read_file", "write_file"]);
     FINALE_TIMEOUT_MS2 = 3 * 6e4;
+    CALL_SEEN_WAIT_MS = 3e3;
+    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) {
@@ -32942,6 +33356,7 @@ async function runLoop2(deps, ctx) {
       executor,
       resident: round2.selection.resident !== void 0
     });
+    ctx.workspaceFiles?.record(staged.outcomes);
     return staged.line;
   } : void 0;
   let artifactSeq = 0;
@@ -32990,10 +33405,19 @@ async function runLoop2(deps, ctx) {
       });
       if (harness === "pi" && piFacts) {
         const container = deps.harness?.containerFor?.(executor, profile.machine) ?? piContainerFor(executor, profile.machine);
-        await container.kill(piFacts.pid).catch(() => {
-        });
-        if (piFacts.root !== void 0) await container.remove(piRunPathsAt(piFacts.root)).catch(() => {
-        });
+        const here = await container.identity();
+        if (piFacts.container === void 0 || here === void 0 || piFacts.container === here) {
+          await container.kill(piFacts.pid).catch(() => {
+          });
+          if (piFacts.root !== void 0) await container.remove(piRunPathsAt(piFacts.root)).catch(() => {
+          });
+        } else {
+          onEvent({
+            type: "run_note",
+            kind: "resumed",
+            summary: `the run's pi (pid ${piFacts.pid}) ran in container ${piFacts.container}, not the one this run was handed (${here}): it was not ended here`
+          });
+        }
       }
       answer = answerUnderEnding(finish2.answer, loopEnding, agent.maxMinutes);
     } else if (harness === "pi") {
@@ -33038,7 +33462,7 @@ async function runLoop2(deps, ctx) {
           messages,
           tools: relayedTools(mergeTools(TOOLSETS[agent.toolset] ?? [], mcpForRun?.tools)),
           toolContext,
-          ...session ? { notepad: () => session.readNotepad() } : {},
+          ...session ? { notepad: () => session.readNotepad(), conversation: () => session.readConversation() } : {},
           rules: {
             checkout: binding?.workspace ?? "/workspace",
             ...ownBranch !== void 0 ? { branch: ownBranch } : {},
@@ -33856,7 +34280,7 @@ async function plan(deps, input) {
   try {
     planId = planIdOf(request.planPath);
   } catch (err2) {
-    return { ok: false, reply: `\u{1F6AB} ${describe5(err2)}` };
+    return { ok: false, reply: `\u{1F6AB} ${describe6(err2)}` };
   }
   let text;
   try {
@@ -33864,7 +34288,7 @@ async function plan(deps, input) {
   } catch (err2) {
     return {
       ok: false,
-      reply: `\u{1F6AB} The plan \`${request.planPath}\` could not be read at \`${base}\` in ${entry.repo}: ${describe5(err2)}`
+      reply: `\u{1F6AB} The plan \`${request.planPath}\` could not be read at \`${base}\` in ${entry.repo}: ${describe6(err2)}`
     };
   }
   const graph = parsePlanGraph(text, planId);
@@ -33877,7 +34301,7 @@ async function plan(deps, input) {
   try {
     selected = openPlanCursor(graph, request.units).order;
   } catch (err2) {
-    return { ok: false, reply: `\u{1F6AB} ${describe5(err2)}` };
+    return { ok: false, reply: `\u{1F6AB} ${describe6(err2)}` };
   }
   return { ok: true, planned: { kind: "plan", planId, path: request.planPath, base, graph, selected, identity: identity2 } };
 }
@@ -33993,7 +34417,7 @@ async function start(deps, input, instance, units, where, write) {
   try {
     answer = await deps.create(instance.id);
   } catch (err2) {
-    answer = { kind: "unanswered", reason: describe5(err2) };
+    answer = { kind: "unanswered", reason: describe6(err2) };
   }
   switch (answer.kind) {
     case "created": {
@@ -34015,7 +34439,7 @@ async function start(deps, input, instance, units, where, write) {
       );
   }
 }
-var refused3, describe5, RUNNING, ENDED;
+var refused3, describe6, RUNNING, ENDED;
 var init_handOff = __esm({
   "../../src/core/coordinator/handOff.ts"() {
     "use strict";
@@ -34023,7 +34447,7 @@ var init_handOff = __esm({
     init_coordinator();
     init_briefs();
     refused3 = (reply) => ({ status: "aborted", reply });
-    describe5 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe6 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     RUNNING = /* @__PURE__ */ new Set(["queued", "running", "paused", "waiting", "waitingForPause"]);
     ENDED = /* @__PURE__ */ new Set(["complete", "errored", "terminated"]);
   }
@@ -34716,6 +35140,77 @@ var init_settle = __esm({
   }
 });
 
+// ../../src/core/dispatch/reattach.ts
+function carriedWorkspaceBinding(row) {
+  const recorded = workspaceBindingOf(row.state.binding);
+  if (recorded) return recorded;
+  if (row.meta.selection === "resident")
+    return { backend: "resident", ...row.meta.workspace ? { workspace: row.meta.workspace } : {} };
+  if (row.meta.selection === "sandbox" || row.meta.selection === "local") return { backend: row.meta.selection };
+  return void 0;
+}
+function lostWorkspaceNote(why, restarts) {
+  const lost = `resumed after a restart: the run's workspace could not be re-attached (${why})`;
+  return restarts ? `${lost}; the run restarts from its request as a new run in this thread` : `${lost}, and the row's request cannot be read, so the run ends here; re-send it to run it again`;
+}
+async function abandonLostWorkspace(ctx) {
+  const { refuse: refuse3, card, shell, closeLines, clock: clock3, run: run2, registry, resume, ledgerRun, why } = ctx;
+  const restored = messageFromInbox(resume.row.meta.request ?? {}, resume.row.startedAt);
+  const summary = lostWorkspaceNote(why, restored !== void 0);
+  const note = { type: "run_note", kind: "resumed", summary, at: clock3() };
+  await refuse3("workspace_lost", async () => {
+    registry.publish(run2.id, note);
+    await card.done(
+      shell.close({
+        kind: "not_started",
+        icon: "\u{1F501}",
+        reason: restored ? "workspace lost across the restart; restarting from the request" : "workspace lost across the restart; re-send to run again",
+        ...closeLines(clock3(), false)
+      })
+    );
+    if (ledgerRun)
+      await closeResumedRow(
+        ledgerRun,
+        { ...resume, events: [...resume.events, { ...note, seq: resume.lastSeq + 1 }] },
+        "the run's workspace could not be re-attached"
+      );
+  });
+  console.log(
+    `[resume] ${resume.row.threadKey} run ${resume.row.runId} ${restored ? "restarts from its request" : "ends"}: ${why}`
+  );
+  return restored?.msg;
+}
+function prepareRestartTurn(deps, ctx) {
+  const { request, pending: pending2, clock: clock3 } = ctx;
+  const merged = mergeFollowUps(pending2);
+  const receivedAt = clock3();
+  const msg = {
+    ...request,
+    ...merged ? {
+      text: `${request.text}
+
+${merged.text}`,
+      ...merged.images || request.images ? { images: [...request.images ?? [], ...merged.images ?? []] } : {},
+      ...merged.documents || request.documents ? { documents: [...request.documents ?? [], ...merged.documents ?? []] } : {},
+      ...merged.staged || request.staged ? { staged: [...request.staged ?? [], ...merged.staged ?? []] } : {}
+    } : {},
+    receivedAt,
+    originAt: void 0
+  };
+  const trace = startRequestRoot(deps, { channel: channelOf(msg.channelId), receivedAt });
+  return { msg, opts: { trace } };
+}
+var init_reattach = __esm({
+  "../../src/core/dispatch/reattach.ts"() {
+    "use strict";
+    init_factory();
+    init_inboxMessage();
+    init_requestTrace();
+    init_threadAdmission();
+    init_admission();
+  }
+});
+
 // ../../src/core/dispatch/lineage.ts
 function lineageOf(newest) {
   if (newest === void 0 || newest.parentRunId === void 0) return void 0;
@@ -34775,31 +35270,6 @@ var init_lineage = __esm({
 });
 
 // ../../src/core/dispatch/thread.ts
-async function readThreadArtifacts(service, thread, warn = (line3) => console.warn(line3)) {
-  const perRun = [];
-  for (const run2 of [...thread].reverse()) {
-    const events = [];
-    let afterSeq;
-    try {
-      for (; ; ) {
-        const r = await service.getRunEvents(run2.id, afterSeq === void 0 ? {} : { afterSeq });
-        if (!r.ok) {
-          warn(`[thread] ${run2.id}: reading its received files stopped after ${events.length} event(s) \u2014 ${r.error}`);
-          break;
-        }
-        events.push(...r.value.events);
-        if (r.value.nextAfterSeq === void 0) break;
-        afterSeq = r.value.nextAfterSeq;
-      }
-    } catch (err2) {
-      warn(
-        `[thread] ${run2.id}: reading its received files failed after ${events.length} event(s) \u2014 ${err2 instanceof Error ? err2.message : String(err2)}`
-      );
-    }
-    perRun.push(events);
-  }
-  return threadInboundArtifacts(perRun);
-}
 async function readThread(service, threadKey) {
   try {
     const page2 = await service.listRuns({
@@ -34841,7 +35311,6 @@ var THREAD_READ_LIMIT;
 var init_thread = __esm({
   "../../src/core/dispatch/thread.ts"() {
     "use strict";
-    init_staging();
     THREAD_READ_LIMIT = 8;
   }
 });
@@ -34961,22 +35430,22 @@ function createRunEnding(deps) {
       try {
         deps.registry.seal(id, replyOk === void 0 ? {} : { replyOk });
       } catch (err2) {
-        log(`[ending] seal ${id}: ${describe6(err2)}`);
+        log(`[ending] seal ${id}: ${describe7(err2)}`);
       }
       try {
         afterSeal?.();
       } catch (err2) {
-        log(`[ending] after seal ${id}: ${describe6(err2)}`);
+        log(`[ending] after seal ${id}: ${describe7(err2)}`);
       }
     }
     for (const entry of pending2.splice(0)) {
       try {
         const result = deps.registry.seal(entry.runId);
         void Promise.resolve(entry.write(result, entry.failedAfterFinish)).catch(
-          (err2) => log(`[ending] record ${entry.runId}: ${describe6(err2)}`)
+          (err2) => log(`[ending] record ${entry.runId}: ${describe7(err2)}`)
         );
       } catch (err2) {
-        log(`[ending] record ${entry.runId}: ${describe6(err2)}`);
+        log(`[ending] record ${entry.runId}: ${describe7(err2)}`);
       }
     }
   };
@@ -34986,7 +35455,7 @@ function createRunEnding(deps) {
       try {
         deps.onFinished?.(runId3);
       } catch (err2) {
-        log(`[ending] finished ${runId3}: ${describe6(err2)}`);
+        log(`[ending] finished ${runId3}: ${describe7(err2)}`);
       }
     },
     register(entry) {
@@ -35014,7 +35483,7 @@ function createRunEnding(deps) {
     }
   };
 }
-function describe6(err2) {
+function describe7(err2) {
   return err2 instanceof Error ? err2.message : String(err2);
 }
 var init_runEnding = __esm({
@@ -35076,6 +35545,8 @@ async function dispatch(deps, msg, io, opts = {}) {
   let reserved;
   let requestRow;
   let fencedWhileAttaching = false;
+  let resumeRowClosed = false;
+  let restartRequest;
   const reservationHooks = {
     onStop: (mode) => void registered?.control.requestStop(mode),
     onFenced: () => {
@@ -35316,18 +35787,21 @@ async function dispatch(deps, msg, io, opts = {}) {
     await tellLineage({ kind: "started", runId: runId3 });
     const staged = !resume && deps.artifacts && msg.staged && msg.staged.length > 0 ? msg.staged : [];
     const nextStagedIndex = stagingIndex();
+    const workspaceFiles = new WorkspaceFiles();
     const stagedCopies = staged.length > 0 && agent.machine !== "none" ? copyStaged(staged, {
       store: deps.artifacts,
       threadKey: msg.threadKey,
       nextIndex: nextStagedIndex,
       publish: (e) => registry.publish(runId3, e)
     }) : void 0;
-    const earlierStaged = !resume && deps.artifacts && agent.machine !== "none" && thread && thread.length > 0 ? readThreadArtifacts(runsService, thread).then(
-      (found) => stageThreadArtifacts(found, {
-        store: deps.artifacts,
-        nextIndex: nextStagedIndex,
-        publish: (e) => registry.publish(runId3, e)
-      })
+    const threadAssets = !resume && deps.artifacts && thread && thread.length > 0 ? readThreadAssets({ runs: runsService, store: deps.artifacts }, msg.threadKey).then(
+      (assets) => assets.filter((a) => a.runId !== runId3)
+    ) : void 0;
+    const earlierStaged = threadAssets && agent.machine !== "none" ? threadAssets.then(
+      (assets) => stageThreadArtifacts(
+        assets.filter((a) => a.direction === "in"),
+        { nextIndex: nextStagedIndex, publish: (e) => registry.publish(runId3, e) }
+      )
     ) : void 0;
     const reservation = await reserveRun(deps, {
       msg,
@@ -35354,6 +35828,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       reserved = reservation.reserved;
       requestRow = reservation.requestRow;
     }
+    const reattach = resume ? carriedWorkspaceBinding(resume.row) : void 0;
     const attach = await attachWorkspace(deps, {
       msg,
       io,
@@ -35365,10 +35840,35 @@ async function dispatch(deps, msg, io, opts = {}) {
       agent,
       profile,
       repoCtx,
-      root
+      root,
+      ...reattach !== void 0 ? { reattach } : {}
     });
     if (attach.kind === "refused") return ended;
+    if (attach.kind === "reattach_refused") {
+      if (resume) {
+        restartRequest = await abandonLostWorkspace({
+          msg,
+          io,
+          refuse: refuse3,
+          card,
+          shell,
+          closeLines,
+          clock: clock3,
+          run: run2,
+          registry,
+          resume,
+          ledgerRun,
+          why: attach.why
+        });
+        resumeRowClosed = true;
+      }
+      return ended;
+    }
     const { round: round2 } = attach;
+    if (resume && ledgerRun) {
+      const rebound = workspaceBindingFor(round2.selection, profile.machine);
+      if (rebound !== void 0) ledgerRun.setState({ binding: rebound });
+    }
     const { executor, note, resident } = round2.selection;
     if (fencedWhileAttaching) {
       console.log(
@@ -35380,13 +35880,16 @@ async function dispatch(deps, msg, io, opts = {}) {
     }
     const earlier2 = earlierStaged ? await earlierStaged : [];
     if (staged.length > 0 || earlier2.length > 0) {
-      const line3 = stagedCopies || earlier2.length > 0 ? attachmentsLine(
-        await pullStaged([...stagedCopies ? await stagedCopies : [], ...earlier2], {
+      let line3;
+      if (stagedCopies || earlier2.length > 0) {
+        const pulled = await pullStaged([...stagedCopies ? await stagedCopies : [], ...earlier2], {
           store: deps.artifacts,
           executor,
           resident: resident !== void 0
-        })
-      ) : noWorkspaceLine(staged);
+        });
+        workspaceFiles.record(pulled);
+        line3 = attachmentsLine(pulled);
+      } else line3 = noWorkspaceLine(staged);
       const request = messages[messages.length - 1];
       if (request && request.role === "user" && line3) {
         request.content = Array.isArray(request.content) ? [...request.content, { type: "text", text: line3 }] : [
@@ -35416,6 +35919,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     if (headGate.headAdopted) publishMeta(repoCtx);
     const isPrReview = agent.name === "review" && repoCtx.repo !== void 0 && repoCtx.pr !== void 0;
     const isCodingPrRun = agent.toolset === "full";
+    const threadFiles = threadAssets ? (await threadAssets).map((a) => describeAsset(a, workspaceFiles.pathOf(a.key))) : [];
     const prompt = await composePrompt(deps, {
       msg,
       agent,
@@ -35432,11 +35936,13 @@ async function dispatch(deps, msg, io, opts = {}) {
       root,
       ...contractBlock !== void 0 && agent.name === "review" ? { contract: contractBlock } : {},
       // What the session already knows (session-log item 10): the notepad and
-      // the newest compaction's summary the seed brought back, for the prompt.
-      ...session && (session.notepad !== void 0 || session.summary !== void 0) ? {
+      // the newest compaction's summary the seed brought back, and the thread's
+      // files (record 0033) with where each is for this run, for the prompt.
+      ...session?.notepad !== void 0 || session?.summary !== void 0 || threadFiles.length > 0 ? {
         session: {
-          ...session.notepad !== void 0 ? { notepad: session.notepad } : {},
-          ...session.summary !== void 0 ? { summary: session.summary } : {}
+          ...session?.notepad !== void 0 ? { notepad: session.notepad } : {},
+          ...session?.summary !== void 0 ? { summary: session.summary } : {},
+          ...threadFiles.length > 0 ? { files: threadFiles } : {}
         }
       } : {}
     });
@@ -35496,7 +36002,14 @@ async function dispatch(deps, msg, io, opts = {}) {
       seed,
       ...session ? { seedLog: session.log } : {}
     });
-    const sessionTools = sessionCapabilityFor(ledgerRun, deps.runLedger);
+    const sessionTools = sessionCapabilityFor(
+      ledgerRun,
+      deps.runLedger,
+      deps.artifacts ? {
+        read: () => readThreadAssets({ runs: runsService, store: deps.artifacts }, msg.threadKey),
+        pathOf: (key) => workspaceFiles.pathOf(key)
+      } : void 0
+    );
     const { spawn: spawn7, runs, steer, wait } = runToolCapabilities(
       { core: deps, dispatch, registry, clock: clock3 },
       {
@@ -35516,6 +36029,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       profile,
       resolved,
       stagingIndex: nextStagedIndex,
+      workspaceFiles,
       provider,
       model,
       messages,
@@ -35618,7 +36132,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     clearInterval(setupHeartbeat);
     ending.drain(void 0);
     if (registered) deps.runBearers?.revoke(registered.id);
-    if (resume && ledgerRun && !runLoopStarted) {
+    if (resume && ledgerRun && !runLoopStarted && !resumeRowClosed) {
       const adopted = ledgerRun;
       await root.span(
         "post.history_write",
@@ -35633,7 +36147,15 @@ async function dispatch(deps, msg, io, opts = {}) {
     const stopMode = settled.kind === "handed-on" ? void 0 : settled.stopMode;
     ended.status = caught ? "failed" : refused5 ? "refused" : stopMode ? "stopped" : "completed";
     root.end(caught ? "error" : "ok", { status: ended.status });
-    if (settled.kind === "handed-on") {
+    if (restartRequest) {
+      const pending2 = settled.kind === "handed-on" ? settled.pending : [];
+      const restart2 = prepareRestartTurn(deps, { request: restartRequest, pending: pending2, clock: clock3 });
+      await dispatch(deps, restart2.msg, io, restart2.opts).catch(
+        (err2) => console.error(
+          `[dispatch] ${msg.threadKey} restart after a lost workspace failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+        )
+      );
+    } else if (settled.kind === "handed-on") {
       const fresh = prepareFreshTurn(deps, { agent: settled.agent, pending: settled.pending, clock: clock3 });
       await dispatch(deps, fresh.msg, fresh.io, fresh.opts).catch(
         (err2) => console.error(
@@ -35676,10 +36198,13 @@ var init_dispatcher = __esm({
     init_contract();
     init_codingChild();
     init_settle();
+    init_reattach();
+    init_factory();
     init_lineage();
     init_seed();
     init_session();
     init_thread();
+    init_threadAssets();
     init_select();
     init_spawn();
     init_runsService();
@@ -35690,7 +36215,7 @@ var init_dispatcher = __esm({
 });
 
 // ../../src/core/runHistoryWriter.ts
-function describe7(err2) {
+function describe8(err2) {
   return err2 instanceof Error ? err2.message : String(err2);
 }
 function createRunHistoryWriter(opts) {
@@ -35707,7 +36232,7 @@ function createRunHistoryWriter(opts) {
     try {
       opts.onPersisted?.(id);
     } catch (err2) {
-      opts.warn(`[run-history] onPersisted hook failed for ${id}: ${describe7(err2)}`);
+      opts.warn(`[run-history] onPersisted hook failed for ${id}: ${describe8(err2)}`);
     }
   };
   const attemptAll = async (record2, flag2, sink, span) => {
@@ -35730,12 +36255,12 @@ function createRunHistoryWriter(opts) {
         }
         if (err2 instanceof PermanentStoreError) {
           failures++;
-          opts.warn(`[run-history] ${record2.id} not persisted (permanent, not retried): ${describe7(err2)}`);
+          opts.warn(`[run-history] ${record2.id} not persisted (permanent, not retried): ${describe8(err2)}`);
           return;
         }
         if (attempt >= attempts) {
           failures++;
-          opts.warn(`[run-history] ${record2.id} not persisted after ${attempts} attempts: ${describe7(err2)}`);
+          opts.warn(`[run-history] ${record2.id} not persisted after ${attempts} attempts: ${describe8(err2)}`);
           return;
         }
         await sleep2(jittered(RUN_HISTORY_RETRY_DELAYS_MS[attempt - 1]));
@@ -35755,7 +36280,7 @@ function createRunHistoryWriter(opts) {
       }
       const p = attemptAll(record2, flag2, writeOpts?.via ?? opts.store, writeOpts?.span).catch((err2) => {
         failures++;
-        opts.warn(`[run-history] ${record2.id} writer failed unexpectedly: ${describe7(err2)}`);
+        opts.warn(`[run-history] ${record2.id} writer failed unexpectedly: ${describe8(err2)}`);
       }).finally(() => {
         if (flag2) provisionalFlags.delete(flag2);
         void inFlight.delete(p);
@@ -36172,7 +36697,7 @@ function createLedgerWriteThrough(opts) {
           return { outcome: "untracked" };
         }
         if (err2 instanceof PermanentStoreError || attempt >= claimAttempts) {
-          warn(`[ledger] ${req.threadKey} not tracked: claim failed after ${attempt} attempt(s): ${describe8(err2)}`);
+          warn(`[ledger] ${req.threadKey} not tracked: claim failed after ${attempt} attempt(s): ${describe9(err2)}`);
           return { outcome: "untracked" };
         }
         await sleep2(RETRY_MS[Math.min(attempt, RETRY_MS.length) - 1]);
@@ -36334,7 +36859,7 @@ function createLedgerWriteThrough(opts) {
         if (!recorded.ok) this.detach(`seed record refused (${recorded.reason})`);
         else this.seeded = true;
       } catch (err2) {
-        this.detach(`seed failed: ${describe8(err2)}`);
+        this.detach(`seed failed: ${describe9(err2)}`);
       }
     }
     async step(report2) {
@@ -36361,7 +36886,7 @@ function createLedgerWriteThrough(opts) {
           return;
         } catch (err2) {
           if (err2 instanceof RouteMissingError || err2 instanceof PermanentStoreError || attempt >= 2) {
-            this.detach(`step ${record2.step} failed: ${describe8(err2)}`);
+            this.detach(`step ${record2.step} failed: ${describe9(err2)}`);
             return;
           }
           await sleep2(RETRY_MS[0]);
@@ -36394,7 +36919,7 @@ function createLedgerWriteThrough(opts) {
         } catch (err2) {
           if (err2 instanceof RouteMissingError || err2 instanceof PermanentStoreError || attempt >= 2) {
             this.stateDirty = true;
-            warn(`[ledger] ${this.threadKey} state not written: ${describe8(err2)}`);
+            warn(`[ledger] ${this.threadKey} state not written: ${describe9(err2)}`);
             return;
           }
           await sleep2(RETRY_MS[0]);
@@ -36412,7 +36937,7 @@ function createLedgerWriteThrough(opts) {
         this.detach(`finishing refused (fenced)`);
         return "fenced";
       } catch (err2) {
-        warn(`[ledger] ${this.threadKey} finishing failed: ${describe8(err2)}`);
+        warn(`[ledger] ${this.threadKey} finishing failed: ${describe9(err2)}`);
         return "unavailable";
       }
     }
@@ -36427,7 +36952,7 @@ function createLedgerWriteThrough(opts) {
           warn(`[ledger] ${this.threadKey} abandon refused (fenced) \u2014 the row is another generation's`);
       } catch (err2) {
         warn(
-          `[ledger] ${this.threadKey} abandon failed: ${describe8(err2)} \u2014 the sweep will take the row once its lease lapses`
+          `[ledger] ${this.threadKey} abandon failed: ${describe9(err2)} \u2014 the sweep will take the row once its lease lapses`
         );
       }
     }
@@ -36448,7 +36973,7 @@ function createLedgerWriteThrough(opts) {
           this.onStop(result.stop);
         }
       } catch (err2) {
-        warn(`[ledger] ${this.threadKey} heartbeat failed: ${describe8(err2)}`);
+        warn(`[ledger] ${this.threadKey} heartbeat failed: ${describe9(err2)}`);
       }
     }
     stopHeartbeat() {
@@ -36526,7 +37051,7 @@ function createLedgerWriteThrough(opts) {
         warn(`[ledger] inbox push refused for run ${runId3}: no live row \u2014 the follow-up rides in memory only`);
         return void 0;
       } catch (err2) {
-        warn(`[ledger] inbox push failed for run ${runId3}: ${describe8(err2)} \u2014 the follow-up rides in memory only`);
+        warn(`[ledger] inbox push failed for run ${runId3}: ${describe9(err2)} \u2014 the follow-up rides in memory only`);
         return void 0;
       }
     },
@@ -36535,7 +37060,7 @@ function createLedgerWriteThrough(opts) {
         return await ledger.readInbox(runId3, afterSeq);
       } catch (err2) {
         warn(
-          err2 instanceof RouteMissingError ? `[ledger] state Worker has no inbox read route \u2014 run ${runId3} resumes with the reclaim's inbox snapshot only` : `[ledger] inbox read failed for run ${runId3}: ${describe8(err2)} \u2014 resuming with the reclaim's snapshot only`
+          err2 instanceof RouteMissingError ? `[ledger] state Worker has no inbox read route \u2014 run ${runId3} resumes with the reclaim's inbox snapshot only` : `[ledger] inbox read failed for run ${runId3}: ${describe9(err2)} \u2014 resuming with the reclaim's snapshot only`
         );
         return [];
       }
@@ -36557,12 +37082,12 @@ function createLedgerWriteThrough(opts) {
         for (const r of candidates) if (markedSet.has(r.runId)) r.markHandedOff();
         return { marked };
       } catch (err2) {
-        return { marked: [], failed: describe8(err2) };
+        return { marked: [], failed: describe9(err2) };
       }
     }
   };
 }
-var NullLedgerWriteThrough, NullLedgerRun, RETRY_MS, describe8;
+var NullLedgerWriteThrough, NullLedgerRun, RETRY_MS, describe9;
 var init_writeThrough = __esm({
   "../../src/core/runLedger/writeThrough.ts"() {
     "use strict";
@@ -36642,7 +37167,7 @@ var init_writeThrough = __esm({
       }
     };
     RETRY_MS = [200, 800];
-    describe8 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe9 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   }
 });
 
@@ -41288,7 +41813,7 @@ async function reclaimRuns(opts) {
     reclaimed = await ledger.reclaim(gen, now(), LEASE_MS);
   } catch (err2) {
     warn(
-      err2 instanceof RouteMissingError ? "[reclaim] state Worker has no run-ledger routes \u2014 nothing to take over" : `[reclaim] reclaim failed: ${describe9(err2)} \u2014 runs the last generation left stay on the ledger until the next boot`
+      err2 instanceof RouteMissingError ? "[reclaim] state Worker has no run-ledger routes \u2014 nothing to take over" : `[reclaim] reclaim failed: ${describe10(err2)} \u2014 runs the last generation left stay on the ledger until the next boot`
     );
     return outcome;
   }
@@ -41356,8 +41881,8 @@ async function reclaimRuns(opts) {
         `[reclaim] ${row.runId} ${row.threadKey} closed ${status3} (from ${run2.reclaimedFrom}; ${why}; ${events.length} event(s))`
       );
     } catch (err2) {
-      outcome.failed.push({ runId: row.runId, error: describe9(err2) });
-      warn(`[reclaim] ${row.runId} ${row.threadKey}: ${describe9(err2)} \u2014 left on the ledger for the next boot`);
+      outcome.failed.push({ runId: row.runId, error: describe10(err2) });
+      warn(`[reclaim] ${row.runId} ${row.threadKey}: ${describe10(err2)} \u2014 left on the ledger for the next boot`);
     }
   }
   try {
@@ -41373,7 +41898,7 @@ async function reclaimRuns(opts) {
         });
     }
   } catch (err2) {
-    warn(`[reclaim] listing live runs failed: ${describe9(err2)} \u2014 the card sweep runs without the ledger's guard`);
+    warn(`[reclaim] listing live runs failed: ${describe10(err2)} \u2014 the card sweep runs without the ledger's guard`);
   }
   if (reclaimed.length > 0 || outcome.liveElsewhere.length > 0) {
     log(
@@ -41395,7 +41920,7 @@ function startReclaimSweep(opts) {
         await opts.onOutcome(outcome);
       }
     } catch (err2) {
-      warn(`[reclaim] sweep failed: ${describe9(err2)}`);
+      warn(`[reclaim] sweep failed: ${describe10(err2)}`);
     } finally {
       running = false;
     }
@@ -41421,7 +41946,7 @@ async function completenessVerdict(ledger, row, lastStep) {
     const source2 = transcriptSource(row.meta);
     transcript = source2.kind === "session" ? await ledger.readSession(source2.key, source2.from) : await ledger.readTranscript(row.runId);
   } catch (err2) {
-    return { resumable: false, why: `transcript unreadable (${describe9(err2)})` };
+    return { resumable: false, why: `transcript unreadable (${describe10(err2)})` };
   }
   if (!transcript.complete) return { resumable: false, why: `transcript incomplete: ${transcript.gap}` };
   const verdict = transcriptCompleteness({
@@ -41442,7 +41967,7 @@ async function completenessVerdict(ledger, row, lastStep) {
       return { resumable: false, why: verdict.why };
   }
 }
-var TERMINAL, describe9;
+var TERMINAL, describe10;
 var init_boot = __esm({
   "../../src/core/boot.ts"() {
     "use strict";
@@ -41459,7 +41984,7 @@ var init_boot = __esm({
       "failed",
       "interrupted"
     ]);
-    describe9 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe10 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   }
 });
 
@@ -42308,6 +42833,17 @@ var init_toolRules = __esm({
 });
 
 // ../../src/core/harness/pi/relay.ts
+async function relayToolCall(harness, calls, ask, opts = {}) {
+  const answer = calls.join(ask.toolCallId, () => runRelayedTool(harness, ask, { signal: calls.signal }));
+  const window = new AbortController();
+  const sleep2 = opts.sleep ?? sleepUnlessAborted;
+  const progress = await Promise.race([
+    answer.then((a) => ({ done: true, answer: a })),
+    sleep2(opts.windowMs ?? RELAY_POLL_WINDOW_MS, window.signal).then(() => ({ done: false }))
+  ]);
+  window.abort();
+  return progress;
+}
 function relayedToolDefinitions(harness) {
   return harness.tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
 }
@@ -42328,18 +42864,23 @@ function authorizeToolCall(harness, ask) {
   if (verdict.verdict === "allowed") return { allow: true };
   return refuse3(verdict.reason);
 }
-async function runRelayedTool(harness, ask) {
+async function runRelayedTool(harness, ask, opts = {}) {
   const tool = harness.tools.find((t) => t.name === ask.tool);
   if (!tool) return { content: [{ type: "text", text: `Unknown tool: ${ask.tool}` }], isError: true };
   const span = harness.toolSpan(ask.toolCallId);
   const base = harness.toolContext;
-  const ctx = span ? {
-    ...base,
-    span,
-    executor: new TracingExecutor(base.executor, span, harness.backend),
-    publish: (e) => harness.emit(withSpanId2(e, span.id)),
-    ...base.github?.api.withSpan ? { github: { ...base.github, api: base.github.api.withSpan(span) } } : {}
-  } : { ...base, publish: (e) => harness.emit(e) };
+  const readConversation = base.conversation;
+  const ctx = {
+    ...span ? {
+      ...base,
+      span,
+      executor: new TracingExecutor(base.executor, span, harness.backend),
+      publish: (e) => harness.emit(withSpanId2(e, span.id)),
+      ...base.github?.api.withSpan ? { github: { ...base.github, api: base.github.api.withSpan(span) } } : {}
+    } : { ...base, publish: (e) => harness.emit(e) },
+    ...opts.signal && !base.signal ? { signal: opts.signal } : {},
+    ...readConversation && harness.callSeen ? { conversation: () => harness.callSeen(ask.toolCallId).then(() => readConversation()) } : {}
+  };
   try {
     const input = typeof ask.input === "object" && ask.input !== null ? ask.input : {};
     const output = await tool.run(input, ctx);
@@ -42367,30 +42908,64 @@ function withSpanId2(e, spanId) {
       return e;
   }
 }
-var HarnessRegistry;
+var HarnessRegistry, RELAY_POLL_WINDOW_MS, RelayedCalls;
 var init_relay = __esm({
   "../../src/core/harness/pi/relay.ts"() {
     "use strict";
     init_tracingExecutor();
     init_types3();
+    init_awaitChildren();
     init_runEvents();
     init_toolRules();
     HarnessRegistry = class {
       live = /* @__PURE__ */ new Map();
-      /** The run drives a pi from here; the returned function forgets it. */
+      /** The run drives a pi from here, its relayed calls kept beside it; the
+       *  returned function forgets it and ends whatever call still runs. */
       register(harness) {
-        this.live.set(harness.runId, harness);
+        const entry = { harness, calls: new RelayedCalls() };
+        this.live.set(harness.runId, entry);
         return () => {
-          if (this.live.get(harness.runId) === harness) this.live.delete(harness.runId);
+          if (this.live.get(harness.runId) !== entry) return;
+          this.live.delete(harness.runId);
+          entry.calls.end();
         };
       }
       get(runId3) {
-        return this.live.get(runId3);
+        return this.live.get(runId3)?.harness;
+      }
+      /** The run's relayed calls, for as long as it is registered. */
+      calls(runId3) {
+        return this.live.get(runId3)?.calls;
       }
       size() {
         return this.live.size;
       }
     };
+    RELAY_POLL_WINDOW_MS = 3e4;
+    RelayedCalls = class {
+      calls = /* @__PURE__ */ new Map();
+      ending = new AbortController();
+      get size() {
+        return this.calls.size;
+      }
+      /** Aborted when the run ends: the signal every call here runs under. */
+      get signal() {
+        return this.ending.signal;
+      }
+      /** The call's answer as a promise: started by `start` on the first ask, the same promise after. */
+      join(callId, start3) {
+        let answer = this.calls.get(callId);
+        if (!answer) {
+          answer = start3();
+          this.calls.set(callId, answer);
+        }
+        return answer;
+      }
+      end() {
+        this.ending.abort();
+        this.calls.clear();
+      }
+    };
   }
 });
 
@@ -42439,7 +43014,15 @@ async function handleHarnessRequest(deps, req) {
     deps.log?.(`[harness] run=${door.runId} authorize ${ask.tool} \u2192 ${answer2.allow ? "allow" : "refuse"}`);
     return { status: 200, body: { ...answer2 } };
   }
-  const answer = await runRelayedTool(harness, ask);
+  const progress = await relayToolCall(harness, deps.harnesses.calls(door.runId), ask, {
+    ...deps.relayWindowMs !== void 0 ? { windowMs: deps.relayWindowMs } : {},
+    ...deps.sleep ? { sleep: deps.sleep } : {}
+  });
+  if (!progress.done) {
+    deps.log?.(`[harness] run=${door.runId} tool ${ask.tool} \u2192 pending`);
+    return { status: 202, body: { pending: true, toolCallId: ask.toolCallId } };
+  }
+  const { answer } = progress;
   deps.log?.(`[harness] run=${door.runId} tool ${ask.tool} \u2192 ${answer.isError ? "error" : "ok"}`);
   return { status: 200, body: { ...answer } };
 }
@@ -42775,7 +43358,7 @@ async function openThreadFromRequester(deps, instance, lead, at) {
       }
     };
   } catch (err2) {
-    return { ok: false, response: json(502, { ok: false, error: "thread_failed", message: describe10(err2), at }) };
+    return { ok: false, response: json(502, { ok: false, error: "thread_failed", message: describe11(err2), at }) };
   }
 }
 async function ensureReviewThread(deps, instance, row, at) {
@@ -42901,8 +43484,8 @@ async function spawn6(body, deps) {
     try {
       turn = await composeChild(req.brief, instance, row, briefReaders(deps, instance, io));
     } catch (err2) {
-      log(`[coordinator] ${instance.id} ${req.step}: the brief could not be composed: ${describe10(err2)}`);
-      return json(502, { ok: false, error: "brief_failed", message: describe10(err2), at });
+      log(`[coordinator] ${instance.id} ${req.step}: the brief could not be composed: ${describe11(err2)}`);
+      return json(502, { ok: false, error: "brief_failed", message: describe11(err2), at });
     }
   } else {
     turn = { prompt: req.prompt };
@@ -42952,7 +43535,7 @@ async function spawn6(body, deps) {
   );
   void settled.then((end) => {
     if (end.kind === "threw")
-      log(`[coordinator] ${instance.id} ${req.step}: the child's dispatch threw: ${describe10(end.err)}`);
+      log(`[coordinator] ${instance.id} ${req.step}: the child's dispatch threw: ${describe11(end.err)}`);
   });
   const first = await Promise.race([started.then((id) => ({ kind: "started", id })), settled]);
   if (first.kind === "started" || startedId !== void 0) {
@@ -42960,7 +43543,7 @@ async function spawn6(body, deps) {
     log(`[coordinator] ${instance.id} ${req.step}: spawned ${req.preset} run ${runId3} in ${threadKey}`);
     return json(200, { ok: true, runId: runId3, threadKey, at });
   }
-  if (first.kind === "threw") return json(502, { ok: false, error: "spawn_failed", message: describe10(first.err), at });
+  if (first.kind === "threw") return json(502, { ok: false, error: "spawn_failed", message: describe11(first.err), at });
   const refusal = first.outcome.refusal;
   if (refusal === "coordinator_thread_live") {
     const now = await liveOnThread(deps.runs, instance, threadKey);
@@ -43113,7 +43696,7 @@ async function prCheck(body, deps) {
       at
     });
   } catch (err2) {
-    return json(502, { ok: false, error: "github_unavailable", message: describe10(err2), at });
+    return json(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
   }
 }
 async function plan2(body, deps) {
@@ -43222,7 +43805,7 @@ async function branch(body, deps) {
     await deps.createBranchRef(instance.repo, name, base);
     return json(200, { ok: true, branch: name, base, at });
   } catch (err2) {
-    return json(200, { ok: false, reason: describe10(err2), at });
+    return json(200, { ok: false, reason: describe11(err2), at });
   }
 }
 function unitLines(units) {
@@ -43274,7 +43857,7 @@ async function round(body, deps) {
     instance,
     units.map((u) => u.unit === updated.unit ? updated : u)
   ).catch(
-    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe10(err2)}`)
+    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe11(err2)}`)
   );
   return json(200, { ok: true, at });
 }
@@ -43308,7 +43891,7 @@ async function unitEnd(body, deps) {
       told = true;
     } catch (err2) {
       (deps.log ?? console.warn)(
-        `[coordinator] ${instance.id} ${row.unit}: the report could not be posted: ${describe10(err2)}`
+        `[coordinator] ${instance.id} ${row.unit}: the report could not be posted: ${describe11(err2)}`
       );
     }
   }
@@ -43322,7 +43905,7 @@ ${ending.report}` + (rendered !== void 0 ? `
 ${rendered}` : "");
     await deps.github.commentIssue(instance.repo, row.issue, comment).catch(
       (err2) => (deps.log ?? console.warn)(
-        `[coordinator] ${instance.id} ${row.unit}: the board comment could not be posted: ${describe10(err2)}`
+        `[coordinator] ${instance.id} ${row.unit}: the board comment could not be posted: ${describe11(err2)}`
       )
     );
   }
@@ -43377,7 +43960,7 @@ async function merge(body, deps, subject2) {
   try {
     facts2 = await deps.fetchPrFacts(pr);
   } catch (err2) {
-    return json(502, { ok: false, error: "github_unavailable", message: describe10(err2), at });
+    return json(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
   }
   if (facts2 === void 0)
     return json(502, { ok: false, error: "github_unavailable", message: `${where} could not be read`, at });
@@ -43429,7 +44012,7 @@ async function merge(body, deps, subject2) {
       title: facts2.title ?? `Merge pull request #${pr.number}`
     });
   } catch (err2) {
-    return json(502, { ok: false, error: "github_unavailable", message: describe10(err2), at });
+    return json(502, { ok: false, error: "github_unavailable", message: describe11(err2), at });
   }
   if (!merged.ok) {
     log(
@@ -43604,13 +44187,13 @@ function createAdminCoordinatorHandler(deps) {
         }
         write(res, await answerCoordinatorStep(door, read.body, deps));
       } catch (err2) {
-        (deps.log ?? console.error)(`[coordinator] ${describe10(err2)}`);
+        (deps.log ?? console.error)(`[coordinator] ${describe11(err2)}`);
         write(res, json(500, { ok: false, error: "internal error" }));
       }
     })();
   };
 }
-var COORDINATOR_ADMIN_PREFIX, MAX_SPAWN_PROMPT_CHARS, FINISHED_LOOKBACK_PAGES, MAX_ADMIN_BODY_BYTES, UNIT_ID, PRESETS_OF_KIND, invalid, json, describe10, EVERY_RUN, REVIEW_POSTED_CHECKS, REVIEW_POSTED_RECHECK_MS, ROUND_OUTCOMES, ENDING_ICON, STEPS;
+var COORDINATOR_ADMIN_PREFIX, MAX_SPAWN_PROMPT_CHARS, FINISHED_LOOKBACK_PAGES, MAX_ADMIN_BODY_BYTES, UNIT_ID, PRESETS_OF_KIND, invalid, json, describe11, EVERY_RUN, REVIEW_POSTED_CHECKS, REVIEW_POSTED_RECHECK_MS, ROUND_OUTCOMES, ENDING_ICON, STEPS;
 var init_adminCoordinator = __esm({
   "../../src/channels/adminCoordinator.ts"() {
     "use strict";
@@ -43643,7 +44226,7 @@ var init_adminCoordinator = __esm({
     };
     invalid = (error) => ({ ok: false, error });
     json = (status3, body) => ({ status: status3, body });
-    describe10 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe11 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     EVERY_RUN = { kind: "all" };
     REVIEW_POSTED_CHECKS = 3;
     REVIEW_POSTED_RECHECK_MS = 2e3;