flowviant 0.116.0 → 0.124.0

package/bin/lib/workSessionTurns.mjs

@@ -12,53 +12,34 @@
  * the credential (workSessionTokens.mjs), the runtime pin (workSessionRuntime
  * .mjs), the adopt carry (workAdoptCarry.mjs), attachments
  * (workAttachments.mjs), the live line (workNarration.mjs), the tool log
- * (workToolLog.mjs) and the command audit (workCommandAudit.mjs).
+ * (workToolLog.mjs), the command audit (workCommandAudit.mjs) and — pure —
+ * what the turn IS, plain, plan, capture or build, with its prompt pair
+ * (workTurnShape.mjs, audit 2026-10-10 F159).
  */
 import { existsSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { git, isSafePathSegment } from './git.mjs';
+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';
 import { runTurn as defaultRunTurn } from './runTurn.mjs';
 import { addUsage } from './turnUsage.mjs';
-import {
-  SYSTEM_WORK,
-  SYSTEM_CAPTURE,
-  WORK_TURN_KICKOFF,
-  CAPTURE_TURN_KICKOFF,
-  SYSTEM_WORK_PLAIN,
-  WORK_TURN_KICKOFF_PLAIN,
-  withProjectContext,
-} from './prompts.mjs';
 import { knowledgeDirFor } from './knowledgeFiles.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
-import { recordSkills, recordMcpServers } from './runtimeCapabilities.mjs';
 import { isTerminalSessionLive } from './claudeSessions.mjs';
 import { isAgyConversationLive } from './agySessions.mjs';
+import { adoptFence } from './localSessions.mjs';
 import { resumeRetriesFresh } from './resumeLost.mjs';
 import { turnLockedByLivePid } from './turnLock.mjs';
+import { killGroup } from './processGroup.mjs';
+import { printable } from './printable.mjs';
 import { brainFor } from './workBrain.mjs';
-import { REPO_PLACE } from './workPlaces.mjs';
-import { CODEX_THREAD_RE, AGY_CONV_RE } from './workSessionRuntime.mjs';
+import { AGY_CONV_RE, CLAUDE_SESSION_RE, CODEX_THREAD_RE, RESUME_MARKERS } from './conversationIds.mjs';
+import { sessionTurnKickoff, sessionTurnShape, sessionTurnSystem } from './workTurnShape.mjs';
 import { createToolLog } from './workToolLog.mjs';
 import { createCommandAudit } from './workCommandAudit.mjs';
-import { APPROVAL_REFUSED, codexApprovalSentence, codexLoginFailure, codexLoginSentence, withRelay } from './codexRelay.mjs';
-
-/**
- * THE ONE SENTENCE A PLAN TURN'S SYSTEM PROMPT GAINS (0.97.0), composed here
- * rather than in prompts.mjs because it is a MODIFIER on whichever contract
- * the tab runs, not a contract of its own.
- *
- * The enforcement is not this sentence — it is `--permission-mode plan`, under
- * which the CLI itself refuses every write (claudePosture.mjs, PLAN_MODE_PERM). What
- * the sentence buys is the ANSWER: the plain contract above it says "edit
- * freely, commit", and a turn told only that would spend itself discovering
- * refusals. It also says not to reach for `ExitPlanMode` (measured: disabled
- * under `-p`, and the probe turn then asked the person to leave plan mode
- * themselves) — leaving plan mode is the person's switch in the tab.
- */
-export const PLAN_TURN_SENTENCE =
-  'THIS IS A PLANNING TURN: the person switched this tab to plan mode, so read what you need, decide, and answer with the plan itself as your reply — change nothing (the CLI refuses every write this turn, whatever the mechanics above say about editing, committing or artifacts), and do not try to leave plan mode; they switch it off in the tab when they want the plan carried out.';
+import { APPROVAL_REFUSED, codexApprovalSentence, codexLoginFailure, codexLoginSentence, SESSION_ANSWER_MAX, withRelay } from './codexRelay.mjs';
 
 /**
  * HOW LONG, AND HOW MANY, SETTLED TURNS THE LANE REMEMBERS (2026-09-29) — see
@@ -70,6 +51,7 @@ export const SETTLED_HERE_MAX = 500;
 
 export function createWorkSessionTurns({
   repoRoot,
+  baseRef = () => null,
   baseDir,
   getMcpUrl,
   getArtifactsAccepted,
@@ -77,7 +59,7 @@ export function createWorkSessionTurns({
   inPlace,
   workChildren,
   workAttempts,
-  sessionPlaces,
+  notePlace,
   placeOf,
   placeWtFor,
   sessionMetaPath,
@@ -106,6 +88,31 @@ export function createWorkSessionTurns({
   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).
    *
@@ -153,10 +160,14 @@ export function createWorkSessionTurns({
    * and it is released in the turn's outer `finally`, after its settle.
    */
   const startingIn = new Set();
+  // 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 (rosterInterrupts.has(job.id)) continue;
       if (workAnswering.has(job.id)) continue;
       // Settled by this lane already: a roster read from before the settle
       // landed. See `settledHere`.
@@ -189,20 +200,33 @@ export function createWorkSessionTurns({
       const releaseSlot = admit.reserve();
       lastDeferSaid.delete(job.sessionId);
       workAnswering.add(job.id);
+      const run = { interrupted: false, spawned: [] };
+      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, exactly as `learnPlaces` validates
-       * the roster's map — this is the OTHER writer of `sessionPlaces`, in the
-       * same reconcile tick, BEFORE the preview jobs and the sweep read it. An
+       * VALIDATED AT THE TRUST BOUNDARY, through the same door `learnPlaces`
+       * uses for the roster's map (`notePlace`, workPlaces.mjs) — in the same
+       * reconcile tick, BEFORE the preview jobs and the sweep read it. An
        * unchecked value stored here reaches every `placeDir` consumer: the
        * turn is spawned in it, `burstListeners` measures it, and a share would
        * publicly tunnel a directory OUTSIDE the checkout — the exact traversal
        * the preview feature's port attribution exists to prevent. Settled out
        * loud rather than skipped, because a silently dropped turn strands the
        * tab for the server's whole expiry window.
+       *
+       * Stored on success: remembered for every other beat — the sweep, ship,
+       * the preview re-check — so they all ask the same directory this turn
+       * runs in.
        */
-      if (place !== REPO_PLACE && !isSafePathSegment(place)) {
+      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',
@@ -210,9 +234,6 @@ export function createWorkSessionTurns({
         releaseSlot();
         continue;
       }
-      // Remembered for every other beat — the sweep, ship, the preview
-      // re-check — so they all ask the same directory this turn runs in.
-      sessionPlaces.set(job.sessionId, place);
       // A READER: other turns in this place run alongside it. See `inPlace`.
       inPlace(place, false, async () => {
         /** This turn's artifact snapshot — set once the place is resolved and
@@ -240,6 +261,20 @@ export function createWorkSessionTurns({
          *  out here beside `usage`, and spread wherever it is. Last write wins
          *  across a fresh retry: that spawn is the one that answered. */
         let model = null;
+        /**
+         * WHAT THIS TURN SPENT AND DID, as every settle after a CLI may have
+         * run reports it (audit 2026-10-10, F164): its tool log when it has
+         * rows, its usage and its model, each only when measured. ONE
+         * null-safe spread for the empty adoption, the answer and the catch —
+         * the catch's own copy is where the 2026-09-26 ReferenceError lived,
+         * and a field added to one copy and not the others drops exactly when
+         * a turn fails.
+         */
+        const spent = () => ({
+          ...(toolLog != null ? { tools: toolLog } : {}),
+          ...(usage ? { usage } : {}),
+          ...(model ? { model } : {}),
+        });
         /** The `startingIn` key this turn claimed — released in the outer
          *  `finally`, and only by the turn that took it. */
         let startClaim = null;
@@ -249,13 +284,17 @@ 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`,
             });
             return;
           }
+          // A person's name and their tab's, both member-written, printed on
+          // the operator's console: scrubbed (2026-10-10, the audit's F097;
+          // see printable.mjs).
           note(
-            `${c.cyan('tab')} ${c.dim(`— ${job.askedByName || 'the owner'} in "${job.sessionName || 'a session'}"`)}`
+            `${c.cyan('tab')} ${c.dim(`— ${printable(job.askedByName) || 'the owner'} in "${printable(job.sessionName) || 'a session'}"`)}`
           );
           // ── ADOPTION: a tab born from a TERMINAL session ────────────────
           // The server sends `adopt {id, cwd}` only while the session has no
@@ -275,6 +314,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',
               });
@@ -289,6 +329,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",
               });
@@ -297,29 +338,20 @@ export function createWorkSessionTurns({
             // Inside the repo, outside the daemon's own worktrees: an adopt
             // source is a HUMAN's checkout, and one of our directories showing
             // up here means a stale or confused offer, not a session to fork.
-            const under = (p, root) =>
-              p === root || p.startsWith(root.endsWith('/') ? root : `${root}/`);
-            let realRoot = repoRoot;
-            let realBase = baseDir;
-            try {
-              realRoot = realpathSync(repoRoot);
-            } catch {
-              /* keep the literal path */
-            }
-            try {
-              realBase = realpathSync(baseDir);
-            } catch {
-              /* keep the literal path */
-            }
-            if (!under(srcCwd, realRoot)) {
+            // The SAME fence the offer was made through (`adoptFence`,
+            // localSessions.mjs), so the two doors cannot disagree.
+            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",
               });
               return;
             }
-            if (under(srcCwd, realBase)) {
+            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",
@@ -330,6 +362,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)",
@@ -347,6 +380,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.',
@@ -363,6 +397,7 @@ 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',
@@ -381,7 +416,7 @@ export function createWorkSessionTurns({
           const startKey = lockPath || dir.wt;
           if (startingIn.has(startKey) || turnLockedByLivePid(lockPath)) {
             warn(
-              `a turn is already running in "${job.sessionName || job.sessionId}" — waiting for it to finish`
+              `a turn is already running in "${printable(job.sessionName) || job.sessionId}" — waiting for it to finish`
             );
             return;
           }
@@ -394,12 +429,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`,
             });
@@ -407,6 +447,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`,
             });
@@ -419,6 +460,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`,
             });
@@ -426,49 +468,30 @@ 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',
             });
             return;
           }
-          if (adopting && rt.id !== 'claude' && rt.id !== 'antigravity') {
-            // An adopt id names a conversation in ITS OWN CLI's store: claude
-            // forks it (--resume --fork-session), agy moves it
-            // (--conversation). Codex has no adoptable store yet, and its
-            // args builder backstops this with a loud throw — but a sentence
-            // here beats a stack there.
-            await settleTurn(job.id, {
-              ok: false,
-              answer:
-                'adopting this terminal session needs its own CLI on the machine — install it, then try again',
-            });
-            return;
-          }
           /**
-           * A PLAN TURN (0.97.0): the tab's switch, off the job. CLAUDE ONLY —
-           * `--permission-mode plan` is Claude Code's, and a codex or agy turn
-           * has no way to spell it, so it is refused HERE in words rather than
-           * run as a build turn wearing the word. The server never sends the
-           * key for a non-Claude tab; this is the machine's own half. Never on
-           * a capture chat, which is read-only by its own profile already.
+           * WHAT THIS TURN IS — plain, plan, capture or build — decided ONCE,
+           * off the runtime's row and the job's own switches
+           * (workTurnShape.mjs, audit 2026-10-10 F159); everything below
+           * reads it instead of re-deciding. Its refusal (an adoption this
+           * CLI cannot take, then plan mode on a CLI that cannot spell it)
+           * settles here, in its words, in the order the lane always said
+           * them.
            */
-          const planTurn = job.planMode === true && job.capture !== true;
-          if (planTurn && rt.id !== 'claude') {
-            await settleTurn(job.id, {
-              ok: false,
-              answer: `plan mode runs on Claude Code only, and this tab is ${rt.id} — turn plan off in the tab, then send the message again`,
-            });
+          const shape = sessionTurnShape({ runtime: rt.id, adopting, job });
+          if (shape.refusal) {
+            await settleTurn(job.id, { ...attempt, ok: false, answer: shape.refusal });
             return;
           }
-          // A PLAIN tab (agy) mounts no MCP: no credential to mint, no config
-          // to write. The trade is stated in SYSTEM_WORK_PLAIN — no cards, no
-          // streaming — and the honesty survives on the existing rails: the
-          // answer lands via work-turn-done, the rail says "no card yet", and
-          // ship-time reconciliation books every branch commit.
-          const plainTab = rt.id === 'antigravity';
+          // A PLAIN tab (agy) mounts no MCP: no credential to mint.
           let mint = null;
-          if (!plainTab) {
+          if (!shape.plain) {
             mint = await mintWorkToken(job.sessionId);
             if (!mint) mint = await mintWorkToken(job.sessionId, true); // one transient blip ≠ a dead turn
             // Another daemon on this credential holds the session. Return
@@ -482,6 +505,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',
@@ -490,6 +514,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',
@@ -528,11 +553,11 @@ export function createWorkSessionTurns({
            */
           let claudeResumeId = null;
           if (rt.id === 'claude') {
-            const convMarker = sessionMetaPath(dir.wt, 'flowviant-claude-session', job.sessionId);
+            const convMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.claude, job.sessionId);
             if (convMarker && existsSync(convMarker)) {
               try {
                 const v = readFileSync(convMarker, 'utf8').trim();
-                if (/^[A-Za-z0-9_-]{8,64}$/.test(v)) claudeResumeId = v;
+                if (CLAUDE_SESSION_RE.test(v)) claudeResumeId = v;
               } catch {
                 /* unreadable marker — run fresh */
               }
@@ -540,7 +565,7 @@ export function createWorkSessionTurns({
           }
           let codexResumeId = null;
           if (rt.id === 'codex') {
-            const threadMarker = sessionMetaPath(dir.wt, 'flowviant-codex-thread', job.sessionId);
+            const threadMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.codex, job.sessionId);
             if (threadMarker && existsSync(threadMarker)) {
               try {
                 const v = readFileSync(threadMarker, 'utf8').trim();
@@ -558,7 +583,7 @@ export function createWorkSessionTurns({
           // dispatch sharing the machine could overwrite that between turns.
           let agyConvId = null;
           if (rt.id === 'antigravity' && !adopting) {
-            const convMarker = sessionMetaPath(dir.wt, 'flowviant-agy-conversation', job.sessionId);
+            const convMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.antigravity, job.sessionId);
             if (convMarker && existsSync(convMarker)) {
               try {
                 const v = readFileSync(convMarker, 'utf8').trim();
@@ -605,17 +630,13 @@ export function createWorkSessionTurns({
           const adoptNote = adopting
             ? '[ADOPTED SESSION — this conversation was brought in from a terminal. Begin your reply with a 2-3 sentence recap of where it left off and what state carried over, then answer the message.]'
             : '';
-          // A PLAN TURN RUNS PLAIN TOO (0.97.0): measured on 2.1.281, plan mode
-          // refuses every `mcp__flowviant` call ("Cannot call … while in plan
-          // mode") unless the tool is annotated read-only, and none of the
-          // session tools are — so mounting the control plane would hand the
-          // turn a list of tools it can only fail at. The credential is still
-          // minted above: its lease answers (held elsewhere, gone) are about
-          // the SESSION, and a plan turn needs them as much as any other.
-          const mcp =
-            plainTab || planTurn
-              ? { args: [], env: null, dir: null }
-              : mcpFor(rt.id, mint.token, getMcpUrl());
+          // Mounted only where the shape says (a plain tab and a plan turn run
+          // without one — see workTurnShape.mjs). A plan turn's credential is
+          // still minted above: its lease answers (held elsewhere, gone) are
+          // about the SESSION, and a plan turn needs them as much as any other.
+          const mcp = shape.mountMcp
+            ? mcpFor(rt.id, mint.token, getMcpUrl())
+            : { args: [], env: null, dir: null };
           // The tab's model/effort, if it named any. Spread into turnArgs so
           // BOTH runTurn calls below carry it — the retry is the same turn on
           // the same brain, not a quieter second opinion.
@@ -637,7 +658,7 @@ export function createWorkSessionTurns({
           toolLog = turnLog.toolLog;
           const { pushToolEvent } = turnLog;
           const narrator = makeNarrator(job.sessionId, job.id, () =>
-            toolLog.ev.length > 0 ? toolLog : undefined
+            toolLog
           );
 
 
@@ -661,42 +682,22 @@ export function createWorkSessionTurns({
             const message = [job.body, filesNote, adoptNote, carryNote]
               .filter(Boolean)
               .join('\n\n');
-            // A CAPTURE chat (the board's New task conversation): its own
-            // system prompt, its own kickoff, and the scratch planner's
-            // READ-ONLY permission profile — the prompt says stage-never-file
-            // and the profile is what makes "read-only" true rather than
-            // asserted. Server-flagged per job; a server too old to flag it
-            // simply runs an ordinary tab, which the web's version floor
-            // prevents ever being offered.
-            const captureTab = job.capture === true;
             const turnArgs = {
-              // A plain tab has no tools to name and no session id to pass —
-              // its kickoff asks for one complete report instead of a stream.
-              prompt: plainTab || planTurn
-                ? WORK_TURN_KICKOFF_PLAIN({
-                    sessionName: job.sessionName,
-                    message,
-                    askedByName: job.askedByName,
-                  })
-                : captureTab
-                  ? CAPTURE_TURN_KICKOFF({
-                      sessionId: job.sessionId,
-                      sessionName: job.sessionName,
-                      message,
-                      askedByName: job.askedByName,
-                    })
-                  : WORK_TURN_KICKOFF({
-                    sessionId: job.sessionId,
-                    sessionName: job.sessionName,
-                    message,
-                    askedByName: job.askedByName,
-                  }),
-              // ONE PROFILE (turnProfile.mjs): the capture chat's read-only
-              // `plan` list; or a plan turn's `plan-mode` — `--permission-mode
-              // plan` INSTEAD of the build posture, never beside
-              // `--dangerously-skip-permissions`, which silently wins
-              // (claudePosture.mjs, PLAN_MODE_PERM); else the build posture.
-              profile: captureTab ? 'plan' : planTurn ? 'plan-mode' : 'build',
+              // 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
+              // restates its posture.
+              prompt: sessionTurnKickoff(shape, {
+                sessionId: job.sessionId,
+                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`.
+              profile: shape.profile,
               // The adopt turn resumes the TERMINAL conversation by forking it
               // into this cwd (claude: --resume <id> --fork-session). After it
               // speaks once, the fork lives natively here and turn 2+ is the
@@ -708,19 +709,17 @@ 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 {
-                  // A PLAN TURN (0.97.0) runs the PLAIN contract — it has no
-                  // Flowviant tools, see `mcp` above — with no artifacts
-                  // paragraph (plan mode cannot write one) and the planning
-                  // sentence appended. Every other tab is untouched.
-                  system: planTurn
-                    ? `${withProjectContext(SYSTEM_WORK_PLAIN, { knowledgeDir, artifacts: false })}\n\n${PLAN_TURN_SENTENCE}`
-                    : withProjectContext(
-                        plainTab ? SYSTEM_WORK_PLAIN : captureTab ? SYSTEM_CAPTURE : SYSTEM_WORK,
-                        // ARTIFACTS (0.94.0): every tab but the read-only capture
-                        // chat, and only while the server can show one.
-                        { knowledgeDir, artifacts: !captureTab && getArtifactsAccepted() }
-                      ),
+                  // The shape's contract (a plan turn: the PLAIN one, no
+                  // artifacts paragraph, the planning sentence appended). The
+                  // artifacts paragraph also waits on the server — ARTIFACTS
+                  // (0.94.0): only while it can show one, read here at spawn.
+                  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.
@@ -729,16 +728,16 @@ export function createWorkSessionTurns({
               })(),
               // Present only when the tab named one — see brainFor.
               ...brain,
-              // The tab watches the CLI work. Claude needs the flag to speak
-              // events at all (codex and agy always do); `answerFromResult`
-              // keeps `out` — which IS the reply posted to the transcript — to
-              // the final result, so streamed prose is narrated once and
-              // posted once. Every line goes to the narrator above, throttled.
-              streamJson: true,
+              // The tab watches the CLI work (every CLI speaks events);
+              // `answerFromResult` keeps `out` — which IS the reply posted to
+              // the transcript — to the final result, so streamed prose is
+              // narrated once and posted once. Every line goes to the narrator
+              // above, throttled.
               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
@@ -747,7 +746,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) => {
@@ -756,16 +761,12 @@ export function createWorkSessionTurns({
               onModel: (m) => {
                 model = m;
               },
-              // What this CLI says it can be asked for by name. Harvested off
-              // the init event the stream already carries — no probe, no scan,
-              // no extra spawn — and reported on the next roster poll so the
-              // composer can autocomplete a `/`. See runtimeCapabilities.mjs for why it is
-              // learned from a turn rather than looked up.
+              // What this CLI says it can be asked for by name, and which of
+              // its connectors need a sign-in, are harvested off this init by
+              // runTurn itself (`initHarvestFor`, runtimeCapabilities.mjs) —
+              // a tab's build turn is the machine's measurement; its fenced
+              // capture chat is not.
               onInit: (i) => {
-                recordSkills(i.skills);
-                // The CLI's mounted MCP servers and connectors (0.97.0) — the
-                // same free fact off the same event; see recordMcpServers.
-                recordMcpServers(i.mcpServers);
                 // 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
@@ -777,11 +778,9 @@ export function createWorkSessionTurns({
               cwd: dir.wt,
               mcpArgs: mcp.args,
               mcpEnv: mcp.env,
-              // A PERSON AT THE KEYBOARD MAY ASK FOR A WINDOW (2026-09-29): a
-              // Terminal tab keeps its environment's display. The capture chat
-              // does not — it only reads and stages cards, and the person
-              // talking to it may be on a phone (noWindowEnv.mjs).
-              display: !captureTab,
+              // A Terminal tab keeps its environment's display; the capture
+              // chat does not (workTurnShape.mjs).
+              display: shape.display,
               runtime: rt.id,
               label: c.cyan('[tab]'),
               // Only codex announces one (thread.started); held here so the id
@@ -794,6 +793,9 @@ export function createWorkSessionTurns({
               onSpawn: (ch) => {
                 if (!ch) return;
                 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);
@@ -817,7 +819,7 @@ export function createWorkSessionTurns({
                 }
               },
             };
-            out = await runTurn({
+            out = await runCli({
               ...turnArgs,
               resume,
               resumeThreadId: codexResumeId || claudeResumeId || undefined,
@@ -858,7 +860,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
@@ -888,9 +890,9 @@ export function createWorkSessionTurns({
           if (
             rt.id === 'claude' &&
             seenClaudeSession &&
-            /^[A-Za-z0-9_-]{8,64}$/.test(seenClaudeSession)
+            CLAUDE_SESSION_RE.test(seenClaudeSession)
           ) {
-            const convMarker = sessionMetaPath(dir.wt, 'flowviant-claude-session', job.sessionId);
+            const convMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.claude, job.sessionId);
             if (convMarker) {
               try {
                 writeFileSync(convMarker, seenClaudeSession);
@@ -900,7 +902,7 @@ export function createWorkSessionTurns({
             }
           }
           if (rt.id === 'codex' && seenThreadId && CODEX_THREAD_RE.test(seenThreadId)) {
-            const threadMarker = sessionMetaPath(dir.wt, 'flowviant-codex-thread', job.sessionId);
+            const threadMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.codex, job.sessionId);
             if (threadMarker) {
               try {
                 writeFileSync(threadMarker, seenThreadId);
@@ -909,6 +911,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
@@ -920,14 +937,13 @@ 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
-              // question a failed turn's log answers.
-              ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
-              // …and an empty fork still spent what it spent.
-              ...(usage ? { usage } : {}),
-              ...(model ? { model } : {}),
+              // question a failed turn's log answers — and an empty fork
+              // still spent what it spent.
+              ...spent(),
             });
             warn('adopt turn produced no output — settled as failed');
             return;
@@ -938,7 +954,7 @@ export function createWorkSessionTurns({
           // cwd registry. From here on the marker is the tab's identity and
           // the registry is never trusted again.
           if (rt.id === 'antigravity' && answer.length > 0) {
-            const convMarker = sessionMetaPath(dir.wt, 'flowviant-agy-conversation', job.sessionId);
+            const convMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.antigravity, job.sessionId);
             if (convMarker && !existsSync(convMarker)) {
               const learned = adopting ? job.adopt.id : agyRegistryLookup(dir.wt);
               if (learned && AGY_CONV_RE.test(learned)) {
@@ -971,16 +987,26 @@ 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
                   ? withRelay(refusedLine, answer)
                   : // Scrub: a reply can quote config or env-adjacent code.
-                    envScrub(answer).slice(0, 16000)
+                    envScrub(answer).slice(0, SESSION_ANSWER_MAX)
                 : (refusedLine ?? noWords),
             // Only a turn that actually SPOKE proves a conversation lives
             // here. Recording the path unconditionally is how a crashed first
@@ -989,30 +1015,34 @@ export function createWorkSessionTurns({
             // The turn's tool log, in final form — the durable copy that lands
             // on the settled message (the live copy on the record is cleared
             // at settle). Already scrubbed at collection.
-            ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
-            ...(usage ? { usage } : {}),
-            ...(model ? { model } : {}),
+            ...spent(),
           });
           if (spoke) ok(`${c.cyan('tab')} ${c.dim('— replied in the session')}`);
           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
             // synced secret.
             answer: envScrub(String(e?.message ?? 'the session turn failed')).slice(0, 2000),
             // "What did it do before it failed" is exactly the question a
-            // crashed turn's log answers — same spread as the main settle.
-            ...(toolLog?.ev.length > 0 ? { tools: toolLog } : {}),
-            // A turn that threw after its CLI ran still spent what it spent.
-            ...(usage ? { usage } : {}),
-            ...(model ? { model } : {}),
+            // crashed turn's log answers, and a turn that threw after its CLI
+            // ran still spent what it spent — the main settle's own spread.
+            ...spent(),
           });
           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
@@ -1028,7 +1058,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,
@@ -1043,5 +1073,32 @@ export function createWorkSessionTurns({
     }
   };
 
-  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 };
 }