@coreplane/switchboard 1.214.0 → 1.215.1

package/dist/cli.js

@@ -2892,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) {
@@ -12790,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;
@@ -12800,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";
@@ -12821,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);
   }
 });
 
@@ -13596,6 +13601,17 @@ var init_runFriction = __esm({
 });
 
 // ../../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;
@@ -13674,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";
@@ -13741,6 +13762,7 @@ function isRunRecord(v) {
   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;
@@ -13872,7 +13894,7 @@ function dropSpanPairsFromTheMiddle(events, eventBudget) {
   }
   return events.filter((_, k) => !dropped.has(k));
 }
-var RUN_STATUSES, RUN_ID_PATTERN, REVIEW_HEAD_PATTERN, RUN_SEEDS, 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";
@@ -13885,6 +13907,8 @@ var init_runRecord = __esm({
     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,
@@ -13910,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;
@@ -22079,6 +22105,9 @@ function reclaimedRunRecord(input) {
     ...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 } } : {},
@@ -22148,7 +22177,8 @@ function assembleRunRecord(input) {
     ...input.profile !== void 0 ? { profile: input.profile } : {},
     ...input.parentRunId !== void 0 ? { parentRunId: input.parentRunId } : {},
     ...coordinatorFields(input.coordinator),
-    ...input.seed !== void 0 ? { seed: input.seed } : {}
+    ...input.seed !== void 0 ? { seed: input.seed } : {},
+    ...input.session !== void 0 ? { session: input.session } : {}
   });
   return fitted.eventCount !== fitted.storedEventCount ? { ...fitted, truncated: true } : fitted;
 }
@@ -22346,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",
@@ -22496,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
     });
   }
@@ -24590,6 +24624,12 @@ 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 |`
@@ -24604,7 +24644,10 @@ function routeMaxOutputTokens(compound) {
 }
 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",
@@ -24615,7 +24658,7 @@ function routeTool(presets, compound) {
     ...compound ? {
       parts: {
         type: "array",
-        description: `only when the request has two or more INDEPENDENT asks on different subjects, each rewritten so it stands alone, with preset "${COMPOUND_PRESET}". 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.`,
+        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: {
@@ -24623,7 +24666,7 @@ function routeTool(presets, compound) {
           additionalProperties: false,
           required: ["preset", "text"],
           properties: {
-            preset: { type: "string", enum: names, description: "the preset this part runs on" },
+            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" }
           }
         }
@@ -24660,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)}`,
@@ -24671,13 +24714,20 @@ function buildRoutePrompt(input) {
   ].join("\n");
   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 \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.`;
@@ -24696,15 +24746,18 @@ 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")
+  const { preset: named, reason, parts } = parsed;
+  const preset = typeof named === "string" ? named : Array.isArray(parts) ? COMPOUND_PRESET : void 0;
+  const inferred = typeof named !== "string" && preset === COMPOUND_PRESET;
+  if (preset === void 0)
     return { preset: void 0, reason: `missing preset in the router's answer: ${tidyReason(trimmed)}` };
-  if (typeof reason !== "string")
+  if (typeof reason !== "string" && !inferred)
     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);
+  const tidy = typeof reason === "string" ? tidyReason(reason) : "compound inferred from parts";
+  if (preset === COMPOUND_PRESET) return parseCompound(parts, tidy, allowed2, compound);
   if (!allowed2.includes(preset))
     return { preset: void 0, reason: `router said "${tidyReason(preset)}", not a preset the requester may run` };
-  return { preset, reason: tidyReason(reason) };
+  return { preset, reason: tidy };
 }
 function parseCompound(parts, reason, allowed2, offer) {
   const rejected = (why) => ({
@@ -24729,16 +24782,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: routeMaxOutputTokens(input.compound),
+      maxTokens: routeMaxOutputTokens(compound),
       signal: AbortSignal.timeout(opts.timeoutMs ?? ROUTE_TIMEOUT_MS)
     });
   } catch (err2) {
@@ -24750,7 +24807,7 @@ async function route(input, model, opts = {}) {
   return parseRouteAnswer(
     raw,
     offered.map((p) => p.name),
-    input.compound
+    compound
   );
 }
 function providerRouteModel(provider, model, opts = {}) {
@@ -24824,18 +24881,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) => {
@@ -24851,7 +24914,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_MIN_OUTPUT_TOKENS, ROUTE_TOOL_NAME, 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";
@@ -24868,6 +24931,7 @@ var init_route = __esm({
     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";
   }
 });
@@ -26638,7 +26702,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: {
@@ -26661,15 +26725,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`;
@@ -28953,7 +29009,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) } : {},
@@ -29872,7 +29928,7 @@ var init_bridge2 = __esm({
             this.onToolEnd(event, out);
             break;
           case "compaction_end":
-            this.onCompactionEnd(event);
+            this.onCompactionEnd(event, out);
             break;
           case "summarization_retry_scheduled":
             this.summarizationRetries++;
@@ -29986,7 +30042,7 @@ var init_bridge2 = __esm({
           }
         }
       }
-      onCompactionEnd(event) {
+      onCompactionEnd(event, out) {
         const result = isRecord3(event.result) ? event.result : void 0;
         if (event.aborted === true || !result) {
           this.note(
@@ -30003,6 +30059,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);
@@ -30071,7 +30134,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(
@@ -30080,12 +30143,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) {
@@ -30113,7 +30199,7 @@ function piSessionFile(messages, opts) {
         stopReason: hasTool ? "toolUse" : "stop",
         timestamp: opts.at
       });
-      continue;
+      return;
     }
     const results = message2.content.filter(
       (p) => p.type === "tool_result"
@@ -30140,7 +30226,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) {
@@ -30197,6 +30284,28 @@ var init_mirror = __esm({
         this.idx += turns.length;
         await this.deps.onStep(report2);
       }
+      /** 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);
+      }
     };
   }
 });
@@ -30535,25 +30644,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) {
@@ -30682,6 +30799,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`);
@@ -31269,8 +31387,7 @@ async function runLoop2(deps, ctx) {
     wait,
     parentRunId,
     coordinator,
-    seed,
-    fixRound
+    seed
   } = ctx;
   const agent = budgetedAgent(ctx.agent, profile);
   const { executor, binding } = round2.selection;
@@ -31373,7 +31490,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;
@@ -31420,7 +31537,7 @@ async function runLoop2(deps, ctx) {
     onDigest,
     onPrDescription,
     onHandoff,
-    ...fixRound ? { knownFindingIds: fixRound.findingIds, onDispositions } : {}
+    onDispositions
   };
   const harness = effectiveHarness(agent, deps.config.config.harness);
   try {
@@ -31481,6 +31598,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,
@@ -32060,6 +32178,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"() {
@@ -32082,29 +32206,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}\`` : "";
@@ -32113,13 +32214,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"() {
@@ -32165,6 +32268,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) {
@@ -32174,10 +32287,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,
@@ -32189,16 +32305,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) {
@@ -32211,7 +32329,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();
@@ -33060,6 +33179,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;
@@ -33647,7 +33778,6 @@ async function dispatch(deps, msg, io, opts = {}) {
       parentRunId,
       coordinator,
       seed,
-      ...opts.fixRound ? { fixRound: opts.fixRound } : {},
       ...bearer !== void 0 ? { bearer } : {}
     });
     const { answer, prNote, toolCalls, runDiagnosis, checklistAsLeft, checklistCheckedOff, releaseWorkspace } = ran;
@@ -33923,7 +34053,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;
@@ -34167,6 +34302,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({
@@ -34212,36 +34365,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): ${describe8(err2)}`);
-          return "untracked";
+          return { outcome: "untracked" };
         }
         await sleep2(RETRY_MS[Math.min(attempt, RETRY_MS.length) - 1]);
       }
@@ -34261,6 +34423,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;
@@ -34281,7 +34452,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 ?? {};
@@ -34290,6 +34464,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);
@@ -34297,11 +34476,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);
@@ -34322,6 +34514,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);
@@ -34339,13 +34532,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,
@@ -34369,11 +34564,14 @@ function createLedgerWriteThrough(opts) {
     }
     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,
@@ -34382,8 +34580,9 @@ 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) {
@@ -34491,8 +34690,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);
@@ -34500,35 +34699,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;
@@ -34578,6 +34788,7 @@ var init_writeThrough = __esm({
     "use strict";
     init_runStoreWorker();
     init_flusher();
+    init_sessionLog();
     init_types5();
     NullLedgerWriteThrough = class {
       constructor(gen, fallback) {
@@ -38847,6 +39058,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) {
@@ -38880,49 +39101,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;
   }
 });
 
@@ -38937,6 +39178,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 } : {}
   });
 }
@@ -38945,7 +39189,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 {
@@ -39009,41 +39255,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 });
@@ -39095,22 +39394,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() {
@@ -39158,6 +39458,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);
@@ -39205,7 +39615,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({
@@ -39306,11 +39716,12 @@ 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 (${describe9(err2)})` };
   }
@@ -39339,6 +39750,7 @@ var init_boot = __esm({
     "use strict";
     init_runStoreWorker();
     init_decisions();
+    init_resume();
     init_types5();
     init_record();
     init_shipPipeline();
@@ -39353,110 +39765,6 @@ var init_boot = __esm({
   }
 });
 
-// ../../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") : [];
-  }
-});
-
 // ../../src/core/resumeLaunch.ts
 function knownToolsFor(agent) {
   return (TOOLSETS[agent.toolset] ?? []).map((t) => ({
@@ -40661,9 +40969,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,
@@ -40677,15 +40988,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) {
@@ -40748,6 +41059,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;
@@ -40836,8 +41171,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);
@@ -40848,10 +41194,9 @@ 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: ${describe10(err2)}`);
       return json(502, { ok: false, error: "brief_failed", message: describe10(err2), at });
@@ -40897,8 +41242,7 @@ 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 })
@@ -41115,30 +41459,32 @@ 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: describe10(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);
     if (issue !== void 0) row = { ...row, issue };
   }
   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 } : {},
@@ -41150,6 +41496,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 });
@@ -41584,7 +41936,7 @@ 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 });