flowviant 0.117.0 → 0.124.1

package/bin/lib/workSessionTurns.mjs

@@ -18,6 +18,8 @@
  */
 import { existsSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { git } from './git.mjs';
+import { measureRepositoryBaseline } from './repositoryBaseline.mjs';
+import { REPOSITORY_BASELINE_PARAGRAPH } from './prompts.mjs';
 import { processStartTime } from './procRegistry.mjs';
 import { c, note, ok, warn } from './ui.mjs';
 import { mcpFor } from './claude.mjs';
@@ -30,6 +32,9 @@ import { isAgyConversationLive } from './agySessions.mjs';
 import { adoptFence } from './localSessions.mjs';
 import { resumeRetriesFresh } from './resumeLost.mjs';
 import { turnLockedByLivePid } from './turnLock.mjs';
+import { createDeliveryReporter } from './workDelivery.mjs';
+import { createLiveMessages } from './workLiveMessages.mjs';
+import { killGroup } from './processGroup.mjs';
 import { printable } from './printable.mjs';
 import { brainFor } from './workBrain.mjs';
 import { AGY_CONV_RE, CLAUDE_SESSION_RE, CODEX_THREAD_RE, RESUME_MARKERS } from './conversationIds.mjs';
@@ -48,6 +53,7 @@ export const SETTLED_HERE_MAX = 500;
 
 export function createWorkSessionTurns({
   repoRoot,
+  baseRef = () => null,
   baseDir,
   getMcpUrl,
   getArtifactsAccepted,
@@ -80,10 +86,37 @@ export function createWorkSessionTurns({
   runTurn = defaultRunTurn,
   // The clock `settledHere` ages by; injectable only for its bound's test.
   now = Date.now,
+  makeLiveMessages = createLiveMessages,
+  reportDelivery = createDeliveryReporter(),
 }) {
   const workAnswering = new Set(); // turn ids currently queued/running here
   const MAX_WORK_TRIES = 3;
 
+  /**
+   * INTERRUPT NOW (2026-10-13) — each turn this lane has taken, with the CLI
+   * children it spawned and whether a person asked to stop it. A stop kills
+   * each child's PROCESS GROUP: the CLI is spawned detached, so everything it
+   * started (a test run, a dev server) is in that group and goes with it —
+   * which is what interrupting a prompt means, and what Pause does too. A
+   * turn asked to stop before it spawned never spawns.
+   */
+  const runs = new Map(); // turnId -> { interrupted, spawned: [] }
+  /** Turns this process answered `ran: false` for, so the roster's next read
+   *  (made before that settle landed) is not answered again at once. */
+  const notRunningSaid = new Map(); // turnId -> when
+  /**
+   * Sessions whose run this lane just stopped. The next turn there is the one
+   * sent to interrupt it, and the roster that hands it over can have been read
+   * before the stop's settle landed — so the note does not wait on the
+   * server's `interrupted` alone. Taken once, and only for a little while.
+   */
+  const stoppedIn = new Map(); // sessionId -> when
+  const tookStop = (sessionId) => {
+    const when = stoppedIn.get(sessionId);
+    stoppedIn.delete(sessionId);
+    return when != null && now() - when < 120_000;
+  };
+
   /**
    * A TURN THIS LANE SETTLED IS NEVER RUN AGAIN (2026-09-29).
    *
@@ -115,12 +148,14 @@ export function createWorkSessionTurns({
     settledHere.delete(turnId); // re-inserted at the end: the map stays in time order
     settledHere.set(turnId, at);
     forgetStale(at);
-    return settleWorkTurn(turnId, payload);
+    const liveMessages = runs.get(turnId)?.live?.receipts();
+    return settleWorkTurn(turnId, { ...payload, ...(liveMessages?.ids.length ? { liveMessages } : {}) });
   };
 
   /**
-   * A PLACE A TURN OF THIS PROCESS IS STARTING IN (2026-09-29) — the turn
-   * lock's in-process half, keyed by the lock's own path.
+   * A TAB A TURN OF THIS PROCESS IS STARTING IN (2026-09-29; per tab since
+   * 2026-10-14) — the turn lock's in-process half, keyed by the lock's own
+   * path.
    *
    * `flowviant-turn.lock` is written at SPAWN, several awaits after it is
    * read (a credential mint, the attachment fetch), so two turns of one
@@ -130,18 +165,33 @@ export function createWorkSessionTurns({
    * check, so the second turn waits for a later poll like any locked one,
    * and it is released in the turn's outer `finally`, after its settle.
    */
-  const startingIn = new Set();
+  const startingIn = new Map(); // lock path -> the holding tab's measured name
+
+  // A roster can contain a turn read before its stop was requested. Never
+  // start that stale job after acknowledging the same roster's interrupt.
+  let rosterInterrupts = new Set();
 
   const processWorkTurns = (jobs) => {
     for (const job of jobs ?? []) {
       if (!job || typeof job.id !== 'string' || !job.body || !job.sessionId) continue;
-      if (workAnswering.has(job.id)) continue;
+      if (rosterInterrupts.has(job.id)) continue;
+      if (workAnswering.has(job.id)) {
+        const reason = runs.get(job.id)?.waitingReason;
+        if (reason) reportDelivery('session', job, 'queued', reason);
+        continue;
+      }
       // Settled by this lane already: a roster read from before the settle
       // landed. See `settledHere`.
       if (settledRecently(job.id)) continue;
       // The turn already RAN and its answer sits in the delivery queue — never
       // run it again while the report is merely undelivered.
       if (pendingWorkReports.has(job.id)) continue;
+      // This conversation already has a streaming Claude. Its input relay
+      // reads the durable queue; a second process must never read these words.
+      if ([...runs.values()].some((r) => r.sessionId === job.sessionId && r.live?.connected() && !r.interrupted)) {
+        reportDelivery('session', job, 'queued', 'waiting for this turn to take in the message');
+        continue;
+      }
       /**
        * THE BOX IS ABOUT TO FALL OVER, OR THIS MACHINE IS ALREADY AT ITS
        * CEILING. Defer: return without settling and without consuming an
@@ -162,11 +212,20 @@ export function createWorkSessionTurns({
       const hold = admit('interactive');
       if (hold) {
         sayTurnDeferred(job.sessionId, job.id, hold.reason);
+        reportDelivery('session', job, 'queued', hold.reason);
         continue;
       }
       const releaseSlot = admit.reserve();
       lastDeferSaid.delete(job.sessionId);
       workAnswering.add(job.id);
+      const run = { interrupted: false, spawned: [], sessionId: job.sessionId, live: null };
+      runs.set(job.id, run);
+      /** The execution generation the server handed, echoed on every settle
+       *  so the server can tell this execution's answer from an older one's. */
+      const attempt = Number.isInteger(job.attempt) ? { attempt: job.attempt } : {};
+      /** The CLI, unless a person already asked to stop this turn — then no
+       *  run starts, the fresh retry after an empty resume included. */
+      const runCli = (args) => (run.interrupted ? Promise.resolve('') : runTurn(args));
       const place = job.place || job.sessionId;
       /**
        * VALIDATED AT THE TRUST BOUNDARY, through the same door `learnPlaces`
@@ -185,6 +244,7 @@ export function createWorkSessionTurns({
        */
       if (!notePlace(job.sessionId, place)) {
         void settleTurn(job.id, {
+          ...attempt,
           ok: false,
           answer:
             'the server named a working directory this machine refuses to use — close and reopen the tab, then send the message again',
@@ -194,6 +254,7 @@ export function createWorkSessionTurns({
       }
       // A READER: other turns in this place run alongside it. See `inPlace`.
       inPlace(place, false, async () => {
+        run.waitingReason = null;
         /** This turn's artifact snapshot — set once the place is resolved and
          *  a CLI is about to spawn there; read in the `finally`. Null on every
          *  path that never ran a CLI, which is exactly when nothing is new. */
@@ -229,7 +290,7 @@ export function createWorkSessionTurns({
          * a turn fails.
          */
         const spent = () => ({
-          ...(toolLog?.ev?.length > 0 ? { tools: toolLog } : {}),
+          ...(toolLog != null ? { tools: toolLog } : {}),
           ...(usage ? { usage } : {}),
           ...(model ? { model } : {}),
         });
@@ -242,6 +303,7 @@ export function createWorkSessionTurns({
             // Out of local tries: SETTLE, don't skip — a silently skipped turn
             // strands the tab for the server's whole 24h expiry window.
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer: `the turn failed ${tries} times on this machine — check the daemon log, then send the message again`,
             });
@@ -271,6 +333,7 @@ export function createWorkSessionTurns({
               !/^[0-9a-f][0-9a-f-]{6,62}$/i.test(job.adopt.id)
             ) {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer: 'that terminal session id is not one this machine can resume',
               });
@@ -285,6 +348,7 @@ export function createWorkSessionTurns({
             }
             if (!srcCwd) {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer: "the terminal session's directory no longer exists on the machine",
               });
@@ -298,6 +362,7 @@ export function createWorkSessionTurns({
             const fenced = adoptFence({ repoRoot, excludeDirs: [baseDir] }).check(srcCwd);
             if (fenced === 'outside') {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer: "the terminal session's directory is outside this project's repository",
               });
@@ -305,6 +370,7 @@ export function createWorkSessionTurns({
             }
             if (fenced === 'ours') {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer:
                   "that directory is one of the daemon's own worktrees — its session is already a tab, not something to adopt",
@@ -315,6 +381,7 @@ export function createWorkSessionTurns({
               srcHead = git(['rev-parse', 'HEAD'], srcCwd);
             } catch {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer:
                   "the terminal session's directory is not a usable git checkout (no HEAD to branch from)",
@@ -332,6 +399,7 @@ export function createWorkSessionTurns({
                 : isTerminalSessionLive(job.adopt.id);
             if (adoptLive) {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer:
                   'That terminal session is still open on the machine — close it there first, then adopt.',
@@ -348,29 +416,44 @@ export function createWorkSessionTurns({
           const dir = placeWtFor(place, adopting ? srcHead : undefined);
           if (!dir) {
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer:
                 'the session worktree could not be opened on the machine — check the daemon log',
             });
             return;
           }
-          // A live CLI is ALREADY in this worktree — this daemon's previous
-          // life, most likely; the lock outlives a restart. Leave the job
-          // pending and look again next poll; spawning a second CLI would put
-          // two Claudes in one held context. Costs no attempt: nothing ran.
+          // A live CLI is ALREADY in this tab's conversation — this daemon's
+          // previous life, most likely; the lock outlives a restart. Leave the
+          // job pending and look again next poll; spawning a second CLI would
+          // put two Claudes in one held context. Costs no attempt: nothing ran.
           // …AND ONE OF OURS MAY BE ABOUT TO: `startingIn`, checked and
           // claimed with no await between, because the file is only written
-          // at spawn. Keyed by the lock's path (the directory, when the git
-          // dir cannot be named) — the file lock's own scope.
-          const lockPath = sessionMetaPath(dir.wt, 'flowviant-turn.lock');
-          const startKey = lockPath || dir.wt;
+          // at spawn. Keyed by the lock's path (the directory and the tab,
+          // when the git dir cannot be named) — the file lock's own scope.
+          // PER TAB (2026-10-14, turnLock.mjs): other tabs in this directory
+          // run beside it. The unscoped file is an older daemon's CLI, whose
+          // tab is unknown, so it holds every tab here until it exits.
+          const lockPath = sessionMetaPath(dir.wt, 'flowviant-turn.lock', job.sessionId);
+          const legacyLock = sessionMetaPath(dir.wt, 'flowviant-turn.lock');
+          const startKey = lockPath || `${dir.wt}\0${job.sessionId}`;
+          const tabId = printable(job.sessionId);
+          const tabLabel = `tab "${printable(job.sessionName) || tabId}" (${tabId})`;
+          if (turnLockedByLivePid(legacyLock)) {
+            reportDelivery('session', job, 'queued', 'waiting for another tab’s turn to finish (legacy lock; tab unknown)');
+            warn(
+              `a turn from an earlier flowviant holds the place; tab unknown (legacy lock) — ${tabLabel} waits for it to finish`
+            );
+            return;
+          }
           if (startingIn.has(startKey) || turnLockedByLivePid(lockPath)) {
+            reportDelivery('session', job, 'queued', 'waiting for this turn to finish');
             warn(
-              `a turn is already running in "${printable(job.sessionName) || job.sessionId}" — waiting for it to finish`
+              `${startingIn.get(startKey) || tabLabel} holds the turn lock — waiting for it to finish`
             );
             return;
           }
-          startingIn.add(startKey);
+          startingIn.set(startKey, tabLabel);
           startClaim = startKey;
           // WHICH BRAIN the roster says this tab speaks (null/absent = Claude,
           // which is what every tab ran on until now) — honored by
@@ -379,12 +462,17 @@ export function createWorkSessionTurns({
           // What the artifact directory held BEFORE this turn — the capture chat
           // excepted: it runs read-only, is never told about artifacts, and
           // whatever sibling tabs wrote in this shared place is theirs.
-          if (job.capture !== true) artifactScan = { dir: dir.wt, before: beforeArtifacts(dir.wt) };
+          if (job.capture !== true) {
+            artifactScan = { dir: dir.wt, before: beforeArtifacts(dir.wt), reported: false };
+            artifactScan.instructions = getArtifactsAccepted()
+              ? await artifacts.prepare?.({ placeDir: dir.wt, before: artifactScan.before, sessionId: job.sessionId }) ?? '' : '';
+          }
           const rt = sessionRuntime(dir.wt, job.runtime || null, job.sessionId);
           if (rt.mismatch) {
             // Something upstream changed this tab's identity mid-life. A held
             // context must never be answered by a different brain — say so.
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer: `this tab is pinned to ${rt.mismatch.pin} but the server says it is a ${rt.mismatch.runtime} tab — reopen a new tab`,
             });
@@ -392,6 +480,7 @@ export function createWorkSessionTurns({
           }
           if (rt.missing) {
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer: `this session runs on ${rt.missing}, which is no longer installed on the machine — reinstall it, or open a new tab`,
             });
@@ -404,6 +493,7 @@ export function createWorkSessionTurns({
             // whole control plane rides one). An honest sentence beats the
             // mcpFor throw this used to crash into every turn.
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer: `this session runs on ${rt.unsupported}, which cannot drive a Terminal tab on this machine — open a new tab`,
             });
@@ -411,6 +501,7 @@ export function createWorkSessionTurns({
           }
           if (!rt.id) {
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer:
                 'No coding CLI is installed on the machine — install Claude Code (or another supported CLI), then send the message again',
@@ -428,7 +519,7 @@ export function createWorkSessionTurns({
            */
           const shape = sessionTurnShape({ runtime: rt.id, adopting, job });
           if (shape.refusal) {
-            await settleTurn(job.id, { ok: false, answer: shape.refusal });
+            await settleTurn(job.id, { ...attempt, ok: false, answer: shape.refusal });
             return;
           }
           // A PLAIN tab (agy) mounts no MCP: no credential to mint.
@@ -447,6 +538,7 @@ export function createWorkSessionTurns({
             }
             if (mint?.gone) {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer:
                   'Flowviant no longer offers this session to this machine — the tab may have been closed or moved',
@@ -455,6 +547,7 @@ export function createWorkSessionTurns({
             }
             if (!mint?.token) {
               await settleTurn(job.id, {
+              ...attempt,
                 ok: false,
                 answer:
                   'the machine could not mint a session credential from Flowviant — check its connection, then send the message again',
@@ -598,7 +691,7 @@ export function createWorkSessionTurns({
           toolLog = turnLog.toolLog;
           const { pushToolEvent } = turnLog;
           const narrator = makeNarrator(job.sessionId, job.id, () =>
-            toolLog.ev.length > 0 ? toolLog : undefined
+            toolLog
           );
 
 
@@ -623,6 +716,17 @@ export function createWorkSessionTurns({
               .filter(Boolean)
               .join('\n\n');
             const turnArgs = {
+              ...(rt.id === 'claude' ? { liveMessages: (run.live = makeLiveMessages({
+                scope: 'session', turnId: job.id, attempt: job.attempt, cwd: dir.wt, sessionMetaPath,
+                interrupted: () => run.interrupted,
+                format: async (followup) => {
+                  const paths = await fetchAttachments(dir.wt, followup.attachments);
+                  const note = paths.length ? `[FILES THE HUMAN ATTACHED TO THIS MESSAGE — already on disk in this worktree]\n${paths.map((f) => `- ${f}`).join('\n')}` : '';
+                  const words = shape.capture ? (followup.libraryPrompt ?? '') + followup.body : followup.body + (followup.libraryPrompt ?? '');
+                  return sessionTurnKickoff(shape, { sessionId: job.sessionId, sessionName: job.sessionName,
+                    askedByName: followup.askedByName, message: [words, note].filter(Boolean).join('\n\n') });
+                },
+              })) } : {}),
               // The kickoff under the turn's contract: a plain tab (or a plan
               // turn) has no tools to name and no session id to pass, and asks
               // for one complete report instead of a stream; a capture chat
@@ -632,6 +736,8 @@ export function createWorkSessionTurns({
                 sessionName: job.sessionName,
                 message,
                 askedByName: job.askedByName,
+                // INTERRUPT NOW: the previous run was stopped to send this.
+                interrupted: tookStop(job.sessionId) || job.interrupted === true,
               }),
               // ONE PROFILE (turnProfile.mjs), the shape's: `plan` for the
               // capture chat, `plan-mode` for a plan turn, else `build`.
@@ -647,6 +753,7 @@ export function createWorkSessionTurns({
               // library that synced a second ago is in THIS turn.
               ...(() => {
                 const knowledgeDir = knowledgeDirFor(repoRoot);
+                if (job.capture === true) toolLog.baseline = measureRepositoryBaseline({ cwd: dir.wt, baseRef, knowledgeDir });
                 return {
                   // The shape's contract (a plan turn: the PLAIN one, no
                   // artifacts paragraph, the planning sentence appended). The
@@ -655,7 +762,8 @@ export function createWorkSessionTurns({
                   system: sessionTurnSystem(shape, {
                     knowledgeDir,
                     artifactsAccepted: getArtifactsAccepted(),
-                  }),
+                    runtime: rt.id,
+                  }) + (toolLog.baseline ? '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(toolLog.baseline) : '') + (artifactScan?.instructions ? `\n\n${artifactScan.instructions}` : ''),
                   // The directory is OUTSIDE a worktree's cwd; Claude Code is
                   // told it may read there (`--add-dir`) rather than left to
                   // refuse a read-only capture turn a path it was just handed.
@@ -672,7 +780,8 @@ export function createWorkSessionTurns({
               answerFromResult: true,
               onActivity: (a) => {
                 narrator.line(a?.label);
-                auditCommand(a);
+                // Claude/Codex commands are audited below with their correlated outcome.
+                if (rt.id !== 'claude' && rt.id !== 'codex') auditCommand(a);
                 if (a?.kind === 'tool' && APPROVAL_REFUSED.test(a.error ?? '')) approvalRefused.push(a.label);
               },
               // One Codex agent MESSAGE (runtimeEvents.mjs `answer`): the turn
@@ -681,7 +790,13 @@ export function createWorkSessionTurns({
                 if (String(a ?? '').trim()) codexSpoke = true;
               },
               // The structured twin of the line above — see toolLog.
-              onToolEvent: pushToolEvent,
+              onToolEvent: (name, input, meta) => {
+                const e = pushToolEvent(name, input, meta);
+                if (e?.t === 'bash') auditCommand({
+                  kind: 'bash', command: input?.command ?? e.c,
+                  observation: { id: e.id, outcome: e.outcome, exitCode: e.exitCode, errorCategory: e.errorCategory },
+                });
+              },
               // The CLI's own token counts, tagged with which CLI counted them
               // — ADDED, not set: both runTurn calls below share these args.
               onUsage: (u) => {
@@ -696,13 +811,15 @@ export function createWorkSessionTurns({
               // a tab's build turn is the machine's measurement; its fenced
               // capture chat is not.
               onInit: (i) => {
-                // The conversation this turn is actually speaking under. Held
-                // and persisted after the turn ends, so the NEXT one resumes
-                // this exact thread rather than whatever the directory saw
-                // last. Last write wins on purpose: a resume that fell back to
-                // fresh reports the fresh id, healing the marker.
-                if (typeof i.sessionId === 'string' && i.sessionId.trim())
+                // Pin at init so a restart during a long tool can resume the
+                // same conversation and recover its native message UUIDs.
+                if (typeof i.sessionId === 'string' && i.sessionId.trim()) {
                   seenClaudeSession = i.sessionId.trim();
+                  if (CLAUDE_SESSION_RE.test(seenClaudeSession)) {
+                    const marker = sessionMetaPath(dir.wt, RESUME_MARKERS.claude, job.sessionId);
+                    if (marker) try { writeFileSync(marker, seenClaudeSession); } catch { /* best effort */ }
+                  }
+                }
               },
               cwd: dir.wt,
               mcpArgs: mcp.args,
@@ -721,7 +838,11 @@ export function createWorkSessionTurns({
               },
               onSpawn: (ch) => {
                 if (!ch) return;
+                if (rt.id !== 'claude') reportDelivery('session', job, 'taken');
                 spawned.push(ch);
+                run.spawned.push(ch);
+                // Asked to stop between the check and the spawn.
+                if (run.interrupted) killGroup(ch);
                 // Keyed to the SESSION it serves — that id is what the machine
                 // snapshot charges this child's memory to.
                 workChildren.set(ch, job.sessionId);
@@ -745,7 +866,7 @@ export function createWorkSessionTurns({
                 }
               },
             };
-            out = await runTurn({
+            out = await runCli({
               ...turnArgs,
               resume,
               resumeThreadId: codexResumeId || claudeResumeId || undefined,
@@ -786,7 +907,7 @@ export function createWorkSessionTurns({
               !adopting &&
               resumeRetriesFresh({ resume, out, runtime: rt.id, sawInit: Boolean(seenClaudeSession) })
             ) {
-              out = await runTurn({ ...turnArgs, resume: false });
+              out = await runCli({ ...turnArgs, resume: false });
             }
           } finally {
             // The CLI has stopped printing, so stop relaying. The LINE itself
@@ -809,24 +930,6 @@ export function createWorkSessionTurns({
           // before it ever touches disk — it later rides in argv as
           // `resume <id>` — and best-effort, like the runtime pin: an
           // unwritable marker just means the tab runs fresh next turn.
-          // The conversation THIS TAB just spoke under, pinned so the next
-          // turn resumes it by id rather than asking the directory. Written
-          // after the turn for the same reason codex's is: an id learned
-          // mid-turn is only true once the turn that learned it finished.
-          if (
-            rt.id === 'claude' &&
-            seenClaudeSession &&
-            CLAUDE_SESSION_RE.test(seenClaudeSession)
-          ) {
-            const convMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.claude, job.sessionId);
-            if (convMarker) {
-              try {
-                writeFileSync(convMarker, seenClaudeSession);
-              } catch {
-                /* best-effort — the next turn re-learns it */
-              }
-            }
-          }
           if (rt.id === 'codex' && seenThreadId && CODEX_THREAD_RE.test(seenThreadId)) {
             const threadMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.codex, job.sessionId);
             if (threadMarker) {
@@ -837,6 +940,21 @@ export function createWorkSessionTurns({
               }
             }
           }
+          /**
+           * A PERSON INTERRUPTED IT. Whatever the CLI printed was cut off, so
+           * it is not an answer: the turn settles `interrupted`, with what it
+           * spent and did, and the message sent to interrupt it runs next in
+           * this same conversation — the markers above already hold its id.
+           * Never spawned, it settles `ran: false`, unremembered, so the
+           * server's re-offer runs it as it was.
+           */
+          if (run.interrupted) {
+            const body = { ...attempt, ok: false, interrupted: true, ran: run.spawned.length > 0, answer: 'the turn was interrupted', ...spent() };
+            if (body.ran) stoppedIn.set(job.sessionId, now());
+            await (body.ran ? settleTurn(job.id, body) : settleWorkTurn(job.id, body));
+            ok(`${c.cyan('tab')} ${c.dim('— interrupted')}`);
+            return;
+          }
           const answer = (out || '').trim();
           // No output at all smells like a dead MCP credential (the lane
           // workers' no-sentinel case) — drop the cached token so the next
@@ -848,6 +966,7 @@ export function createWorkSessionTurns({
             // exactly that; no sessionRef is recorded, so the server keeps
             // offering the adoption and a retry after the user checks is cheap.
             await settleTurn(job.id, {
+              ...attempt,
               ok: false,
               answer: "Couldn't resume the terminal session — it may have been removed.",
               // Whatever it DID before coming back empty is exactly the
@@ -897,10 +1016,20 @@ export function createWorkSessionTurns({
            */
           const loginFailure = rt.id === 'codex' && !codexSpoke ? codexLoginFailure(answer) : null;
           const refusedLine = rt.id === 'codex' ? codexApprovalSentence(approvalRefused) : null;
+          let artifactFailure = null;
+          if (artifactScan) {
+            artifactScan.reported = true;
+            try {
+              await artifacts.report({ placeDir: artifactScan.dir, before: artifactScan.before, sessionId: job.sessionId, turnId: job.id });
+            } catch (error) {
+              artifactFailure = `Artifact delivery is incomplete: ${error.message}`;
+            }
+          }
           const spoke = answer.length > 0 && !loginFailure;
           await settleTurn(job.id, {
-            ok: spoke,
-            answer: loginFailure
+              ...attempt,
+            ok: spoke && !artifactFailure,
+            answer: artifactFailure ? withRelay(artifactFailure, answer) : loginFailure
               ? withRelay(codexLoginSentence(loginFailure), answer)
               : answer.length > 0
                 ? refusedLine
@@ -921,7 +1050,14 @@ export function createWorkSessionTurns({
           else if (loginFailure) warn('codex answered 401 for this session turn — settled as failed, in words');
           else warn('session turn produced no output — settled as failed');
         } catch (e) {
+          if (toolLog) toolLog.state = 'partial';
+          if (run.interrupted) {
+            const body = { ...attempt, ok: false, interrupted: true, ran: run.spawned.length > 0, answer: 'the turn was interrupted', ...spent() };
+            await (body.ran ? settleTurn(job.id, body) : settleWorkTurn(job.id, body));
+            return;
+          }
           await settleTurn(job.id, {
+              ...attempt,
             ok: false,
             // Scrub, like every string that leaves this machine: an exception
             // routinely quotes command output, and command output can quote a
@@ -935,6 +1071,7 @@ export function createWorkSessionTurns({
           warn(`session turn failed: ${e?.message ?? e}`);
         } finally {
           workAnswering.delete(job.id);
+          runs.delete(job.id);
           if (startClaim) startingIn.delete(startClaim);
           // Nothing spawned, or everything already has: releasing twice is the
           // normal case and costs nothing. A reservation that leaked would
@@ -950,7 +1087,7 @@ export function createWorkSessionTurns({
           // …and relay what it wrote to SHOW its owner (2026-09-22) — the same
           // beat, the same reason it is not awaited. A failed turn's half-drawn
           // page is still what the turn left, and the tab should see it.
-          if (artifactScan) {
+          if (artifactScan && !artifactScan.reported) {
             void artifacts
               .report({
                 placeDir: artifactScan.dir,
@@ -961,9 +1098,39 @@ export function createWorkSessionTurns({
               .catch(() => {});
           }
         }
+      }, () => {
+        run.waitingReason = 'waiting for a ship to finish';
+        reportDelivery('session', job, 'queued', run.waitingReason);
       });
     }
   };
 
-  return { processWorkTurns, workAnswering, settledHere };
+  /**
+   * THE RUNS A PERSON ASKED TO STOP (`roster.interruptTurns`, read before the
+   * jobs). One this lane is running is stopped — its process groups killed —
+   * and settles `interrupted` when its CLI is gone. One it finished already
+   * keeps its own settle. One it is not running at all is answered `ran:
+   * false`: nothing was running here to stop, and the server puts it back in
+   * the queue.
+   */
+  const interruptWorkTurns = (ids) => {
+    rosterInterrupts = new Set(Array.isArray(ids) ? ids : []);
+    const at = now();
+    for (const [id, when] of notRunningSaid) if (at - when > 30_000) notRunningSaid.delete(id);
+    for (const id of Array.isArray(ids) ? ids : []) {
+      if (typeof id !== 'string' || !id) continue;
+      const run = runs.get(id);
+      if (run) {
+        if (!run.interrupted) note(`${c.cyan('tab')} ${c.dim('— interrupting the running turn')}`);
+        run.interrupted = true;
+        for (const ch of run.spawned) killGroup(ch);
+        continue;
+      }
+      if (pendingWorkReports.has(id) || settledRecently(id) || notRunningSaid.has(id)) continue;
+      notRunningSaid.set(id, at);
+      void Promise.resolve(settleWorkTurn(id, { ok: false, interrupted: true, ran: false, answer: '' })).catch(() => {});
+    }
+  };
+
+  return { processWorkTurns, interruptWorkTurns, workAnswering, settledHere };
 }

package/bin/lib/workShip.mjs

@@ -7,7 +7,7 @@ import { gitMergeIn } from './gitMergeIdentity.mjs';
 import { c, note, ok, warn } from './ui.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { REPO_PLACE } from './workPlaces.mjs';
-import { turnLockedByLivePid } from './turnLock.mjs';
+import { placeTurnLockHolder } from './turnLock.mjs';
 import { printable } from './printable.mjs';
 
 export function createWorkShipper({
@@ -227,11 +227,24 @@ export function createWorkShipper({
             ok(`${c.cyan('ship')} ${c.dim('— already on main; nothing new to merge')}`);
             return;
           }
+          // Any tab's orphaned CLI holds this shared HEAD across a restart.
+          // This also applies when the SHIPPING tab is closed: another tab
+          // can still be editing its place. Query the directory without
+          // re-cutting a retired worktree, after the idempotent receipt path.
+          const holder = placeTurnLockHolder(sessionMetaPath(wt, 'flowviant-turn.lock'));
+          if (holder) {
+            const holderTab = holder.sessionId === null ? 'tab unknown (legacy lock)' : `tab "${printable(holder.sessionId)}"`;
+            warn(
+              `${holderTab} holds the turn lock — ship of "${sessionName || job.sessionId}" waits for it`
+            );
+            deferred = true;
+            return;
+          }
           const ended = liveIds ? !liveIds.has(job.sessionId) : false;
           if (ended) {
-            // The tab is closed: no turn can commit, discard, or resolve
-            // anything in the directory, so a dirty worktree must not strand
-            // the branch's committed work in review forever. Ship the TIP.
+            // The tab is closed: it cannot commit, discard, or resolve, so
+            // a dirty worktree must not strand its committed work in review
+            // forever. With every other tab's CLI quiet, ship the TIP.
             if (!branchExists) {
               await done({
                 ok: false,
@@ -284,18 +297,6 @@ export function createWorkShipper({
             });
             return;
           }
-          // A live CLI is in this worktree — a restarted daemon's orphan
-          // mid-turn (in-process the chain serializes, but the lock is the
-          // only guarantee that survives a crash). Folding under it would
-          // rewrite HEAD inside a held conversation; defer like the turn
-          // path, and the job re-offers next poll.
-          if (turnLockedByLivePid(sessionMetaPath(dir.wt, 'flowviant-turn.lock'))) {
-            warn(
-              `a turn is still running in "${sessionName || job.sessionId}" — ship waits for it`
-            );
-            deferred = true;
-            return;
-          }
           if (git(['status', '--porcelain'], dir.wt) !== '') {
             await done({
               ok: false,