flowviant 0.125.5 → 0.125.7

package/bin/lib/workAgentTurnShape.mjs

@@ -0,0 +1,90 @@
+/**
+ * AN AGENT TURN'S PROMPT PAIR — its kickoff, a live message's follow-up and
+ * its system prompt (pure, 2026-10-18, the SOLID pass). The twin of
+ * workTurnShape.mjs, which is the same thing for a tab.
+ *
+ * Split out of workAgentTurnExecution.mjs, which composed all three inline in
+ * the turn: two AGENT_HUMAN_KICKOFF argument bags spelling the same ten
+ * fields, the task kickoff beside them, and a system prompt of eight sections
+ * on one line. The copies had already drifted: investigationContext reached
+ * the task and human kickoffs on 2026-10-12, the follow-up written two days
+ * later went without it, and live messages carried less context than the
+ * first prompt until 2026-10-15 added it beside researchContext at all three
+ * sites. So the fields every kickoff shares are spelled once (`shared`), and
+ * the next job context key is one edit here.
+ *
+ * ONE SPEC BUILDER (`AGENT_TASK_SPEC`) is shared by the stash the run writes
+ * before the CLI and the kickoff here, so what the reviewer reads is
+ * byte-identical to what the agent read — the card's discussion included
+ * (0.106.0): both are handed the same `job.cardThread`, and the builder
+ * prints it inside the spec — and the card's files after it (0.112.0).
+ *
+ * Pure: the run measures (the files, the roster's answers, the tools note)
+ * and hands the values in; nothing here reads a disk or a clock.
+ */
+import { AGENT_TASK_KICKOFF, AGENT_HUMAN_KICKOFF, SYSTEM_AGENT_FOR, withProjectContext } from './prompts.mjs';
+import { INTERNAL_WAIT_CONTRACT } from './agentInternalWait.mjs';
+import { ORCHESTRATOR_CONTRACT } from './orchestratorPrompt.mjs';
+
+/** What every kickoff of this job is handed: the agent, the card and its
+ *  discussion, the job's context handoffs, the card's files, the place in
+ *  the run. */
+const shared = (job, cardFiles) => ({
+  agentName: job.agentName,
+  task: job.task,
+  cardThread: job.cardThread,
+  investigationContext: job.investigationContext,
+  researchContext: job.researchContext,
+  cardFiles,
+  position: job.position ?? 1,
+  total: job.total ?? 1,
+});
+
+/** The turn's first prompt: the card, on a task turn; the person's words
+ *  otherwise. `cardFiles` and `messageFiles` are the files already on disk. */
+export const agentKickoff = (job, { cardFiles, messageFiles }) =>
+  job.kind === 'task' && job.task
+    ? AGENT_TASK_KICKOFF({
+        // The card's discussion (0.106.0), printed inside THE CARD by
+        // the same builder the run's stash wrote down — and the files
+        // on it (0.112.0), after it, the same way.
+        ...shared(job, cardFiles),
+        resumeBody: job.body,
+      })
+    : AGENT_HUMAN_KICKOFF({
+        // The discussion on the one card this message is about, in a
+        // fence of its own after the person's words (0.106.0).
+        ...shared(job, cardFiles),
+        // INTERRUPT NOW: the previous run was stopped to send this.
+        interrupted: job.interrupted === true,
+        message: job.body ?? '',
+        askedByName: job.askedByName,
+        // The files (0.112.0): the person's inside their words, the
+        // card's at the foot of its discussion.
+        messageFiles,
+      });
+
+/** A live message sent while the turn runs, as the CLI is handed it — on an
+ *  orchestrated card with its id, so the route it takes is reported. */
+export const agentFollowupKickoff = (job, followup, { cardFiles, messageFiles, orchestrated }) =>
+  AGENT_HUMAN_KICKOFF({
+    ...shared(job, cardFiles),
+    message: followup.body + (followup.libraryPrompt ?? '') + (orchestrated ? `\nMessage id: ${followup.id}. Choose and report its route with card_orchestrator.route_message.` : ''),
+    askedByName: followup.askedByName,
+    messageFiles,
+  });
+
+/** The turn's system prompt, in its fixed section order. */
+export function agentTurnSystem({ taskKind, runtimeLabel, prerequisitesAccepted, knowledgeDir, artifactsAccepted, toolsNote, artifactInstructions, toolInstructions, repositoryRun, orchestrated }) {
+  // The knowledge paragraph, when this box holds a library — the same
+  // composer the tabs use, so an agent and a tab can never be told two
+  // different things about the same directory.
+  // Spoken to the CLI that runs it (0.115.0): a mockup on Codex is
+  // told it is Codex, never Claude.
+  return withProjectContext(SYSTEM_AGENT_FOR(taskKind, runtimeLabel, { prerequisitesAccepted }), {
+    knowledgeDir,
+    // ARTIFACTS (0.94.0), while the server can show one — an agent's
+    // land on its page, under the facts row.
+    artifacts: artifactsAccepted,
+  }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (toolInstructions ? `\n\n${toolInstructions}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : '') + (orchestrated ? `\n\n${ORCHESTRATOR_CONTRACT}` : '');
+}

package/bin/lib/workAgentTurns.mjs

@@ -21,11 +21,13 @@
  */
 import { existsSync } from 'node:fs';
 import { isSafePathSegment } from './git.mjs';
+import { AGENT_PLACE_PREFIX } from './workPlaces.mjs';
 import { c, note } from './ui.mjs';
 import { createAgentTurnReports } from './workAgentTurnReports.mjs';
 import { createAgentTurnExecution } from './workAgentTurnExecution.mjs';
-import { failedTurnSettlement } from './workAgentTurnOutcome.mjs';
-import { killGroup } from './processGroup.mjs';
+import { failedTurnSettlement, interruptedTurnSettlement } from './workAgentTurnOutcome.mjs';
+import { turnCommits } from './turnReceipts.mjs';
+import { interruptThenKill } from './processGroup.mjs';
 import { createDeliveryReporter } from './workDelivery.mjs';
 import { createAgentBriefRunner } from './workAgentBriefRunner.mjs';
 
@@ -54,12 +56,15 @@ export function createWorkAgentTurns({
   /** The turn's files, fetched into its worktree (workAttachments.mjs, 0.112.0). */
   fetchAgentFiles,
   makeBrief = createAgentBriefRunner({ admit, workChildren }),
+  /** The run's live-message relay (workLiveMessages.mjs); a test's stand-in. */
+  makeLiveMessages,
 }) {
   const reportDelivery = createDeliveryReporter();
   const {
     postAgentTurn,
     postAgentTrace,
     postAgentActivity,
+    postAgentContext,
     postAgentParked,
     pruneHeldReports,
     agentReported,
@@ -111,7 +116,7 @@ export function createWorkAgentTurns({
    *  read before the stop's settle landed. Taken once, for a little while. */
   const stoppedFor = new Map(); // agentId -> when
 
-  const { runAgentTurnInPlace, commitsBetween } = createAgentTurnExecution({
+  const { runAgentTurnInPlace } = createAgentTurnExecution({
     admit,
     agentRepositories,
     makeBrief,
@@ -131,8 +136,10 @@ export function createWorkAgentTurns({
     agentChildren,
     postAgentTrace,
     postAgentActivity,
+    postAgentContext,
     postAgentParked,
     fetchAgentFiles,
+    makeLiveMessages,
   });
 
   /** `releaseSlot` hands back the admission reservation the caller took on this
@@ -183,33 +190,42 @@ export function createWorkAgentTurns({
      * branch, the spend, the branch and worktree. Through the same held-body
      * wire, so a failed POST is re-sent on the next offer and the CLI is not
      * run again.
+     *
+     * The catch carries what the run's own settles carry, the live receipts
+     * included (2026-10-18): a note the CLI already took is folded into this
+     * run only when a settle names it, and the relay's own flush is bounded,
+     * so a catch that posted without them left the note pending — offered
+     * later as its own turn, a second paid run.
      */
     const measured = { wt: null, before: null, branch: null, usage: null, model: null };
     let settled = false;
+    const withLiveReceipts = (body) => {
+      const liveMessages = agentRuns.get(turnId)?.live?.receipts();
+      return { ...body, ...(liveMessages?.ids.length ? { liveMessages } : {}) };
+    };
     const settleOnce = (body) => {
       settled = true;
-      const liveMessages = agentRuns.get(turnId)?.live?.receipts();
-      return postAgentTurn({ ...body, ...(liveMessages?.ids.length ? { liveMessages } : {}) });
+      return postAgentTurn(withLiveReceipts(body));
     };
 
     // A WRITER on the agent's own place — see the lane header. Only `a-<id>`
     // places: those are agents' by construction, and anything else here would
     // be a tab's directory, where a turn is a reader by the product's own law.
     const run = agentRuns.get(turnId) ?? { place, interrupted: false };
-    await inPlace(place, place.startsWith('a-'), async () => {
+    await inPlace(place, place.startsWith(AGENT_PLACE_PREFIX), async () => {
       run.waitingReason = null;
       try {
         await runAgentTurnInPlace(job, { turnId, agentId, place, releaseSlot, postAgentTurn: settleOnce, measured, run });
         if (run.interrupted && measured.ranCli) stoppedFor.set(agentId, Date.now());
       } catch (error) {
         if (settled) return;
-        const commits = measured.repositoryReceipts ? [...new Set(measured.repositoryReceipts().map((r) => r.sha))].slice(0, 50) : measured.wt ? commitsBetween(measured.wt, measured.before) : [];
+        const commits = turnCommits({ repositoryReceipts: measured.repositoryReceipts, wt: measured.wt, before: measured.before, baseRef });
         if (run.interrupted) {
-          await postAgentTurn({ turnId, outcome: 'nothing', interrupted: true, ran: measured.ranCli === true, commits, ...(measured.usage ? { usage: measured.usage } : {}) });
+          await postAgentTurn(withLiveReceipts(interruptedTurnSettlement({ turnId, ran: measured.ranCli === true, commits, usage: measured.usage, model: measured.model, branch: measured.branch, wt: measured.wt })));
           return;
         }
         await postAgentTurn(
-          failedTurnSettlement({
+          withLiveReceipts(failedTurnSettlement({
             turnId,
             error,
             commits,
@@ -217,7 +233,7 @@ export function createWorkAgentTurns({
             model: measured.model,
             branch: measured.branch,
             wt: measured.wt,
-          })
+          }))
         );
       }
     }, () => {
@@ -299,7 +315,7 @@ export function createWorkAgentTurns({
           const place = String(job.placeId || '');
           const wt = typeof held.body.worktree === 'string' ? held.body.worktree : null;
           if (reply?.review === true && isSafePathSegment(place) && wt && existsSync(wt)) {
-            await inPlace(place, place.startsWith('a-'), () =>
+            await inPlace(place, place.startsWith(AGENT_PLACE_PREFIX), () =>
               runReviewEntry(String(job.agentId || ''), wt, job.agentName)
             );
           }
@@ -420,7 +436,7 @@ export function createWorkAgentTurns({
         run.interrupted = true;
         run.abortSetup?.();
         const child = agentChildren.get(run.place);
-        if (child) killGroup(child);
+        if (child) interruptThenKill(child);
         continue;
       }
       if (agentReported.has(id) || notRunningSaid.has(id)) continue;

package/bin/lib/workArtifactReconcile.mjs

@@ -15,6 +15,7 @@
  * number of times; the stored files stay listed, which is the truth.
  */
 import { existsSync } from 'node:fs';
+import { agentIdFromPlace } from './workPlaces.mjs';
 
 /** Attempts per agent per process, and the wait between two of them. */
 const MAX_TRIES = 4;
@@ -37,7 +38,7 @@ export function createWorkArtifactReconcile({
   const reconcileOne = async (place) => {
     const wt = placeDir(place);
     if (!wt || !existsSync(wt)) return;
-    const agentId = place.slice(2);
+    const agentId = agentIdFromPlace(place);
     try {
       await inPlace(place, true, () => artifacts.reconcile({ placeDir: wt, before: beforeArtifacts(wt), agentId }));
       done.add(place);
@@ -58,7 +59,7 @@ export function createWorkArtifactReconcile({
     for (const id of done) if (!live.has(id)) done.delete(id);
     for (const id of tries.keys()) if (!live.has(id)) tries.delete(id);
     const due = activeIds.filter((place) => {
-      if (typeof place !== 'string' || !place.startsWith('a-') || place.length <= 2) return false;
+      if (agentIdFromPlace(place) === null) return false;
       if (done.has(place) || placeLocks.has(place)) return false; // a turn or a merge is there
       const t = tries.get(place);
       return !t || (t.n < MAX_TRIES && now() - t.at >= RETRY_MS);

package/bin/lib/workAttachments.mjs

@@ -54,6 +54,8 @@ export function createWorkAttachments() {
    * doing that check is one deploy away from being zero places.
    */
   const UPLOAD_DIR = '.flowviant/uploads';
+  /** The pause before a file fetch's one retry. */
+  const RETRY_FETCH_MS = 1_000;
   // `safeFileName` (bin/lib/safeFileName.mjs — the server's rule, one daemon
   // home): THE EXTENSION SURVIVES A CUT, and it is idempotent over its own
   // output, so re-applying it to what the server already sanitized is a no-op
@@ -151,10 +153,17 @@ export function createWorkAttachments() {
       if (!a?.id || typeof a.id !== 'string' || !/^[0-9a-f-]{8,64}$/i.test(a.id)) continue;
       if (Number(a.size) > ATTACHMENT_MAX_BYTES) continue;
       try {
-        const res = await fetch(`${FILE_URL[endpoint]}/${a.id}`, {
+        // ONE MORE TRY for a blip (2026-10-19): a dropped connection or a 5xx
+        // cost the file outright. A 4xx is the server's answer and stands.
+        const get = () => fetch(`${FILE_URL[endpoint]}/${a.id}`, {
           headers: { Authorization: `Bearer ${FLEET_TOKEN}`, 'User-Agent': USER_AGENT },
           signal: AbortSignal.timeout(60_000),
         });
+        let res = await get().catch(() => null);
+        if (!res || res.status >= 500) {
+          await new Promise((r) => setTimeout(r, RETRY_FETCH_MS));
+          res = await get();
+        }
         if (!res.ok) continue;
         const buf = Buffer.from(await res.arrayBuffer());
         if (buf.byteLength === 0 || buf.byteLength > ATTACHMENT_MAX_BYTES) continue;
@@ -187,12 +196,25 @@ export function createWorkAttachments() {
     return landed;
   };
 
-  /** @returns relative paths written, in the order the human attached them. */
-  const fetchAttachments = async (wt, attachments) => {
+  /**
+   * A TAB MESSAGE'S FILES, each `{ path }` landed or `{ missed: name }`
+   * (2026-10-19). The Terminal listed only what arrived, on the argument that
+   * its person is watching and re-attaches — but the person sees the file's
+   * chip on their message whether it arrived or not, and a CLI told nothing
+   * answered as if it had read it. Named, a miss is said in the reply, as the
+   * agent lane's always were (`fetchAgentFiles`).
+   */
+  const fetchTabFiles = async (wt, attachments) => {
     if (!Array.isArray(attachments) || attachments.length === 0) return [];
-    return (await landFiles(wt, attachments.slice(0, 8), 'attachment', false)).filter(Boolean);
+    const list = attachments.slice(0, 8);
+    const landed = await landFiles(wt, list, 'attachment', false);
+    return list.map((a, i) => (landed[i] ? { path: landed[i] } : { missed: safeUploadName(a?.name) }));
   };
 
+  /** @returns relative paths written, in the order the human attached them. */
+  const fetchAttachments = async (wt, attachments) =>
+    (await fetchTabFiles(wt, attachments)).flatMap((f) => (f.path ? [f.path] : []));
+
   /**
    * AN AGENT TURN'S FILES (0.112.0), read off the wire (agentFiles.mjs: each
    * origin at the server's cap, message files first) and fetched from
@@ -218,5 +240,5 @@ export function createWorkAttachments() {
     return out;
   };
 
-  return { fetchAttachments, fetchAgentFiles };
+  return { fetchAttachments, fetchTabFiles, fetchAgentFiles };
 }

package/bin/lib/workMergeBatch.mjs

@@ -1,17 +1,19 @@
+/** The daemon holds every selected place while one personal CLI integrates it. */
 import { trackedRepositorySetup } from './repositorySetup.mjs';
 import { git } from './git.mjs';
 import { knowledgeDirFor } from './knowledgeFiles.mjs';
-/** The daemon holds every selected place while one personal CLI integrates it. */
-import { integrateMergeBatch, mergeBatchPrompt } from './mergeBatch.mjs';
+import { integrateMergeBatch } from './mergeBatch.mjs';
+import { mergeBatchPrompt, MERGE_BATCH_SYSTEM } from './repositoryPrompts.mjs';
 import { runTurn } from './runTurn.mjs';
 import { runCappedTurn } from './workCappedTurn.mjs';
-import { candidateObjects } from './agentPlan.mjs';
+import { candidateObjects } from './modelJson.mjs';
 import { pickRuntimeFor } from './runtimeDetection.mjs';
 import { fleetRequest } from './fleetPost.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
 import { worktreePath } from './workPlaces.mjs';
 import { scrub } from './uplinkScrub.mjs';
+import { relayedText } from './prWorkflow.mjs';
 import { isSafePathSegment, stripUrlUserinfo } from './git.mjs';
 import { killGroup } from './processGroup.mjs';
 
@@ -63,7 +65,7 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
               const result = await runCappedTurn({ runTurn: runCli, workChildren, releaseSlot: release,
                 transcriptCwd: context.repositories[0].integrationWorktree, capMs: 20 * 60_000, killChild: killGroup,
                 onSpawn: (ch) => { child = ch; groupKillChildren?.add(ch); },
-                turnArgs: { prompt: mergeBatchPrompt(context), system: 'You are the person’s local merge coordinator. Integrate the whole authorized selection and preserve every card’s intent.',
+                turnArgs: { prompt: mergeBatchPrompt(context), system: MERGE_BATCH_SYSTEM,
                   runtime, profile: 'build', knowledgeDir: knowledgeDirFor(repoRoot), model: leader.model || undefined, effort: leader.effort || undefined,
                   cwd: context.repositories[0].integrationWorktree, writableDirs: context.repositories.filter((r) => !r.alreadyLanded).map((r) => r.integrationWorktree),
                   answerFromResult: true, label: '[batch merge]' } });
@@ -88,7 +90,7 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
       // After a successful push/report attempt, leave the lease for replay: a transport
       // failure says nothing about whether the server committed the final receipt.
       if (claimed && !reporting) {
-        const detail = scrub(stripUrlUserinfo([e?.stdout, e?.stderr, e?.message].filter(Boolean).join('\n'))).slice(0, 2000);
+        const detail = relayedText([e?.stdout, e?.stderr, e?.message].filter(Boolean).join('\n')).slice(0, 2000);
         await request('agent-merge-batch-done', { batchId: spec.id, ok: false, detail }).catch(() => {});
       }
     } finally {

package/bin/lib/workNarration.mjs

@@ -82,7 +82,39 @@ export function createWorkNarration() {
       }, wait);
       timer.unref?.(); // never hold the process open for a spinner
     };
+    // THE CONTEXT READOUT rides the same door with its turn (2026-10-19):
+    // the latest measurement only, one POST at a time, never a turn's failure.
+    // The server writes no narration line for a context post.
+    let ctxPending = null;
+    let ctxSending = false;
+    const sendContext = async () => {
+      ctxSending = true;
+      while (ctxPending && !stopped) {
+        const context = ctxPending;
+        ctxPending = null;
+        try {
+          await fetch(ACTIVITY_URL, {
+            method: 'POST',
+            headers: {
+              Authorization: `Bearer ${FLEET_TOKEN}`,
+              'User-Agent': USER_AGENT,
+              'Content-Type': 'application/json',
+            },
+            signal: AbortSignal.timeout(10_000),
+            body: JSON.stringify({ sessionId, turnId, lines: [], context }),
+          });
+        } catch {
+          /* a readout is decoration, like the line */
+        }
+      }
+      ctxSending = false;
+    };
     return {
+      context(measured) {
+        if (!turnId || stopped || !measured) return;
+        ctxPending = measured;
+        if (!ctxSending) void sendContext();
+      },
       line(label) {
         // Scrub, like every string that leaves this machine: a narration line
         // is the CLI's own stdout — a command echoing an env var, a read of a

package/bin/lib/workPlaceReports.mjs

@@ -20,7 +20,7 @@ import { RESUME_MARKERS } from './conversationIds.mjs';
 import { worktreeDiff } from './worktreeDiff.mjs';
 import { myPubB64 } from './boxIdentity.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
-import { isValidPlace } from './workPlaces.mjs';
+import { isValidPlace, AGENT_PLACE_PREFIX, agentIdFromPlace } from './workPlaces.mjs';
 
 export function createWorkPlaceReports({
   repositoryPlaces,
@@ -176,7 +176,7 @@ export function createWorkPlaceReports({
      * TABS GET NOTHING. A tab's place is shared by design and its work is a
      * human's own directory; attributing one would be a fact with no reader.
      */
-    const pub = sessionId.startsWith('a-') && sessionId.length > 2 ? myPubB64() : null;
+    const pub = agentIdFromPlace(sessionId) !== null ? myPubB64() : null;
     /**
      * …AND WHAT THIS MACHINE PUSHED OF IT (0.86.0).
      *
@@ -193,7 +193,7 @@ export function createWorkPlaceReports({
      * Mutually exclusive without a rule of its own, because the state it reads
      * holds a sha or an error and never both.
      */
-    const pushed = sessionId.startsWith('a-') ? agentPublished.get(sessionId) : null;
+    const pushed = sessionId.startsWith(AGENT_PLACE_PREFIX) ? agentPublished.get(sessionId) : null;
     return {
       sessionId,
       ...d,

package/bin/lib/workPlaces.mjs

@@ -29,6 +29,20 @@ export const REPO_PLACE = 'repo';
  *  audit F163). */
 export const PERSON_PLACE_PREFIX = 'u-';
 
+/** An AGENT's place is `a-<agentId>` — the shared AGENT_PLACE_PREFIX /
+ *  agentPlaceId; a wire value held by the release parity gate (2026-10-18,
+ *  the SOLID pass, as F163 holds the other two). Its writer lock, its envpub
+ *  and the artifact reconcile all key on it. */
+export const AGENT_PLACE_PREFIX = 'a-';
+
+/** The agent a place names, or null for every other place shape — the shared
+ *  `agentIdFromPlace`, mirrored: the prefix alone names nothing. */
+export function agentIdFromPlace(place) {
+  return typeof place === 'string' && place.startsWith(AGENT_PLACE_PREFIX) && place.length > AGENT_PLACE_PREFIX.length
+    ? place.slice(AGENT_PLACE_PREFIX.length)
+    : null;
+}
+
 /**
  * A PLACE THIS MACHINE WILL RESOLVE: the checkout, or a safe path segment.
  *

package/bin/lib/workReportQueue.mjs

@@ -19,6 +19,7 @@ import { sweepMergedBranch } from './shipSweep.mjs';
 import { note } from './ui.mjs';
 import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
 import { fleetRequest } from './fleetPost.mjs';
+import { createReportJournal } from './reportJournal.mjs';
 
 export function createWorkReportQueue({
   repoRoot,
@@ -29,6 +30,9 @@ export function createWorkReportQueue({
   onRepoChanged,
   reportPlaceWorktrees,
   burstListeners,
+  /** Where the queue survives a restart (`reportJournal.mjs`); absent, the
+   *  queue lives in memory only, as it did before 2026-10-19. */
+  journalDir = null,
 }) {
   const WORK_DONE_URL = fleetEndpoint('work-turn-done', FLEET_URL);
   const SHIP_DONE_URL = fleetEndpoint('ship-done', FLEET_URL);
@@ -43,6 +47,16 @@ export function createWorkReportQueue({
    */
   const pendingWorkReports = new Map(); // turnId -> work-turn-done body
   const pendingShipReports = new Map(); // sessionId -> ship-done body
+  // …AND ON DISK, so a restart between the answer and the 200 delivers the
+  // answer rather than re-running the turn (reportJournal.mjs). Seeded once;
+  // the first poll's flush delivers what a previous process left.
+  const journal = journalDir ? createReportJournal(journalDir) : null;
+  if (journal) {
+    const kept = journal.load();
+    for (const [id, body] of kept.work) pendingWorkReports.set(id, body);
+    for (const [id, body] of kept.ship) pendingShipReports.set(id, body);
+  }
+  const persist = () => journal?.save(pendingWorkReports, pendingShipReports);
   /** POST a settle body. Four outcomes, and the split between the last two is
    *  load-bearing:
    *   - 'ok' — delivered.
@@ -142,10 +156,13 @@ export function createWorkReportQueue({
   const deliver = async (q, id, body) => {
     const r = await postSettle(q.url, body, q.terminal);
     if (r === 'retry' || r === 'reject') {
+      const fresh = !q.pending.has(id);
       q.pending.set(id, body);
+      if (fresh) persist();
       if (r === 'reject') reportBackoff.set(backoffKey(q, id), Date.now() + REJECT_RETRY_MS);
     } else {
-      q.pending.delete(id);
+      const held = q.pending.delete(id);
+      if (held) persist();
       reportBackoff.delete(backoffKey(q, id));
       q.delivered(id);
     }

package/bin/lib/workSessionRuntime.mjs

@@ -8,17 +8,14 @@
  * THE ID SHAPES MOVED to a leaf (audit 2026-10-10, F157): conversationIds.mjs
  * owns every CLI's conversation-id guard and marker name, because the
  * machine readers below the lanes (runtimeLimits, the session scanners) need
- * them too and a lane module is not theirs to import. The two guards the
- * agent lane imports from here are re-exported unchanged.
+ * them too and a lane module is not theirs to import.
  */
 import { existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { canRun, RUNTIMES, runtimeById, runtimeLabel } from './runtimes.mjs';
 import { detectRuntimes } from './runtimeDetection.mjs';
-import { AGY_CONV_RE, CODEX_THREAD_RE } from './conversationIds.mjs';
-
-export { AGY_CONV_RE, CODEX_THREAD_RE };
+import { AGY_CONV_RE } from './conversationIds.mjs';
 
 export function createWorkSessionRuntime({ sessionMetaPath }) {
   /**