@coreplane/switchboard 1.213.0 → 1.215.0

package/dist/cli.js

@@ -1404,19 +1404,19 @@ function clampBashTimeout(requested) {
   return Math.min(Math.max(Math.trunc(requested), BASH_TIMEOUT_MIN_MS), BASH_TIMEOUT_MAX_MS);
 }
 function bashBudgetWithinRun(wantedMs, remainingMs) {
-  const secs = (ms) => Math.max(0, Math.round(ms / 1e3));
+  const secs2 = (ms) => Math.max(0, Math.round(ms / 1e3));
   const cap = Math.trunc(remainingMs - RUN_DEADLINE_RESERVE_MS);
   if (cap < BASH_TIMEOUT_MIN_MS) {
     return {
       kind: "exhausted",
-      note: `run budget exhausted \u2014 ${secs(remainingMs)}s of wall clock left, inside the ${secs(RUN_DEADLINE_RESERVE_MS)}s write-up reserve, so the command was not run; write up what you have now`
+      note: `run budget exhausted \u2014 ${secs2(remainingMs)}s of wall clock left, inside the ${secs2(RUN_DEADLINE_RESERVE_MS)}s write-up reserve, so the command was not run; write up what you have now`
     };
   }
   if (cap >= wantedMs) return { kind: "unchanged" };
   return {
     kind: "clipped",
     timeoutMs: cap,
-    note: `[timeout clipped to ${secs(cap)}s \u2014 the run's wall clock ends in ${secs(remainingMs)}s]`
+    note: `[timeout clipped to ${secs2(cap)}s \u2014 the run's wall clock ends in ${secs2(remainingMs)}s]`
   };
 }
 function bashTimeoutNote(timeoutMs) {
@@ -1758,6 +1758,31 @@ function runawayTurnCap(maxMinutes) {
 function loopBudget(maxMinutes) {
   return { maxMinutes, maxTurns: runawayTurnCap(maxMinutes) };
 }
+function conductorSystem(siblings) {
+  const readers = siblings.filter((a) => a.identity !== "write");
+  const writers = siblings.filter((a) => a.identity === "write");
+  const rows = readers.map(
+    (a) => `- \`${a.name}\`${machineNeedsRepo(a.machine) ? " (needs the repository)" : ""}: ${a.description}`
+  );
+  return `You are Switchboard's conductor: you coordinate other runs instead of doing the work yourself, answering a request from Slack.
+
+You have no workspace and no shell. Your tools: \`spawn_run\` (start a child run), \`send_to_run\` (steer a live child: your text reaches it as a follow-up at its next step), \`await_runs\` (wait for your children to end and get each end \u2014 its status and final reply \u2014 back as data), \`list_runs\` (the runs you may see \u2014 your own children by default), \`get_run_status\` (one run: whether it is running, what it is doing, and its final reply once it finished), the GitHub reads \u2014 \`github_repos\`, \`github_tree\` / \`github_file\` (browse and read our repositories), \`github_search_code\`, \`github_issue_list\` / \`github_issue_get\` \u2014 \`web_fetch\` (read a public URL), and \`update_status\`.
+
+WHAT A CHILD IS. A child is an ordinary Switchboard run started as the person who asked you \u2014 exactly the run they could start by hand with \`agent:<preset>\` \u2014 in a thread of its own in this channel, visible to everyone there, with its own status card and run page, and under their permissions: a preset they may not run, a repository they may not use, or a profile a boundary caps is refused in the child's thread, and the refusal comes back to you as the tool result naming the gate. Children cannot spawn children. You may have a few live at once (the deployment's \`spawn.maxChildren\`, three by default); a spawn past the cap is refused until one finishes. A child's wall clock is capped by what is left of yours.
+
+THE PRESETS a child can run \u2014 a child reads, so only a preset whose identity is \`none\` or \`read\`:
+${rows.join("\n")}
+
+A preset that writes \u2014 ${writers.map((a) => `\`${a.name}\``).join(", ")} \u2014 is refused by name (\`spawn_identity\`): a spawned child never holds a write credential, so pushing a branch or opening a pull request is the requester's to start by hand with \`agent:<preset>\`; say so in your answer instead of spawning it.
+
+ROUTED COMPOUNDS. A request may arrive already split: the router found independent parts, and the message ends with the line "Routed as a compound request: N independent parts" followed by a numbered list, one part per line as \`<preset>\`: <text>. Spawn exactly those children \u2014 one \`spawn_run\` per line, the preset as listed, the line's text as the child's prompt (it already stands alone; add the repository where the preset needs one) \u2014 then \`await_runs\` them all and compile. Never merge, drop or add a part; a part whose spawn is refused is reported as refused, by the gate's name.
+
+HOW TO WORK. Fan out, await, compile. Read the request and split it into children only where the parts are independent; a request one preset answers is one child. Spawn each child with a prompt that says what it should do, and the repository where the preset needs one: a child starts from this conversation's text so far \u2014 every user and assistant turn before your call, never your tool calls, their results or your thinking \u2014 and your prompt is its one new turn, so tell it what to do rather than repeat what was said. Then call \`await_runs\` once with every child's id: it returns when all of them have ended, or earlier \u2014 at the edge of your own budget, at a stop, or when a follow-up lands in this thread \u2014 and \`ended\` says which; a child still running at the cut keeps running (name it in your answer, or await again after a follow-up). Steer a child with \`send_to_run\` when the request changes or a child is heading the wrong way. A child that ended \u2014 finished, failed, interrupted by a restart \u2014 is reported as it ended and never restarted; spawn a new child if the work still matters. Then compile: one answer from the write-ups \`await_runs\` returned. Never do a child's job yourself, and never claim a child finished or found something you did not read from \`await_runs\` or \`get_run_status\`.
+
+Maintain the user-facing status card with the update_status tool: one item per child (\u25CB pending, \u2731 running, \u2713 finished \u2014 only once await_runs or get_run_status said so).
+
+Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks). Your final message is posted to Slack: lead with the outcome, then one line per child \u2014 its preset, its thread, its status and its result in a sentence \u2014 and what is still running, if anything.`;
+}
 function presetDoor(def) {
   if (def.routable !== false) return "routed";
   return def.name === COMPOUND_PRESET ? "compound" : "directive";
@@ -1769,7 +1794,7 @@ function getAgent(name) {
   }
   return a;
 }
-var MACHINE_CLASSES, IDENTITIES, HARNESSES, RUNAWAY_TURNS_PER_MINUTE, PR_DESCRIPTION_TEMPLATE, NEVER_MERGE, CONTRACT_HEADINGS_LIST, UNIT_CONTRACT, UNIT_HANDOFF, IMAGE_TOOLCHAIN, SANDBOX_TOOLCHAIN, RESIDENT_TOOLCHAIN, SHOW_FILES, CODING_SYSTEM, CODING_SYSTEM_RESIDENT, REVIEW_VERDICT_INSTRUCTION, REVIEW_SPEC_CHECK, REVIEW_UNIT_CONTRACT, REVIEW_WHOLE_CHANGE, REVIEW_SYSTEM, REVIEW_SYSTEM_RESIDENT, RESEARCH_SYSTEM, GENERAL_SYSTEM, EXPLORE_SYSTEM, CONDUCTOR_SYSTEM, COMPOUND_PRESET, AGENTS;
+var MACHINE_CLASSES, IDENTITIES, HARNESSES, RUNAWAY_TURNS_PER_MINUTE, PR_DESCRIPTION_TEMPLATE, NEVER_MERGE, CONTRACT_HEADINGS_LIST, UNIT_CONTRACT, UNIT_HANDOFF, IMAGE_TOOLCHAIN, SANDBOX_TOOLCHAIN, RESIDENT_TOOLCHAIN, SHOW_FILES, CODING_SYSTEM, CODING_SYSTEM_RESIDENT, REVIEW_VERDICT_INSTRUCTION, REVIEW_SPEC_CHECK, REVIEW_UNIT_CONTRACT, REVIEW_WHOLE_CHANGE, REVIEW_SYSTEM, REVIEW_SYSTEM_RESIDENT, RESEARCH_SYSTEM, GENERAL_SYSTEM, EXPLORE_SYSTEM, COMPOUND_PRESET, WORK_PRESETS, AGENTS;
 var init_registry = __esm({
   "../../src/agents/registry.ts"() {
     "use strict";
@@ -1797,6 +1822,8 @@ EVERY PR includes one that already exists when you push \u2014 opened by a perso
     RESIDENT_TOOLCHAIN = `The resident image carries ${IMAGE_TOOLCHAIN}; plus yarn and bun \u2014 and no Docker.`;
     SHOW_FILES = `Files the person should SEE go through the attach_file tool: a screenshot from \`playwright screenshot\`, a rendered PDF, a recording \u2014 it posts the workspace file into this conversation, where an image renders inline. Use it whenever you produce an image worth showing (a visual change, a rendered page, a before/after); a link to a file on GitHub is not a picture.
 SCREENSHOTS GO TO BOTH PLACES, ALL OF THEM: when the request asks for screenshots, or the change is visual, every capture is attached here with attach_file AND published on the pull request \u2014 commit the images to an assets branch (never the PR's own diff) and reference them from the description's validation section or a PR comment so they render inline there too \u2014 unless the request names one destination. Never attach a subset and link the rest.
+Whole files: up to 1 GiB where the artifact store is configured (a recording, a large PDF), 10 MiB otherwise \u2014 the tool's result says which applies; over the limit, link to the file.
+Files the person dropped on the thread that were too large to show you inline are already in ./attachments/ in your workspace when the turn's text names them (a video for ffmpeg, a large PDF, a zip); read them from there \u2014 never ask for a re-upload.
 Text stays in your message; do not attach what you can say.`;
     CODING_SYSTEM = `You are Switchboard's coding agent, operating from a Slack request.
 
@@ -1953,26 +1980,11 @@ READ-ONLY: NEVER open a pull request, and never commit or push \u2014 no branch,
 Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending) once you have it, and update items as they start (\u2731) and finish (\u2713 \u2014 only after they actually happened). Items are short outcomes ("Clone and install", "Time the full suite"), never commands.
 
 Report outcomes faithfully: a check you could not run is "could not check", never a guess. Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks \u2014 render the claim table as aligned rows inside a code block). Your final message is posted to Slack: lead with the overall verdict in one line, then the claim table, then what a follow-up should do.`;
-    CONDUCTOR_SYSTEM = `You are Switchboard's conductor: you coordinate other runs instead of doing the work yourself, answering a request from Slack.
-
-You have no workspace and no shell. Your tools: \`spawn_run\` (start a child run), \`send_to_run\` (steer a live child: your text reaches it as a follow-up at its next step), \`await_runs\` (wait for your children to end and get each end \u2014 its status and final reply \u2014 back as data), \`list_runs\` (the runs you may see \u2014 your own children by default), \`get_run_status\` (one run: whether it is running, what it is doing, and its final reply once it finished), the GitHub reads \u2014 \`github_repos\`, \`github_tree\` / \`github_file\` (browse and read our repositories), \`github_search_code\`, \`github_issue_list\` / \`github_issue_get\` \u2014 \`web_fetch\` (read a public URL), and \`update_status\`.
-
-WHAT A CHILD IS. A child is an ordinary Switchboard run started as the person who asked you \u2014 exactly the run they could start by hand with \`agent:<preset>\` \u2014 in a thread of its own in this channel, visible to everyone there, with its own status card and run page, and under their permissions: a preset they may not run, a repository they may not use, or a profile a boundary caps is refused in the child's thread, and the refusal comes back to you as the tool result naming the gate. Children cannot spawn children. You may have a few live at once (the deployment's \`spawn.maxChildren\`, three by default); a spawn past the cap is refused until one finishes. A child's wall clock is capped by what is left of yours.
-
-THE PRESETS a child can run: \`research\` (a question the web or our repositories answer), \`coding\` (implement a change and open a pull request; needs the repository), \`review\` (review a pull request; needs its URL), \`explore\` (a long, read-only investigation with a shell; needs the repository), \`general\` (a quick answer with the GitHub tools), \`ship\` (coding, review and fixes until a pull request is merge-ready; needs the repository).
-
-ROUTED COMPOUNDS. A request may arrive already split: the router found independent parts, and the message ends with the line "Routed as a compound request: N independent parts" followed by a numbered list, one part per line as \`<preset>\`: <text>. Spawn exactly those children \u2014 one \`spawn_run\` per line, the preset as listed, the line's text as the child's prompt (it already stands alone; add the repository where the preset needs one) \u2014 then \`await_runs\` them all and compile. Never merge, drop or add a part; a part whose spawn is refused is reported as refused, by the gate's name.
-
-HOW TO WORK. Fan out, await, compile. Read the request and split it into children only where the parts are independent; a request one preset answers is one child. Spawn each child with a self-contained prompt \u2014 everything it needs, since it sees none of this thread \u2014 and the repository where the preset needs one. Then call \`await_runs\` once with every child's id: it returns when all of them have ended, or earlier \u2014 at the edge of your own budget, at a stop, or when a follow-up lands in this thread \u2014 and \`ended\` says which; a child still running at the cut keeps running (name it in your answer, or await again after a follow-up). Steer a child with \`send_to_run\` when the request changes or a child is heading the wrong way. A child that ended \u2014 finished, failed, interrupted by a restart \u2014 is reported as it ended and never restarted; spawn a new child if the work still matters. Then compile: one answer from the write-ups \`await_runs\` returned. Never do a child's job yourself, and never claim a child finished or found something you did not read from \`await_runs\` or \`get_run_status\`.
-
-Maintain the user-facing status card with the update_status tool: one item per child (\u25CB pending, \u2731 running, \u2713 finished \u2014 only once await_runs or get_run_status said so).
-
-Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks). Your final message is posted to Slack: lead with the outcome, then one line per child \u2014 its preset, its thread, its status and its result in a sentence \u2014 and what is still running, if anything.`;
     COMPOUND_PRESET = "conductor";
-    AGENTS = {
+    WORK_PRESETS = {
       general: {
         name: "general",
-        description: "Default assistant on the configured model: answers directly, reads the org's repos and manages their issues over GitHub, reads URLs. No workspace or shell.",
+        description: "Default assistant: answers directly, reads URLs, manages issues; the preset for any question the org's GitHub answers. No workspace or shell.",
         system: GENERAL_SYSTEM,
         toolset: "assistant",
         // The GitHub tools are REST in the bot process, so a general ask never
@@ -2047,7 +2059,7 @@ Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks
       },
       research: {
         name: "research",
-        description: "Answers questions with web search, URL reading, and read access to the org's repos and issues over GitHub. No workspace.",
+        description: "Answers questions that need the web (search, URL reading); GitHub for context, not for a question GitHub alone answers. No workspace.",
         system: RESEARCH_SYSTEM,
         toolset: "web",
         machine: "none",
@@ -2073,11 +2085,14 @@ Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks
         // would expire between them, so the 2× write buys reads for the whole run.
         cacheTtl: "1h"
         // No built-in effort: the deployment decides, as for coding.
-      },
+      }
+    };
+    AGENTS = {
+      ...WORK_PRESETS,
       conductor: {
         name: "conductor",
         description: "Coordinates other runs: spawns child runs as the requester \u2014 each in a thread of its own, under their permissions \u2014 follows them, and reports. No workspace or shell.",
-        system: CONDUCTOR_SYSTEM,
+        system: conductorSystem(Object.values(WORK_PRESETS)),
         toolset: "conductor",
         // Nothing is provisioned and no credential minted: the run tools call the
         // dispatcher, the GitHub reads are REST in the bot process.
@@ -2821,6 +2836,8 @@ function validateRouting(routing, providers) {
     throw new Error(`config.yaml: routing.${key} is not a known key`);
   if (routing.auto !== void 0 && typeof routing.auto !== "boolean")
     throw new Error("config.yaml: routing.auto must be true or false");
+  if (routing.answer !== void 0 && !ROUTE_ANSWER_MODES.includes(routing.answer))
+    throw new Error(`config.yaml: routing.answer must be ${ROUTE_ANSWER_MODES.join(" or ")}`);
   if (routing.model !== void 0) {
     if (typeof routing.model !== "string" || !routing.model.includes("/"))
       throw new Error("config.yaml: routing.model must be a <provider>/<model> ref");
@@ -2875,8 +2892,11 @@ function validateRunHistory(rh) {
     if (v !== void 0 && (!Number.isInteger(v) || v < 1))
       throw new Error(`config.yaml: runHistory.${key} must be an integer >= 1`);
   }
-  if (rh.maxBytes !== void 0 && (!Number.isInteger(rh.maxBytes) || rh.maxBytes < 1))
-    throw new Error("config.yaml: runHistory.maxBytes must be an integer >= 1");
+  for (const key of ["maxBytes", "sessionLogMaxBytes"]) {
+    const v = rh[key];
+    if (v !== void 0 && (!Number.isInteger(v) || v < 1))
+      throw new Error(`config.yaml: runHistory.${key} must be an integer >= 1`);
+  }
   if (rh.store !== void 0 && rh.store !== "worker" && rh.store !== "file")
     throw new Error('config.yaml: runHistory.store must be "worker" or "file"');
   if (rh.worker !== void 0) {
@@ -2917,7 +2937,7 @@ function validateRuntimeOverrides(ro) {
     }
   }
 }
-var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, ROUTING_KEYS, SHIP_KEYS, SPAWN_KEYS;
+var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES, ROUTE_ANSWER_MODES, ROUTING_KEYS, SHIP_KEYS, SPAWN_KEYS;
 var init_validate = __esm({
   "../../src/config/validate.ts"() {
     "use strict";
@@ -2966,7 +2986,8 @@ var init_validate = __esm({
     };
     BOUNDARY_KEYS = { maxMinutes: true, maxIdentity: true, machines: true };
     MIN_BOUNDARY_MINUTES = 2;
-    ROUTING_KEYS = { auto: true, model: true };
+    ROUTE_ANSWER_MODES = ["tool", "text"];
+    ROUTING_KEYS = { auto: true, model: true, answer: true };
     SHIP_KEYS = { maxRounds: true, maxMinutes: true };
     SPAWN_KEYS = { maxChildren: true };
   }
@@ -2987,7 +3008,7 @@ function identityWithin(identity2, cap) {
   return IDENTITY_ORDER[identity2] <= IDENTITY_ORDER[cap];
 }
 function budgetedAgent(agent, profile) {
-  return { ...agent, maxMinutes: profile.minutes };
+  return { ...agent, maxMinutes: profile.minutes, maxTurns: runawayTurnCap(profile.minutes) };
 }
 function intersectBoundaries(layers) {
   const out = {};
@@ -3058,6 +3079,7 @@ var IDENTITY_ORDER, MACHINE_ORDER;
 var init_profile = __esm({
   "../../src/config/profile.ts"() {
     "use strict";
+    init_registry();
     IDENTITY_ORDER = { none: 0, read: 1, write: 2 };
     MACHINE_ORDER = { none: 0, blank: 1, "repo-cold": 2, "repo-resident": 3 };
   }
@@ -4833,7 +4855,14 @@ var init_profile2 = __esm({
       images: z2.enum(IMAGE_MODES).default("build"),
       /** The Cloudflare Access application in front of the bot's dashboards, when
        *  there is one: the team domain the JWT is issued by and the app's AUD. */
-      access: z2.object({ teamDomain: hostname, aud: z2.string().regex(/^[0-9a-f]{64}$/) }).optional()
+      access: z2.object({ teamDomain: hostname, aud: z2.string().regex(/^[0-9a-f]{64}$/) }).optional(),
+      /** The artifact store's bucket (docs/reference/specs/execution.md item 20), when the installation
+       *  has one: the bot Worker's template binds it as `ARTIFACTS` and `deploy` creates it before the
+       *  upload. The bot's runtime config (`artifacts.r2.bucket`) must name the same bucket — the two
+       *  are held equal by `artifacts check`, not by the profile. R2's own bucket-name rules. */
+      artifacts: z2.object({
+        bucket: z2.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/, "an R2 bucket name: 3\u201363 lowercase letters, digits and hyphens")
+      }).optional()
     });
     EXAMPLE_ACCOUNT = "00000000000000000000000000000000";
   }
@@ -4906,7 +4935,11 @@ function planDeploy(opts, host, loaded, images) {
     setEnv: w.preflight ? { [w.preflight.baseUrlEnv]: w.baseUrl, ...opts.force ? { [w.preflight.forceEnv]: "1" } : {} } : {},
     ...opts.force && w.preflight ? { forcedBy: w.preflight.forceEnv } : {},
     requiredEnv: w.requiredEnv ?? [],
-    capabilities: w.capabilities ?? [],
+    // The bot's `npm run deploy` creates the artifacts bucket before the upload
+    // (deploy/cloudflare/ensure-bucket.mjs) when the profile names one — that
+    // needs R2 on the credential, checked up front like every capability; an
+    // installation without artifacts asks nothing extra of its token.
+    capabilities: [...w.capabilities ?? [], ...w.name === "bot" && profile.artifacts ? [R2_CAPABILITY] : []],
     retryOnPreflightRefusal: !!w.preflight && !opts.force,
     ...w.waitMaxMs !== void 0 ? { waitMaxMs: w.waitMaxMs } : {},
     ...w.preflight?.healthUrl ? { healthUrl: w.preflight.healthUrl } : {},
@@ -5039,7 +5072,7 @@ function classifyDeployOutput(exitCode, output) {
   const firstError = lines.find((l) => isErrorish(l) && !/^npm ERR!/i.test(l)) ?? lines.find(isErrorish);
   return { kind: "failed", reason: firstError ?? `exit ${exitCode}` };
 }
-var UNSET_ENV, SANDBOX_CONTAINER_CLASS, SANDBOX_BEARER_ENV, RESIDENT_BEARER_ENVS, RESIDENT_WAIT_MAX_MS, CONTAINERS_CAPABILITY, WORKER_DIRS, WORKER_SPECS, DEPLOY_ORDER, CONFIG_DOCUMENT_KEY, hasImage, ANSI_SEQUENCE;
+var UNSET_ENV, SANDBOX_CONTAINER_CLASS, SANDBOX_BEARER_ENV, R2_CAPABILITY, RESIDENT_BEARER_ENVS, RESIDENT_WAIT_MAX_MS, CONTAINERS_CAPABILITY, WORKER_DIRS, WORKER_SPECS, DEPLOY_ORDER, CONFIG_DOCUMENT_KEY, hasImage, ANSI_SEQUENCE;
 var init_plan = __esm({
   "../../src/deploy/plan.ts"() {
     "use strict";
@@ -5051,6 +5084,10 @@ var init_plan = __esm({
     UNSET_ENV = ["CLOUDFLARE_ACCOUNT_ID"];
     SANDBOX_CONTAINER_CLASS = "SwitchboardSandbox";
     SANDBOX_BEARER_ENV = "SANDBOX_TOKEN";
+    R2_CAPABILITY = {
+      command: ["wrangler", "r2", "bucket", "list"],
+      needs: "Workers R2 Storage: Edit"
+    };
     RESIDENT_BEARER_ENVS = ["RESIDENT_ADMIN_TOKEN", "RESIDENT_OPERATOR_TOKEN", "RESIDENT_READ_TOKEN"];
     RESIDENT_WAIT_MAX_MS = 30 * 6e4;
     CONTAINERS_CAPABILITY = {
@@ -5123,10 +5160,7 @@ var init_plan = __esm({
         // A container image like the bot's — checked here too, since an --affected
         // release can select the resident without the bot — plus the BACKUP_BUCKET
         // R2 binding wrangler validates on deploy.
-        capabilities: [
-          CONTAINERS_CAPABILITY,
-          { command: ["wrangler", "r2", "bucket", "list"], needs: "Workers R2 Storage: Edit" }
-        ],
+        capabilities: [CONTAINERS_CAPABILITY, R2_CAPABILITY],
         waitMaxMs: RESIDENT_WAIT_MAX_MS,
         why: "per-repo DOs \u2014 preflight refuses while a resident has a run in flight or is provisioning (a refresh or restore mid-cycle only warns: it resumes after the swap)"
       },
@@ -5680,6 +5714,7 @@ function templateView(profile, kind, published) {
     ...hasImage2(kind) ? { image: containerImage(kind, profile, published) } : {},
     urls: { publicBaseUrl: urls.publicBaseUrl, stateWorkerUrl: urls.stateWorkerUrl },
     access: profile.access,
+    artifacts: profile.artifacts,
     bot: { script: profile.workers.bot.script }
   };
 }
@@ -7811,7 +7846,8 @@ var init_runEvents = __esm({
       "review_not_posted",
       "compacted",
       "harness_error",
-      "tool_refused"
+      "tool_refused",
+      "stuck_loop"
     ];
     ACTOR_ID_CHARS = "A-Za-z0-9:@._-";
     ACTOR_ID_MAX = 128;
@@ -8108,6 +8144,13 @@ var init_host3 = __esm({
 });
 
 // ../../src/execution/binaryRead.ts
+function statCommandFor(resolvedPath) {
+  return `stat -c %s -- ${resolvedPath}`;
+}
+function parseByteSize(stdout) {
+  const m = /^\s*(\d{1,15})\s*$/.exec(stdout);
+  return m ? Number(m[1]) : null;
+}
 function tooLargeMessage(path, bytes) {
   const size = bytes === void 0 ? "" : ` (${bytes} bytes)`;
   return `${path}${size} is over the ${MAX_READ_BYTES}-byte cap of a binary read`;
@@ -8731,9 +8774,9 @@ function sendDeadlineMs(budgetMs) {
   return budgetMs + EXEC_CALL_MARGIN_MS;
 }
 function noAnswerMessage(route3, budgetMs) {
-  const secs = (ms) => Math.round(ms / 1e3);
+  const secs2 = (ms) => Math.round(ms / 1e3);
   const exec = route3 === "/exec";
-  return `sandbox worker ${route3} gave no answer within ${secs(sendDeadlineMs(budgetMs))}s (${exec ? "command budget" : "budget"} ${secs(budgetMs)}s + ${secs(EXEC_CALL_MARGIN_MS)}s margin) \u2014 the sandbox may be gone; ${exec ? "the command may still be running in it" : "the operation may still have run in it"}`;
+  return `sandbox worker ${route3} gave no answer within ${secs2(sendDeadlineMs(budgetMs))}s (${exec ? "command budget" : "budget"} ${secs2(budgetMs)}s + ${secs2(EXEC_CALL_MARGIN_MS)}s margin) \u2014 the sandbox may be gone; ${exec ? "the command may still be running in it" : "the operation may still have run in it"}`;
 }
 function waitForSlot(ms, waitedMs, signal) {
   return new Promise((resolve12, reject) => {
@@ -8896,6 +8939,9 @@ ${parts}`);
 function residentText(text) {
   return redactAndCap(stripAnsi(text), RESIDENT_TEXT_CAP);
 }
+function residentErrorText(text) {
+  return redactAndCap(stripAnsi(text), RESIDENT_ERROR_CAP);
+}
 function sanitizeResidentBody(data) {
   return walk(data, SANITIZE_DEPTH);
 }
@@ -8905,7 +8951,7 @@ function walk(value, depth) {
   const src = value;
   const out = {};
   for (const [key, v] of Object.entries(src)) {
-    out[key] = SANITIZED_FIELDS.includes(key) && typeof v === "string" ? residentText(v) : walk(v, depth - 1);
+    out[key] = SANITIZED_FIELDS.includes(key) && typeof v === "string" ? key === "error" ? residentErrorText(v) : residentText(v) : walk(v, depth - 1);
   }
   if (typeof src.stderr === "string" && src.stderr === src.error && typeof out.error === "string") {
     out.stderr = out.error;
@@ -8915,12 +8961,13 @@ function walk(value, depth) {
 function residentState(value) {
   return typeof value === "string" && PROBE_STATES.has(value) ? value : "unknown";
 }
-var RESIDENT_TEXT_CAP, SANITIZED_FIELDS, SANITIZE_DEPTH, PROBE_STATES;
+var RESIDENT_TEXT_CAP, RESIDENT_ERROR_CAP, SANITIZED_FIELDS, SANITIZE_DEPTH, PROBE_STATES;
 var init_residentText = __esm({
   "../../src/execution/residentText.ts"() {
     "use strict";
     init_redact();
     RESIDENT_TEXT_CAP = 300;
+    RESIDENT_ERROR_CAP = 1e3;
     SANITIZED_FIELDS = ["error", "reason", "summary"];
     SANITIZE_DEPTH = 4;
     PROBE_STATES = /* @__PURE__ */ new Set([
@@ -10928,7 +10975,8 @@ function buildAnthropicParams(req) {
     ...req.system ? { system: [{ type: "text", text: req.system, cache_control: cache2 }] } : {},
     messages,
     ...effort2 ? { output_config: { effort: effort2 } } : {},
-    ...tools.length > 0 ? { tools } : {}
+    ...tools.length > 0 ? { tools } : {},
+    ...req.toolChoice ? { tool_choice: { type: "tool", name: req.toolChoice.name } } : {}
   };
 }
 function effortFor(model, effort2) {
@@ -12745,6 +12793,7 @@ function isCoordinatorUnit(v) {
   if (!isText(r.unit, 32) || !isText(r.slug) || !isText(r.branch) || !isOptionalText(r.title)) return false;
   if (!Array.isArray(r.dependsOn) || !r.dependsOn.every((d) => isText(d, 32))) return false;
   if (!isOptionalText(r.threadKey) || !isOptionalText(r.sourceUrl)) return false;
+  if (r.reviewThread !== void 0 && !isThread(r.reviewThread)) return false;
   if (r.issue !== void 0 && !isFinite(r.issue)) return false;
   if (r.pr !== void 0 && !isPr(r.pr)) return false;
   if (r.resume !== void 0 && !isResume(r.resume)) return false;
@@ -12755,7 +12804,7 @@ function isCoordinatorUnit(v) {
   if (r.startedAt !== void 0 && !isFinite(r.startedAt)) return false;
   return true;
 }
-var COORDINATOR_IDENTITY, COORDINATOR_STEP_ACTION, PLAN_MERGE_ACTION, COORDINATOR_STEP_PATH_PREFIX, INSTANCE_ID_PATTERN, STEP_NAME_PATTERN, IDEMPOTENCY_KEY_PATTERN, REPO_SLUG2, MAX_TEXT, MAX_REPORT, MAX_ROUNDS, isText, isOptionalText, isFinite, isObject2, isPr, isResume;
+var COORDINATOR_IDENTITY, COORDINATOR_STEP_ACTION, PLAN_MERGE_ACTION, COORDINATOR_STEP_PATH_PREFIX, INSTANCE_ID_PATTERN, STEP_NAME_PATTERN, IDEMPOTENCY_KEY_PATTERN, REPO_SLUG2, MAX_TEXT, MAX_REPORT, MAX_ROUNDS, isText, isOptionalText, isFinite, isObject2, isPr, isResume, isThread;
 var init_contract3 = __esm({
   "../../src/core/coordinator/contract.ts"() {
     "use strict";
@@ -12776,6 +12825,7 @@ var init_contract3 = __esm({
     isObject2 = (v) => typeof v === "object" && v !== null;
     isPr = (v) => isObject2(v) && isFinite(v.number) && isText(v.url, 2048);
     isResume = (v) => isObject2(v) && isFinite(v.pr) && (v.headSha === void 0 || isText(v.headSha)) && (v.url === void 0 || isText(v.url, 2048));
+    isThread = (v) => isObject2(v) && isText(v.threadKey) && isOptionalText(v.sourceUrl);
   }
 });
 
@@ -13288,7 +13338,7 @@ function analyzeRunFriction(events, opts = {}) {
     }
     if (ev.type === "tool_call") {
       toolCalls++;
-      if (failedCalls.has(`${ev.tool} ${ev.summary}`)) {
+      if (failedCalls.has(callSignature(ev.tool, ev.summary))) {
         findings.push({
           category: "retry",
           severity: "low",
@@ -13310,7 +13360,7 @@ function analyzeRunFriction(events, opts = {}) {
       const durationMs = span ? durationOfSpan(span) : void 0;
       const timed = (f) => durationMs !== void 0 ? { ...f, durationMs } : f;
       const interval = span && durationMs !== void 0 ? { interval: { start: span.startedAt, end: span.startedAt + durationMs } } : {};
-      if (!ev.ok) failedCalls.add(`${ev.tool} ${callSummary}`);
+      if (!ev.ok) failedCalls.add(callSignature(ev.tool, callSummary));
       if (ev.infra) {
         findings.push(
           timed({
@@ -13503,7 +13553,7 @@ function formatFrictionReport(d) {
   }
   return lines.join("\n");
 }
-var FRICTION_CATEGORIES, CATEGORY_LABEL, DENOMINATOR_OF, DEFAULT_SLOW_TOOL_MS, DEFAULT_SLOW_MODEL_TURN_MS, INSTALL_SEGMENT, QUOTED;
+var FRICTION_CATEGORIES, CATEGORY_LABEL, DENOMINATOR_OF, DEFAULT_SLOW_TOOL_MS, DEFAULT_SLOW_MODEL_TURN_MS, INSTALL_SEGMENT, QUOTED, callSignature;
 var init_runFriction = __esm({
   "../../src/core/runFriction.ts"() {
     "use strict";
@@ -13546,10 +13596,22 @@ var init_runFriction = __esm({
     DEFAULT_SLOW_MODEL_TURN_MS = 6e4;
     INSTALL_SEGMENT = /(?:^|&&|;|\|\|?)\s*(?:sudo\s+)?(?:corepack\s+)?(?:(?:npm|pnpm|bun)\s+(?:install|i|ci|add)(?=\s|$)|yarn(?:\s+(?:install|add)(?=\s|$)|\s*$)|npx\s+playwright\s+install(?=\s|$)|(?:python3?\s+-m\s+)?pip3?\s+install(?=\s|$)|poetry\s+install(?=\s|$)|uv\s+(?:sync|pip\s+install)(?=\s|$)|apt(?:-get)?\s+install(?=\s|$)|apk\s+add(?=\s|$)|brew\s+install(?=\s|$)|bundle\s+install(?=\s|$)|gem\s+install(?=\s|$)|cargo\s+(?:fetch|build)(?=\s|$)|go\s+mod\s+download(?=\s|$)|git\s+clone(?=\s|$)|make\s+(?:deps|install|setup)(?=\s|$))/;
     QUOTED = /"(?:[^"\\]|\\.)*"|'[^']*'/g;
+    callSignature = (tool, summary) => `${tool} ${summary}`;
   }
 });
 
 // ../../src/core/runRecord.ts
+function isRunSession(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const s = v;
+  if (typeof s.key !== "string" || !SESSION_KEY_PATTERN.test(s.key)) return false;
+  if (!isIndex(s.seedFrom) || !isIndex(s.request) || s.request < s.seedFrom) return false;
+  if (s.range === "broken") return true;
+  if (typeof s.range !== "object" || s.range === null) return false;
+  const range = s.range;
+  if (!isIndex(range.from) || range.from < s.seedFrom) return false;
+  return range.to === void 0 || isIndex(range.to) && range.to >= range.from;
+}
 function isRunProfileRecord(v) {
   if (typeof v !== "object" || v === null) return false;
   const p = v;
@@ -13628,7 +13690,12 @@ function clampRetentionPolicy(partial) {
     const [lo, hi] = RETENTION_BOUNDS[k];
     return Math.min(hi, Math.max(lo, n2));
   };
-  return { retentionDays: field("retentionDays"), maxRuns: field("maxRuns"), maxBytes: field("maxBytes") };
+  return {
+    retentionDays: field("retentionDays"),
+    maxRuns: field("maxRuns"),
+    maxBytes: field("maxBytes"),
+    sessionLogMaxBytes: field("sessionLogMaxBytes")
+  };
 }
 function isOptionalString(v) {
   return v === void 0 || typeof v === "string";
@@ -13694,6 +13761,8 @@ function isRunRecord(v) {
   if (r.profile !== void 0 && !isRunProfileRecord(r.profile)) return false;
   if (r.parentRunId !== void 0 && (typeof r.parentRunId !== "string" || !RUN_ID_PATTERN.test(r.parentRunId)))
     return false;
+  if (r.seed !== void 0 && !RUN_SEEDS.includes(r.seed)) return false;
+  if (r.session !== void 0 && !isRunSession(r.session)) return false;
   if (r.parentInstanceId === void 0 !== (r.idempotencyKey === void 0)) return false;
   if (r.parentInstanceId !== void 0 && (typeof r.parentInstanceId !== "string" || !INSTANCE_ID_PATTERN.test(r.parentInstanceId)))
     return false;
@@ -13825,7 +13894,7 @@ function dropSpanPairsFromTheMiddle(events, eventBudget) {
   }
   return events.filter((_, k) => !dropped.has(k));
 }
-var RUN_STATUSES, RUN_ID_PATTERN, REVIEW_HEAD_PATTERN, MACHINE_CLASSES_IN_RECORD, IDENTITIES_IN_RECORD, BOUNDARY_SCOPES_IN_RECORD, RUN_LIST_DEFAULT_LIMIT, RUN_LIST_MAX_LIMIT, RUN_EVENTS_DEFAULT_PAGE, RUN_EVENTS_MAX_PAGE, CHANNEL_VISIBILITIES2, KIB, MIB, GIB2, DEFAULT_RETENTION_POLICY, RETENTION_BOUNDS, MAX_RECORD_BYTES, MAX_EVENT_BYTES, ELLIPSIS, encoder;
+var RUN_STATUSES, RUN_ID_PATTERN, REVIEW_HEAD_PATTERN, RUN_SEEDS, SESSION_KEY_PATTERN, isIndex, MACHINE_CLASSES_IN_RECORD, IDENTITIES_IN_RECORD, BOUNDARY_SCOPES_IN_RECORD, RUN_LIST_DEFAULT_LIMIT, RUN_LIST_MAX_LIMIT, RUN_EVENTS_DEFAULT_PAGE, RUN_EVENTS_MAX_PAGE, CHANNEL_VISIBILITIES2, KIB, MIB, GIB2, DEFAULT_RETENTION_POLICY, RETENTION_BOUNDS, MAX_RECORD_BYTES, MAX_EVENT_BYTES, ELLIPSIS, encoder;
 var init_runRecord = __esm({
   "../../src/core/runRecord.ts"() {
     "use strict";
@@ -13837,6 +13906,9 @@ var init_runRecord = __esm({
     RUN_STATUSES = ["completed", "stopped_soft", "stopped_hard", "failed", "interrupted"];
     RUN_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
     REVIEW_HEAD_PATTERN = /^[0-9a-f]{7,40}$/;
+    RUN_SEEDS = ["channel", "parent"];
+    SESSION_KEY_PATTERN = /^[A-Za-z0-9_.:@+/-]{1,512}$/;
+    isIndex = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
     MACHINE_CLASSES_IN_RECORD = {
       none: true,
       blank: true,
@@ -13862,12 +13934,14 @@ var init_runRecord = __esm({
     DEFAULT_RETENTION_POLICY = {
       retentionDays: 30,
       maxRuns: 5e3,
-      maxBytes: 2 * GIB2
+      maxBytes: 2 * GIB2,
+      sessionLogMaxBytes: 200 * MIB
     };
     RETENTION_BOUNDS = {
       retentionDays: [1, 365],
       maxRuns: [1, 2e4],
-      maxBytes: [16 * MIB, 8 * GIB2]
+      maxBytes: [16 * MIB, 8 * GIB2],
+      sessionLogMaxBytes: [16 * MIB, 2 * GIB2]
     };
     MAX_RECORD_BYTES = 1.5 * MIB;
     MAX_EVENT_BYTES = 64 * KIB;
@@ -19896,7 +19970,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 describe9 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+  const describe11 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   let listing;
   const liveRows = () => {
     if (!ledger) return null;
@@ -19916,7 +19990,7 @@ function createRunsService(deps) {
     try {
       rows = await pending2;
     } catch (err2) {
-      warn(`[runs] run ledger list failed \u2014 showing this process's runs only: ${describe9(err2)}`);
+      warn(`[runs] run ledger list failed \u2014 showing this process's runs only: ${describe11(err2)}`);
       return [];
     }
     const foreign = rows.filter((row) => !registry.getById(row.runId));
@@ -19926,7 +20000,7 @@ function createRunsService(deps) {
         try {
           events = await ledger.readEvents(row.runId);
         } catch (err2) {
-          warn(`[runs] run ledger events read failed for ${row.runId}: ${describe9(err2)}`);
+          warn(`[runs] run ledger events read failed for ${row.runId}: ${describe11(err2)}`);
         }
         return ledgerView(row, events);
       })
@@ -19940,7 +20014,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}: ${describe9(err2)}`);
+      warn(`[runs] run ledger read failed for ${id}: ${describe11(err2)}`);
       return null;
     }
   };
@@ -19958,7 +20032,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: ${describe9(err2)}`
+        `[runs] history store read failed for ${id} \u2014 serving the registry row without its record: ${describe11(err2)}`
       );
       return {};
     }
@@ -20127,7 +20201,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}: ${describe9(err2)}`);
+          warn(`[runs] run ledger stop failed for ${id}: ${describe11(err2)}`);
         }
       }
       return await storeSummary(id) ? conflict : notFound;
@@ -21502,6 +21576,11 @@ function liveViewLink(id, token2) {
   if (!base) return void 0;
   return `${base.replace(/\/+$/, "")}/runs/${encodeURIComponent(id)}?t=${encodeURIComponent(token2)}`;
 }
+function runPageLink(id) {
+  const base = process.env.PUBLIC_BASE_URL?.trim();
+  if (!base) return void 0;
+  return `${base.replace(/\/+$/, "")}/runs/${encodeURIComponent(id)}`;
+}
 function stripPlatformPrefix(id) {
   const i = id.indexOf(":");
   return i === -1 ? id : id.slice(i + 1);
@@ -21748,7 +21827,11 @@ function durableInboxMessage(msg, text, at, from) {
     ...msg.userName !== void 0 ? { userName: msg.userName } : {},
     ...msg.sourceUrl !== void 0 ? { sourceUrl: msg.sourceUrl } : {},
     ...msg.channelName !== void 0 ? { channelName: msg.channelName } : {},
-    ...from !== void 0 ? { fromRunId: from.runId } : {}
+    ...from !== void 0 ? { fromRunId: from.runId } : {},
+    // Staged references are metadata (record 0033) — a few hundred bytes each —
+    // so they ride the base row and survive the restart whatever the
+    // attachments below do.
+    ...msg.staged && msg.staged.length > 0 ? { staged: msg.staged.map(stagedRow) } : {}
   };
   const images = msg.images ?? [];
   const documents = msg.documents ?? [];
@@ -21761,6 +21844,17 @@ function durableInboxMessage(msg, text, at, from) {
   if (Buffer.byteLength(JSON.stringify(withAttachments), "utf8") <= DURABLE_INBOX_MAX_BYTES) return withAttachments;
   return { ...base, attachmentsDropped: { images: images.length, documents: documents.length } };
 }
+function stagedFromInbox(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = v.flatMap((e) => {
+    if (typeof e !== "object" || e === null) return [];
+    const r = e;
+    if (typeof r.name !== "string" || typeof r.size !== "number" || typeof r.type !== "string" || typeof r.url !== "string" || typeof r.messageId !== "string")
+      return [];
+    return [{ name: r.name, size: r.size, type: r.type, url: r.url, messageId: r.messageId }];
+  });
+  return out.length > 0 ? out : void 0;
+}
 function messageFromInbox(stored, fallbackAt) {
   const m = stored;
   const str7 = (k) => typeof m[k] === "string" ? m[k] : void 0;
@@ -21777,6 +21871,7 @@ function messageFromInbox(stored, fallbackAt) {
   const at = typeof m.at === "number" && Number.isFinite(m.at) ? m.at : fallbackAt;
   const images = attachmentsFromInbox(m.images);
   const documents = attachmentsFromInbox(m.documents);
+  const staged = stagedFromInbox(m.staged);
   const note = droppedNote(m.attachmentsDropped);
   const msg = {
     channelId,
@@ -21789,7 +21884,8 @@ ${note}` : text,
     ...sourceUrl !== void 0 ? { sourceUrl } : {},
     ...channelName !== void 0 ? { channelName } : {},
     ...images ? { images } : {},
-    ...documents ? { documents } : {}
+    ...documents ? { documents } : {},
+    ...staged ? { staged } : {}
   };
   return { msg, at, ...fromRunId !== void 0 ? { from: { runId: fromRunId } } : {} };
 }
@@ -21810,7 +21906,7 @@ function droppedNote(dropped) {
   if (n2 <= 0) return void 0;
   return `(${n2} attachment${n2 === 1 ? "" : "s"} from this reply could not be carried across the bot's restart and ${n2 === 1 ? "is" : "are"} not attached.)`;
 }
-var DURABLE_INBOX_MAX_BYTES, attachmentRow;
+var DURABLE_INBOX_MAX_BYTES, attachmentRow, stagedRow;
 var init_inboxMessage = __esm({
   "../../src/core/runLedger/inboxMessage.ts"() {
     "use strict";
@@ -21820,6 +21916,7 @@ var init_inboxMessage = __esm({
       data: a.data,
       ...a.name !== void 0 ? { name: a.name } : {}
     });
+    stagedRow = (s) => ({ name: s.name, size: s.size, type: s.type, url: s.url, messageId: s.messageId });
   }
 });
 
@@ -21851,13 +21948,15 @@ function mergeFollowUps(inputs) {
   const last = inputs[inputs.length - 1];
   const images = inputs.flatMap((i) => i.images ?? []);
   const documents = inputs.flatMap((i) => i.documents ?? []);
+  const staged = inputs.flatMap((i) => i.staged ?? []);
   return {
     text: inputs.map((i) => i.text).join("\n\n"),
     userId: last.userId,
     ...last.userName !== void 0 ? { userName: last.userName } : {},
     ...last.sourceUrl !== void 0 ? { sourceUrl: last.sourceUrl } : {},
     ...images.length > 0 ? { images } : {},
-    ...documents.length > 0 ? { documents } : {}
+    ...documents.length > 0 ? { documents } : {},
+    ...staged.length > 0 ? { staged } : {}
   };
 }
 var FollowUpInbox, ThreadAdmission, elapsed, linkSuffix, followUpHeader, supersededHeader;
@@ -21969,6 +22068,7 @@ function interruptedRunRecord(summary, snap, finishedAt) {
     channelVisibility: summary.channelVisibility ?? "unknown",
     repo: summary.repo,
     ...summary.parentRunId !== void 0 ? { parentRunId: summary.parentRunId } : {},
+    ...summary.seed !== void 0 ? { seed: summary.seed } : {},
     ...summary.parentInstanceId !== void 0 && summary.idempotencyKey !== void 0 ? { coordinator: { parentInstanceId: summary.parentInstanceId, idempotencyKey: summary.idempotencyKey } } : {},
     finishedAt,
     status: "interrupted",
@@ -22004,6 +22104,10 @@ function reclaimedRunRecord(input) {
     // included); a row from before profiles existed leaves the record without one.
     ...row.meta.profile && row.meta.agent ? { profile: { preset: row.meta.agent, ...row.meta.profile } } : {},
     ...row.meta.parentRunId !== void 0 ? { parentRunId: row.meta.parentRunId } : {},
+    ...row.meta.seed !== void 0 ? { seed: row.meta.seed } : {},
+    // The row's place in its session log (item 53): the range stays open on a
+    // record closed here, since the closer has no turn count to end it with.
+    ...row.meta.session !== void 0 ? { session: row.meta.session } : {},
     // A coordinator's child keeps its instance and key on the close (item 48),
     // so the state Worker's finish still sends the parent its event.
     ...row.meta.parentInstanceId !== void 0 && row.meta.idempotencyKey !== void 0 ? { coordinator: { parentInstanceId: row.meta.parentInstanceId, idempotencyKey: row.meta.idempotencyKey } } : {},
@@ -22072,7 +22176,9 @@ function assembleRunRecord(input) {
     ...input.reviewPost !== void 0 ? { reviewPost: redactReviewPost(input.reviewPost) } : {},
     ...input.profile !== void 0 ? { profile: input.profile } : {},
     ...input.parentRunId !== void 0 ? { parentRunId: input.parentRunId } : {},
-    ...coordinatorFields(input.coordinator)
+    ...coordinatorFields(input.coordinator),
+    ...input.seed !== void 0 ? { seed: input.seed } : {},
+    ...input.session !== void 0 ? { session: input.session } : {}
   });
   return fitted.eventCount !== fitted.storedEventCount ? { ...fitted, truncated: true } : fitted;
 }
@@ -22080,7 +22186,20 @@ function profileRecordOf(agent, profile) {
   return { preset: agent.name, ...profile };
 }
 function writeTombstone(deps, ctx) {
-  const { msg, agent, profile, resolved, repoCtx, channelVisibility, run: run2, registry, resume, parentRunId, coordinator } = ctx;
+  const {
+    msg,
+    agent,
+    profile,
+    resolved,
+    repoCtx,
+    channelVisibility,
+    run: run2,
+    registry,
+    resume,
+    parentRunId,
+    coordinator,
+    seed
+  } = ctx;
   if (!resume) {
     const startSnap = registry.snapshot(run2.id, run2.token);
     if (startSnap) {
@@ -22096,6 +22215,7 @@ function writeTombstone(deps, ctx) {
           profile: profileRecordOf(agent, profile),
           ...parentRunId !== void 0 ? { parentRunId } : {},
           ...coordinator !== void 0 ? { coordinator } : {},
+          ...seed !== void 0 ? { seed } : {},
           finishedAt: startSnap.startedAt,
           status: "interrupted",
           diagnosis: analyzeRunFriction(startSnap.events, {
@@ -22130,7 +22250,8 @@ function registerFinishRecord(deps, ctx) {
     dispositions,
     reviewPost,
     parentRunId,
-    coordinator
+    coordinator,
+    seed
   } = ctx;
   ending.register({
     runId: run2.id,
@@ -22155,7 +22276,8 @@ function registerFinishRecord(deps, ctx) {
         ...dispositions !== void 0 ? { dispositions } : {},
         ...reviewPost !== void 0 ? { reviewPost } : {},
         ...parentRunId !== void 0 ? { parentRunId } : {},
-        ...coordinator !== void 0 ? { coordinator } : {}
+        ...coordinator !== void 0 ? { coordinator } : {},
+        ...seed !== void 0 ? { seed } : {}
       }),
       { span: root, ...ledgerRun ? { via: ledgerRun.sink } : {} }
     )
@@ -22188,6 +22310,7 @@ function followUpOf(msg, text, at, opts) {
     ...msg.sourceUrl !== void 0 ? { sourceUrl: msg.sourceUrl } : {},
     ...msg.images !== void 0 ? { images: msg.images } : {},
     ...msg.documents !== void 0 ? { documents: msg.documents } : {},
+    ...msg.staged !== void 0 ? { staged: msg.staged } : {},
     at,
     ...opts.ledgerSeq !== void 0 ? { ledgerSeq: opts.ledgerSeq } : {},
     ...opts.from !== void 0 ? { from: opts.from } : {},
@@ -22253,7 +22376,9 @@ async function admit(deps, ctx) {
       threadKey: msg.threadKey,
       state: resume.row.state,
       lastStep: resume.lastStep.step,
-      lastSeq: resume.lastSeq
+      lastSeq: resume.lastSeq,
+      // The row's place in its session log, so the resumed run appends where it left off.
+      ...resume.row.meta.session ? { session: resume.row.meta.session } : {}
     });
     await root.span(
       "dispatch.admission",
@@ -22403,6 +22528,8 @@ async function adoptCarriedRun(deps, ctx) {
       state: resume.row.state,
       lastStep: resume.lastStep.step,
       lastSeq: resume.lastSeq,
+      // The row's place in its session log, so the resumed run appends where it left off.
+      ...resume.row.meta.session ? { session: resume.row.meta.session } : {},
       ...ctx.hooks.adopt
     });
   }
@@ -23353,6 +23480,7 @@ function summaryOf(run2) {
     ...m?.parentRunId !== void 0 ? { parentRunId: m.parentRunId } : {},
     ...m?.parentInstanceId !== void 0 ? { parentInstanceId: m.parentInstanceId } : {},
     ...m?.idempotencyKey !== void 0 ? { idempotencyKey: m.idempotencyKey } : {},
+    ...m?.seed !== void 0 ? { seed: m.seed } : {},
     finished: run2.finished,
     startedAt: run2.startedAt,
     ...run2.finishedAt !== void 0 ? { finishedAt: run2.finishedAt } : {},
@@ -24254,6 +24382,21 @@ var init_awaitChildren = __esm({
   }
 });
 
+// ../../src/core/dispatch/textTurns.ts
+function textTurnsOf(messages) {
+  const turns = [];
+  for (const m of messages) {
+    const text = m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n\n");
+    if (text.length > 0) turns.push({ role: m.role, text });
+  }
+  return turns;
+}
+var init_textTurns = __esm({
+  "../../src/core/dispatch/textTurns.ts"() {
+    "use strict";
+  }
+});
+
 // ../../src/core/dispatch/spawn.ts
 function maxChildrenOf(cfg) {
   return cfg?.maxChildren ?? DEFAULT_MAX_CHILDREN;
@@ -24290,6 +24433,7 @@ function watchedChild(io, on) {
   };
   if (io.attach) watched2.attach = (file) => io.attach(file);
   if (io.attachFile) watched2.attachFile = (file) => io.attachFile(file);
+  if (io.uploadTicket) watched2.uploadTicket = (file) => io.uploadTicket(file);
   if (io.runFinished) watched2.runFinished = (receipt) => io.runFinished(receipt);
   if (io.openThread) watched2.openThread = (lead) => io.openThread(lead);
   return watched2;
@@ -24302,6 +24446,12 @@ async function spawnChild(deps, parent, request) {
       `a child run cannot spawn: this run is itself a child, and a tree is ${MAX_SPAWN_DEPTH} level deep \u2014 the run that started it is the one to ask`
     );
   }
+  if (AGENTS[request.preset]?.identity === "write") {
+    return refused5(
+      "spawn_identity",
+      `\`${request.preset}\` runs as a \`write\` identity \u2014 it pushes branches and opens pull requests \u2014 and a spawned child never writes: it reads this conversation and reports; the person who asked starts that work by hand with \`agent:${request.preset}\``
+    );
+  }
   const minutesLeft = Math.floor(parent.remainingMs / 6e4);
   if (minutesLeft < MIN_BOUNDARY_MINUTES) {
     return refused5(
@@ -24354,8 +24504,10 @@ async function spawnChild(deps, parent, request) {
       lastReply = text;
     }
   });
+  const seed = parent.conversation ? textTurnsOf(parent.conversation) : void 0;
   const settled = deps.dispatch(deps.core, child, io, {
-    parent: { runId: parent.runId, depth: parent.depth + 1, remainingMs: parent.remainingMs }
+    parent: { runId: parent.runId, depth: parent.depth + 1, remainingMs: parent.remainingMs },
+    ...seed ? { seed } : {}
   }).then(
     (outcome) => ({ kind: "ended", outcome }),
     (err2) => ({ kind: "threw", err: err2 })
@@ -24396,8 +24548,8 @@ function spawnCapabilityFor(deps, parent) {
   };
   let previous = Promise.resolve();
   return {
-    spawn: (request, remainingMs) => {
-      const turn = previous.then(() => spawnChild(withHook, { ...parent, remainingMs }, request));
+    spawn: (request, at) => {
+      const turn = previous.then(() => spawnChild(withHook, { ...parent, ...at }, request));
       previous = turn.catch(() => {
       });
       return turn;
@@ -24441,11 +24593,13 @@ var DEFAULT_MAX_CHILDREN, MAX_SPAWN_DEPTH, describe2, nullSpawnCapability;
 var init_spawn = __esm({
   "../../src/core/dispatch/spawn.ts"() {
     "use strict";
+    init_registry();
     init_validate();
     init_actor();
     init_runsService();
     init_admission();
     init_awaitChildren();
+    init_textTurns();
     DEFAULT_MAX_CHILDREN = 3;
     MAX_SPAWN_DEPTH = 1;
     describe2 = (err2) => err2 instanceof Error ? err2.message : String(err2);
@@ -24470,12 +24624,61 @@ function routablePresets() {
     maxMinutes
   }));
 }
+function partPresets(presets) {
+  return presets.filter((p) => p.identity !== "write");
+}
+function nameList(names) {
+  return names.length <= 1 ? names.join("") : `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+}
 function renderPresetTable(presets) {
   const rows = presets.map(
     (p) => `| \`${p.name}\` | ${oneLine(p.description)} | ${p.machine} | ${p.identity} | ${p.maxMinutes} min |`
   );
   return ["| name | what it does | machine | credential | budget |", "|---|---|---|---|---|", ...rows].join("\n");
 }
+function routeMaxOutputTokens(compound) {
+  const PART_JSON_OVERHEAD = 40;
+  const ANSWER_JSON_OVERHEAD = 80;
+  const chars = ANSWER_JSON_OVERHEAD + ROUTE_REASON_CAP + (compound ? compound.maxParts * (ROUTE_PART_TEXT_CAP + PART_JSON_OVERHEAD) : 0);
+  return Math.max(ROUTE_MIN_OUTPUT_TOKENS, Math.ceil(chars / 3));
+}
+function routeTool(presets, compound) {
+  const names = presets.map((p) => p.name);
+  const readers = partPresets(presets).map((p) => p.name);
+  const writers = presets.filter((p) => p.identity === "write").map((p) => p.name);
+  const table = presets.map((p) => `${p.name}: ${oneLine(p.description)}`).join("; ");
+  const writeAsk = writers.length > 0 ? ` An ask that needs ${nameList(writers)} is never a part: when any part would need it, omit parts and answer ${nameList(writers)} for the whole request.` : "";
+  const properties = {
+    preset: {
+      type: "string",
+      enum: compound ? [...names, COMPOUND_PRESET] : names,
+      description: `the least capable preset whose description covers the request \u2014 ${table}${compound ? `; ${COMPOUND_PRESET}: only for a compound request, with parts` : ""}`
+    },
+    reason: { type: "string", description: "one line, under 100 characters: why this preset" },
+    ...compound ? {
+      parts: {
+        type: "array",
+        description: `only when the request has two or more INDEPENDENT asks on different subjects, each rewritten so it stands alone and each on a read-only preset (${nameList(readers)}), with preset "${COMPOUND_PRESET}".${writeAsk} A single ask with several steps is one request on one preset: omit parts and name that preset. When one ask is in doubt, omit parts.`,
+        minItems: 2,
+        maxItems: compound.maxParts,
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["preset", "text"],
+          properties: {
+            preset: { type: "string", enum: readers, description: "the read-only preset this part runs on" },
+            text: { type: "string", description: "the part as a request of its own" }
+          }
+        }
+      }
+    } : {}
+  };
+  return {
+    name: ROUTE_TOOL_NAME,
+    description: "Route the request: name the preset it runs on and why.",
+    inputSchema: { type: "object", additionalProperties: false, required: ["preset", "reason"], properties }
+  };
+}
 function quoteRequest(text) {
   const bent = text.replace(/<(\/?)request>/gi, "\u2039$1request\u203A");
   if (bent.length <= ROUTE_TEXT_CAP) return bent;
@@ -24500,7 +24703,7 @@ function buildRoutePrompt(input) {
     "",
     "Presets you may pick:",
     renderPresetTable(input.presets),
-    ...input.compound ? ["", ...compoundRules(input.compound)] : []
+    ...input.compound ? ["", ...compoundRules(input.compound, input.presets)] : []
   ].join("\n");
   const user = [
     `Earlier directives in this thread: ${directivesLine(input.recentDirectives)}`,
@@ -24509,18 +24712,25 @@ function buildRoutePrompt(input) {
     quoteRequest(input.text),
     "</request>"
   ].join("\n");
-  return { system, user };
+  return { system, user, tool: routeTool(input.presets, input.compound) };
 }
-function compoundRules(offer) {
+function compoundRules(offer, presets) {
+  const readers = partPresets(presets).map((p) => p.name);
+  const writers = presets.filter((p) => p.identity === "write").map((p) => `\`${p.name}\``);
   return [
     "Compound requests: when the request has two or more INDEPENDENT parts \u2014 neither part needs the other's result, and each would stand alone as a request of its own \u2014 answer this form instead, and only then:",
-    `{"preset": "${COMPOUND_PRESET}", "parts": [{"text": "<one part, rewritten so it stands alone>", "preset": "<a name from the table>"}, \u2026], "reason": "<one line: why the parts are independent>"}`,
-    `Independent means neither part needs the other's result. A single ask with several steps ("clone it, run the tests, tell me what fails") is NOT compound: it is one request on one preset, however many steps it takes. Two asks on two different subjects ("summarize what is in the docs folder, and run the lint on main in a sandbox") ARE compound even when both are read-only or would land on the same preset \u2014 the same preset may appear twice. When one ask is in doubt, do not split it. At most ${offer.maxParts} parts; each part's preset comes from the table above, chosen for that part alone by the same rules as a single request \u2014 least capable first.`
+    `{"preset": "${COMPOUND_PRESET}", "parts": [{"text": "<one part, rewritten so it stands alone>", "preset": "<one of ${readers.join(", ")}>"}, \u2026], "reason": "<one line: why the parts are independent>"}`,
+    `Independent means neither part needs the other's result. A single ask with several steps ("clone it, run the tests, tell me what fails") is NOT compound: it is one request on one preset, however many steps it takes. Two asks on two different subjects ("summarize what is in the docs folder, and run the lint on main in a sandbox") ARE compound even when both are read-only or would land on the same preset \u2014 the same preset may appear twice. When one ask is in doubt, do not split it. At most ${offer.maxParts} parts. Each part runs as a child that only reads, so each part's preset is one of ${readers.map((r) => `\`${r}\``).join(", ")} (the rows above whose credential is none or read), chosen for that part alone by the same rules as a single request \u2014 least capable first.`,
+    ...writers.length > 0 ? [writeAskRule(writers)] : []
   ];
 }
+function writeAskRule(writers) {
+  const names = writers.join(" or ");
+  return `An ask that needs ${names} is never a part: a part runs as a child that only reads, and ${names} pushes. When any part of the request would need ${names}, do not split it: answer ${names} alone for the whole request as typed, and it reads what it must before it changes anything ("review PR 7 and fix what it finds" is one ${names} request; "research X and open a PR for Y" is one ${names} request).`;
+}
 function imperativeRule(writers) {
   const names = writers.map((w) => `\`${w}\``).join(" or ");
-  return `Short imperatives: one terse order to change something or to make a failure go away \u2014 "fix it", "make it pass", "make the tests green", "add X", "rename Y", "bump Z" \u2014 is a request to change code even when it names no file, repository or cause: the channel or thread it arrives in is bound to a repository, and the preset that implements changes finds the failure itself. For it, answer ${names}. A question or a read-only ask about the same failure \u2014 "why did ci fail?", "check whether ci is red", "tell me why the build failed", "list the failing tests" \u2014 changes nothing: answer a read-only preset that covers it, never ${names}. An ask to look at, check or judge a pull request is a review, not an order to change it.`;
+  return `Short imperatives: one terse order to change something or to make a failure go away \u2014 "fix it", "make it pass", "make the tests green", "add X", "rename Y", "bump Z" \u2014 is a request to change code even when it names no file, repository or cause: the channel or thread it arrives in is bound to a repository, and the preset that implements changes finds the failure itself. For it, answer ${names}. A question or a read-only ask about the same failure \u2014 "why did ci fail?", "check whether ci is red", "tell me why the build failed", "list the failing tests" \u2014 changes nothing: answer a read-only preset that covers it, never ${names}. An ask to look at, check or judge a pull request \u2014 named by a link or a number, or the thread's own ("this PR") \u2014 is a review, not an order to change it; a question about a failure with no pull request in view is not a review.`;
 }
 function tidyReason(reason) {
   const line3 = oneLine(redactAndCap(reason, ROUTE_REASON_CAP));
@@ -24537,8 +24747,10 @@ function parseRouteAnswer(raw, allowed2, compound) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
     return { preset: void 0, reason: `not a single JSON object: ${tidyReason(trimmed)}` };
   const { preset, reason, parts } = parsed;
-  if (typeof preset !== "string") return { preset: void 0, reason: "missing preset in the router's answer" };
-  if (typeof reason !== "string") return { preset: void 0, reason: "missing reason in the router's answer" };
+  if (typeof preset !== "string")
+    return { preset: void 0, reason: `missing preset in the router's answer: ${tidyReason(trimmed)}` };
+  if (typeof reason !== "string")
+    return { preset: void 0, reason: `missing reason in the router's answer: ${tidyReason(trimmed)}` };
   if (preset === COMPOUND_PRESET) return parseCompound(parts, tidyReason(reason), allowed2, compound);
   if (!allowed2.includes(preset))
     return { preset: void 0, reason: `router said "${tidyReason(preset)}", not a preset the requester may run` };
@@ -24567,16 +24779,20 @@ function parseCompound(parts, reason, allowed2, offer) {
     if (tidy.length === 0) return rejected(`part ${n2} has no text`);
     out.push({ preset, text: tidy });
   }
+  const writer = out.find((p) => identityOf(p.preset) === "write");
+  if (writer) return { preset: writer.preset, reason, collapsed: { presets: out.map((p) => p.preset) } };
   return { preset: COMPOUND_PRESET, reason, parts: out };
 }
 async function route(input, model, opts = {}) {
-  const offered = input.presets.filter((p) => input.allowed.includes(p.name));
+  const { compound: offer, ...rest } = input;
+  const offered = rest.presets.filter((p) => rest.allowed.includes(p.name));
   if (offered.length === 0) return { preset: void 0, reason: "no preset the requester may run" };
-  const prompt = buildRoutePrompt({ ...input, presets: offered });
+  const compound = offer && partPresets(offered).length > 0 ? offer : void 0;
+  const prompt = buildRoutePrompt({ ...rest, presets: offered, ...compound ? { compound } : {} });
   let raw;
   try {
     raw = await model(prompt, {
-      maxTokens: ROUTE_MAX_OUTPUT_TOKENS,
+      maxTokens: routeMaxOutputTokens(compound),
       signal: AbortSignal.timeout(opts.timeoutMs ?? ROUTE_TIMEOUT_MS)
     });
   } catch (err2) {
@@ -24588,18 +24804,25 @@ async function route(input, model, opts = {}) {
   return parseRouteAnswer(
     raw,
     offered.map((p) => p.name),
-    input.compound
+    compound
   );
 }
-function providerRouteModel(provider, model) {
-  return async (prompt, opts) => {
+function providerRouteModel(provider, model, opts = {}) {
+  const forced = (opts.answer ?? "tool") === "tool";
+  return async (prompt, call2) => {
     const result = await provider.complete({
       model,
       system: prompt.system,
       messages: [{ role: "user", content: [{ type: "text", text: prompt.user }] }],
-      maxTokens: opts.maxTokens,
-      signal: opts.signal
+      maxTokens: call2.maxTokens,
+      signal: call2.signal,
+      ...forced ? { tools: [prompt.tool], toolChoice: { type: "tool", name: prompt.tool.name } } : {}
     });
+    if (result.stopReason === "max_tokens") throw new Error(`answer cut at the output cap (${call2.maxTokens} tokens)`);
+    const answer = result.content.find(
+      (p) => p.type === "tool_use" && p.name === prompt.tool.name
+    );
+    if (answer) return JSON.stringify(answer.input);
     return result.content.filter((p) => p.type === "text").map((p) => p.text).join("");
   };
 }
@@ -24617,7 +24840,9 @@ async function routeRequest(deps, ctx) {
     if (deps.routeModel) model = deps.routeModel;
     else {
       const ref = parseModelRef(modelRef2);
-      model = providerRouteModel(deps.providers.get(ref.provider), ref.model);
+      model = providerRouteModel(deps.providers.get(ref.provider), ref.model, {
+        ...cfg.routing?.answer ? { answer: cfg.routing.answer } : {}
+      });
     }
   } catch (err2) {
     console.log(`[route] ${msg.threadKey} not routed: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -24653,18 +24878,24 @@ async function routeRequest(deps, ctx) {
       effort: directives.effort ?? sticky.effort
     }
   });
-  const parts = decision.parts;
+  const { parts, collapsed } = decision;
   console.log(
-    `[route] ${msg.threadKey} routed to ${decision.preset} on ${modelRef2}${parts ? ` (${parts.length} parts)` : ""}: ${decision.reason}`
+    `[route] ${msg.threadKey} routed to ${decision.preset} on ${modelRef2}${parts ? ` (${parts.length} parts)` : ""}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}: ${decision.reason}`
   );
   return {
     kind: "routed",
     resolved,
-    route: { preset: decision.preset, reason: decision.reason, model: modelRef2, ...parts ? { parts } : {} }
+    route: {
+      preset: decision.preset,
+      reason: decision.reason,
+      model: modelRef2,
+      ...parts ? { parts } : {},
+      ...collapsed ? { collapsed } : {}
+    }
   };
 }
-function routedLabel(reason) {
-  return `routed: ${reason}`;
+function routedLabel(reason, collapsed) {
+  return `routed: ${reason}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}`;
 }
 function routedPartLines(parts) {
   return parts.map((p) => {
@@ -24680,7 +24911,7 @@ function compoundBrief(text, parts) {
     ...parts.map((p, i) => `${i + 1}. \`${p.preset}\`: ${p.text}`)
   ].join("\n");
 }
-var ROUTE_TEXT_CAP, ROUTE_REASON_CAP, ROUTE_MAX_OUTPUT_TOKENS, ROUTE_TIMEOUT_MS, ROUTE_PART_TEXT_CAP, ROUTE_PART_LINE_CAP, COMPOUND_BRIEF_HEADING, ROUTED_CARD_FOOTER;
+var ROUTE_TEXT_CAP, ROUTE_REASON_CAP, ROUTE_MIN_OUTPUT_TOKENS, ROUTE_TOOL_NAME, ROUTE_TIMEOUT_MS, ROUTE_PART_TEXT_CAP, ROUTE_PART_LINE_CAP, COMPOUND_BRIEF_HEADING, identityOf, ROUTED_CARD_FOOTER;
 var init_route = __esm({
   "../../src/core/dispatch/route.ts"() {
     "use strict";
@@ -24691,11 +24922,13 @@ var init_route = __esm({
     init_spawn();
     ROUTE_TEXT_CAP = 2e3;
     ROUTE_REASON_CAP = 120;
-    ROUTE_MAX_OUTPUT_TOKENS = 200;
+    ROUTE_MIN_OUTPUT_TOKENS = 200;
+    ROUTE_TOOL_NAME = "route";
     ROUTE_TIMEOUT_MS = 8e3;
     ROUTE_PART_TEXT_CAP = 1e3;
     ROUTE_PART_LINE_CAP = 100;
     COMPOUND_BRIEF_HEADING = "Routed as a compound request";
+    identityOf = (preset) => AGENTS[preset]?.identity;
     ROUTED_CARD_FOOTER = "reply agent:<preset> to run it another way";
   }
 });
@@ -25723,19 +25956,162 @@ ${skill.body}${footer}`;
   }
 });
 
+// ../../src/artifacts/contentType.ts
+function contentTypeFor(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot < 0 || dot === name.length - 1) return OCTET_STREAM;
+  return BY_EXTENSION[name.slice(dot + 1).toLowerCase()] ?? OCTET_STREAM;
+}
+var BY_EXTENSION, OCTET_STREAM, INLINE_IMAGE_TYPES;
+var init_contentType = __esm({
+  "../../src/artifacts/contentType.ts"() {
+    "use strict";
+    BY_EXTENSION = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      pdf: "application/pdf",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      mov: "video/quicktime",
+      mp3: "audio/mpeg",
+      wav: "audio/wav",
+      txt: "text/plain",
+      md: "text/markdown",
+      csv: "text/csv",
+      json: "application/json",
+      html: "text/html",
+      zip: "application/zip",
+      gz: "application/gzip",
+      tar: "application/x-tar"
+    };
+    OCTET_STREAM = "application/octet-stream";
+    INLINE_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+  }
+});
+
+// ../../src/artifacts/keys.ts
+function safeBasename(name) {
+  const segments2 = name.split(/[\\/]+/).filter((s) => s.length > 0);
+  const last = segments2[segments2.length - 1] ?? "";
+  const reduced = last.replace(SAFE, "_").replace(/\.{2,}/g, "_").replace(/_+/g, "_");
+  if (reduced === "" || /^[._-]+$/.test(reduced)) return "file";
+  return reduced;
+}
+function threadKeySafe(threadKey) {
+  return threadKey.replace(/:/g, "-").replace(SAFE, "_");
+}
+function outboundKey(runId3, seq, name) {
+  return `runs/${runId3}/out/${seq}-${safeBasename(name)}`;
+}
+function inboundKey(threadKey, messageTs, index, name) {
+  return `threads/${threadKeySafe(threadKey)}/in/${messageTs}/${index}-${safeBasename(name)}`;
+}
+var SAFE;
+var init_keys = __esm({
+  "../../src/artifacts/keys.ts"() {
+    "use strict";
+    SAFE = /[^A-Za-z0-9._-]+/g;
+  }
+});
+
 // ../../src/tools/attach.ts
+function transferBudgetMs(size) {
+  return Math.ceil(size / TRANSFER_FLOOR_BYTES_PER_MS) + TRANSFER_SETUP_MS;
+}
 function fileNameOf2(path) {
   const segments2 = path.split("/").filter(Boolean);
   return segments2[segments2.length - 1] ?? path;
 }
-var attachFileTool;
+function putCommandFor(path, contentType, url) {
+  return `curl -fsS -T ${shellQuote(path)} -H ${shellQuote(`Content-Type: ${contentType}`)} ${shellQuote(url)}`;
+}
+function postCommandFor(path, url) {
+  return `curl -fsS --data-binary @${shellQuote(path)} ${shellQuote(url)}`;
+}
+async function attachThroughStore(path, name, lead, artifacts, ctx) {
+  const exec = (command2, timeoutMs2) => {
+    const opts = { timeoutMs: timeoutMs2, ...ctx.signal ? { signal: ctx.signal } : {} };
+    return ctx.executor.exec(command2, opts);
+  };
+  const statOut = await exec(statCommandFor(shellQuote(path)), STAT_TIMEOUT_MS);
+  if (parseExitPrefix(statOut).failed) return `error: could not read ${path}: ${statOut.trim()}`;
+  const size = parseByteSize(statOut);
+  if (size === null) return `error: could not measure ${path}: ${statOut.trim()}`;
+  if (size === 0) return `error: ${path} is empty \u2014 nothing to attach`;
+  if (size > MAX_ARTIFACT_BYTES) {
+    return `error: ${path} is ${size} bytes; attach_file takes files up to ${MAX_ARTIFACT_BYTES} bytes (1 GiB) \u2014 link to the file instead`;
+  }
+  let timeoutMs = BASH_TIMEOUT_MAX_MS;
+  if (ctx.remainingMs) {
+    const budget = bashBudgetWithinRun(BASH_TIMEOUT_MAX_MS, ctx.remainingMs());
+    if (budget.kind === "exhausted") return `error: ${budget.note}`;
+    if (budget.kind === "clipped") timeoutMs = budget.timeoutMs;
+  }
+  const needed = transferBudgetMs(size);
+  if (needed > timeoutMs) {
+    return `error: ${name} is ${size} bytes and needs about ${secs(needed)}s to move at ${TRANSFER_FLOOR_BYTES_PER_MS} KB/s; the run has ${secs(timeoutMs)}s of command budget left \u2014 write up what you have and link to the file instead`;
+  }
+  const contentType = contentTypeFor(name);
+  const key = outboundKey(artifacts.runId, artifacts.nextSeq(), name);
+  const putUrl = await artifacts.store.presignPut(key, contentType);
+  const putOut = await exec(putCommandFor(path, contentType, putUrl), timeoutMs);
+  if (parseExitPrefix(putOut).failed) {
+    return `error: the upload of ${name} to the artifact store failed: ${putOut.trim()}`;
+  }
+  const head = await artifacts.store.head(key);
+  if (!head)
+    return `error: the artifact store holds nothing under ${key} after the upload of ${name} \u2014 nothing was posted`;
+  if (head.size !== size) {
+    return `error: the artifact store holds ${head.size} bytes for ${name}, not the ${size} measured \u2014 nothing was posted`;
+  }
+  ctx.publish?.({ type: "artifact", direction: "out", key, name, size, contentType });
+  if (!ctx.uploadTicket) {
+    const where = artifacts.runUrl ? ` \u2014 ${artifacts.runUrl}` : "";
+    await artifacts.reply(`${lead}
+\u{1F4CE} ${name} (${size} bytes) is on the run page${where}`);
+    return `attached ${name} (${size} bytes) to the run page; this conversation's channel takes no file uploads, so the lead and the page's link were posted instead`;
+  }
+  const kept = "the file is kept on the run page";
+  let ticket;
+  try {
+    ticket = await ctx.uploadTicket({ name, size });
+  } catch (err2) {
+    return `error: the channel refused an upload ticket for ${name}: ${describe3(err2)}; ${kept}`;
+  }
+  const postOut = await exec(postCommandFor(path, ticket.url), timeoutMs);
+  if (parseExitPrefix(postOut).failed) {
+    return `error: the upload of ${name} to the channel failed: ${postOut.trim()}; ${kept}`;
+  }
+  try {
+    await ticket.complete(lead);
+  } catch (err2) {
+    return `error: the channel refused to complete the upload of ${name}: ${describe3(err2)}; ${kept}`;
+  }
+  return `attached ${name} (${size} bytes) to the conversation and the run page`;
+}
+var MAX_ARTIFACT_BYTES, TRANSFER_FLOOR_BYTES_PER_MS, TRANSFER_SETUP_MS, STAT_TIMEOUT_MS, describe3, secs, attachFileTool;
 var init_attach = __esm({
   "../../src/tools/attach.ts"() {
     "use strict";
+    init_contentType();
+    init_keys();
+    init_runEvents();
+    init_bashTimeout();
     init_binaryRead();
+    init_shellQuote();
+    MAX_ARTIFACT_BYTES = 1073741824;
+    TRANSFER_FLOOR_BYTES_PER_MS = 1024;
+    TRANSFER_SETUP_MS = 1e4;
+    STAT_TIMEOUT_MS = 3e4;
+    describe3 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    secs = (ms) => Math.max(0, Math.round(ms / 1e3));
     attachFileTool = {
       name: "attach_file",
-      description: `Post a file from the workspace into the conversation so the person sees it inline \u2014 a screenshot (e.g. from \`playwright screenshot\`), a rendered PDF, a recording, a log. Use it whenever you produce an image worth showing: a link to a file is not a picture. Whole files only, up to ${MAX_READ_BYTES} bytes.`,
+      description: `Post a file from the workspace into the conversation so the person sees it inline \u2014 a screenshot (e.g. from \`playwright screenshot\`), a rendered PDF, a recording, a log. Use it whenever you produce an image worth showing: a link to a file is not a picture. Whole files only: up to ${MAX_ARTIFACT_BYTES} bytes (1 GiB) where the artifact store is configured, ${MAX_READ_BYTES} bytes otherwise \u2014 the result says which.`,
       inputSchema: {
         type: "object",
         properties: {
@@ -25752,6 +26128,7 @@ var init_attach = __esm({
         if (!path) return "error: path is required";
         const name = fileNameOf2(path);
         const lead = typeof input.comment === "string" && input.comment.trim() ? input.comment.trim() : name;
+        if (ctx.artifacts) return attachThroughStore(path, name, lead, ctx.artifacts, ctx);
         if (!ctx.attach) {
           return "attach_file is not available here: this conversation's channel takes no file uploads \u2014 link to the file instead";
         }
@@ -25763,13 +26140,13 @@ var init_attach = __esm({
         try {
           bytes = await readBytes(path);
         } catch (err2) {
-          return `error: could not read ${path}: ${err2 instanceof Error ? err2.message : String(err2)}`;
+          return `error: could not read ${path}: ${describe3(err2)}`;
         }
         if (bytes.byteLength === 0) return `error: ${path} is empty \u2014 nothing to attach`;
         try {
           await ctx.attach({ name, bytes, lead });
         } catch (err2) {
-          return `error: the channel refused the upload of ${name}: ${err2 instanceof Error ? err2.message : String(err2)}`;
+          return `error: the channel refused the upload of ${name}: ${describe3(err2)}`;
         }
         return `attached ${name} (${bytes.byteLength} bytes) to the conversation`;
       }
@@ -25902,7 +26279,7 @@ async function nextTick(wait, ids, ms, signal) {
     signal?.removeEventListener("abort", end);
   }
 }
-var UNAVAILABLE2, NOT_FOUND, PRESETS, CHILDREN_PAGES_MAX, spawnRunTool, sendToRunTool, AWAIT_IDS_MAX, awaitRunsTool, listRunsTool, getRunStatusTool, RUN_TOOLS;
+var UNAVAILABLE2, NOT_FOUND, CHILD_PRESETS, WRITE_PRESETS, REPO_PRESETS, CHILDREN_PAGES_MAX, spawnRunTool, sendToRunTool, AWAIT_IDS_MAX, awaitRunsTool, listRunsTool, getRunStatusTool, RUN_TOOLS;
 var init_runs2 = __esm({
   "../../src/tools/runs.ts"() {
     "use strict";
@@ -25917,16 +26294,24 @@ var init_runs2 = __esm({
     init_runsService();
     UNAVAILABLE2 = "run tools are not available in this context.";
     NOT_FOUND = "not_found";
-    PRESETS = () => Object.keys(AGENTS);
+    CHILD_PRESETS = () => Object.values(AGENTS).filter((a) => a.name !== "conductor" && a.identity !== "write").map((a) => a.name);
+    WRITE_PRESETS = () => Object.values(AGENTS).filter((a) => a.identity === "write").map((a) => a.name);
+    REPO_PRESETS = () => Object.values(AGENTS).filter((a) => machineNeedsRepo(a.machine)).map((a) => a.name);
     CHILDREN_PAGES_MAX = 25;
     spawnRunTool = {
       name: "spawn_run",
-      description: "Start a child run as the person who asked you: an ordinary Switchboard run of the named preset, in a thread of its own in this channel, under their permissions \u2014 what they could start by hand with `agent:<preset>`. `prompt` is everything the child needs (it sees none of this thread); `repo` (owner/name) for a preset that works in a repository (coding, review, explore, ship); `budget` narrows the child's wall clock in whole minutes (at least 2; it is also capped by what is left of yours). Returns the child's run id, its thread and a link, or a refusal by name: a preset or repository the requester may not use, a boundary the child's profile exceeds, the fan-out cap, or a channel that cannot open a thread. A child cannot spawn children.",
+      description: `Start a child run as the person who asked you: an ordinary Switchboard run of the named preset, in a thread of its own in this channel, under their permissions \u2014 what they could start by hand with \`agent:<preset>\`. The child is a reader of this conversation: it starts from this conversation's text so far (every user and assistant turn, never your tool calls or their results) plus \`prompt\`, its one new turn \u2014 so say what it should do. Presets a child can run: ${CHILD_PRESETS().join(", ")}; a preset that writes (${WRITE_PRESETS().join(", ")}) is refused \`spawn_identity\`. \`repo\` (owner/name) for a preset that works in a repository (${REPO_PRESETS().join(", ")}); \`budget\` narrows the child's wall clock in whole minutes (at least 2; it is also capped by what is left of yours). Returns the child's run id, its thread and a link, or a refusal by name: a preset or repository the requester may not use, a boundary the child's profile exceeds, the fan-out cap, or a channel that cannot open a thread. A child cannot spawn children.`,
       inputSchema: {
         type: "object",
         properties: {
-          preset: { type: "string", description: `The preset the child runs: one of ${PRESETS().join(", ")}` },
-          prompt: { type: "string", description: "The child's whole request, self-contained" },
+          preset: {
+            type: "string",
+            description: `The preset the child runs: one of ${CHILD_PRESETS().join(", ")} (a preset that writes \u2014 ${WRITE_PRESETS().join(", ")} \u2014 is refused spawn_identity)`
+          },
+          prompt: {
+            type: "string",
+            description: "What the child should do \u2014 its one new turn after this conversation's text"
+          },
           repo: { type: "string", description: "owner/name of the repository the child works in, for a repository preset" },
           budget: { type: "integer", description: "The child's wall clock in whole minutes, at least 2 (optional)" }
         },
@@ -25934,9 +26319,10 @@ var init_runs2 = __esm({
       },
       async run(input, ctx) {
         const preset = String(input.preset ?? "");
-        if (!Object.hasOwn(AGENTS, preset)) return `error: unknown preset "${preset}" \u2014 one of ${PRESETS().join(", ")}`;
+        if (!Object.hasOwn(AGENTS, preset))
+          return `error: unknown preset "${preset}" \u2014 one of ${CHILD_PRESETS().join(", ")}`;
         const prompt = String(input.prompt ?? "").trim();
-        if (!prompt) return "error: prompt is required \u2014 the child's whole request, since it sees none of this thread";
+        if (!prompt) return "error: prompt is required \u2014 what the child should do, after this conversation's text";
         const request = { preset, prompt };
         if (input.repo !== void 0 && String(input.repo).trim()) request.repo = String(input.repo).trim();
         if (input.budget !== void 0) {
@@ -25946,7 +26332,10 @@ var init_runs2 = __esm({
           request.budget = budget;
         }
         const spawn7 = ctx.spawn ?? nullSpawnCapability;
-        const out = await spawn7.spawn(request, ctx.remainingMs?.() ?? Number.POSITIVE_INFINITY);
+        const out = await spawn7.spawn(request, {
+          remainingMs: ctx.remainingMs?.() ?? Number.POSITIVE_INFINITY,
+          ...ctx.conversation ? { conversation: ctx.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.`;
       }
@@ -26310,7 +26699,7 @@ ${raw.trim()}`;
     };
     submitDispositionsTool = {
       name: "submit_dispositions",
-      description: "Record one disposition per review finding after addressing them: `fixed` (the finding is addressed in your pushed code) or `declined` (deliberately not doing it \u2014 the note says why). `findingId` is the finding's stable id from the review (F1, F2, \u2026) \u2014 use exactly those ids; an unknown id is rejected by name. Every finding gets exactly one entry, every severity included (nits too). Call it once with the complete set after your last push; a later call replaces the earlier one. Dispositions are recorded only inside a ship pipeline's fix round; anywhere else the call is an honest no-op that says nothing was recorded.",
+      description: "Record one disposition per review finding after addressing them: `fixed` (the finding is addressed in your pushed code) or `declined` (deliberately not doing it \u2014 the note says why). `findingId` is the finding's stable id from the review (F1, F2, \u2026) \u2014 use exactly those ids; an id the review never issued answers nothing and is dropped when the plan runner reads your record. Every finding gets exactly one entry, every severity included (nits too). Call it once with the complete set after your last push; a later call replaces the earlier one. The set rides this run's record, where the plan runner reads it for the re-review.",
       inputSchema: {
         type: "object",
         properties: {
@@ -26333,15 +26722,7 @@ ${raw.trim()}`;
       async run(input, ctx) {
         const parsed = parseDispositionsInput(input);
         if (!parsed) return "error: dispositions must be an array of { findingId, disposition: fixed|declined, note }";
-        if (ctx.knownFindingIds) {
-          const known = new Set(ctx.knownFindingIds);
-          const unknown = [...new Set(parsed.dispositions.map((d) => d.findingId).filter((id) => !known.has(id)))];
-          if (unknown.length) {
-            return `error: unknown finding id${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} \u2014 use exactly the ids from the review's findings list`;
-          }
-        }
-        if (!ctx.onDispositions)
-          return "no ship fix round is active here \u2014 dispositions were not recorded (they apply only when addressing a ship review's findings)";
+        if (!ctx.onDispositions) return "no run is recording dispositions here";
         ctx.onDispositions(parsed.dispositions);
         const drops = parsed.dropped.length ? ` (dropped: ${parsed.dropped.join("; ")})` : "";
         return `dispositions recorded: ${parsed.dispositions.length}${drops}; a later call replaces this one`;
@@ -26673,14 +27054,34 @@ async function runLoop(opts, now, note, emit, agentSpan) {
   const deadline = now() + (opts.resume ? opts.resume.remainingMs : opts.agent.maxMinutes * 6e4);
   const warnAt = deadline - Math.min(3 * 6e4, opts.agent.maxMinutes * 15e3);
   toolContext.remainingMs = () => deadline - now();
+  toolContext.conversation = () => messages;
   let warned = false;
   let sandboxDead = false;
+  let stuckLoop = false;
+  let stuckSig;
+  let stuckStreak = 0;
+  let stuckNudged = false;
+  const trackStuck = (tu, ok2) => {
+    const sig = callSignature(tu.name, redactAndCap(describeToolCall(tu)));
+    if (ok2) {
+      if (sig === stuckSig) {
+        stuckSig = void 0;
+        stuckStreak = 0;
+        stuckNudged = false;
+      }
+      return;
+    }
+    if (sig !== stuckSig) stuckNudged = false;
+    stuckStreak = sig === stuckSig ? stuckStreak + 1 : 1;
+    stuckSig = sig;
+  };
   let turn = 0;
   const wouldStep = (turns, iteration) => turns < opts.agent.maxTurns && iteration < opts.agent.maxTurns * 2 && now() < deadline && !control?.requested;
   const pendingFollowUps = () => (opts.inbox?.size ?? 0) > 0;
   let inboxConsumedSeq = opts.resume?.inboxConsumedSeq ?? 0;
-  const drainFollowUps = (superseded = false) => {
+  const drainFollowUps = async (superseded = false) => {
     const inputs = opts.inbox?.drain() ?? [];
+    const stagedLine = opts.stageFollowUps ? await opts.stageFollowUps(inputs) : "";
     for (const input of inputs) {
       if (input.ledgerSeq !== void 0 && input.ledgerSeq > inboxConsumedSeq) inboxConsumedSeq = input.ledgerSeq;
       const source2 = {
@@ -26691,7 +27092,10 @@ async function runLoop(opts, now, note, emit, agentSpan) {
       emit({ type: "input", text: redactSecrets(input.text), ...Object.keys(source2).length > 0 ? { source: source2 } : {} });
       note("follow_up", `follow-up folded in: ${redactSecrets(followUpSnippet(input))}`);
     }
-    const parts = [{ type: "text", text: followUpPrompt(inputs, { superseded }) }];
+    const prompt = followUpPrompt(inputs, { superseded });
+    const parts = [{ type: "text", text: stagedLine ? `${prompt}
+
+${stagedLine}` : prompt }];
     for (const input of inputs) {
       for (const img of input.images ?? []) parts.push({ type: "image", mediaType: img.mediaType, data: img.data });
       for (const doc of input.documents ?? [])
@@ -26708,12 +27112,15 @@ async function runLoop(opts, now, note, emit, agentSpan) {
     const body = async (callSpan) => {
       if (announceIt) announce(tu, callSpan?.id);
       const spanId = callSpan ? { spanId: callSpan.id } : {};
-      const settle2 = (ok2, extra = {}) => callSpan?.end(ok2 ? "ok" : "error", {
-        callId: tu.id,
-        ok: ok2,
-        ...extra.exitCode !== void 0 ? { exitCode: extra.exitCode } : {},
-        ...extra.infra ? { infra: true } : {}
-      });
+      const settle2 = (ok2, extra = {}) => {
+        trackStuck(tu, ok2);
+        callSpan?.end(ok2 ? "ok" : "error", {
+          callId: tu.id,
+          ok: ok2,
+          ...extra.exitCode !== void 0 ? { exitCode: extra.exitCode } : {},
+          ...extra.infra ? { infra: true } : {}
+        });
+      };
       const tool = toolsByName.get(tu.name);
       if (!tool) {
         emit({
@@ -26897,7 +27304,7 @@ async function runLoop(opts, now, note, emit, agentSpan) {
         turn++;
         if (text2) emit({ type: "assistant", text: redactSecrets(text2) });
         messages.push({ role: "assistant", content: result.content });
-        messages.push({ role: "user", content: drainFollowUps(true) });
+        messages.push({ role: "user", content: await drainFollowUps(true) });
         continue;
       }
       return text2 || "_(no response)_";
@@ -26922,6 +27329,10 @@ async function runLoop(opts, now, note, emit, agentSpan) {
       reportedUpTo = messages.length;
     }
     const results = await dispatchToolUses(toolUses);
+    if (!stuckNudged && stuckStreak >= STUCK_NUDGE_AT) {
+      stuckNudged = true;
+      results.push({ type: "text", text: stuckLoopNudge() });
+    }
     if (!warned && now() >= warnAt) {
       warned = true;
       const minutesLeft = Math.max(1, Math.round((deadline - now()) / 6e4));
@@ -26929,12 +27340,16 @@ async function runLoop(opts, now, note, emit, agentSpan) {
       results.push({ type: "text", text: wrapUpInstruction(minutesLeft) });
     }
     const dead = execTracker.consecutiveInfraFailures >= MAX_CONSECUTIVE_INFRA_FAILURES;
-    if (pendingFollowUps() && !dead && wouldStep(turn, iteration + 1)) results.push(...drainFollowUps());
+    if (pendingFollowUps() && !dead && wouldStep(turn, iteration + 1)) results.push(...await drainFollowUps());
     messages.push({ role: "user", content: results });
     if (dead) {
       sandboxDead = true;
       break;
     }
+    if (stuckStreak >= STUCK_WRITE_UP_AT) {
+      stuckLoop = true;
+      break;
+    }
   }
   narrateHeld();
   if (control?.requested === "soft") {
@@ -26946,6 +27361,11 @@ async function runLoop(opts, now, note, emit, agentSpan) {
     note("sandbox_dead", `${diagnosis} \u2014 aborting instead of retrying into a dead sandbox`);
     return await finishSandboxDead(complete2, opts, messages, system, diagnosis);
   }
+  if (stuckLoop) {
+    note("stuck_loop", stuckLoopNote());
+    const text2 = await runFinale(complete2, opts, messages, system, stuckLoopInstruction());
+    return stuckLoopAnswer(text2);
+  }
   const wasTimeout = now() >= deadline;
   const elapsedMs = opts.agent.maxMinutes * 6e4 - (deadline - now());
   const pace = turnGuardPace(turn, elapsedMs);
@@ -27047,7 +27467,7 @@ function withSpanId(e, spanId) {
       return e;
   }
 }
-var MAX_CONSECUTIVE_INFRA_FAILURES, HardStopError, HARD_STOP_MESSAGE, wrapUpNote, wrapUpInstruction, WRITE_UP_REQUEST, timeBudgetInstruction, turnGuardInstruction, SOFT_STOP_INSTRUCTION, turnGuardPace, timeBudgetNote, turnGuardNote, softStopNote, hardStopNote, timeBudgetAnswer, turnGuardAnswer, softStopAnswer, FinaleTimeoutError, FINALE_TIMEOUT_MS;
+var MAX_CONSECUTIVE_INFRA_FAILURES, HardStopError, HARD_STOP_MESSAGE, wrapUpNote, wrapUpInstruction, WRITE_UP_REQUEST, timeBudgetInstruction, turnGuardInstruction, SOFT_STOP_INSTRUCTION, turnGuardPace, timeBudgetNote, turnGuardNote, softStopNote, hardStopNote, timeBudgetAnswer, turnGuardAnswer, STUCK_NUDGE_AT, STUCK_WRITE_UP_AT, stuckLoopNudge, stuckLoopNote, stuckLoopInstruction, stuckLoopAnswer, softStopAnswer, FinaleTimeoutError, FINALE_TIMEOUT_MS;
 var init_runner = __esm({
   "../../src/runner.ts"() {
     "use strict";
@@ -27058,6 +27478,7 @@ var init_runner = __esm({
     init_tracingExecutor();
     init_workspace();
     init_formatDuration();
+    init_runFriction();
     MAX_CONSECUTIVE_INFRA_FAILURES = 2;
     HardStopError = class extends Error {
       constructor() {
@@ -27083,6 +27504,14 @@ ${text}` : `Stopped at the ${maxMinutes}-minute budget without finishing. Partia
     turnGuardAnswer = (text, pace) => text ? `\u26A0\uFE0F _Stopped after ${pace} \u2014 that pace looks like a loop; findings so far:_
 
 ${text}` : `Stopped after ${pace} \u2014 that pace looks like a loop \u2014 without finishing. Partial work may exist in the workspace \u2014 look for a retry loop in the run's events before trying again.`;
+    STUCK_NUDGE_AT = 3;
+    STUCK_WRITE_UP_AT = 6;
+    stuckLoopNudge = () => `\u26A0\uFE0F That exact tool call has now failed ${STUCK_NUDGE_AT} times identically. Change approach \u2014 different arguments, a different tool, a smaller step \u2014 or write up what you have.`;
+    stuckLoopNote = () => `stuck loop: the same call failed ${STUCK_WRITE_UP_AT} times identically \u2014 writing up findings so far`;
+    stuckLoopInstruction = () => `The same tool call has failed ${STUCK_WRITE_UP_AT} times identically; the run is stuck and can make no more tool calls. ${WRITE_UP_REQUEST}`;
+    stuckLoopAnswer = (text) => text ? `\u26A0\uFE0F _Stopped after the same call failed ${STUCK_WRITE_UP_AT} times identically \u2014 findings so far:_
+
+${text}` : `Stopped after the same call failed ${STUCK_WRITE_UP_AT} times identically, without finishing. Partial work may exist in the workspace \u2014 look at the failing call in the run's events before trying again.`;
     softStopAnswer = (text) => text ? `\u23F9 _Stopped early by an operator (soft stop) \u2014 findings so far:_
 
 ${text}` : "\u23F9 Stopped early by an operator (soft stop) before any findings were written. Partial work may exist in the workspace.";
@@ -27925,11 +28354,107 @@ var init_messages = __esm({
     init_runEvents();
     init_runRecord();
     init_reply();
+    init_textTurns();
     CONTEXT_MAX_ITEMS = 20;
     CONTEXT_MAX_BYTES = 256 * 1024;
   }
 });
 
+// ../../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})`).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);
+    return error === void 0 ? { file: o.file, basename: o.basename, key: o.key } : { ...o, error };
+  });
+}
+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 { randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function token(runId3, secret2) {
@@ -28481,7 +29006,7 @@ function startMemoryRead(deps, ctx) {
 async function openAckCard(deps, ctx) {
   const { io, agent, resolved, startedAt, clock: clock3, root, trace, route: route3 } = ctx;
   const shell = createCardShell({
-    label: `*${agent.name}* on \`${resolved.modelRef}\`${route3 ? ` \xB7 ${routedLabel(route3.reason)}` : ""}`,
+    label: `*${agent.name}* on \`${resolved.modelRef}\`${route3 ? ` \xB7 ${routedLabel(route3.reason, route3.collapsed)}` : ""}`,
     startedAt,
     now: clock3,
     ...route3?.parts ? { lead: routedPartLines(route3.parts) } : {},
@@ -28525,6 +29050,8 @@ async function registerRun(deps, ctx) {
     admitted,
     parentRunId,
     coordinator,
+    seed,
+    seedTurns,
     agentSource,
     route: route3
   } = ctx;
@@ -28557,7 +29084,8 @@ async function registerRun(deps, ctx) {
       ...msg.sourceUrl !== void 0 ? { sourceUrl: msg.sourceUrl } : {},
       ...msg.userName !== void 0 ? { userName: msg.userName } : {},
       ...parentRunId !== void 0 ? { parentRunId } : {},
-      ...coordinatorFields(coordinator)
+      ...coordinatorFields(coordinator),
+      ...seed !== void 0 ? { seed } : {}
     },
     // Under the run's id, at the card's start (the reservation's, or the
     // carried row's) — a resume replays its events, a restart starts them
@@ -28606,7 +29134,7 @@ async function registerRun(deps, ctx) {
   if (!resume) publishMeta(repoCtx);
   if (!resume && route3) registry.publish(run2.id, { type: "route", ...route3, at: clock3() });
   if (!resume && deps.config.config.runHistory?.includeContext !== false) {
-    for (const text of contextMessageTexts(history, humanize)) publishText("context", text);
+    for (const text of contextMessageTexts(seedTurns ?? history, humanize)) publishText("context", text);
   }
   return { run: run2, runId: runId3, channelVisibility, liveUrl, publishText, publishMeta };
 }
@@ -28628,7 +29156,8 @@ async function reserveRun(deps, ctx) {
     admitted,
     root,
     parentRunId,
-    coordinator
+    coordinator,
+    seed
   } = ctx;
   if (!resume && !restart) {
     const requestRow = durableInboxMessage(msg, msg.text, receivedAt);
@@ -28656,6 +29185,7 @@ async function reserveRun(deps, ctx) {
           profile,
           ...parentRunId !== void 0 ? { parentRunId } : {},
           ...coordinatorFields(coordinator),
+          ...seed !== void 0 ? { seed } : {},
           request: requestRow
         },
         card: card.handle ?? null,
@@ -28885,7 +29415,8 @@ async function claimRun(deps, ctx) {
     clock: clock3,
     root,
     parentRunId,
-    coordinator
+    coordinator,
+    seed
   } = ctx;
   const { resident, binding } = selection;
   let ledgerRun = ctx.ledgerRun;
@@ -28915,6 +29446,7 @@ async function claimRun(deps, ctx) {
           profile,
           ...parentRunId !== void 0 ? { parentRunId } : {},
           ...coordinatorFields(coordinator),
+          ...seed !== void 0 ? { seed } : {},
           selection: resident === true ? "resident" : "sandbox",
           ...binding?.workspace !== void 0 ? { workspace: binding.workspace } : {},
           ...requestRow !== void 0 ? { request: requestRow } : {}
@@ -29113,6 +29645,157 @@ var init_container = __esm({
   }
 });
 
+// ../../src/core/harness/pi/extensionSource.ts
+var BLOCKED_AT_DOOR_PREFIX, BLOCKED_UNAVAILABLE_PREFIX, PI_EXTENSION_SOURCE;
+var init_extensionSource = __esm({
+  "../../src/core/harness/pi/extensionSource.ts"() {
+    "use strict";
+    BLOCKED_AT_DOOR_PREFIX = "authorization refused at the door: ";
+    BLOCKED_UNAVAILABLE_PREFIX = "authorization unavailable: ";
+    PI_EXTENSION_SOURCE = `// Switchboard's pi harness extension. Written into the run's directory by the
+// bot before pi starts; loaded with \`-e\`. Imports nothing.
+
+const BEARER_ENV = "SWITCHBOARD_RUN_BEARER";
+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;
+
+function settings() {
+  const url = process.env[URL_ENV];
+  const bearer = process.env[BEARER_ENV];
+  if (!url || !bearer) throw new Error("switchboard harness: " + URL_ENV + " and " + BEARER_ENV + " must be set");
+  return { base: url.replace(/\\/$/, ""), bearer };
+}
+
+/** The bot answered, and said no: the status rides along so a caller can tell
+ *  a verdict from a bot it could not reach. */
+class HarnessAnswerError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
+async function call(method, path, body, signal) {
+  const { base, bearer } = settings();
+  const res = await fetch(base + path, {
+    method,
+    headers: { authorization: "Bearer " + bearer, "content-type": "application/json", accept: "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal,
+  });
+  const text = await res.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error("switchboard harness: " + method + " " + path + " answered " + res.status + " with a body that is not JSON");
+  }
+  if (!res.ok) {
+    throw new HarnessAnswerError(
+      "switchboard harness: " + method + " " + path + " answered " + res.status + ": " + (json.error || text),
+      res.status,
+    );
+  }
+  return json;
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** The bot's verdict on one tool call. A verdict answers at once, and so does
+ *  a refusal at the door \u2014 a 4xx: the bearer wrong, expired or revoked, the
+ *  run not on the harness \u2014 since nothing later changes it. A bot that cannot
+ *  be reached or is failing (a network error, a 5xx, a body that is not JSON)
+ *  is asked again every two seconds until the wait is up, then the call is
+ *  blocked naming why. */
+async function authorize(event) {
+  const started = Date.now();
+  let lastError = "";
+  for (;;) {
+    try {
+      return await call("POST", "/harness/authorize", {
+        toolCallId: event.toolCallId,
+        tool: event.toolName,
+        input: event.input,
+      });
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+      const status = err instanceof HarnessAnswerError ? err.status : undefined;
+      if (status !== undefined && status >= 400 && status < 500) {
+        return { allow: false, reason: "${BLOCKED_AT_DOOR_PREFIX}" + lastError };
+      }
+      if (Date.now() - started >= AUTHORIZE_WAIT_MS) {
+        return { allow: false, reason: "${BLOCKED_UNAVAILABLE_PREFIX}the bot did not answer for 90 s (" + lastError + ")" };
+      }
+      await sleep(AUTHORIZE_RETRY_MS);
+    }
+  }
+}
+
+function relayTool(def) {
+  return {
+    name: def.name,
+    label: def.name,
+    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);
+      if (answer.isError) throw new Error(answer.content.map((c) => (c.type === "text" ? c.text : "")).join("\\n"));
+      return { content: answer.content, details: {} };
+    },
+  };
+}
+
+export default async function switchboardHarness(pi) {
+  const { tools } = await call("GET", "/harness/tools");
+  for (const def of tools) pi.registerTool(relayTool(def));
+  pi.on("tool_call", async (event) => {
+    const verdict = await authorize(event);
+    if (!verdict.allow) return { block: true, reason: verdict.reason };
+    return undefined;
+  });
+}
+`;
+  }
+});
+
+// ../../src/core/harness/pi/protocol.ts
+function parsePiLine(line3) {
+  try {
+    const value = JSON.parse(line3);
+    if (typeof value === "object" && value !== null && typeof value.type === "string") {
+      return value;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function piAnsweredWithoutRunning(event) {
+  if (event.type !== "tool_execution_end" || event.isError !== true) return void 0;
+  const tool = typeof event.toolName === "string" ? event.toolName : "";
+  const result = event.result;
+  const content = Array.isArray(result?.content) ? result.content : [];
+  const text = content.filter(
+    (p) => typeof p === "object" && p !== null && p.type === "text" && typeof p.text === "string"
+  ).map((p) => p.text).join("\n");
+  const validation = `Validation failed for tool "${tool}":
+`;
+  if (text.startsWith(validation)) {
+    const problems = text.slice(validation.length).split("\n\n")[0].split("\n").map((line3) => line3.replace(/^\s*-\s*/, "").trim()).filter((line3) => line3.length > 0);
+    return `its arguments failed pi's validation (${problems.join("; ")})`;
+  }
+  if (text.startsWith(`Tool call "${tool}" was not executed: the response hit the output token limit`))
+    return "its arguments were cut by the output token limit";
+  if (text === `Tool ${tool} not found`) return "the tool is not on pi's list";
+  return void 0;
+}
+var init_protocol = __esm({
+  "../../src/core/harness/pi/protocol.ts"() {
+    "use strict";
+  }
+});
+
 // ../../src/core/harness/pi/bridge.ts
 function describePiToolCall(tool, args) {
   const input = isRecord3(args) ? args : void 0;
@@ -29140,6 +29823,8 @@ var init_bridge2 = __esm({
     "use strict";
     init_formatDuration();
     init_runEvents();
+    init_extensionSource();
+    init_protocol();
     PI_EVENT_DISPOSITION = {
       response: "structure",
       agent_start: "structure",
@@ -29182,8 +29867,23 @@ var init_bridge2 = __esm({
       /** Text beside a bookkeeping-only call, held until the next message decides (run-loop item 15). */
       heldAnswer;
       assistantStartedAt;
+      /** The calls under way: their span, their tool, and whether their end is
+       *  judged against the gate (harness-pi item 7). */
       openTools = /* @__PURE__ */ new Map();
+      /** The calls the gate saw — the extension asked `/harness/authorize` for
+       *  them (`gateSaw`) — not yet ended. */
+      vetted = /* @__PURE__ */ new Set();
+      /** Whether a call starting now is judged against the gate when it ends.
+       *  The harness turns it off while catching up on a re-attach: those calls
+       *  were vetted by the bot generation that died, and this one never heard. */
+      judgeGate = true;
       summarizationRetries = 0;
+      /** The gate saw this call: the extension's `tool_call` hook asked the bot
+       *  for it, whatever the answer. Called from the authorize route, before pi
+       *  runs the tool — so it always precedes the call's `tool_execution_end`. */
+      gateSaw(callId) {
+        this.vetted.add(callId);
+      }
       /** The run's answer as it stands: the last text-only assistant message, else a held bookkeeping text. */
       answer() {
         return this.answerText ?? this.heldAnswer;
@@ -29222,10 +29922,10 @@ var init_bridge2 = __esm({
             this.onToolStart(event);
             break;
           case "tool_execution_end":
-            this.onToolEnd(event);
+            this.onToolEnd(event, out);
             break;
           case "compaction_end":
-            this.onCompactionEnd(event);
+            this.onCompactionEnd(event, out);
             break;
           case "summarization_retry_scheduled":
             this.summarizationRetries++;
@@ -29285,7 +29985,7 @@ var init_bridge2 = __esm({
         const tool = str5(event.toolName);
         const callId = str5(event.toolCallId);
         const span = this.deps.agentSpan?.start(`tool.${tool}`);
-        this.openTools.set(callId, { span, tool });
+        this.openTools.set(callId, { span, tool, judged: this.judgeGate });
         this.toolCalls++;
         const input = isRecord3(event.args) ? event.args : void 0;
         const command2 = tool === "bash" && typeof input?.command === "string" ? { command: redactAndCap(input.command, COMMAND_CAP) } : {};
@@ -29298,7 +29998,7 @@ var init_bridge2 = __esm({
           ...span ? { spanId: span.id } : {}
         });
       }
-      onToolEnd(event) {
+      onToolEnd(event, out) {
         const callId = str5(event.toolCallId);
         const open = this.openTools.get(callId);
         this.openTools.delete(callId);
@@ -29321,8 +30021,25 @@ var init_bridge2 = __esm({
           ok: ok2,
           ...exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {}
         });
+        const seen = this.vetted.delete(callId);
+        if (!seen && open?.judged) {
+          const rejection = piAnsweredWithoutRunning(event);
+          if (rejection !== void 0) {
+            this.note(
+              "harness_error",
+              `pi answered the ${tool} call ${callId} itself, before the gate: ${redactAndCap(rejection, 300)}; nothing ran`
+            );
+          } else if (isError && (text.startsWith(BLOCKED_AT_DOOR_PREFIX) || text.startsWith(BLOCKED_UNAVAILABLE_PREFIX))) {
+            this.note(
+              "harness_error",
+              `the extension blocked the ${tool} call ${callId} without the gate's verdict: ${redactAndCap(text, 300)}; nothing ran`
+            );
+          } else {
+            out.gateBypassed = { callId, tool };
+          }
+        }
       }
-      onCompactionEnd(event) {
+      onCompactionEnd(event, out) {
         const result = isRecord3(event.result) ? event.result : void 0;
         if (event.aborted === true || !result) {
           this.note(
@@ -29339,6 +30056,13 @@ var init_bridge2 = __esm({
           "compacted",
           `pi compacted the context (${str5(event.reason)}): ${before ?? "?"} \u2192 about ${after ?? "?"} tokens; the transcript keeps the originals${retries > 0 ? `; ${retries} summarization retr${retries === 1 ? "y" : "ies"}` : ""}`
         );
+        if (typeof result.summary === "string") {
+          out.compaction = {
+            summary: result.summary,
+            ...before !== void 0 ? { tokensBefore: before } : {},
+            ...typeof result.firstKeptEntryId === "string" ? { firstKeptEntryId: result.firstKeptEntryId } : {}
+          };
+        }
       }
       onUiRequest(event, out) {
         const method = str5(event.method);
@@ -29360,6 +30084,7 @@ var init_bridge2 = __esm({
           this.emit({ type: "tool_result", tool: open.tool, ok: false, callId, summary: redactAndCap(reason) });
         }
         this.openTools.clear();
+        this.vetted.clear();
       }
     };
   }
@@ -29406,7 +30131,7 @@ function chatMessageOf(message2) {
       return void 0;
   }
 }
-function piSessionFile(messages, opts) {
+function piSessionFile(messages, opts, compactions = []) {
   const lines = [];
   const stamp = new Date(opts.at).toISOString();
   lines.push(
@@ -29415,12 +30140,35 @@ function piSessionFile(messages, opts) {
   let parentId = null;
   let n2 = 0;
   const toolNames = /* @__PURE__ */ new Map();
+  const firstEntryOf = [];
+  const nextId = () => (n2++).toString(16).padStart(8, "0");
   const push = (message2) => {
-    const id = (n2++).toString(16).padStart(8, "0");
+    const id = nextId();
     lines.push(JSON.stringify({ type: "message", id, parentId, timestamp: stamp, message: message2 }));
     parentId = id;
+    return id;
   };
-  for (const message2 of messages) {
+  const pushCompaction = (c) => {
+    const id = nextId();
+    const kept = c.keptBefore !== void 0 ? firstEntryOf[c.keptBefore] : void 0;
+    lines.push(
+      JSON.stringify({
+        type: "compaction",
+        id,
+        parentId,
+        timestamp: stamp,
+        summary: c.entry.summary,
+        firstKeptEntryId: kept ?? c.entry.firstKeptEntryId ?? "",
+        tokensBefore: c.entry.tokensBefore ?? 0
+      })
+    );
+    parentId = id;
+  };
+  const byPosition = /* @__PURE__ */ new Map();
+  for (const c of compactions) byPosition.set(c.before, [...byPosition.get(c.before) ?? [], c]);
+  messages.forEach((message2, i) => {
+    for (const c of byPosition.get(i) ?? []) pushCompaction(c);
+    firstEntryOf[i] = n2.toString(16).padStart(8, "0");
     if (message2.role === "assistant") {
       const content = [];
       for (const p of message2.content) {
@@ -29448,7 +30196,7 @@ function piSessionFile(messages, opts) {
         stopReason: hasTool ? "toolUse" : "stop",
         timestamp: opts.at
       });
-      continue;
+      return;
     }
     const results = message2.content.filter(
       (p) => p.type === "tool_result"
@@ -29475,7 +30223,8 @@ function piSessionFile(messages, opts) {
         });
     }
     if (rest.length > 0) push({ role: "user", content: rest, timestamp: opts.at });
-  }
+  });
+  for (const c of byPosition.get(messages.length) ?? []) pushCompaction(c);
   return lines.join("\n") + "\n";
 }
 function sessionIdOf(at) {
@@ -29532,124 +30281,36 @@ var init_mirror = __esm({
         this.idx += turns.length;
         await this.deps.onStep(report2);
       }
-    };
-  }
-});
-
-// ../../src/core/harness/pi/extensionSource.ts
-var PI_EXTENSION_SOURCE;
-var init_extensionSource = __esm({
-  "../../src/core/harness/pi/extensionSource.ts"() {
-    "use strict";
-    PI_EXTENSION_SOURCE = `// Switchboard's pi harness extension. Written into the run's directory by the
-// bot before pi starts; loaded with \`-e\`. Imports nothing.
-
-const BEARER_ENV = "SWITCHBOARD_RUN_BEARER";
-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;
-
-function settings() {
-  const url = process.env[URL_ENV];
-  const bearer = process.env[BEARER_ENV];
-  if (!url || !bearer) throw new Error("switchboard harness: " + URL_ENV + " and " + BEARER_ENV + " must be set");
-  return { base: url.replace(/\\/$/, ""), bearer };
-}
-
-/** The bot answered, and said no: the status rides along so a caller can tell
- *  a verdict from a bot it could not reach. */
-class HarnessAnswerError extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-  }
-}
-
-async function call(method, path, body, signal) {
-  const { base, bearer } = settings();
-  const res = await fetch(base + path, {
-    method,
-    headers: { authorization: "Bearer " + bearer, "content-type": "application/json", accept: "application/json" },
-    body: body === undefined ? undefined : JSON.stringify(body),
-    signal,
-  });
-  const text = await res.text();
-  let json;
-  try {
-    json = JSON.parse(text);
-  } catch {
-    throw new Error("switchboard harness: " + method + " " + path + " answered " + res.status + " with a body that is not JSON");
-  }
-  if (!res.ok) {
-    throw new HarnessAnswerError(
-      "switchboard harness: " + method + " " + path + " answered " + res.status + ": " + (json.error || text),
-      res.status,
-    );
-  }
-  return json;
-}
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-/** The bot's verdict on one tool call. A verdict answers at once, and so does
- *  a refusal at the door \u2014 a 4xx: the bearer wrong, expired or revoked, the
- *  run not on the harness \u2014 since nothing later changes it. A bot that cannot
- *  be reached or is failing (a network error, a 5xx, a body that is not JSON)
- *  is asked again every two seconds until the wait is up, then the call is
- *  blocked naming why. */
-async function authorize(event) {
-  const started = Date.now();
-  let lastError = "";
-  for (;;) {
-    try {
-      return await call("POST", "/harness/authorize", {
-        toolCallId: event.toolCallId,
-        tool: event.toolName,
-        input: event.input,
-      });
-    } catch (err) {
-      lastError = err instanceof Error ? err.message : String(err);
-      const status = err instanceof HarnessAnswerError ? err.status : undefined;
-      if (status !== undefined && status >= 400 && status < 500) {
-        return { allow: false, reason: "authorization refused at the door: " + lastError };
-      }
-      if (Date.now() - started >= AUTHORIZE_WAIT_MS) {
-        return { allow: false, reason: "authorization unavailable: the bot did not answer for 90 s (" + lastError + ")" };
+      /** pi compacted (session-log item 6): the results pending since the last
+       *  assistant turn go as the user turn they would have been, the entry as the
+       *  row after them — its own step with nothing in flight, so the log holds
+       *  the summary where pi wrote it and the index moves past it. */
+      async onCompaction(entry, turn) {
+        if (!this.deps.onStep) return;
+        const turns = [];
+        if (this.pendingUser.length > 0) turns.push({ role: "user", content: this.pendingUser });
+        this.pendingUser = [];
+        const report2 = {
+          turns,
+          firstIdx: this.idx,
+          compaction: entry,
+          inFlight: [],
+          turn,
+          iteration: this.iteration,
+          remainingMs: Math.max(0, this.deps.remainingMs()),
+          inboxConsumedSeq: this.inboxConsumedSeq
+        };
+        this.idx += turns.length + 1;
+        await this.deps.onStep(report2);
       }
-      await sleep(AUTHORIZE_RETRY_MS);
-    }
-  }
-}
-
-function relayTool(def) {
-  return {
-    name: def.name,
-    label: def.name,
-    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);
-      if (answer.isError) throw new Error(answer.content.map((c) => (c.type === "text" ? c.text : "")).join("\\n"));
-      return { content: answer.content, details: {} };
-    },
-  };
-}
-
-export default async function switchboardHarness(pi) {
-  const { tools } = await call("GET", "/harness/tools");
-  for (const def of tools) pi.registerTool(relayTool(def));
-  pi.on("tool_call", async (event) => {
-    const verdict = await authorize(event);
-    if (!verdict.allow) return { block: true, reason: verdict.reason };
-    return undefined;
-  });
-}
-`;
+    };
   }
 });
 
 // ../../src/core/harness/pi/process.ts
+function piBuiltinToolsFor(identity2) {
+  return identity2 === "write" ? PI_BUILTIN_TOOLS : PI_READ_TOOLS;
+}
 function piThinkingLevel(effort2) {
   return effort2;
 }
@@ -29679,7 +30340,7 @@ function piLaunchArgs(spec) {
     "-e",
     spec.paths.extension,
     "--tools",
-    [...PI_BUILTIN_TOOLS, ...spec.relayTools].join(","),
+    [...piBuiltinToolsFor(spec.identity), ...spec.relayTools].join(","),
     "--provider",
     PROXY_PROVIDER,
     "--model",
@@ -29698,6 +30359,13 @@ function piLaunchEnv(spec, bearer) {
     PI_TELEMETRY: "0"
   };
 }
+function takesAdaptiveThinking(modelId) {
+  const version2 = /(?:^|-)(\d{1,2})(?:-(\d{1,2}))?(?=-|$)/.exec(modelId);
+  if (!version2) return true;
+  const major = Number(version2[1]);
+  const minor = version2[2] === void 0 ? 0 : Number(version2[2]);
+  return major > 4 || major === 4 && minor >= 6;
+}
 function piModelsJson(spec) {
   const anthropic = spec.model.providerType === "anthropic";
   const base = spec.harnessUrl.replace(/\/$/, "");
@@ -29713,6 +30381,7 @@ function piModelsJson(spec) {
               id: spec.model.id,
               name: spec.model.id,
               reasoning: true,
+              ...anthropic ? { compat: { forceAdaptiveThinking: takesAdaptiveThinking(spec.model.id) } } : {},
               input: ["text", "image"],
               contextWindow: 2e5,
               maxTokens: spec.model.maxTokens,
@@ -29726,17 +30395,18 @@ function piModelsJson(spec) {
     2
   ) + "\n";
 }
-function harnessPromptNote(relayTools) {
+function harnessPromptNote(relayTools, identity2) {
+  const write = identity2 === "write";
   return [
-    "HARNESS NOTE: this run's workspace tools are pi's own \u2014 `read`, `bash`, `edit`, `write`, `grep`, `find` and `ls`, all running in the worktree.",
-    "Where these instructions say `read_file` use `read`; where they say `write_file` use `write` (a whole file) or `edit` (a targeted change).",
+    write ? "HARNESS NOTE: this run's workspace tools are pi's own \u2014 `read`, `bash`, `edit`, `write`, `grep`, `find` and `ls`, all running in the worktree." : "HARNESS NOTE: this run's workspace tools are pi's own \u2014 `read`, `bash`, `grep`, `find` and `ls`, all running in the worktree; it has no `edit` and no `write`: the run is read-only, and a call to either is refused.",
+    write ? "Where these instructions say `read_file` use `read`; where they say `write_file` use `write` (a whole file) or `edit` (a targeted change)." : "Where these instructions say `read_file` use `read`.",
     relayTools.length > 0 ? `Every other tool named above is available under its own name: ${relayTools.map((t) => `\`${t}\``).join(", ")}.` : "No other tools are available in this run."
   ].join(" ");
 }
 function piSystemPrompt(spec) {
   return `${spec.system.trimEnd()}
 
-${harnessPromptNote(spec.relayTools)}
+${harnessPromptNote(spec.relayTools, spec.identity)}
 `;
 }
 function piSettingsJson() {
@@ -29750,7 +30420,7 @@ function piLaunchFiles(spec) {
     { path: spec.paths.extension, content: PI_EXTENSION_SOURCE }
   ];
 }
-var RUN_BEARER_ENV, HARNESS_URL_ENV, PROXY_PROVIDER, PI_BUILTIN_TOOLS;
+var RUN_BEARER_ENV, HARNESS_URL_ENV, PROXY_PROVIDER, PI_BUILTIN_TOOLS, PI_READ_TOOLS;
 var init_process = __esm({
   "../../src/core/harness/pi/process.ts"() {
     "use strict";
@@ -29759,23 +30429,7 @@ var init_process = __esm({
     HARNESS_URL_ENV = "SWITCHBOARD_HARNESS_URL";
     PROXY_PROVIDER = "switchboard";
     PI_BUILTIN_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls"];
-  }
-});
-
-// ../../src/core/harness/pi/protocol.ts
-function parsePiLine(line3) {
-  try {
-    const value = JSON.parse(line3);
-    if (typeof value === "object" && value !== null && typeof value.type === "string") {
-      return value;
-    }
-  } catch {
-  }
-  return void 0;
-}
-var init_protocol = __esm({
-  "../../src/core/harness/pi/protocol.ts"() {
-    "use strict";
+    PI_READ_TOOLS = ["read", "bash", "grep", "find", "ls"];
   }
 });
 
@@ -29923,6 +30577,7 @@ async function runPiHarness(deps, run2) {
   let writeUp;
   let writeUpAt;
   let hardStopped = false;
+  let bypass;
   const toolsBlocked = () => {
     if (!writeUp) return void 0;
     if (writeUp.kind === "time")
@@ -29931,14 +30586,16 @@ async function runPiHarness(deps, run2) {
       return "the run has hit its turn guard: no more tool calls \u2014 write your final answer now";
     return "an operator asked this run to stop: no more tool calls \u2014 write your final answer now";
   };
+  const rules = { ...run2.rules, identity: run2.agent.identity };
   const live = {
     runId: run2.runId,
     tools: run2.tools,
     toolContext: run2.toolContext,
     ...run2.backend ? { backend: run2.backend } : {},
-    rules: run2.rules,
+    rules,
     emit,
     toolSpan: (callId) => bridge.openSpan(callId),
+    gateSaw: (callId) => bridge.gateSaw(callId),
     toolsBlocked
   };
   const forget = deps.registry.register(live);
@@ -29948,6 +30605,7 @@ async function runPiHarness(deps, run2) {
     model: { id: run2.model.id, providerType: run2.model.providerType, maxTokens: run2.agent.maxTokens },
     harnessUrl: deps.harnessUrl,
     ...run2.effort ? { effort: run2.effort } : {},
+    identity: run2.agent.identity,
     system: run2.system,
     relayTools: run2.tools.map((t) => t.name)
   };
@@ -29983,25 +30641,33 @@ async function runPiHarness(deps, run2) {
       let session;
       if (run2.resume) {
         const settled2 = settlementResults(run2.resume.settlements);
-        session = { stem: "resumed", messages: settled2 ? [...run2.resume.messages, settled2] : run2.resume.messages };
+        session = {
+          stem: "resumed",
+          messages: settled2 ? [...run2.resume.messages, settled2] : run2.resume.messages,
+          compactions: run2.resume.compactions ?? []
+        };
       } else {
         const earlier2 = splitSeed(run2.messages).session;
-        if (earlier2.length > 0) session = { stem: "seed", messages: earlier2 };
+        if (earlier2.length > 0) session = { stem: "seed", messages: earlier2, compactions: [] };
       }
       let sessionPath;
       if (session) {
         sessionPath = `${paths.sessionDir}/${session.stem}-${now()}.jsonl`;
         await container.writeFile(
           sessionPath,
-          piSessionFile(session.messages, {
-            cwd: run2.rules.checkout,
-            model: {
-              provider: run2.model.provider,
-              id: run2.model.id,
-              api: run2.model.providerType === "anthropic" ? "anthropic-messages" : "openai-completions"
+          piSessionFile(
+            session.messages,
+            {
+              cwd: run2.rules.checkout,
+              model: {
+                provider: run2.model.provider,
+                id: run2.model.id,
+                api: run2.model.providerType === "anthropic" ? "anthropic-messages" : "openai-completions"
+              },
+              at: now()
             },
-            at: now()
-          })
+            session.compactions
+          )
         );
       }
       if (run2.resume) {
@@ -30108,8 +30774,15 @@ async function runPiHarness(deps, run2) {
       if (next.done) break;
       const event = parsePiLine(next.value);
       if (!event) continue;
+      bridge.judgeGate = !catchingUp;
       const obs = bridge.observe(event);
       for (const reply of obs.replies) transport.send(reply);
+      if (obs.gateBypassed) {
+        bypass = new GateBypassed(obs.gateBypassed.tool, obs.gateBypassed.callId);
+        note("harness_error", `${bypass.message} \u2014 the run is stopped`);
+        transport.send({ type: "abort" });
+        break;
+      }
       if (obs.response) {
         const r = obs.response;
         if (r.id === "state" && r.success === true && typeof r.data?.sessionFile === "string") {
@@ -30123,6 +30796,7 @@ async function runPiHarness(deps, run2) {
         }
       }
       if (obs.message) await mirror.onMessage(obs.message, bridge.turns);
+      if (obs.compaction) await mirror.onCompaction(obs.compaction, bridge.turns);
       if (obs.providerError !== void 0) {
         if (catchingUp)
           note("harness_error", `a model call failed while the bot was away (${obs.providerError}); continuing`);
@@ -30140,6 +30814,7 @@ async function runPiHarness(deps, run2) {
       note("stopped", hardStopNote(), "hard");
       return HARD_STOP_MESSAGE;
     }
+    if (bypass) throw bypass;
     if (!settled) {
       const tail = await container.tail(paths.errLog, 2e3);
       throw new Error(`pi exited before the run settled${tail.trim() ? `: ${redactAndCap(tail.trim(), 400)}` : ""}`);
@@ -30152,15 +30827,17 @@ async function runPiHarness(deps, run2) {
     return text || "_(no response)_";
   } finally {
     transport?.close();
-    bridge.closeOpenSpans(hardStopped ? "the run was hard-stopped" : "the run ended");
+    bridge.closeOpenSpans(
+      hardStopped ? "the run was hard-stopped" : bypass ? "the run was stopped: a tool call bypassed the gate" : "the run ended"
+    );
     save();
     forget();
     if (pid !== void 0) await container.kill(pid).catch(() => {
     });
-    agentSpan?.end(hardStopped ? "error" : "ok");
+    agentSpan?.end(hardStopped || bypass ? "error" : "ok");
   }
 }
-var NATIVE_WORKSPACE_TOOLS, FINALE_TIMEOUT_MS2, CONTINUE_PROMPT, PromptRefused;
+var NATIVE_WORKSPACE_TOOLS, FINALE_TIMEOUT_MS2, CONTINUE_PROMPT, PromptRefused, GateBypassed;
 var init_harness = __esm({
   "../../src/core/harness/pi/harness.ts"() {
     "use strict";
@@ -30181,6 +30858,12 @@ var init_harness = __esm({
         this.name = "PromptRefused";
       }
     };
+    GateBypassed = class extends Error {
+      constructor(tool, callId) {
+        super(`the gate was bypassed: pi ran ${tool} (call ${callId}) without asking the bot`);
+        this.name = "GateBypassed";
+      }
+    };
   }
 });
 
@@ -30648,8 +31331,8 @@ var init_descriptionTurn = __esm({
 // ../../src/core/statusCardLabel.ts
 function quietSuffix(quietMs, inFlightTool) {
   if (quietMs <= QUIET_SUFFIX_AFTER_MS) return "";
-  const secs = Math.round(quietMs / 1e3);
-  return inFlightTool ? ` \u2014 running ${inFlightTool} (${secs}s)` : ` \u2014 thinking (${secs}s since last tool)`;
+  const secs2 = Math.round(quietMs / 1e3);
+  return inFlightTool ? ` \u2014 running ${inFlightTool} (${secs2}s)` : ` \u2014 thinking (${secs2}s since last tool)`;
 }
 function inFlightToolAfter(current, e) {
   if (e.type === "tool_call") return e.tool;
@@ -30701,7 +31384,7 @@ async function runLoop2(deps, ctx) {
     wait,
     parentRunId,
     coordinator,
-    fixRound
+    seed
   } = ctx;
   const agent = budgetedAgent(ctx.agent, profile);
   const { executor, binding } = round2.selection;
@@ -30804,7 +31487,7 @@ async function runLoop2(deps, ctx) {
     handoff = h;
     ledgerRun?.setState({ handoff: h });
   };
-  const restoredDispositions = fixRound ? parseDispositionsInput({ dispositions: restored.dispositions })?.dispositions : void 0;
+  const restoredDispositions = parseDispositionsInput({ dispositions: restored.dispositions })?.dispositions;
   let dispositions = restoredDispositions;
   const onDispositions = (d) => {
     dispositions = d;
@@ -30822,10 +31505,23 @@ async function runLoop2(deps, ctx) {
   let runDiagnosis;
   const releaseWorkspace = (span) => round2.release({ hardStopped: run2.control.requested === "hard", ...span ? { span } : {} });
   const attachFile = io.attachFile?.bind(io);
+  const uploadTicket = io.uploadTicket?.bind(io);
+  const nextStagedIndex = ctx.stagingIndex ?? stagingIndex();
+  let artifactSeq = 0;
+  const runUrl = runPageLink(run2.id);
+  const artifacts = deps.artifacts ? {
+    store: deps.artifacts,
+    runId: run2.id,
+    nextSeq: () => ++artifactSeq,
+    ...runUrl ? { runUrl } : {},
+    reply: (text) => io.reply(text)
+  } : void 0;
   const toolContext = {
     executor,
     reportProgress,
     ...attachFile ? { attach: attachFile } : {},
+    ...artifacts ? { artifacts } : {},
+    ...uploadTicket ? { uploadTicket } : {},
     web: webCapability(),
     skills: deps.skills,
     github: githubCapabilityFor(deps, msg.userId),
@@ -30838,7 +31534,7 @@ async function runLoop2(deps, ctx) {
     onDigest,
     onPrDescription,
     onHandoff,
-    ...fixRound ? { knownFindingIds: fixRound.findingIds, onDispositions } : {}
+    onDispositions
   };
   const harness = effectiveHarness(agent, deps.config.config.harness);
   try {
@@ -30899,6 +31595,7 @@ async function runLoop2(deps, ctx) {
           ...resume ? {
             resume: {
               messages: resume.plan.messages,
+              compactions: resume.plan.compactions,
               settlements: resume.plan.settlements,
               remainingMs: resume.plan.remainingMs,
               turn: resume.plan.turn,
@@ -30927,6 +31624,23 @@ async function runLoop2(deps, ctx) {
         // operator stop from /runs
         inbox: admitted.inbox,
         // thread follow-ups steered into this run (thread-admission item 2)
+        // A steered follow-up's staged files (record 0033): copied into the
+        // store and pulled into this workspace before the model reads the turn.
+        ...deps.artifacts ? {
+          stageFollowUps: async (inputs) => {
+            const files = inputs.flatMap((i) => i.staged ?? []);
+            if (files.length === 0) return "";
+            const staged = await stageIntoWorkspace(files, {
+              store: deps.artifacts,
+              threadKey: msg.threadKey,
+              publish: (e) => registry.publish(run2.id, e),
+              nextIndex: nextStagedIndex,
+              executor,
+              resident: round2.selection.resident !== void 0
+            });
+            return staged.line;
+          }
+        } : {},
         // The step record before each step's tools (run-history item 35).
         ...ledgerRun ? { onStep: ledgerRun.step.bind(ledgerRun) } : {},
         // A resume re-enters the loop from the plan (run-history item 37).
@@ -31150,7 +31864,8 @@ async function runLoop2(deps, ctx) {
       ...dispositions !== void 0 ? { dispositions } : {},
       ...reviewPost !== void 0 ? { reviewPost } : {},
       ...parentRunId !== void 0 ? { parentRunId } : {},
-      ...coordinator !== void 0 ? { coordinator } : {}
+      ...coordinator !== void 0 ? { coordinator } : {},
+      ...seed !== void 0 ? { seed } : {}
     });
     if (runFailed)
       await root.span(
@@ -31209,6 +31924,7 @@ var init_runLoop = __esm({
     init_secrets2();
     init_record();
     init_reply();
+    init_staging();
     init_run2();
   }
 });
@@ -31459,6 +32175,12 @@ function openPlanCursor(graph, selected) {
   for (const id of order) visit(id, []);
   return cursor;
 }
+function matchDispositions(findings, dispositions) {
+  const issued = new Set(findings.map((f) => f.id));
+  const matched = dispositions.filter((d) => issued.has(d.findingId));
+  const dropped = [...new Set(dispositions.filter((d) => !issued.has(d.findingId)).map((d) => d.findingId))];
+  return { matched, dropped };
+}
 var MIN, SHIP_ROUND_RESERVE_MS, PLAN_ID_PATTERN, PLAN_BRANCH, UNIT_REF, SLUG_MAX, INSTANCE_ID_MAX, WAIT_MARGIN_MS, WAIT_CHUNK_MS, MERGE_POLL_MS, MERGE_WAIT_MAX_MS, BUSY_RETRY_MS;
 var init_coordinator = __esm({
   "../../src/core/ship/coordinator.ts"() {
@@ -31481,29 +32203,6 @@ var init_coordinator = __esm({
   }
 });
 
-// ../../src/core/ship/codingChild.ts
-function buildShipFixTurn(input) {
-  const findings = input.findings.map(formatFinding).join("\n") || "(the review listed no structured findings \u2014 address its prose)";
-  return `The review of ${input.where} requested changes. Load the \`address-review-findings\` skill and address EVERY finding below, nits included: record one disposition per finding with submit_dispositions (fixed|declined, with a note), squash to coherent commits, resubmit the PR description with submit_pr_description, and push the branch. Never merge and never approve.
-
-Findings:
-${findings}
-
-Review:
-${input.review}`;
-}
-function withContractInFirstUserTurn(messages, block) {
-  const at = messages.findIndex((m) => m.role === "user");
-  if (at < 0) return [...messages, { role: "user", content: [{ type: "text", text: block }] }];
-  return messages.map((m, i) => i === at ? { ...m, content: [...m.content, { type: "text", text: block }] } : m);
-}
-var init_codingChild = __esm({
-  "../../src/core/ship/codingChild.ts"() {
-    "use strict";
-    init_reviewVerdict();
-  }
-});
-
 // ../../src/core/ship/reviewChild.ts
 function buildShipReviewTurn(input) {
   const at = input.headSha ? ` at head \`${input.headSha}\`` : "";
@@ -31512,13 +32211,15 @@ function buildShipReviewTurn(input) {
   }
   const findings = input.prior.findings.map(formatFinding).join("\n") || "(none recorded)";
   const dispositions = input.prior.dispositions.map((d) => `${d.findingId}: ${d.disposition}${d.note ? ` \u2014 ${d.note}` : ""}`).join("\n") || "(none recorded)";
+  const dropped = input.prior.dropped !== void 0 && input.prior.dropped.length > 0 ? `
+Dispositions naming no finding of the previous round (dropped): ${input.prior.dropped.join(", ")}` : "";
   return `Re-review pull request ${input.where}${at} \u2014 review round ${input.round} of this ship pipeline. Load the \`re-review-delta\` skill: narrow your READING to the delta since the previously reviewed head and verify each prior finding's disposition, but your verdict still covers the full diff against base. Carry every unresolved prior finding forward under its existing id.
 
 Previous round's findings:
 ${findings}
 
 Fix round's dispositions:
-${dispositions}`;
+${dispositions}${dropped}`;
 }
 var init_reviewChild = __esm({
   "../../src/core/ship/reviewChild.ts"() {
@@ -31564,6 +32265,16 @@ async function contractFor(instance, unit, readers) {
     ...issue ? { issue } : {}
   });
 }
+function findingsRequest(input) {
+  const findings = input.findings.map(formatFinding).join("\n") || "(the review listed no structured findings, address its prose)";
+  return `The review of ${input.where} requested changes. Load the \`address-review-findings\` skill and address every finding below, nits included: record one disposition per finding with submit_dispositions (fixed or declined, with a note), squash to coherent commits, resubmit the pull request description with submit_pr_description, and push the branch. Never merge and never approve.
+
+Findings:
+${findings}
+
+Review:
+${input.review}`;
+}
 async function composeChild(brief, instance, unit, readers) {
   const where = `${instance.repo}#${"pr" in brief ? brief.pr : ""}`;
   switch (brief.kind) {
@@ -31573,10 +32284,13 @@ async function composeChild(brief, instance, unit, readers) {
       return { preset: "coding", prompt, ref: unit.branch, contract };
     }
     case "review": {
-      const prior = brief.prior !== void 0 ? {
-        findings: (await facts(readers, brief.prior.reviewRunId)).findings ?? [],
-        dispositions: brief.prior.fixRunId !== void 0 ? (await facts(readers, brief.prior.fixRunId)).dispositions ?? [] : []
-      } : void 0;
+      let prior;
+      if (brief.prior !== void 0) {
+        const findings = (await facts(readers, brief.prior.reviewRunId)).findings ?? [];
+        const recorded = brief.prior.codingRunId !== void 0 ? (await facts(readers, brief.prior.codingRunId)).dispositions ?? [] : [];
+        const { matched, dropped } = matchDispositions(findings, recorded);
+        prior = { findings, dispositions: matched, dropped };
+      }
       const turn = buildShipReviewTurn({
         where,
         round: brief.round,
@@ -31588,16 +32302,18 @@ async function composeChild(brief, instance, unit, readers) {
 
 ${turn}`, contract };
     }
-    case "fix": {
+    case "findings": {
       const review = await facts(readers, brief.reviewRunId);
-      const findings = review.findings ?? [];
       return {
         preset: "coding",
-        prompt: buildShipFixTurn({ where, findings, review: review.finalReply ?? "" }),
-        ref: unit.branch,
-        fixRound: { findingIds: findings.map((f) => f.id) }
+        prompt: findingsRequest({ where, findings: review.findings ?? [], review: review.finalReply ?? "" }),
+        ref: unit.branch
       };
     }
+    default: {
+      const unknown = brief;
+      throw new Error(`unknown brief kind ${JSON.stringify(unknown.kind)}`);
+    }
   }
 }
 async function facts(readers, runId3) {
@@ -31610,7 +32326,8 @@ var init_briefs = __esm({
   "../../src/core/coordinator/briefs.ts"() {
     "use strict";
     init_directives();
-    init_codingChild();
+    init_reviewVerdict();
+    init_coordinator();
     init_contract();
     init_preflight();
     init_reviewChild();
@@ -31675,7 +32392,7 @@ async function plan(deps, input) {
   try {
     planId = planIdOf(request.planPath);
   } catch (err2) {
-    return { ok: false, reply: `\u{1F6AB} ${describe3(err2)}` };
+    return { ok: false, reply: `\u{1F6AB} ${describe5(err2)}` };
   }
   let text;
   try {
@@ -31683,7 +32400,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}: ${describe3(err2)}`
+      reply: `\u{1F6AB} The plan \`${request.planPath}\` could not be read at \`${base}\` in ${entry.repo}: ${describe5(err2)}`
     };
   }
   const graph = parsePlanGraph(text, planId);
@@ -31696,7 +32413,7 @@ async function plan(deps, input) {
   try {
     selected = openPlanCursor(graph, request.units).order;
   } catch (err2) {
-    return { ok: false, reply: `\u{1F6AB} ${describe3(err2)}` };
+    return { ok: false, reply: `\u{1F6AB} ${describe5(err2)}` };
   }
   return { ok: true, planned: { kind: "plan", planId, path: request.planPath, base, graph, selected, identity: identity2 } };
 }
@@ -31812,7 +32529,7 @@ async function start(deps, input, instance, units, where, write) {
   try {
     answer = await deps.create(instance.id);
   } catch (err2) {
-    answer = { kind: "unanswered", reason: describe3(err2) };
+    answer = { kind: "unanswered", reason: describe5(err2) };
   }
   switch (answer.kind) {
     case "created": {
@@ -31834,7 +32551,7 @@ async function start(deps, input, instance, units, where, write) {
       );
   }
 }
-var refused3, describe3, RUNNING, ENDED;
+var refused3, describe5, RUNNING, ENDED;
 var init_handOff = __esm({
   "../../src/core/coordinator/handOff.ts"() {
     "use strict";
@@ -31842,7 +32559,7 @@ var init_handOff = __esm({
     init_coordinator();
     init_briefs();
     refused3 = (reply) => ({ status: "aborted", reply });
-    describe3 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe5 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     RUNNING = /* @__PURE__ */ new Set(["queued", "running", "paused", "waiting", "waitingForPause"]);
     ENDED = /* @__PURE__ */ new Set(["complete", "errored", "terminated"]);
   }
@@ -32459,6 +33176,18 @@ var init_ship = __esm({
   }
 });
 
+// ../../src/core/ship/codingChild.ts
+function withContractInFirstUserTurn(messages, block) {
+  const at = messages.findIndex((m) => m.role === "user");
+  if (at < 0) return [...messages, { role: "user", content: [{ type: "text", text: block }] }];
+  return messages.map((m, i) => i === at ? { ...m, content: [...m.content, { type: "text", text: block }] } : m);
+}
+var init_codingChild = __esm({
+  "../../src/core/ship/codingChild.ts"() {
+    "use strict";
+  }
+});
+
 // ../../src/core/dispatch/settle.ts
 function settleThread(deps, ctx) {
   const { msg, admitted, runLoopStarted, control } = ctx;
@@ -32533,22 +33262,22 @@ function createRunEnding(deps) {
       try {
         deps.registry.seal(id, replyOk === void 0 ? {} : { replyOk });
       } catch (err2) {
-        log(`[ending] seal ${id}: ${describe4(err2)}`);
+        log(`[ending] seal ${id}: ${describe6(err2)}`);
       }
       try {
         afterSeal?.();
       } catch (err2) {
-        log(`[ending] after seal ${id}: ${describe4(err2)}`);
+        log(`[ending] after seal ${id}: ${describe6(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}: ${describe4(err2)}`)
+          (err2) => log(`[ending] record ${entry.runId}: ${describe6(err2)}`)
         );
       } catch (err2) {
-        log(`[ending] record ${entry.runId}: ${describe4(err2)}`);
+        log(`[ending] record ${entry.runId}: ${describe6(err2)}`);
       }
     }
   };
@@ -32558,7 +33287,7 @@ function createRunEnding(deps) {
       try {
         deps.onFinished?.(runId3);
       } catch (err2) {
-        log(`[ending] finished ${runId3}: ${describe4(err2)}`);
+        log(`[ending] finished ${runId3}: ${describe6(err2)}`);
       }
     },
     register(entry) {
@@ -32586,7 +33315,7 @@ function createRunEnding(deps) {
     }
   };
 }
-function describe4(err2) {
+function describe6(err2) {
   return err2 instanceof Error ? err2.message : String(err2);
 }
 var init_runEnding = __esm({
@@ -32715,6 +33444,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     if (outcome.kind === "redispatch")
       return dispatch(deps, msg, io, {
         ...opts.parent ? { parent: opts.parent } : {},
+        ...opts.seed ? { seed: opts.seed } : {},
         ...opts.coordinator ? { coordinator: opts.coordinator } : {}
       });
     if (outcome.kind !== "proceed") return ended;
@@ -32784,7 +33514,8 @@ async function dispatch(deps, msg, io, opts = {}) {
     }
     const contractBlock = opts.contract ? renderContract(opts.contract, { maxChars: DEFAULT_CONTRACT_MAX_CHARS }).text : void 0;
     const requestText = route3?.parts ? compoundBrief(directives.text, route3.parts) : directives.text;
-    const built = buildMessages(history, requestText, msg.images, msg.documents);
+    const seed = opts.seed ? "parent" : "channel";
+    const built = buildMessages(opts.seed ?? history, requestText, msg.images, msg.documents);
     const messages = resume ? resume.plan.messages : contractBlock !== void 0 && agent.name !== "review" ? withContractInFirstUserTurn(built, contractBlock) : built;
     const headPreflight = await authorizePrHead({
       msg,
@@ -32821,11 +33552,21 @@ async function dispatch(deps, msg, io, opts = {}) {
       admitted,
       parentRunId,
       coordinator,
+      seed,
+      ...opts.seed ? { seedTurns: opts.seed } : {},
       agentSource,
       ...routeEvent ? { route: routeEvent } : {}
     });
     const { run: run2, runId: runId3, channelVisibility, liveUrl, publishText, publishMeta } = registration;
     registered = run2;
+    const staged = !resume && deps.artifacts && msg.staged && msg.staged.length > 0 ? msg.staged : [];
+    const nextStagedIndex = stagingIndex();
+    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 reservation = await reserveRun(deps, {
       msg,
       agent,
@@ -32843,7 +33584,8 @@ async function dispatch(deps, msg, io, opts = {}) {
       admitted,
       root,
       parentRunId,
-      coordinator
+      coordinator,
+      seed
     });
     if (reservation) {
       reserved = reservation.reserved;
@@ -32873,6 +33615,22 @@ async function dispatch(deps, msg, io, opts = {}) {
       });
       return ended;
     }
+    if (staged.length > 0) {
+      const line3 = stagedCopies ? attachmentsLine(
+        await pullStaged(await stagedCopies, {
+          store: deps.artifacts,
+          executor,
+          resident: resident !== void 0
+        })
+      ) : 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 }] : [
+          { type: "text", text: request.content },
+          { type: "text", text: line3 }
+        ];
+      }
+    }
     const bearer = mintRunBearer(deps, { runId: runId3, agent, profile, resolved, registry, root, clock: clock3 });
     const headGate = await authorizeAttachedHead(deps, {
       msg,
@@ -32937,7 +33695,8 @@ async function dispatch(deps, msg, io, opts = {}) {
       registry,
       resume,
       parentRunId,
-      coordinator
+      coordinator,
+      seed
     });
     ledgerRun = await claimRun(deps, {
       msg,
@@ -32960,7 +33719,8 @@ async function dispatch(deps, msg, io, opts = {}) {
       clock: clock3,
       root,
       parentRunId,
-      coordinator
+      coordinator,
+      seed
     });
     const { spawn: spawn7, runs, steer, wait } = runToolCapabilities(
       { core: deps, dispatch, registry, clock: clock3 },
@@ -32980,6 +33740,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       agent,
       profile,
       resolved,
+      stagingIndex: nextStagedIndex,
       provider,
       model,
       messages,
@@ -33013,7 +33774,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       wait,
       parentRunId,
       coordinator,
-      ...opts.fixRound ? { fixRound: opts.fixRound } : {},
+      seed,
       ...bearer !== void 0 ? { bearer } : {}
     });
     const { answer, prNote, toolCalls, runDiagnosis, checklistAsLeft, checklistCheckedOff, releaseWorkspace } = ran;
@@ -33128,6 +33889,7 @@ var init_dispatcher = __esm({
     init_route();
     init_authorize2();
     init_messages();
+    init_staging();
     init_provision();
     init_run2();
     init_runLoop();
@@ -33146,7 +33908,7 @@ var init_dispatcher = __esm({
 });
 
 // ../../src/core/runHistoryWriter.ts
-function describe5(err2) {
+function describe7(err2) {
   return err2 instanceof Error ? err2.message : String(err2);
 }
 function createRunHistoryWriter(opts) {
@@ -33163,7 +33925,7 @@ function createRunHistoryWriter(opts) {
     try {
       opts.onPersisted?.(id);
     } catch (err2) {
-      opts.warn(`[run-history] onPersisted hook failed for ${id}: ${describe5(err2)}`);
+      opts.warn(`[run-history] onPersisted hook failed for ${id}: ${describe7(err2)}`);
     }
   };
   const attemptAll = async (record2, flag2, sink, span) => {
@@ -33186,12 +33948,12 @@ function createRunHistoryWriter(opts) {
         }
         if (err2 instanceof PermanentStoreError) {
           failures++;
-          opts.warn(`[run-history] ${record2.id} not persisted (permanent, not retried): ${describe5(err2)}`);
+          opts.warn(`[run-history] ${record2.id} not persisted (permanent, not retried): ${describe7(err2)}`);
           return;
         }
         if (attempt >= attempts) {
           failures++;
-          opts.warn(`[run-history] ${record2.id} not persisted after ${attempts} attempts: ${describe5(err2)}`);
+          opts.warn(`[run-history] ${record2.id} not persisted after ${attempts} attempts: ${describe7(err2)}`);
           return;
         }
         await sleep2(jittered(RUN_HISTORY_RETRY_DELAYS_MS[attempt - 1]));
@@ -33211,7 +33973,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: ${describe5(err2)}`);
+        opts.warn(`[run-history] ${record2.id} writer failed unexpectedly: ${describe7(err2)}`);
       }).finally(() => {
         if (flag2) provisionalFlags.delete(flag2);
         void inFlight.delete(p);
@@ -33288,7 +34050,12 @@ function toListItem(record2, bytes) {
   return { ...rest, bytes };
 }
 function retentionPolicyOf(cfg) {
-  return clampRetentionPolicy({ retentionDays: cfg.retentionDays, maxRuns: cfg.maxRuns, maxBytes: cfg.maxBytes });
+  return clampRetentionPolicy({
+    retentionDays: cfg.retentionDays,
+    maxRuns: cfg.maxRuns,
+    maxBytes: cfg.maxBytes,
+    sessionLogMaxBytes: cfg.sessionLogMaxBytes
+  });
 }
 function buildRunStore(cfg, secrets, deps) {
   if (!cfg) return null;
@@ -33532,6 +34299,24 @@ var init_flusher = __esm({
   }
 });
 
+// ../../src/core/runLedger/sessionLog.ts
+function sessionKey(threadKey, agent) {
+  return `${threadKey}:${agent ?? "-"}`;
+}
+function requestIndex(seed) {
+  for (let i = seed.length - 1; i >= 0; i--) if (seed[i].role === "user") return i;
+  return 0;
+}
+var DEFAULT_SESSION_LOG_MAX_BYTES;
+var init_sessionLog = __esm({
+  "../../src/core/runLedger/sessionLog.ts"() {
+    "use strict";
+    init_runRecord();
+    init_runRecord();
+    DEFAULT_SESSION_LOG_MAX_BYTES = DEFAULT_RETENTION_POLICY.sessionLogMaxBytes;
+  }
+});
+
 // ../../src/core/runLedger/types.ts
 var LEASE_MS, HEARTBEAT_MS, APPEND_FLUSH_MS, APPEND_FLUSH_EVENTS, TRANSCRIPT_REQUEST_BYTES, TRANSCRIPT_PART_BYTES, ATTACHMENT_REF_BYTES, GEN_PATTERN;
 var init_types5 = __esm({
@@ -33577,36 +34362,45 @@ function createLedgerWriteThrough(opts) {
       "[ledger] state Worker has no run-ledger routes \u2014 deploy it before this bot version; runs are not tracked until then"
     );
   };
-  async function claim(req, phase) {
+  async function claim(req, opts2 = {}) {
     for (let attempt = 1; ; attempt++) {
       try {
+        let session;
+        if (opts2.seed) {
+          const key = sessionKey(req.threadKey, req.meta.agent);
+          const next = await ledger.sessionTail(key);
+          session = { key, seedFrom: next, request: next + requestIndex(opts2.seed), range: { from: next } };
+        }
         const result = await ledger.claim({
           runId: req.runId,
           threadKey: req.threadKey,
           gen,
           leaseMs,
           startedAt: req.startedAt,
-          meta: req.meta,
+          meta: session ? { ...req.meta, session } : req.meta,
           card: req.card ?? null,
           system: req.system,
           tools: req.tools,
           ...req.state !== void 0 ? { state: req.state } : {},
-          ...phase ? { phase } : {}
+          ...opts2.phase ? { phase: opts2.phase } : {}
         });
-        if (result.ok) return "ok";
-        if (result.live.runId === req.runId) return "fenced";
+        if (result.ok) {
+          if (session) await ledger.claimSession(session.key, req.runId, gen);
+          return session ? { outcome: "ok", session } : { outcome: "ok" };
+        }
+        if (result.live.runId === req.runId) return { outcome: "fenced" };
         warn(
           `[ledger] ${req.threadKey} not tracked: the thread's live row belongs to run ${result.live.runId} (started ${new Date(result.live.startedAt).toISOString()}) \u2014 reclaim is the resume phase's`
         );
-        return "untracked";
+        return { outcome: "untracked" };
       } catch (err2) {
         if (err2 instanceof RouteMissingError) {
           routeMissing();
-          return "untracked";
+          return { outcome: "untracked" };
         }
         if (err2 instanceof PermanentStoreError || attempt >= claimAttempts) {
-          warn(`[ledger] ${req.threadKey} not tracked: claim failed after ${attempt} attempt(s): ${describe6(err2)}`);
-          return "untracked";
+          warn(`[ledger] ${req.threadKey} not tracked: claim failed after ${attempt} attempt(s): ${describe8(err2)}`);
+          return { outcome: "untracked" };
         }
         await sleep2(RETRY_MS[Math.min(attempt, RETRY_MS.length) - 1]);
       }
@@ -33626,6 +34420,15 @@ function createLedgerWriteThrough(opts) {
     seeded = false;
     adopted = false;
     handedOff = false;
+    /** The run's place in its session log (session-log item 2); undefined for
+     *  a run without a conversation of its own and for an adopted row claimed
+     *  before the log existed. */
+    session;
+    /** Turns of the run's conversation on the ledger, counted from its seed —
+     *  the last step record's `turnIndex` — so the finish can close the range. */
+    turnsWritten;
+    /** A detach left the log short of what the model saw: the record says `broken`. */
+    broken = false;
     stepNo;
     lastSeq;
     state;
@@ -33646,7 +34449,10 @@ function createLedgerWriteThrough(opts) {
       },
       ...opts.schedule ? { schedule: opts.schedule } : {}
     });
-    constructor(req, from = { stepNo: 0, lastSeq: 0 }) {
+    constructor(req, from = {
+      stepNo: 0,
+      lastSeq: 0
+    }) {
       this.runId = req.runId;
       this.threadKey = req.threadKey;
       this.state = req.state ?? {};
@@ -33655,6 +34461,11 @@ function createLedgerWriteThrough(opts) {
       this.stepNo = from.stepNo;
       this.lastSeq = from.lastSeq;
       this.adopted = from.resumable === true;
+      this.session = from.session;
+    }
+    /** A reservation learns its session when the prompt's claim promotes it. */
+    bindSession(session) {
+      this.session = session;
     }
     get resumable() {
       return !this.detached && (this.seeded || this.adopted);
@@ -33662,11 +34473,24 @@ function createLedgerWriteThrough(opts) {
     markHandedOff() {
       this.handedOff = true;
     }
+    /** The run's range as the finished record carries it (session-log item 2):
+     *  closed at the last turn written, or `broken` after a detach — the log
+     *  ends short of what the model saw, and the next run in the session must
+     *  know. A run that wrote no turn leaves the range open. */
+    sessionOnRecord() {
+      if (!this.session) return void 0;
+      if (this.broken) return { ...this.session, range: "broken" };
+      const from = this.session.range === "broken" ? this.session.seedFrom : this.session.range.from;
+      const to = this.turnsWritten !== void 0 && this.turnsWritten > 0 ? this.session.seedFrom + this.turnsWritten - 1 : void 0;
+      return { ...this.session, range: to !== void 0 && to >= from ? { from, to } : { from } };
+    }
     sink = {
-      put: async (record2) => {
+      put: async (plain4) => {
         this.finished = true;
         live.delete(this);
         await this.close();
+        const session = this.sessionOnRecord();
+        const record2 = session ? { ...plain4, session } : plain4;
         let result;
         try {
           result = await ledger.finish(this.runId, gen, record2);
@@ -33687,6 +34511,7 @@ function createLedgerWriteThrough(opts) {
     detach(reason) {
       if (this.detached) return;
       this.detached = true;
+      this.broken = true;
       warn(`[ledger] ${this.threadKey} run ${this.runId} detached: ${reason} \u2014 this run is not resumable`);
       this.stopHeartbeat();
       live.delete(this);
@@ -33704,13 +34529,15 @@ function createLedgerWriteThrough(opts) {
      *  no record at all was killed before its conversation was stored and
      *  closes `interrupted`. */
     async seed(messages, budgetMs) {
-      const turns = messages.map((message2, idx) => ({ idx, message: message2 }));
+      const base = this.session?.seedFrom ?? 0;
+      const turns = messages.map((message2, i) => ({ idx: base + i, message: message2 }));
       try {
-        const seeded = await ledger.seed(this.runId, gen, turns);
+        const seeded = await ledger.seed(this.runId, gen, turns, this.session?.key);
         if (!seeded.ok) {
           this.detach(`seed refused (${seeded.reason})`);
           return;
         }
+        this.turnsWritten = messages.length;
         const recorded = await ledger.step(
           this.runId,
           gen,
@@ -33729,16 +34556,19 @@ function createLedgerWriteThrough(opts) {
         if (!recorded.ok) this.detach(`seed record refused (${recorded.reason})`);
         else this.seeded = true;
       } catch (err2) {
-        this.detach(`seed failed: ${describe6(err2)}`);
+        this.detach(`seed failed: ${describe8(err2)}`);
       }
     }
     async step(report2) {
       if (this.detached) return;
-      const turns = report2.turns.map((message2, i) => ({ idx: report2.firstIdx + i, message: message2 }));
+      const base = this.session?.seedFrom ?? 0;
+      const turns = report2.turns.map((message2, i) => ({ idx: base + report2.firstIdx + i, message: message2 }));
+      if (report2.compaction)
+        turns.push({ idx: base + report2.firstIdx + report2.turns.length, compaction: report2.compaction });
       const record2 = {
         step: ++this.stepNo,
         seq: this.lastSeq,
-        turnIndex: report2.firstIdx + report2.turns.length,
+        turnIndex: report2.firstIdx + turns.length,
         inFlight: report2.inFlight,
         inboxConsumedSeq: report2.inboxConsumedSeq,
         remainingMs: report2.remainingMs,
@@ -33747,12 +34577,13 @@ function createLedgerWriteThrough(opts) {
       };
       for (let attempt = 1; ; attempt++) {
         try {
-          const result = await ledger.step(this.runId, gen, record2, turns);
+          const result = await ledger.step(this.runId, gen, record2, turns, this.session?.key);
           if (!result.ok) this.detach(`step ${record2.step} refused (${result.reason})`);
+          else this.turnsWritten = record2.turnIndex;
           return;
         } catch (err2) {
           if (err2 instanceof RouteMissingError || err2 instanceof PermanentStoreError || attempt >= 2) {
-            this.detach(`step ${record2.step} failed: ${describe6(err2)}`);
+            this.detach(`step ${record2.step} failed: ${describe8(err2)}`);
             return;
           }
           await sleep2(RETRY_MS[0]);
@@ -33785,7 +34616,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: ${describe6(err2)}`);
+            warn(`[ledger] ${this.threadKey} state not written: ${describe8(err2)}`);
             return;
           }
           await sleep2(RETRY_MS[0]);
@@ -33803,7 +34634,7 @@ function createLedgerWriteThrough(opts) {
         this.detach(`finishing refused (fenced)`);
         return "fenced";
       } catch (err2) {
-        warn(`[ledger] ${this.threadKey} finishing failed: ${describe6(err2)}`);
+        warn(`[ledger] ${this.threadKey} finishing failed: ${describe8(err2)}`);
         return "unavailable";
       }
     }
@@ -33818,7 +34649,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: ${describe6(err2)} \u2014 the sweep will take the row once its lease lapses`
+          `[ledger] ${this.threadKey} abandon failed: ${describe8(err2)} \u2014 the sweep will take the row once its lease lapses`
         );
       }
     }
@@ -33839,7 +34670,7 @@ function createLedgerWriteThrough(opts) {
           this.onStop(result.stop);
         }
       } catch (err2) {
-        warn(`[ledger] ${this.threadKey} heartbeat failed: ${describe6(err2)}`);
+        warn(`[ledger] ${this.threadKey} heartbeat failed: ${describe8(err2)}`);
       }
     }
     stopHeartbeat() {
@@ -33856,8 +34687,8 @@ function createLedgerWriteThrough(opts) {
   return {
     gen,
     async reserve(req) {
-      const claimed2 = await claim({ ...req, system: "", tools: [], state: {} }, "attaching");
-      if (claimed2 !== "ok") return void 0;
+      const claimed2 = await claim({ ...req, system: "", tools: [], state: {} }, { phase: "attaching" });
+      if (claimed2.outcome !== "ok") return void 0;
       const run2 = new TrackedRun(req);
       run2.startHeartbeat();
       live.add(run2);
@@ -33865,35 +34696,46 @@ function createLedgerWriteThrough(opts) {
     },
     async open(req) {
       const reserved = req.reservation;
+      const seed = req.seed?.messages;
       if (reserved instanceof TrackedRun) {
         if (!reserved.tracked()) return void 0;
-        const claimed3 = await claim(req);
-        if (claimed3 === "fenced") {
+        const claimed3 = await claim(req, seed ? { seed } : {});
+        if (claimed3.outcome === "fenced") {
           reserved.detach("promotion refused (fenced)");
           return void 0;
         }
-        if (claimed3 !== "ok") {
+        if (claimed3.outcome !== "ok") {
           await reserved.close();
           live.delete(reserved);
           return void 0;
         }
+        if (claimed3.session) reserved.bindSession(claimed3.session);
         if (req.seed) await reserved.seed(req.seed.messages, req.seed.budgetMs);
         return reserved;
       }
-      const claimed2 = await claim(req);
-      if (claimed2 === "fenced") {
+      const claimed2 = await claim(req, seed ? { seed } : {});
+      if (claimed2.outcome === "fenced") {
         warn(`[ledger] ${req.threadKey} not tracked: run ${req.runId} is live under another generation`);
         return void 0;
       }
-      if (claimed2 !== "ok") return void 0;
-      const run2 = new TrackedRun(req);
+      if (claimed2.outcome !== "ok") return void 0;
+      const run2 = new TrackedRun(req, {
+        stepNo: 0,
+        lastSeq: 0,
+        ...claimed2.session ? { session: claimed2.session } : {}
+      });
       if (req.seed) await run2.seed(req.seed.messages, req.seed.budgetMs);
       run2.startHeartbeat();
       live.add(run2);
       return run2;
     },
     adopt(req) {
-      const run2 = new TrackedRun(req, { stepNo: req.lastStep, lastSeq: req.lastSeq, resumable: true });
+      const run2 = new TrackedRun(req, {
+        stepNo: req.lastStep,
+        lastSeq: req.lastSeq,
+        resumable: true,
+        ...req.session ? { session: req.session } : {}
+      });
       run2.startHeartbeat();
       live.add(run2);
       return run2;
@@ -33906,7 +34748,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}: ${describe6(err2)} \u2014 the follow-up rides in memory only`);
+        warn(`[ledger] inbox push failed for run ${runId3}: ${describe8(err2)} \u2014 the follow-up rides in memory only`);
         return void 0;
       }
     },
@@ -33915,7 +34757,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}: ${describe6(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}: ${describe8(err2)} \u2014 resuming with the reclaim's snapshot only`
         );
         return [];
       }
@@ -33932,17 +34774,18 @@ function createLedgerWriteThrough(opts) {
         for (const r of candidates) if (markedSet.has(r.runId)) r.markHandedOff();
         return { marked };
       } catch (err2) {
-        return { marked: [], failed: describe6(err2) };
+        return { marked: [], failed: describe8(err2) };
       }
     }
   };
 }
-var NullLedgerWriteThrough, NullLedgerRun, RETRY_MS, describe6;
+var NullLedgerWriteThrough, NullLedgerRun, RETRY_MS, describe8;
 var init_writeThrough = __esm({
   "../../src/core/runLedger/writeThrough.ts"() {
     "use strict";
     init_runStoreWorker();
     init_flusher();
+    init_sessionLog();
     init_types5();
     NullLedgerWriteThrough = class {
       constructor(gen, fallback) {
@@ -34000,7 +34843,7 @@ var init_writeThrough = __esm({
       }
     };
     RETRY_MS = [200, 800];
-    describe6 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe8 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   }
 });
 
@@ -34092,6 +34935,24 @@ var init_residentFleet = __esm({
 });
 
 // ../../src/providers/openaiCompat.ts
+function buildOpenAIBody(req) {
+  const messages = [];
+  if (req.system) messages.push({ role: "system", content: req.system });
+  for (const m of req.messages) messages.push(...toOAIMessages(m));
+  const body = {
+    model: req.model,
+    max_tokens: req.maxTokens,
+    messages
+  };
+  if (req.tools && req.tools.length > 0) {
+    body.tools = req.tools.map((t) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.inputSchema }
+    }));
+    if (req.toolChoice) body.tool_choice = { type: "function", function: { name: req.toolChoice.name } };
+  }
+  return body;
+}
 function toOAIMessages(m) {
   if (m.role === "assistant") {
     const text = m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
@@ -34178,20 +35039,7 @@ var init_openaiCompat = __esm({
         this.apiKey = cfg.apiKeyEnv ? processSecrets.named(cfg.apiKeyEnv) : void 0;
       }
       async complete(req) {
-        const messages = [];
-        if (req.system) messages.push({ role: "system", content: req.system });
-        for (const m of req.messages) messages.push(...toOAIMessages(m));
-        const body = {
-          model: req.model,
-          max_tokens: req.maxTokens,
-          messages
-        };
-        if (req.tools && req.tools.length > 0) {
-          body.tools = req.tools.map((t) => ({
-            type: "function",
-            function: { name: t.name, description: t.description, parameters: t.inputSchema }
-          }));
-        }
+        const body = buildOpenAIBody(req);
         const res = await fetch(`${this.baseUrl}/chat/completions`, {
           method: "POST",
           headers: {
@@ -34683,6 +35531,7 @@ function classifyDocument(mimetype, name) {
 async function fetchImages(files, maxImages, maxTotalBytes = Infinity) {
   const images = [];
   const skipped = [];
+  const skippedFiles = [];
   let bytes = 0;
   const candidates = [];
   for (const f of files ?? []) {
@@ -34690,6 +35539,7 @@ async function fetchImages(files, maxImages, maxTotalBytes = Infinity) {
     const url = f.url_private_download ?? f.url_private;
     if (!url || !f.mimetype || !IMAGE_TYPES2.has(f.mimetype) || (f.size ?? 0) > MAX_IMAGE_BYTES || candidates.length >= maxImages) {
       skipped.push(label);
+      skippedFiles.push(f);
       continue;
     }
     candidates.push({ f, label, url, mediaType: f.mimetype });
@@ -34703,12 +35553,13 @@ async function fetchImages(files, maxImages, maxTotalBytes = Infinity) {
     const buf2 = downloads[i];
     if (!buf2 || buf2.byteLength > MAX_IMAGE_BYTES || bytes + buf2.byteLength > maxTotalBytes) {
       skipped.push(label);
+      skippedFiles.push(f);
       return;
     }
     bytes += buf2.byteLength;
     images.push({ mediaType, data: buf2.toString("base64"), name: f.name });
   });
-  return { images, skipped, bytes };
+  return { images, skipped, skippedFiles, bytes };
 }
 async function downloadSlackFile(url, label, isLoginPage) {
   const token2 = processSecrets.get("SLACK_BOT_TOKEN");
@@ -34727,6 +35578,7 @@ async function downloadSlackFile(url, label, isLoginPage) {
 async function fetchDocuments(files, maxDocs, maxTotalBytes = Infinity) {
   const documents = [];
   const skipped = [];
+  const skippedFiles = [];
   let bytes = 0;
   const candidates = [];
   for (const f of files ?? []) {
@@ -34735,6 +35587,7 @@ async function fetchDocuments(files, maxDocs, maxTotalBytes = Infinity) {
     const kind = classifyDocument(f.mimetype, f.name);
     if (!url || !kind || (f.size ?? 0) > MAX_DOCUMENT_BYTES || candidates.length >= maxDocs) {
       skipped.push(label);
+      skippedFiles.push(f);
       continue;
     }
     candidates.push({ f, label, url, kind });
@@ -34748,6 +35601,7 @@ async function fetchDocuments(files, maxDocs, maxTotalBytes = Infinity) {
     const buf2 = downloads[i];
     if (!buf2 || buf2.byteLength > MAX_DOCUMENT_BYTES || bytes + buf2.byteLength > maxTotalBytes) {
       skipped.push(label);
+      skippedFiles.push(f);
       return;
     }
     bytes += buf2.byteLength;
@@ -34757,9 +35611,43 @@ async function fetchDocuments(files, maxDocs, maxTotalBytes = Infinity) {
       name: f.name
     });
   });
-  return { documents, skipped, bytes };
+  return { documents, skipped, skippedFiles, bytes };
 }
-var IMAGE_TYPES2, MAX_IMAGE_BYTES, MAX_IMAGES_PER_MESSAGE, MAX_HISTORY_IMAGES, MAX_HISTORY_IMAGE_BYTES, PDF_TYPE2, TEXT_MIME_TYPES, GENERIC_MIME_TYPES, TEXT_EXTENSIONS, SECRET_FILE_EXTENSIONS, SECRET_FILE_PREFIXES, MAX_DOCUMENT_BYTES, MAX_DOCS_PER_MESSAGE, MAX_HISTORY_DOCS, MAX_HISTORY_DOCUMENT_BYTES, fileLabel;
+function stagedFiles(unsupported, opts) {
+  if (!opts.staging) return { staged: [], skipped: unsupported.map(fileLabel) };
+  const staged = [];
+  const skipped = [];
+  let total = 0;
+  for (const f of unsupported) {
+    const label = fileLabel(f);
+    const url = f.url_private_download ?? f.url_private;
+    const size = f.size ?? 0;
+    if (isSecretFile(f.name)) {
+      skipped.push(`${label} \u2014 looks like a credential or key file`);
+      continue;
+    }
+    if (!url || !f.name || size <= 0) {
+      skipped.push(`${label} \u2014 Slack gave no download URL, name or size`);
+      continue;
+    }
+    if (size > MAX_STAGED_FILE_BYTES) {
+      skipped.push(`${label} \u2014 ${size} bytes is over the ${MAX_STAGED_FILE_BYTES}-byte per-file ceiling`);
+      continue;
+    }
+    if (staged.length >= MAX_STAGED_PER_MESSAGE) {
+      skipped.push(`${label} \u2014 more than ${MAX_STAGED_PER_MESSAGE} files on one message`);
+      continue;
+    }
+    if (total + size > opts.maxBytesPerMessage) {
+      skipped.push(`${label} \u2014 the message's files exceed the ${opts.maxBytesPerMessage}-byte budget`);
+      continue;
+    }
+    total += size;
+    staged.push({ name: f.name, size, type: f.mimetype ?? "application/octet-stream", url, messageId: opts.messageId });
+  }
+  return { staged, skipped };
+}
+var IMAGE_TYPES2, MAX_IMAGE_BYTES, MAX_IMAGES_PER_MESSAGE, MAX_HISTORY_IMAGES, MAX_HISTORY_IMAGE_BYTES, PDF_TYPE2, TEXT_MIME_TYPES, GENERIC_MIME_TYPES, TEXT_EXTENSIONS, SECRET_FILE_EXTENSIONS, SECRET_FILE_PREFIXES, MAX_DOCUMENT_BYTES, MAX_DOCS_PER_MESSAGE, MAX_HISTORY_DOCS, MAX_HISTORY_DOCUMENT_BYTES, fileLabel, MAX_STAGED_FILE_BYTES, MAX_STAGED_PER_MESSAGE;
 var init_attachments = __esm({
   "../../src/channels/slack/attachments.ts"() {
     "use strict";
@@ -34842,6 +35730,8 @@ var init_attachments = __esm({
     MAX_HISTORY_DOCS = 20;
     MAX_HISTORY_DOCUMENT_BYTES = 32 * 1024 * 1024;
     fileLabel = (f) => `${f.name ?? f.id ?? "file"} (${f.mimetype ?? "unknown type"})`;
+    MAX_STAGED_FILE_BYTES = 1073741824;
+    MAX_STAGED_PER_MESSAGE = 10;
   }
 });
 
@@ -35480,7 +36370,13 @@ async function handle(deps, { client, statusClient }, ev) {
   const receivedAt = systemClock();
   const trace = startRequestRoot(deps, { channel: "slack", receivedAt, originAt: tsMs(ev.ts) });
   try {
-    const received = await trace.root.span("slack.receive", (span) => receiveSlackMessage(client, ev, span));
+    const received = await trace.root.span(
+      "slack.receive",
+      (span) => receiveSlackMessage(client, ev, span, {
+        staging: deps.artifacts !== void 0,
+        maxBytesPerMessage: deps.config.config.artifacts?.inbound?.maxBytesPerMessage ?? ARTIFACT_DEFAULTS.maxBytesPerMessage
+      })
+    );
     if (!received) {
       trace.root.end("ok", { status: "refused" });
       return;
@@ -35495,7 +36391,7 @@ async function handle(deps, { client, statusClient }, ev) {
     if (!trace.root.ended) trace.root.end("error", { status: "failed" });
   }
 }
-async function receiveSlackMessage(client, ev, span) {
+async function receiveSlackMessage(client, ev, span, policy) {
   const drop = await dedupeDelivery(client, ev);
   if (drop) {
     console.log(`[redelivery] ${ev.channel}:${ev.ts} dropped: ${drop}`);
@@ -35509,12 +36405,13 @@ async function receiveSlackMessage(client, ev, span) {
   const delayNote = ev.caughtUp ? new SlackIO(client, ev).reply(catchUpDelayNote(ev.ts, systemClock())).catch((err2) => {
     console.error(`[catch-up] ${ev.channel}:${ev.ts} delay note failed: ${err2.message}`);
   }) : Promise.resolve();
-  const [{ images, skipped: skippedImages }, { documents, skipped: skippedDocs }] = await Promise.all([
+  const [{ images, skippedFiles: imagePassSkipped }, { documents, skippedFiles: documentPassSkipped }] = await Promise.all([
     fetchImages(ev.files, MAX_IMAGES_PER_MESSAGE),
     fetchDocuments(ev.files, MAX_DOCS_PER_MESSAGE),
     delayNote
   ]);
-  const skipped = skippedImages.filter((s) => skippedDocs.includes(s));
+  const unsupported = imagePassSkipped.filter((f) => documentPassSkipped.includes(f));
+  const { staged, skipped } = stagedFiles(unsupported, { ...policy, messageId: ev.ts });
   const [channelName, userName, team] = await Promise.all([
     resolveChannelName(client, ev.channel),
     resolveUserName(client, ev.user),
@@ -35532,7 +36429,8 @@ async function receiveSlackMessage(client, ev, span) {
     userName,
     sourceUrl: team ? slackPermalink(team, ev.channel, ev.ts, ev.threadTs) : void 0,
     images: images.length > 0 ? images : void 0,
-    documents: documents.length > 0 ? documents : void 0
+    documents: documents.length > 0 ? documents : void 0,
+    ...staged.length > 0 ? { staged } : {}
   };
 }
 function resumeSlackIO(client, run2, opts = {}) {
@@ -35599,6 +36497,7 @@ var init_slack = __esm({
     init_statusCard();
     init_slackCatchUp();
     init_secrets2();
+    init_config();
     init_slackCatchUpStatus();
     init_slackSocketStatus();
     init_slackTriggers();
@@ -35664,6 +36563,30 @@ ${file.text}`));
           initial_comment: mdToMrkdwn(file.lead)
         });
       }
+      /** The external-upload flow (docs/reference/specs/slack-channel.md item 10,
+       *  record 0033): `files.getUploadURLExternal` mints a URL for exactly
+       *  `size` bytes under `name`; the run's container POSTs the file there; then
+       *  `complete` shares it into this thread with the lead as the comment
+       *  (`files.completeUploadExternal`). The bot never sees the bytes. A ticket
+       *  Slack answers without a URL or id is refused by name. */
+      async uploadTicket(file) {
+        const minted = await this.client.files.getUploadURLExternal({ filename: file.name, length: file.size });
+        const url = minted.upload_url;
+        const id = minted.file_id;
+        if (!url || !id)
+          throw new Error(`files.getUploadURLExternal answered without an upload_url and file_id for ${file.name}`);
+        return {
+          url,
+          complete: async (lead) => {
+            await this.client.files.completeUploadExternal({
+              files: [{ id, title: file.name }],
+              channel_id: this.ev.channel,
+              thread_ts: this.ev.threadTs,
+              initial_comment: mdToMrkdwn(lead)
+            });
+          }
+        };
+      }
       async post(mrkdwn) {
         for (const chunk of chunkText(mrkdwn, SLACK_MSG_LIMIT)) {
           await this.client.chat.postMessage({
@@ -36385,31 +37308,6 @@ var init_mcp3 = __esm({
   }
 });
 
-// ../../src/artifacts/contentType.ts
-var INLINE_IMAGE_TYPES;
-var init_contentType = __esm({
-  "../../src/artifacts/contentType.ts"() {
-    "use strict";
-    INLINE_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-  }
-});
-
-// ../../src/artifacts/keys.ts
-function safeBasename(name) {
-  const segments2 = name.split(/[\\/]+/).filter((s) => s.length > 0);
-  const last = segments2[segments2.length - 1] ?? "";
-  const reduced = last.replace(SAFE, "_").replace(/\.{2,}/g, "_").replace(/_+/g, "_");
-  if (reduced === "" || /^[._-]+$/.test(reduced)) return "file";
-  return reduced;
-}
-var SAFE;
-var init_keys = __esm({
-  "../../src/artifacts/keys.ts"() {
-    "use strict";
-    SAFE = /[^A-Za-z0-9._-]+/g;
-  }
-});
-
 // ../../src/channels/scheduledPanel.ts
 function buildScheduledRows(schedules, firings, liveRuns, now) {
   const byName = /* @__PURE__ */ new Map();
@@ -37226,7 +38124,7 @@ var init_liveView = __esm({
 // ../../src/channels/webAssets.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync3 } from "node:fs";
 import { join as join13 } from "node:path";
-function contentTypeFor(path) {
+function contentTypeFor2(path) {
   const dot = path.lastIndexOf(".");
   return (dot === -1 ? void 0 : CONTENT_TYPES[path.slice(dot)]) ?? "application/octet-stream";
 }
@@ -37271,7 +38169,7 @@ function loadWebAssets(distDir) {
       return true;
     }
     res.writeHead(200, {
-      "content-type": contentTypeFor(path),
+      "content-type": contentTypeFor2(path),
       "content-length": String(body.byteLength),
       "cache-control": "public, max-age=31536000, immutable"
     });
@@ -38157,6 +39055,16 @@ function turnRows(idx, message2, opts = {}) {
   const refBytes = opts.attachmentRefBytes ?? ATTACHMENT_REF_BYTES;
   const rows = [];
   const attachments = [];
+  if (isCompaction(message2)) {
+    const json2 = JSON.stringify({ compaction: message2.compaction });
+    const bytes = utf8ByteLength(json2);
+    if (bytes > partBytes) {
+      throw new Error(
+        `transcript: the compaction row at turn ${idx} is ${bytes} bytes, over the ${partBytes} row budget`
+      );
+    }
+    return { rows: [{ idx, part: 0, json: json2 }], attachments };
+  }
   message2.content.forEach((part, i) => {
     let stored = part;
     if (hasData(part) && part.data.length > refBytes) {
@@ -38190,49 +39098,69 @@ function chunkRows(rows, maxBytes) {
   if (current.length > 0) chunks.push(current);
   return chunks;
 }
-function assembleTranscript(rows, attachments) {
+function assembleTranscript(rows, attachments, base = 0) {
   const byRef = new Map(attachments.map((a) => [a.ref, a]));
   const byTurn = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    let parts = byTurn.get(row.idx);
-    if (!parts) byTurn.set(row.idx, parts = /* @__PURE__ */ new Map());
+    const idx = row.idx - base;
+    let parts = byTurn.get(idx);
+    if (!parts) byTurn.set(idx, parts = /* @__PURE__ */ new Map());
     parts.set(row.part, JSON.parse(row.json));
   }
   const messages = [];
+  const compactions = [];
+  const messageIndexOf = /* @__PURE__ */ new Map();
+  const gap = (why) => ({
+    complete: false,
+    turns: messages.length + compactions.length,
+    messages,
+    compactions,
+    gap: why
+  });
   const turnCount = byTurn.size === 0 ? 0 : Math.max(...byTurn.keys()) + 1;
   for (let idx = 0; idx < turnCount; idx++) {
     const parts = byTurn.get(idx);
-    if (!parts) return { complete: false, turns: messages.length, messages, gap: `turn ${idx} is missing` };
+    if (!parts) return gap(`turn ${idx} is missing`);
+    const first = parts.get(0);
+    if (first && "compaction" in first) {
+      compactions.push({ before: messages.length, entry: first.compaction });
+      continue;
+    }
     const content = [];
     let role;
     const partCount = Math.max(...parts.keys()) + 1;
     for (let p = 0; p < partCount; p++) {
       const stored = parts.get(p);
-      if (!stored)
-        return { complete: false, turns: messages.length, messages, gap: `turn ${idx} is missing part ${p}` };
+      if (!stored || "compaction" in stored) return gap(`turn ${idx} is missing part ${p}`);
       role = stored.role;
       const part = stored.part;
       if (part.dataRef !== void 0) {
         const att = byRef.get(part.dataRef);
-        if (!att)
-          return { complete: false, turns: messages.length, messages, gap: `attachment ${part.dataRef} is missing` };
+        if (!att) return gap(`attachment ${part.dataRef} is missing`);
         const { dataRef: _ref, ...rest } = part;
         content.push({ ...rest, data: att.data });
       } else {
         content.push(part);
       }
     }
+    messageIndexOf.set(idx, messages.length);
     messages.push({ role: role ?? "user", content });
   }
-  return { complete: true, turns: messages.length, messages };
+  for (const c of compactions) {
+    if (c.entry.keptFrom === void 0) continue;
+    const kept = messageIndexOf.get(c.entry.keptFrom - base);
+    if (kept !== void 0) c.keptBefore = kept;
+  }
+  return { complete: true, turns: messages.length + compactions.length, messages, compactions };
 }
-var attachmentRef;
+var attachmentRef, isCompaction;
 var init_transcript = __esm({
   "../../src/core/runLedger/transcript.ts"() {
     "use strict";
     init_runRecord();
     init_types5();
     attachmentRef = (idx, part) => `t${idx}p${part}`;
+    isCompaction = (v) => "compaction" in v;
   }
 });
 
@@ -38247,6 +39175,9 @@ function buildRunLedger(cfg, secrets, deps = {}) {
     baseUrl: worker.baseUrl,
     token: token2.reveal(),
     storeKey: RUN_STORE_KEY,
+    // The same clamped policy the run store proposes, so the session logs and
+    // the run records are bounded by one configuration.
+    sessionLogMaxBytes: retentionPolicyOf(cfg).sessionLogMaxBytes,
     ...deps.fetch ? { fetch: deps.fetch } : {}
   });
 }
@@ -38255,7 +39186,9 @@ var init_runLedgerWorker = __esm({
   "../../src/core/runLedgerWorker.ts"() {
     "use strict";
     init_runRecord();
+    init_runStore();
     init_runStoreWorker();
+    init_sessionLog();
     init_transcript();
     init_types5();
     WorkerRunLedger = class {
@@ -38319,41 +39252,94 @@ var init_runLedgerWorker = __esm({
             }
           };
         }
-        await this.post("/runs/transcript/owner", { runId: req.runId, gen: req.gen });
         return { ok: true };
       }
-      async writeTurns(runId3, gen, turns) {
+      /** The write route and its body for a run's rows: the session log when the
+       *  run has one, the run's own transcript object otherwise. */
+      target(runId3, gen, session) {
+        if (session === void 0) return { path: "/runs/transcript/write", body: { runId: runId3, gen } };
+        this.checkSessionKey(session);
+        return { path: "/runs/session/write", body: { key: session, gen } };
+      }
+      async writeTurns(runId3, gen, turns, session) {
         const rows = [];
         const attachments = [];
         for (const t of turns) {
-          const out = turnRows(t.idx, t.message);
+          const out = turnRows(t.idx, "message" in t ? t.message : { compaction: t.compaction });
           rows.push(...out.rows);
           attachments.push(...out.attachments);
         }
+        const { path, body } = this.target(runId3, gen, session);
         for (const a of attachments) {
-          const r = await this.post("/runs/transcript/write", { runId: runId3, gen, rows: [], attachments: [a] });
+          const r = await this.post(path, { ...body, rows: [], attachments: [a] });
           const f = this.fenceResult(r);
           if (!f.ok) return f;
         }
         const chunks = chunkRows(rows, TRANSCRIPT_REQUEST_BYTES - 4096);
         for (const chunk of chunks.length ? chunks : [[]]) {
           if (chunk.length === 0 && attachments.length > 0) continue;
-          const r = await this.post("/runs/transcript/write", { runId: runId3, gen, rows: chunk, attachments: [] });
+          const r = await this.post(path, { ...body, rows: chunk, attachments: [] });
           const f = this.fenceResult(r);
           if (!f.ok) return f;
         }
         return { ok: true };
       }
-      async seed(runId3, gen, turns) {
+      async seed(runId3, gen, turns, session) {
         this.checkIds(runId3, gen);
-        return this.writeTurns(runId3, gen, turns);
+        return this.writeTurns(runId3, gen, turns, session);
       }
-      async step(runId3, gen, record2, turns) {
+      async step(runId3, gen, record2, turns, session) {
         this.checkIds(runId3, gen);
-        const written = await this.writeTurns(runId3, gen, turns);
+        const written = await this.writeTurns(runId3, gen, turns, session);
         if (!written.ok) return written;
         return this.fenceResult(await this.post("/runs/step", { storeKey: this.opts.storeKey, runId: runId3, gen, record: record2 }));
       }
+      checkSessionKey(key) {
+        if (!SESSION_KEY_PATTERN.test(key))
+          throw new PermanentStoreError(`run ledger: malformed session key ${JSON.stringify(key)}`);
+      }
+      async sessionTail(key) {
+        this.checkSessionKey(key);
+        const r = await this.post("/runs/session/tail", { key });
+        return typeof r.data.next === "number" ? r.data.next : 0;
+      }
+      async claimSession(key, runId3, gen, maxBytes) {
+        this.checkSessionKey(key);
+        this.checkIds(runId3, gen);
+        await this.post("/runs/session/owner", {
+          key,
+          runId: runId3,
+          gen,
+          maxBytes: maxBytes ?? this.opts.sessionLogMaxBytes ?? DEFAULT_SESSION_LOG_MAX_BYTES
+        });
+      }
+      async releaseSession(key, runId3, gen) {
+        this.checkSessionKey(key);
+        this.checkIds(runId3, gen);
+        return this.fenceResult(await this.post("/runs/session/clear-owner", { key, runId: runId3, gen }));
+      }
+      async readSession(key, from, to) {
+        this.checkSessionKey(key);
+        const r = await this.post("/runs/session/read", { key, from, ...to !== void 0 ? { to } : {} });
+        return assembleTranscript(
+          Array.isArray(r.data.rows) ? r.data.rows : [],
+          Array.isArray(r.data.attachments) ? r.data.attachments : [],
+          from
+        );
+      }
+      async readSessionTail(key, maxBytes) {
+        this.checkSessionKey(key);
+        const r = await this.post("/runs/session/read-tail", { key, maxBytes });
+        const from = typeof r.data.from === "number" ? r.data.from : 0;
+        return {
+          from,
+          transcript: assembleTranscript(
+            Array.isArray(r.data.rows) ? r.data.rows : [],
+            Array.isArray(r.data.attachments) ? r.data.attachments : [],
+            from
+          )
+        };
+      }
       async heartbeat(runId3, gen, leaseMs) {
         this.checkIds(runId3, gen);
         const r = await this.post("/runs/heartbeat", { storeKey: this.opts.storeKey, runId: runId3, gen, leaseMs });
@@ -38405,22 +39391,23 @@ var init_runLedgerWorker = __esm({
         const r = await this.post("/runs/finish", { storeKey: this.opts.storeKey, runId: runId3, gen, record: record2 });
         const f = this.fenceResult(r);
         if (!f.ok) return f;
-        await this.post("/runs/transcript/clear", { runId: runId3 }).catch(() => {
-        });
+        if (record2.session)
+          await this.post("/runs/session/clear-owner", { key: record2.session.key, runId: runId3, gen }).catch(() => {
+          });
         return { ok: true, stored: r.data.stored === true };
       }
       async abandon(runId3, gen) {
         this.checkIds(runId3, gen);
-        const f = this.fenceResult(await this.post("/runs/abandon", { storeKey: this.opts.storeKey, runId: runId3, gen }));
-        if (!f.ok) return f;
-        await this.post("/runs/transcript/clear", { runId: runId3 }).catch(() => {
-        });
-        return f;
+        return this.fenceResult(await this.post("/runs/abandon", { storeKey: this.opts.storeKey, runId: runId3, gen }));
       }
       async reclaim(gen, now, leaseMs) {
         const r = await this.post("/runs/reclaim", { storeKey: this.opts.storeKey, gen, now, leaseMs });
         const runs = Array.isArray(r.data.runs) ? r.data.runs : [];
-        for (const run2 of runs) await this.post("/runs/transcript/owner", { runId: run2.row.runId, gen });
+        for (const run2 of runs) {
+          const session = run2.row.meta?.session;
+          if (session) await this.claimSession(session.key, run2.row.runId, gen);
+          else await this.post("/runs/transcript/owner", { runId: run2.row.runId, gen });
+        }
         return runs;
       }
       async listLive() {
@@ -38468,6 +39455,116 @@ var init_decisions = __esm({
   }
 });
 
+// ../../src/core/runLedger/resume.ts
+function transcriptSource(meta) {
+  return meta.session ? { kind: "session", key: meta.session.key, from: meta.session.seedFrom } : { kind: "run" };
+}
+function settlementFor(toolUse, tools) {
+  const tool = tools.get(toolUse.name);
+  if (!tool) {
+    return {
+      toolUse,
+      action: "synthetic",
+      text: `Tool ${toolUse.name} is not available after the bot restarted; continue without it.`
+    };
+  }
+  if (tool.sideEffectFree || RERUN_SAFE_TOOLS.has(toolUse.name)) return { toolUse, action: "rerun" };
+  return {
+    toolUse,
+    action: "synthetic",
+    text: `The bot restarted while this ${toolUse.name} call was in flight; its effects are unknown \u2014 re-check them before re-running it.`
+  };
+}
+function planResume(input) {
+  const { transcript, lastStep } = input;
+  if (!lastStep) return { kind: "interrupted", why: "no step record: killed before its conversation was stored" };
+  if (!transcript.complete) return { kind: "interrupted", why: `transcript incomplete: ${transcript.gap}` };
+  const completeness = transcriptCompleteness({
+    lastStep,
+    seedTurns: lastStep.turnIndex,
+    transcriptTurns: transcript.turns
+  });
+  if (completeness.kind === "interrupted") return completeness;
+  const tools = /* @__PURE__ */ new Map();
+  for (const t of input.tools) tools.set(t.name, t);
+  const messages = transcript.messages;
+  const last = messages[messages.length - 1];
+  const calls = toolUsesOf(last);
+  if (completeness.kind === "resume") {
+    if (lastStep.inFlight.length === 0) {
+      if (last?.role !== "user") {
+        return {
+          kind: "interrupted",
+          why: "transcript ends with an assistant turn but the last step recorded nothing in flight"
+        };
+      }
+      return {
+        kind: "resume",
+        messages,
+        compactions: transcript.compactions,
+        settlements: [],
+        stepRecorded: true,
+        inboxConsumedSeq: lastStep.inboxConsumedSeq,
+        step: lastStep.step,
+        turn: lastStep.turn,
+        iteration: lastStep.iteration,
+        remainingMs: lastStep.remainingMs
+      };
+    }
+    const recorded = new Set(lastStep.inFlight.map((c) => c.callId));
+    if (calls.length === 0 || calls.length !== recorded.size || !calls.every((c) => recorded.has(c.id))) {
+      return {
+        kind: "interrupted",
+        why: `the last step's calls in flight (${[...recorded].join(", ")}) do not match the transcript's last assistant turn`
+      };
+    }
+    return {
+      kind: "resume",
+      messages,
+      compactions: transcript.compactions,
+      settlements: calls.map((c) => settlementFor(c, tools)),
+      stepRecorded: true,
+      inboxConsumedSeq: lastStep.inboxConsumedSeq,
+      step: lastStep.step,
+      turn: lastStep.turn,
+      iteration: lastStep.iteration,
+      remainingMs: lastStep.remainingMs
+    };
+  }
+  if (calls.length === 0) {
+    return { kind: "interrupted", why: "the next step's turns landed but its assistant turn has no tool calls" };
+  }
+  const bookkeepingOnly = calls.every((c) => c.name === "update_status");
+  return {
+    kind: "resume",
+    messages,
+    compactions: transcript.compactions,
+    settlements: calls.map((c) => ({ toolUse: c, action: "rerun" })),
+    stepRecorded: false,
+    inboxConsumedSeq: lastStep.inboxConsumedSeq,
+    step: lastStep.step + 1,
+    turn: lastStep.turn + (bookkeepingOnly ? 0 : 1),
+    iteration: lastStep.iteration + 1,
+    remainingMs: lastStep.remainingMs
+  };
+}
+var RERUN_SAFE_TOOLS, toolUsesOf;
+var init_resume = __esm({
+  "../../src/core/runLedger/resume.ts"() {
+    "use strict";
+    init_decisions();
+    RERUN_SAFE_TOOLS = /* @__PURE__ */ new Set([
+      "write_file",
+      "update_status",
+      "submit_verdict",
+      "submit_pr_description",
+      "submit_handoff",
+      "submit_dispositions"
+    ]);
+    toolUsesOf = (message2) => message2?.role === "assistant" ? message2.content.filter((p) => p.type === "tool_use") : [];
+  }
+});
+
 // ../../src/core/boot.ts
 function closureNote(agent, prUrl2) {
   if (agent === "ship") return shipInterruptedNote(prUrl2);
@@ -38491,7 +39588,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: ${describe7(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: ${describe9(err2)} \u2014 runs the last generation left stay on the ledger until the next boot`
     );
     return outcome;
   }
@@ -38515,7 +39612,7 @@ async function reclaimRuns(opts) {
         status3 = "interrupted";
         why = "reserved at admission without its request: nothing to restart from";
       } else {
-        const verdict = await completenessVerdict(ledger, row.runId, run2.lastStep);
+        const verdict = await completenessVerdict(ledger, row, run2.lastStep);
         if (verdict.resumable && run2.lastStep) {
           const events2 = await ledger.readEvents(row.runId);
           outcome.resumable.push({
@@ -38558,8 +39655,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: describe7(err2) });
-      warn(`[reclaim] ${row.runId} ${row.threadKey}: ${describe7(err2)} \u2014 left on the ledger for the next boot`);
+      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`);
     }
   }
   try {
@@ -38575,7 +39672,7 @@ async function reclaimRuns(opts) {
         });
     }
   } catch (err2) {
-    warn(`[reclaim] listing live runs failed: ${describe7(err2)} \u2014 the card sweep runs without the ledger's guard`);
+    warn(`[reclaim] listing live runs failed: ${describe9(err2)} \u2014 the card sweep runs without the ledger's guard`);
   }
   if (reclaimed.length > 0 || outcome.liveElsewhere.length > 0) {
     log(
@@ -38597,7 +39694,7 @@ function startReclaimSweep(opts) {
         await opts.onOutcome(outcome);
       }
     } catch (err2) {
-      warn(`[reclaim] sweep failed: ${describe7(err2)}`);
+      warn(`[reclaim] sweep failed: ${describe9(err2)}`);
     } finally {
       running = false;
     }
@@ -38616,13 +39713,14 @@ async function closeReclaimed(ledger, gen, input) {
   const result = await ledger.finish(input.row.runId, gen, record2);
   return result.ok ? { ok: true, record: record2 } : { ok: false, reason: result.reason ?? "refused" };
 }
-async function completenessVerdict(ledger, runId3, lastStep) {
+async function completenessVerdict(ledger, row, lastStep) {
   if (!lastStep) return { resumable: false, why: "no step record: killed before its conversation was stored" };
   let transcript;
   try {
-    transcript = await ledger.readTranscript(runId3);
+    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 (${describe7(err2)})` };
+    return { resumable: false, why: `transcript unreadable (${describe9(err2)})` };
   }
   if (!transcript.complete) return { resumable: false, why: `transcript incomplete: ${transcript.gap}` };
   const verdict = transcriptCompleteness({
@@ -38643,12 +39741,13 @@ async function completenessVerdict(ledger, runId3, lastStep) {
       return { resumable: false, why: verdict.why };
   }
 }
-var TERMINAL, describe7;
+var TERMINAL, describe9;
 var init_boot = __esm({
   "../../src/core/boot.ts"() {
     "use strict";
     init_runStoreWorker();
     init_decisions();
+    init_resume();
     init_types5();
     init_record();
     init_shipPipeline();
@@ -38659,111 +39758,7 @@ var init_boot = __esm({
       "failed",
       "interrupted"
     ]);
-    describe7 = (err2) => err2 instanceof Error ? err2.message : String(err2);
-  }
-});
-
-// ../../src/core/runLedger/resume.ts
-function settlementFor(toolUse, tools) {
-  const tool = tools.get(toolUse.name);
-  if (!tool) {
-    return {
-      toolUse,
-      action: "synthetic",
-      text: `Tool ${toolUse.name} is not available after the bot restarted; continue without it.`
-    };
-  }
-  if (tool.sideEffectFree || RERUN_SAFE_TOOLS.has(toolUse.name)) return { toolUse, action: "rerun" };
-  return {
-    toolUse,
-    action: "synthetic",
-    text: `The bot restarted while this ${toolUse.name} call was in flight; its effects are unknown \u2014 re-check them before re-running it.`
-  };
-}
-function planResume(input) {
-  const { transcript, lastStep } = input;
-  if (!lastStep) return { kind: "interrupted", why: "no step record: killed before its conversation was stored" };
-  if (!transcript.complete) return { kind: "interrupted", why: `transcript incomplete: ${transcript.gap}` };
-  const completeness = transcriptCompleteness({
-    lastStep,
-    seedTurns: lastStep.turnIndex,
-    transcriptTurns: transcript.turns
-  });
-  if (completeness.kind === "interrupted") return completeness;
-  const tools = /* @__PURE__ */ new Map();
-  for (const t of input.tools) tools.set(t.name, t);
-  const messages = transcript.messages;
-  const last = messages[messages.length - 1];
-  const calls = toolUsesOf(last);
-  if (completeness.kind === "resume") {
-    if (lastStep.inFlight.length === 0) {
-      if (last?.role !== "user") {
-        return {
-          kind: "interrupted",
-          why: "transcript ends with an assistant turn but the last step recorded nothing in flight"
-        };
-      }
-      return {
-        kind: "resume",
-        messages,
-        settlements: [],
-        stepRecorded: true,
-        inboxConsumedSeq: lastStep.inboxConsumedSeq,
-        step: lastStep.step,
-        turn: lastStep.turn,
-        iteration: lastStep.iteration,
-        remainingMs: lastStep.remainingMs
-      };
-    }
-    const recorded = new Set(lastStep.inFlight.map((c) => c.callId));
-    if (calls.length === 0 || calls.length !== recorded.size || !calls.every((c) => recorded.has(c.id))) {
-      return {
-        kind: "interrupted",
-        why: `the last step's calls in flight (${[...recorded].join(", ")}) do not match the transcript's last assistant turn`
-      };
-    }
-    return {
-      kind: "resume",
-      messages,
-      settlements: calls.map((c) => settlementFor(c, tools)),
-      stepRecorded: true,
-      inboxConsumedSeq: lastStep.inboxConsumedSeq,
-      step: lastStep.step,
-      turn: lastStep.turn,
-      iteration: lastStep.iteration,
-      remainingMs: lastStep.remainingMs
-    };
-  }
-  if (calls.length === 0) {
-    return { kind: "interrupted", why: "the next step's turns landed but its assistant turn has no tool calls" };
-  }
-  const bookkeepingOnly = calls.every((c) => c.name === "update_status");
-  return {
-    kind: "resume",
-    messages,
-    settlements: calls.map((c) => ({ toolUse: c, action: "rerun" })),
-    stepRecorded: false,
-    inboxConsumedSeq: lastStep.inboxConsumedSeq,
-    step: lastStep.step + 1,
-    turn: lastStep.turn + (bookkeepingOnly ? 0 : 1),
-    iteration: lastStep.iteration + 1,
-    remainingMs: lastStep.remainingMs
-  };
-}
-var RERUN_SAFE_TOOLS, toolUsesOf;
-var init_resume = __esm({
-  "../../src/core/runLedger/resume.ts"() {
-    "use strict";
-    init_decisions();
-    RERUN_SAFE_TOOLS = /* @__PURE__ */ new Set([
-      "write_file",
-      "update_status",
-      "submit_verdict",
-      "submit_pr_description",
-      "submit_handoff",
-      "submit_dispositions"
-    ]);
-    toolUsesOf = (message2) => message2?.role === "assistant" ? message2.content.filter((p) => p.type === "tool_use") : [];
+    describe9 = (err2) => err2 instanceof Error ? err2.message : String(err2);
   }
 });
 
@@ -39495,11 +40490,14 @@ var init_adminModelProxy = __esm({
 
 // ../../src/core/harness/pi/toolRules.ts
 import { isAbsolute as isAbsolute5, relative, resolve as resolve11 } from "node:path";
+function reachFor(identity2) {
+  return identity2 === "write" ? CODING_REACH : READ_REACH;
+}
 function judgeToolCall(tool, input, ctx) {
   const bundle = PI_TOOL_BUNDLES[tool];
-  if (bundle === void 0) return outside(`${tool} is not in any bundle the coding preset reaches`);
-  if (!CODING_REACH.has(bundle)) {
-    return outside(`${tool} is the \`${bundle}\` bundle; the coding preset's reach does not include it`);
+  if (bundle === void 0) return outside(`${tool} is not in any bundle the ${ctx.identity} identity reaches`);
+  if (!reachFor(ctx.identity).has(bundle)) {
+    return outside(`${tool} is the \`${bundle}\` bundle, outside the ${ctx.identity} identity's reach`);
   }
   const args = isRecord5(input) ? input : {};
   if (tool === "bash") return judgeBash(args.command, ctx);
@@ -39514,6 +40512,13 @@ function judgeBash(command2, ctx) {
   if (MERGE_OR_APPROVE.test(command2)) {
     return refused4("merge/approve \u2014 a coding run never merges or approves a pull request");
   }
+  if (ctx.identity !== "write") {
+    if (ANY_PUSH.test(command2)) return refused4("read-only \u2014 a read-identity run never pushes");
+    if (GH_WRITE_VERB.test(command2) || GH_API_WRITE.test(command2) || CURL_GITHUB_WRITE.test(command2)) {
+      return refused4("read-only \u2014 a read-identity run never writes to GitHub");
+    }
+    return allowed;
+  }
   for (const match of command2.matchAll(GIT_PUSH)) {
     const verdict = judgePush(match[1], ctx);
     if (verdict.verdict !== "allowed") return verdict;
@@ -39549,7 +40554,7 @@ function judgePath(path, ctx) {
   if (rel.startsWith("..") || isAbsolute5(rel)) return refused4(`path \u2014 \`${path}\` resolves outside the checkout`);
   return allowed;
 }
-var PI_TOOL_BUNDLES, CODING_REACH, allowed, refused4, outside, isRecord5, CREDENTIAL_FILE, ENV_DUMP, CREDENTIAL_VAR, MERGE_OR_APPROVE, GIT_PUSH;
+var PI_TOOL_BUNDLES, CODING_REACH, READ_REACH, allowed, refused4, outside, isRecord5, CREDENTIAL_FILE, ENV_DUMP, CREDENTIAL_VAR, MERGE_OR_APPROVE, GIT_THEN_PUSH, GIT_PUSH, ANY_PUSH, GH_WRITE_VERB, WRITE_METHOD, GH_API_WRITE, CURL_GITHUB_WRITE;
 var init_toolRules = __esm({
   "../../src/core/harness/pi/toolRules.ts"() {
     "use strict";
@@ -39573,6 +40578,7 @@ var init_toolRules = __esm({
       "github-write",
       "pr"
     ]);
+    READ_REACH = /* @__PURE__ */ new Set(["shell", "files", "web", "search", "github-read", "verdict"]);
     allowed = { verdict: "allowed" };
     refused4 = (reason) => ({ verdict: "refused", reason });
     outside = (reason) => ({ verdict: "outside-profile", reason });
@@ -39581,7 +40587,17 @@ var init_toolRules = __esm({
     ENV_DUMP = /(^|[;&|(]\s*)((printenv|env)(\s+-[A-Za-z0-9-]+)*|export\s+-p|declare\s+-[a-zA-Z]*[px][a-zA-Z]*|set)\s*($|[|;&>)])|\/proc\/(self|\d+)\/environ|process\.env(?![.[\w])/;
     CREDENTIAL_VAR = /\$\{?[A-Z][A-Z0-9_]*(_API_KEY|_TOKEN|_SECRET|_BEARER|_PASSWORD)\b|printenv\s+[A-Z][A-Z0-9_]*(_API_KEY|_TOKEN|_SECRET|_BEARER|_PASSWORD)\b/;
     MERGE_OR_APPROVE = /\bgh\s+pr\s+(merge|review)\b|\/pulls\/\d+\/(merge|reviews)\b/;
-    GIT_PUSH = /\bgit\s+push\b([^;&|]*)/g;
+    GIT_THEN_PUSH = String.raw`\bgit(?:\s+(?:-C\s+\S+|--git-dir=\S+|--work-tree=\S+|-c\s+\S+|--no-pager))*\s+push\b`;
+    GIT_PUSH = new RegExp(`${GIT_THEN_PUSH}([^;&|]*)`, "g");
+    ANY_PUSH = new RegExp(GIT_THEN_PUSH);
+    GH_WRITE_VERB = /\bgh\s+(pr|issue)\s+(comment|create|edit|close|reopen|ready|lock|unlock|review|merge|delete|transfer|pin|unpin)\b/;
+    WRITE_METHOD = "(POST|post|PATCH|patch|PUT|put|DELETE|delete)";
+    GH_API_WRITE = new RegExp(
+      `\\bgh\\s+api\\b(?=[^;&|]*(?:\\s(?:-X|--method)[\\s=]*${WRITE_METHOD}\\b|\\s(?:-f|-F|--field|--raw-field|--input)[\\s=]))`
+    );
+    CURL_GITHUB_WRITE = new RegExp(
+      `\\bcurl\\b(?=[^;&|]*api\\.github\\.com)(?=[^;&|]*(?:\\s(?:-X|--request)[\\s=]*${WRITE_METHOD}\\b|\\s(?:-d|--data(?:-\\w+)?|--json|-T|--upload-file)[\\s=]))`
+    );
   }
 });
 
@@ -39590,6 +40606,7 @@ function relayedToolDefinitions(harness) {
   return harness.tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
 }
 function authorizeToolCall(harness, ask) {
+  harness.gateSaw(ask.toolCallId);
   const blocked = harness.toolsBlocked();
   const refuse3 = (reason) => {
     harness.emit({
@@ -39949,9 +40966,12 @@ function parseBrief(v) {
         const p = b.prior;
         if (typeof p !== "object" || p === null || typeof p.reviewRunId !== "string" || !RUN_ID_PATTERN.test(p.reviewRunId))
           return invalid("brief.prior.reviewRunId must be a run id");
-        if (p.fixRunId !== void 0 && (typeof p.fixRunId !== "string" || !RUN_ID_PATTERN.test(p.fixRunId)))
-          return invalid("brief.prior.fixRunId must be a run id");
-        prior = { reviewRunId: p.reviewRunId, ...p.fixRunId !== void 0 ? { fixRunId: p.fixRunId } : {} };
+        if (p.codingRunId !== void 0 && (typeof p.codingRunId !== "string" || !RUN_ID_PATTERN.test(p.codingRunId)))
+          return invalid("brief.prior.codingRunId must be a run id");
+        prior = {
+          reviewRunId: p.reviewRunId,
+          ...p.codingRunId !== void 0 ? { codingRunId: p.codingRunId } : {}
+        };
       }
       return {
         ok: true,
@@ -39965,15 +40985,15 @@ function parseBrief(v) {
         }
       };
     }
-    case "fix": {
+    case "findings": {
       const n2 = pr();
       if (!n2.ok) return n2;
       const review = runId3("reviewRunId");
       if (!review.ok) return review;
-      return { ok: true, value: { kind: "fix", unit: b.unit, pr: n2.value, reviewRunId: review.value } };
+      return { ok: true, value: { kind: "findings", unit: b.unit, pr: n2.value, reviewRunId: review.value } };
     }
     default:
-      return invalid("brief.kind must be contract, review or fix");
+      return invalid("brief.kind must be contract, review or findings");
   }
 }
 function parseObject(text) {
@@ -40036,6 +41056,30 @@ function unitThread(instance, row) {
   const sourceUrl = row?.sourceUrl ?? (threadKey === instance.threadKey ? instance.sourceUrl : void 0);
   return { threadKey, sourceUrl };
 }
+async function openThreadFromRequester(deps, instance, lead, at) {
+  const parent = deps.ioFor({ threadKey: instance.threadKey, userId: instance.userId });
+  if (!parent?.openThread) return { ok: false, response: json(503, { ok: false, error: "no_channel", at }) };
+  try {
+    const opened = await parent.openThread(lead);
+    return {
+      ok: true,
+      thread: {
+        threadKey: opened.thread.threadKey,
+        ...opened.thread.sourceUrl !== void 0 ? { sourceUrl: opened.thread.sourceUrl } : {}
+      }
+    };
+  } catch (err2) {
+    return { ok: false, response: json(502, { ok: false, error: "thread_failed", message: describe10(err2), at }) };
+  }
+}
+async function ensureReviewThread(deps, instance, row, at) {
+  if (row.reviewThread !== void 0) return { ok: true, row, thread: row.reviewThread };
+  const opened = await openThreadFromRequester(deps, instance, reviewLead(instance, row), at);
+  if (!opened.ok) return opened;
+  const updated = { ...row, reviewThread: opened.thread };
+  await deps.instances.putUnits([updated]);
+  return { ok: true, row: updated, thread: opened.thread };
+}
 function authorizeStep(headers, step, deps) {
   const raw = headers.authorization;
   const authorization = Array.isArray(raw) ? raw[0] : raw;
@@ -40109,6 +41153,7 @@ function watched(io, on) {
   };
   if (io.attach) out.attach = (file) => io.attach(file);
   if (io.attachFile) out.attachFile = (file) => io.attachFile(file);
+  if (io.uploadTicket) out.uploadTicket = (file) => io.uploadTicket(file);
   if (io.runFinished) out.runFinished = (receipt) => io.runFinished(receipt);
   if (io.openThread) out.openThread = (lead) => io.openThread(lead);
   return out;
@@ -40123,8 +41168,19 @@ async function spawn6(body, deps) {
   const at = (deps.clock ?? systemClock)();
   const unit = await unitRowOf(deps, instance, req.unit);
   if (!unit.ok) return unit.response;
-  const thread = unitThread(instance, unit.row);
-  if (thread.threadKey === void 0) return json(409, { ok: false, error: "unit_not_started", unit: req.unit, at });
+  const own = unitThread(instance, unit.row);
+  if (own.threadKey === void 0) return json(409, { ok: false, error: "unit_not_started", unit: req.unit, at });
+  let row = unit.row;
+  let thread = {
+    threadKey: own.threadKey,
+    ...own.sourceUrl !== void 0 ? { sourceUrl: own.sourceUrl } : {}
+  };
+  if (req.preset === "review" && row !== void 0) {
+    const review = await ensureReviewThread(deps, instance, row, at);
+    if (!review.ok) return review.response;
+    row = review.row;
+    thread = review.thread;
+  }
   const threadKey = thread.threadKey;
   const key = idempotencyKeyFor(instance.id, req.step);
   const live = await liveOnThread(deps.runs, instance, threadKey);
@@ -40135,13 +41191,12 @@ async function spawn6(body, deps) {
   if (!io) return json(503, { ok: false, error: "no_channel", at });
   let turn;
   if (req.brief !== void 0) {
-    if (unit.row === void 0) return json(400, { ok: false, error: "a brief needs the unit it runs for" });
+    if (row === void 0) return json(400, { ok: false, error: "a brief needs the unit it runs for" });
     try {
-      const composed = await composeChild(req.brief, instance, unit.row, briefReaders(deps, instance, io));
-      turn = composed;
+      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: ${describe8(err2)}`);
-      return json(502, { ok: false, error: "brief_failed", message: describe8(err2), at });
+      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 });
     }
   } else {
     turn = { prompt: req.prompt };
@@ -40184,15 +41239,14 @@ async function spawn6(body, deps) {
   };
   const settled = deps.dispatch(msg, child, {
     coordinator: tag,
-    ...turn.contract !== void 0 ? { contract: turn.contract } : {},
-    ...turn.fixRound !== void 0 ? { fixRound: turn.fixRound } : {}
+    ...turn.contract !== void 0 ? { contract: turn.contract } : {}
   }).then(
     (outcome) => ({ kind: "ended", outcome }),
     (err2) => ({ kind: "threw", err: err2 })
   );
   void settled.then((end) => {
     if (end.kind === "threw")
-      log(`[coordinator] ${instance.id} ${req.step}: the child's dispatch threw: ${describe8(end.err)}`);
+      log(`[coordinator] ${instance.id} ${req.step}: the child's dispatch threw: ${describe10(end.err)}`);
   });
   const first = await Promise.race([started.then((id) => ({ kind: "started", id })), settled]);
   if (first.kind === "started" || startedId !== void 0) {
@@ -40200,7 +41254,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: describe8(first.err), at });
+  if (first.kind === "threw") return json(502, { ok: false, error: "spawn_failed", message: describe10(first.err), at });
   const refusal = first.outcome.refusal;
   if (refusal === "coordinator_thread_live") {
     const now = await liveOnThread(deps.runs, instance, threadKey);
@@ -40353,7 +41407,7 @@ async function prCheck(body, deps) {
       at
     });
   } catch (err2) {
-    return json(502, { ok: false, error: "github_unavailable", message: describe8(err2), at });
+    return json(502, { ok: false, error: "github_unavailable", message: describe10(err2), at });
   }
 }
 async function plan2(body, deps) {
@@ -40402,19 +41456,18 @@ async function unitStart(body, deps) {
         ...instance.sourceUrl !== void 0 ? { sourceUrl: instance.sourceUrl } : {}
       };
     } else {
-      const parent = deps.ioFor({ threadKey: instance.threadKey, userId: instance.userId });
-      if (!parent?.openThread) return json(503, { ok: false, error: "no_channel", at });
-      try {
-        const opened = await parent.openThread(unitLead(instance, row));
-        row = {
-          ...row,
-          threadKey: opened.thread.threadKey,
-          ...opened.thread.sourceUrl !== void 0 ? { sourceUrl: opened.thread.sourceUrl } : {}
-        };
-      } catch (err2) {
-        return json(502, { ok: false, error: "thread_failed", message: describe8(err2), at });
-      }
+      const opened = await openThreadFromRequester(deps, instance, unitLead(instance, row), at);
+      if (!opened.ok) return opened.response;
+      row = { ...row, ...opened.thread };
+    }
+  }
+  if (row.reviewThread === void 0) {
+    const review = await ensureReviewThread(deps, instance, row, at);
+    if (!review.ok) {
+      if (row !== unit.row) await deps.instances.putUnits([row]);
+      return review.response;
     }
+    row = review.row;
   }
   if (row.issue === void 0 && row.unit !== TASK_UNIT) {
     const issue = await unitIssueOf(deps, instance.repo, row.unit);
@@ -40422,10 +41475,13 @@ async function unitStart(body, deps) {
   }
   row = { ...row, startedAt: row.startedAt ?? at };
   await deps.instances.putUnits([row]);
-  (deps.log ?? console.log)(`[coordinator] ${instance.id} ${row.unit}: started in ${row.threadKey}`);
+  (deps.log ?? console.log)(
+    `[coordinator] ${instance.id} ${row.unit}: started in ${row.threadKey}, review in ${row.reviewThread?.threadKey}`
+  );
   return json(200, {
     ok: true,
     threadKey: row.threadKey,
+    reviewThreadKey: row.reviewThread?.threadKey,
     branch: row.branch,
     base: instance.base ?? "main",
     ...row.issue !== void 0 ? { issue: row.issue } : {},
@@ -40437,6 +41493,12 @@ function unitLead(instance, row) {
   const from = instance.sourceUrl !== void 0 ? `[the *ship* run](${instance.sourceUrl})` : "the *ship* run";
   return `\u21B3 *ship* unit ${row.unit}${row.title ? ` \u2014 ${row.title}` : ""} for ${who2}, from ${from}: \`${row.branch}\` in ${instance.repo}`;
 }
+function reviewLead(instance, row) {
+  const who2 = instance.userName ?? instance.userId;
+  const from = instance.sourceUrl !== void 0 ? `[the *ship* run](${instance.sourceUrl})` : "the *ship* run";
+  const what = row.unit === TASK_UNIT ? "the task" : `unit ${row.unit}${row.title ? ` \u2014 ${row.title}` : ""}`;
+  return `\u21B3 *ship* review of ${what} for ${who2}, from ${from}: \`${row.branch}\` in ${instance.repo}`;
+}
 async function branch(body, deps) {
   const id = parseInstanceId(body.parentInstanceId);
   if (!id.ok) return json(400, { ok: false, error: id.error });
@@ -40454,7 +41516,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: describe8(err2), at });
+    return json(200, { ok: false, reason: describe10(err2), at });
   }
 }
 function unitLines(units) {
@@ -40506,7 +41568,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: ${describe8(err2)}`)
+    (err2) => (deps.log ?? console.warn)(`[coordinator] ${instance.id}: the card could not be redrawn: ${describe10(err2)}`)
   );
   return json(200, { ok: true, at });
 }
@@ -40540,7 +41602,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: ${describe8(err2)}`
+        `[coordinator] ${instance.id} ${row.unit}: the report could not be posted: ${describe10(err2)}`
       );
     }
   }
@@ -40554,7 +41616,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: ${describe8(err2)}`
+        `[coordinator] ${instance.id} ${row.unit}: the board comment could not be posted: ${describe10(err2)}`
       )
     );
   }
@@ -40609,7 +41671,7 @@ async function merge(body, deps, subject2) {
   try {
     facts2 = await deps.fetchPrFacts(pr);
   } catch (err2) {
-    return json(502, { ok: false, error: "github_unavailable", message: describe8(err2), at });
+    return json(502, { ok: false, error: "github_unavailable", message: describe10(err2), at });
   }
   if (facts2 === void 0)
     return json(502, { ok: false, error: "github_unavailable", message: `${where} could not be read`, at });
@@ -40661,7 +41723,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: describe8(err2), at });
+    return json(502, { ok: false, error: "github_unavailable", message: describe10(err2), at });
   }
   if (!merged.ok) {
     log(
@@ -40836,13 +41898,13 @@ function createAdminCoordinatorHandler(deps) {
         }
         write(res, await answerCoordinatorStep(door, read.body, deps));
       } catch (err2) {
-        (deps.log ?? console.error)(`[coordinator] ${describe8(err2)}`);
+        (deps.log ?? console.error)(`[coordinator] ${describe10(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, describe8, 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, describe10, EVERY_RUN, REVIEW_POSTED_CHECKS, REVIEW_POSTED_RECHECK_MS, ROUND_OUTCOMES, ENDING_ICON, STEPS;
 var init_adminCoordinator = __esm({
   "../../src/channels/adminCoordinator.ts"() {
     "use strict";
@@ -40871,11 +41933,11 @@ var init_adminCoordinator = __esm({
     PRESETS_OF_KIND = {
       contract: "coding",
       review: "review",
-      fix: "coding"
+      findings: "coding"
     };
     invalid = (error) => ({ ok: false, error });
     json = (status3, body) => ({ status: status3, body });
-    describe8 = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    describe10 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     EVERY_RUN = { kind: "all" };
     REVIEW_POSTED_CHECKS = 3;
     REVIEW_POSTED_RECHECK_MS = 2e3;