flowviant 0.115.0 → 0.117.0

package/bin/lib/workSessionTurns.mjs

@@ -12,53 +12,31 @@
  * 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 { 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 { 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
@@ -77,7 +55,7 @@ export function createWorkSessionTurns({
   inPlace,
   workChildren,
   workAttempts,
-  sessionPlaces,
+  notePlace,
   placeOf,
   placeWtFor,
   sessionMetaPath,
@@ -191,17 +169,21 @@ export function createWorkSessionTurns({
       workAnswering.add(job.id);
       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, {
           ok: false,
           answer:
@@ -210,9 +192,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 +219,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?.ev?.length > 0 ? { 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;
@@ -254,8 +247,11 @@ export function createWorkSessionTurns({
             });
             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
@@ -297,28 +293,17 @@ 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, {
                 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, {
                 ok: false,
                 answer:
@@ -381,7 +366,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;
           }
@@ -432,43 +417,23 @@ export function createWorkSessionTurns({
             });
             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, { 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
@@ -528,11 +493,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 +505,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 +523,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 +570,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.
@@ -661,42 +622,20 @@ 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,
+              }),
+              // 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
@@ -709,18 +648,14 @@ export function createWorkSessionTurns({
               ...(() => {
                 const knowledgeDir = knowledgeDirFor(repoRoot);
                 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(),
+                  }),
                   // 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,12 +664,11 @@ 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);
@@ -756,16 +690,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 +707,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
@@ -888,9 +816,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 +828,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);
@@ -923,11 +851,9 @@ export function createWorkSessionTurns({
               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 +864,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)) {
@@ -980,7 +906,7 @@ export function createWorkSessionTurns({
                 ? 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,9 +915,7 @@ 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');
@@ -1004,11 +928,9 @@ export function createWorkSessionTurns({
             // 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 {