@coreplane/switchboard 1.220.1 → 1.221.1

package/dist/cli.js

@@ -356,13 +356,14 @@ function amzDate(now) {
 function encodeKey(key) {
   return key.split("/").map(encodeURIComponent).join("/");
 }
-var PRESIGN_TTL_SECONDS, R2ArtifactStore;
+var PRESIGN_TTL_SECONDS, IDENTITY, R2ArtifactStore;
 var init_store = __esm({
   "../../src/artifacts/store.ts"() {
     "use strict";
     init_clock();
     init_config();
     PRESIGN_TTL_SECONDS = ARTIFACT_DEFAULTS.presignTtlSeconds;
+    IDENTITY = { "accept-encoding": "identity" };
     R2ArtifactStore = class {
       bucket;
       client;
@@ -402,7 +403,7 @@ var init_store = __esm({
         return this.presign(key, "GET");
       }
       async head(key) {
-        const signed = await this.client.sign(new Request(this.objectUrl(key), { method: "HEAD" }), {
+        const signed = await this.client.sign(new Request(this.objectUrl(key), { method: "HEAD", headers: IDENTITY }), {
           aws: { datetime: amzDate(this.clock()) }
         });
         const res = await this.fetchImpl(signed);
@@ -416,7 +417,7 @@ var init_store = __esm({
         return { size, contentType: res.headers.get("content-type") ?? "application/octet-stream" };
       }
       async get(key) {
-        const signed = await this.client.sign(new Request(this.objectUrl(key), { method: "GET" }), {
+        const signed = await this.client.sign(new Request(this.objectUrl(key), { method: "GET", headers: IDENTITY }), {
           aws: { datetime: amzDate(this.clock()) }
         });
         const res = await this.fetchImpl(signed);
@@ -4139,6 +4140,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",
@@ -9419,7 +9421,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";
@@ -9451,6 +9453,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;
@@ -9608,6 +9620,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;
@@ -9621,6 +9634,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 } : {}
         };
@@ -9640,6 +9654,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}`));
       }
@@ -9994,11 +10010,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 () => ({}) }),
@@ -10056,6 +10094,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;
@@ -10206,7 +10296,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";
@@ -10221,6 +10311,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) {
@@ -20508,7 +20609,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;
@@ -20528,7 +20629,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));
@@ -20538,7 +20639,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);
       })
@@ -20552,7 +20653,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;
     }
   };
@@ -20570,7 +20671,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 {};
     }
@@ -20741,7 +20842,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;
@@ -26605,9 +26706,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.`;
@@ -26786,6 +26888,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 ?? "-"}`;
@@ -26807,31 +27155,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;
@@ -26842,7 +27209,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: {
@@ -26851,6 +27218,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"
           }
         }
       },
@@ -26859,13 +27230,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)
@@ -26875,12 +27263,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`
           } : {},
@@ -27545,7 +27938,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));
@@ -28613,7 +29010,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
   );
@@ -29240,157 +29638,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) {
@@ -30093,7 +30340,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) => {
@@ -30118,7 +30365,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
@@ -30145,6 +30393,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 };
@@ -30181,6 +30430,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) {
@@ -30280,6 +30533,7 @@ var init_provision = __esm({
     init_contract3();
     init_registry();
     init_profile();
+    init_factory();
     init_residentTrace();
     init_resident();
     init_memory();
@@ -30333,6 +30587,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(
@@ -30366,6 +30621,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,
@@ -30422,6 +30678,7 @@ var init_run2 = __esm({
     init_workspace();
     init_web();
     init_githubApi();
+    init_factory();
     init_runRegistry();
     init_secrets2();
     webCapability = () => sharedWeb ??= makeWebCapability(processSecrets);
@@ -30454,6 +30711,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];
@@ -30527,6 +30795,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,
@@ -30534,7 +30845,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: {} };
     },
@@ -30733,6 +31044,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`;
 }
@@ -30749,7 +31063,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";
@@ -30769,6 +31083,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 {
@@ -30782,6 +31097,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));
       }
@@ -30807,6 +31128,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)));
       }
@@ -30938,6 +31269,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
@@ -31058,6 +31397,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) {
@@ -31220,8 +31565,13 @@ var init_bridge2 = __esm({
             break;
           case "message_end":
             if (isRecord3(event.message)) {
-              out.message = event.message;
-              if (event.message.role === "assistant") this.onAssistant(event.message, out);
+              if (event.message.role === "assistant") {
+                const assistant = event.message;
+                this.onAssistant(assistant, out);
+                if (assistant.stopReason !== "error") out.message = event.message;
+              } else {
+                out.message = event.message;
+              }
             }
             break;
           case "tool_execution_start":
@@ -31383,6 +31733,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) {
@@ -31562,6 +31917,7 @@ var init_mirror = __esm({
         if (!this.deps.onStep) return;
         const chat = chatMessageOf(message3);
         if (!chat) return;
+        if (chat.content.length === 0) return;
         if (chat.role === "user") {
           if (!this.seedEchoed && !chat.content.some((p) => p.type === "tool_result")) {
             this.seedEchoed = true;
@@ -31704,7 +32060,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) {
@@ -31773,6 +32130,24 @@ async function runPiHarness(deps, run2) {
   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,
@@ -31802,7 +32177,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;
@@ -31819,21 +32198,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,
@@ -31849,7 +32234,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 = {
@@ -31882,7 +32267,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,
@@ -31896,7 +32281,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`
@@ -31906,7 +32291,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 });
     }
@@ -32101,7 +32492,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";
@@ -32116,6 +32507,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) {
@@ -32970,6 +33363,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;
@@ -33018,10 +33412,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") {
@@ -33066,7 +33469,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 } : {},
@@ -33884,7 +34287,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 {
@@ -33892,7 +34295,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);
@@ -33905,7 +34308,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 } };
 }
@@ -34021,7 +34424,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": {
@@ -34043,7 +34446,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";
@@ -34051,7 +34454,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"]);
   }
@@ -34744,6 +35147,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;
@@ -34803,31 +35277,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({
@@ -34869,7 +35318,6 @@ var THREAD_READ_LIMIT;
 var init_thread = __esm({
   "../../src/core/dispatch/thread.ts"() {
     "use strict";
-    init_staging();
     THREAD_READ_LIMIT = 8;
   }
 });
@@ -34989,22 +35437,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)}`);
       }
     }
   };
@@ -35014,7 +35462,7 @@ function createRunEnding(deps) {
       try {
         deps.onFinished?.(runId3);
       } catch (err2) {
-        log(`[ending] finished ${runId3}: ${describe6(err2)}`);
+        log(`[ending] finished ${runId3}: ${describe7(err2)}`);
       }
     },
     register(entry) {
@@ -35042,7 +35490,7 @@ function createRunEnding(deps) {
     }
   };
 }
-function describe6(err2) {
+function describe7(err2) {
   return err2 instanceof Error ? err2.message : String(err2);
 }
 var init_runEnding = __esm({
@@ -35104,6 +35552,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: () => {
@@ -35344,18 +35794,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,
@@ -35382,6 +35835,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,
@@ -35393,10 +35847,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(
@@ -35408,13 +35887,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 }] : [
@@ -35444,6 +35926,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,
@@ -35460,11 +35943,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 } : {}
         }
       } : {}
     });
@@ -35524,7 +36009,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 },
       {
@@ -35544,6 +36036,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       profile,
       resolved,
       stagingIndex: nextStagedIndex,
+      workspaceFiles,
       provider,
       model,
       messages,
@@ -35646,7 +36139,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",
@@ -35661,7 +36154,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(
@@ -35704,10 +36205,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();
@@ -35718,7 +36222,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) {
@@ -35735,7 +36239,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) => {
@@ -35758,12 +36262,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]));
@@ -35783,7 +36287,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);
@@ -36200,7 +36704,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]);
@@ -36362,7 +36866,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) {
@@ -36389,7 +36893,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]);
@@ -36422,7 +36926,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]);
@@ -36440,7 +36944,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";
       }
     }
@@ -36455,7 +36959,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`
         );
       }
     }
@@ -36476,7 +36980,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() {
@@ -36554,7 +37058,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;
       }
     },
@@ -36563,7 +37067,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 [];
       }
@@ -36585,12 +37089,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";
@@ -36670,7 +37174,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);
   }
 });
 
@@ -41316,7 +41820,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;
   }
@@ -41384,8 +41888,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 {
@@ -41401,7 +41905,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(
@@ -41423,7 +41927,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;
     }
@@ -41449,7 +41953,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({
@@ -41470,7 +41974,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";
@@ -41487,7 +41991,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);
   }
 });
 
@@ -42336,6 +42840,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 }));
 }
@@ -42356,18 +42871,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);
@@ -42395,30 +42915,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();
+      }
+    };
   }
 });
 
@@ -42467,7 +43021,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 } };
 }
@@ -42803,7 +43365,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) {
@@ -42929,8 +43491,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 };
@@ -42980,7 +43542,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) {
@@ -42988,7 +43550,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);
@@ -43141,7 +43703,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) {
@@ -43250,7 +43812,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) {
@@ -43302,7 +43864,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 });
 }
@@ -43336,7 +43898,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)}`
       );
     }
   }
@@ -43350,7 +43912,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)}`
       )
     );
   }
@@ -43405,7 +43967,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 });
@@ -43457,7 +44019,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(
@@ -43632,13 +44194,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";
@@ -43671,7 +44233,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;