flowviant 0.125.6 → 0.125.7

package/bin/lib/runtimeCapabilities.mjs

@@ -168,9 +168,14 @@ export function claudeMcpInventoryOf(list, tools) {
   for (const e of list) {
     if (!e || typeof e !== 'object' || typeof e.name !== 'string') continue;
     const name = e.name.trim().slice(0, MCP_NAME_MAX).trim();
-    if (!name || name === 'flowviant' || seen.has(name)) continue;
+    const scope = typeof e.scope === 'string' ? e.scope : typeof e.source === 'string' ? e.source : null;
+    // The daemon's own `flowviant` rides `--mcp-config`, reported `dynamic`.
+    // One in the person's own config is theirs (2026-10-17, the owner) and is
+    // listed, so a revoked token there reads failed (2026-10-19). An
+    // unscoped report cannot say which, and stays hidden.
+    if (!name || name === 'flowviant' && (scope === 'dynamic' || scope == null) || seen.has(name)) continue;
     const status = MCP_STATUSES.has(e.status) ? e.status : 'other';
-    seen.set(name, { name, status, scope: typeof e.scope === 'string' ? e.scope : typeof e.source === 'string' ? e.source : null, prefix: mcpToolPrefix(e.name.trim()), tools: status === 'connected' ? [] : null });
+    seen.set(name, { name, status, scope, prefix: mcpToolPrefix(e.name.trim()), tools: status === 'connected' ? [] : null });
   }
   // The longest prefix wins, so `a_b` never claims `a`'s tools or the reverse.
   const byPrefix = [...seen.values()].sort((a, b) => b.prefix.length - a.prefix.length);

package/bin/lib/runtimeClaude.mjs

@@ -19,6 +19,15 @@ import { machineMcpServers } from './claudeMachineMcp.mjs';
 import { claudePermFor, withMachineMcp } from './claudePosture.mjs';
 import { withSettings } from './claudeSettingsArg.mjs';
 import { orchestratorHooks } from './orchestratorHooks.mjs';
+import { versionAtLeast } from './versionOrder.mjs';
+
+/** The release the agent lane first measured `--system-prompt-snapshot` on
+ *  (decisions.md, 2026-09-24). */
+export const SYSTEM_PROMPT_SNAPSHOT_MIN = '2.1.281';
+/** `--version` prints "2.1.303 (Claude Code)"; the first word is the version. */
+export function claudeSnapshotFlagKnown(version) {
+  return versionAtLeast(String(version ?? '').trim().split(/\s+/)[0], SYSTEM_PROMPT_SNAPSHOT_MIN);
+}
 
 function claudeMcp(token, mcpUrl) {
   const dir = mkdtempSync(join(tmpdir(), 'flowviant-mcp-'));
@@ -113,7 +122,7 @@ export const CLAUDE_RUNTIME = {
    * strongest form of it available anywhere: `--append-system-prompt` sits
    * above the conversation rather than inside it.
    */
-  args({ writableDirs = [], prompt, system, model, effort, resume, perm, profile = 'build', mcp = [], resultSchemaArgs = [], adoptResumeId, resumeThreadId, knowledgeDir, vaultDir, agentTools, personalSettings, machineMcp, baseMcp = [], mcpCheckout = null, streamInput = false, orchestration = false }) {
+  args({ writableDirs = [], prompt, system, model, effort, resume, perm, profile = 'build', mcp = [], resultSchemaArgs = [], adoptResumeId, resumeThreadId, knowledgeDir, vaultDir, agentTools, personalSettings, machineMcp, baseMcp = [], mcpCheckout = null, streamInput = false, orchestration = false, claudeVersion = null }) {
     // THE CARTOGRAPHER'S FENCE NAMES ITS VAULT (2026-10-10): its one write rule
     // is the vault's absolute path (claudePosture.mjs `wikiPermFor`), so a turn
     // with no vault, or one no rule can name, has no list — refused here in
@@ -191,10 +200,18 @@ export const CLAUDE_RUNTIME = {
     // states `default` itself, unless its own list names a mode (plan-mode).
     if (fenced && !perm.includes('--permission-mode')) a.push('--permission-mode', 'default');
     else if (agentTools) a.push('--setting-sources', 'user');
-    if (agentTools) {
-      a.push('--system-prompt-snapshot', 'off');
-      if (agentTools.pluginDir) a.push('--plugin-dir', agentTools.pluginDir);
-    }
+    // EVERY TURN RENDERS ITS OWN SYSTEM PROMPT (2026-10-19). By default the
+    // CLI records a conversation's first system prompt and resends that record
+    // on every resume "even when a later launch passes different text" —
+    // measured offline on 2.1.303: a resumed turn appended BETA and the model
+    // was sent the first turn's ALPHA. A tab's appended prompt moves between
+    // turns (plan mode on and off, the knowledge and artifact paragraphs), so
+    // a tab switched out of plan mode kept being told to change nothing. An
+    // agent turn always passed this (its current base instructions). A CLI too
+    // old to name the flag refuses it, so an unmeasured version keeps the old
+    // argv.
+    if (agentTools || claudeSnapshotFlagKnown(claudeVersion)) a.push('--system-prompt-snapshot', 'off');
+    if (agentTools?.pluginDir) a.push('--plugin-dir', agentTools.pluginDir);
     // WHICH MCP SERVERS A TURN MOUNTS. An agent's code, write-up and
     // mockup/3D-model/deck turns (2026-10-11, the owner) mount this machine's
     // own — its user and local servers and the account's claude.ai connectors —

package/bin/lib/runtimeCodex.mjs

@@ -173,6 +173,9 @@ const codexWikiFence = (vaultDir) => [
 ];
 
 function codexPrompt({ system, prompt, profile = 'build' }) {
+  // A resumed tab whose thread already holds the contract sends none
+  // (codexContract.mjs): the message alone.
+  if (!system) return prompt;
   const readers = profile === 'consult' || profile === 'plan'
     ? '\nUse exec_command with shell="/bin/bash" and login=false for project discovery. Project files, local Git history and the project knowledge directory are readable; host files are outside this turn’s read boundary.'
     : '';

package/bin/lib/runtimeOfferings.mjs

@@ -96,7 +96,9 @@ function commandFound(command, env) {
 export function codexServerRows(servers, env = process.env) {
   const rows = [];
   for (const s of servers) {
-    if (!s || typeof s.name !== 'string' || !nameOk(s.name)) continue;
+    // `mcp list` reads the person's own config; the daemon's `flowviant`
+    // rides `-c` and is never in it, so one of that name is theirs.
+    if (!s || typeof s.name !== 'string' || !(nameOk(s.name) || s.name === 'flowviant')) continue;
     const t = s.transport && typeof s.transport === 'object' ? s.transport : {};
     const auth = typeof s.auth_status === 'string' ? s.auth_status : '';
     let status = 'configured';

package/bin/lib/startProject.mjs

@@ -208,6 +208,16 @@ export async function resolveStartProject({ dirGiven }) {
           `or connect this repo to its own project with \`${terminalCommand('login')}\`.`
       );
       process.exit(1);
+    } else if (interactive && !CREDENTIAL.choices?.length) {
+      // NOTHING STORED AND A PERSON AT THE TERMINAL IS A FIRST CONNECTION
+      // (2026-10-19). The app's connect command ends in a bare `flowviant`
+      // and the README promises "approve the code in Flowviant → connected",
+      // yet this branch printed "no credential found" and exited 1 — so the
+      // one command every first connection runs failed after a successful
+      // install. Log in here, as the picker's connect row does; headless
+      // still refuses in the words below, because nobody can approve a code.
+      console.log('No project is connected on this machine yet — connecting one now.');
+      await reexecAfterLogin();
     } else {
       console.error(
         'error: no credential found. Easiest:\n' +

package/bin/lib/update.mjs

@@ -39,7 +39,7 @@ import { platform, arch } from 'node:process';
 import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
 import { relaunchSelf, runningCompiledBinary, runningViaNpx, selfArgv, terminalCommand } from './launchCommand.mjs';
-import { VERSION } from './config.mjs';
+import { DAEMON_INSTANCE, VERSION } from './config.mjs';
 import { compareVersions, versionBelow } from './versionOrder.mjs';
 import { note, ok, warn } from './ui.mjs';
 
@@ -194,6 +194,9 @@ export function reexec(teardown, { viaNpx = false, target = null } = {}, deps =
       // as a rival and the new daemon SIGTERMed this proxy. instance.mjs adopts
       // the lock from this pid when it is really an ancestor of the successor.
       FLOWVIANT_REEXEC_FROM: String(process.pid),
+      // WHO THE SUCCESSOR IS, to the server: this process's own instance, so
+      // the idle tabs' session leases are already its own (config.mjs).
+      FLOWVIANT_DAEMON_INSTANCE: DAEMON_INSTANCE,
       // WHAT WE RESTARTED IN ORDER TO BECOME. The successor compares its own
       // VERSION against this: if it came back still short, the update did not
       // take (a registry serving a stale `latest`, an npx cache that refused to
@@ -223,9 +226,20 @@ export function updateRestartFailed(target) {
   return nowVsAttempted === -1 && targetVsAttempted !== null && targetVsAttempted <= 0;
 }
 
-/** Install @latest globally. Throws on failure (EACCES without sudo, offline…). */
-function installLatest() {
-  execFileSync('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit' });
+/**
+ * HOW LONG A GLOBAL INSTALL MAY TAKE (2026-10-19). The install is synchronous
+ * — it holds the event loop for as long as npm runs — and it had no bound, so
+ * a registry or a lock that hung npm hung the whole daemon: no poll, no wake,
+ * no turn, on a machine that read as connected. Five minutes is far past a
+ * real install; past it npm is killed and the failure is the usual one,
+ * retried in fifteen minutes.
+ */
+export const INSTALL_TIMEOUT_MS = 5 * 60_000;
+
+/** Install @latest globally. Throws on failure (EACCES without sudo, offline,
+ *  past `INSTALL_TIMEOUT_MS`…). `exec` and `timeoutMs` are the test seams. */
+export function installLatest({ exec = execFileSync, timeoutMs = INSTALL_TIMEOUT_MS } = {}) {
+  exec('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit', timeout: timeoutMs, killSignal: 'SIGKILL' });
 }
 
 /**

package/bin/lib/work.mjs

@@ -250,7 +250,7 @@ export function createWorkManager({
     flushWorkReports,
     sweepMergedSessionBranch,
   } = createWorkReportQueue({
-    repoRoot,
+    repoRoot, journalDir: baseDir,
     baseRef,
     workAttempts,
     artifacts,
@@ -261,7 +261,7 @@ export function createWorkManager({
   });
   const { workTokens, mintWorkToken } = createWorkSessionTokens({ getLeaseTtl });
   const { makeNarrator, sayTurnDeferred, lastDeferSaid } = createWorkNarration();
-  const { fetchAttachments, fetchAgentFiles } = createWorkAttachments();
+  const { fetchTabFiles, fetchAgentFiles } = createWorkAttachments();
   const { sessionRuntime, agyRegistryLookup } = createWorkSessionRuntime({ sessionMetaPath });
   const { carryDirtyState } = createAdoptCarry({ sessionMetaPath });
   const { processWorkTurns, interruptWorkTurns, workAnswering } = createWorkSessionTurns({
@@ -287,7 +287,7 @@ export function createWorkManager({
     sessionRuntime,
     agyRegistryLookup,
     carryDirtyState,
-    fetchAttachments,
+    fetchTabFiles,
     makeNarrator,
     sayTurnDeferred,
     lastDeferSaid,

package/bin/lib/workAgentTurnExecution.mjs

@@ -72,6 +72,7 @@ export function createAgentTurnExecution({
   agentChildren,
   postAgentTrace,
   postAgentActivity,
+  postAgentContext = () => {},
   postAgentParked,
   fetchAgentFiles,
   makeLiveMessages = createLiveMessages,
@@ -465,6 +466,25 @@ export function createAgentTurnExecution({
         ...brain,
         answerFromResult: true,
         label: c.cyan('[agent]'),
+        // The CLI's own context measure while the turn runs (claudeInput.mjs),
+        // the latest one at a time; the server clears it at turn end.
+        onContext: (() => {
+          let next = null;
+          let busy = false;
+          return (ctx) => {
+            next = ctx;
+            if (busy) return;
+            busy = true;
+            void (async () => {
+              while (next) {
+                const measured = next;
+                next = null;
+                await postAgentContext(agentId, turnId, measured);
+              }
+              busy = false;
+            })();
+          };
+        })(),
         // The CLI's own tail, relayed. Throttled by the same rule the tab's
         // narrator keeps: overwritten, never appended, and ignored by the
         // board past ~90 seconds.

package/bin/lib/workAgentTurnReports.mjs

@@ -114,6 +114,21 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
     }
   };
 
+  /** The CLI's context measure for a running turn (2026-10-19); the server
+   *  drops one whose turn already settled. Best effort, like the line. */
+  const postAgentContext = async (agentId, turnId, context) => {
+    try {
+      await fetch(AGENT_ACTIVITY_URL, {
+        method: 'POST',
+        headers: fleetHeaders(),
+        signal: AbortSignal.timeout(15_000),
+        body: JSON.stringify({ agentId, turnId, context }),
+      });
+    } catch {
+      /* a readout; the next measurement replaces it */
+    }
+  };
+
   const postAgentParked = async (reason, runtime) => {
     try {
       await fetch(AGENT_PARKED_URL, {
@@ -153,6 +168,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
     postAgentTurn,
     postAgentTrace,
     postAgentActivity,
+    postAgentContext,
     postAgentParked,
     pruneHeldReports,
     agentReported,

package/bin/lib/workAgentTurns.mjs

@@ -27,7 +27,7 @@ import { createAgentTurnReports } from './workAgentTurnReports.mjs';
 import { createAgentTurnExecution } from './workAgentTurnExecution.mjs';
 import { failedTurnSettlement, interruptedTurnSettlement } from './workAgentTurnOutcome.mjs';
 import { turnCommits } from './turnReceipts.mjs';
-import { killGroup } from './processGroup.mjs';
+import { interruptThenKill } from './processGroup.mjs';
 import { createDeliveryReporter } from './workDelivery.mjs';
 import { createAgentBriefRunner } from './workAgentBriefRunner.mjs';
 
@@ -64,6 +64,7 @@ export function createWorkAgentTurns({
     postAgentTurn,
     postAgentTrace,
     postAgentActivity,
+    postAgentContext,
     postAgentParked,
     pruneHeldReports,
     agentReported,
@@ -135,6 +136,7 @@ export function createWorkAgentTurns({
     agentChildren,
     postAgentTrace,
     postAgentActivity,
+    postAgentContext,
     postAgentParked,
     fetchAgentFiles,
     makeLiveMessages,
@@ -434,7 +436,7 @@ export function createWorkAgentTurns({
         run.interrupted = true;
         run.abortSetup?.();
         const child = agentChildren.get(run.place);
-        if (child) killGroup(child);
+        if (child) interruptThenKill(child);
         continue;
       }
       if (agentReported.has(id) || notRunningSaid.has(id)) continue;

package/bin/lib/workAttachments.mjs

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

package/bin/lib/workNarration.mjs

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

package/bin/lib/workReportQueue.mjs

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

package/bin/lib/workSessionTurns.mjs

@@ -19,7 +19,7 @@
 import { existsSync, 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 { REPOSITORY_BASELINE_PARAGRAPH, tabFilesNote } from './prompts.mjs';
 import { processStartTime } from './procRegistry.mjs';
 import { c, note, ok, warn } from './ui.mjs';
 import { mcpFor } from './claude.mjs';
@@ -31,10 +31,11 @@ import { isTerminalSessionLive } from './claudeSessions.mjs';
 import { isAgyConversationLive } from './agySessions.mjs';
 import { adoptFence } from './localSessions.mjs';
 import { resumeRetriesFresh } from './resumeLost.mjs';
+import { CODEX_CONTRACT_MARKER, codexContractKnown, recordCodexContract } from './codexContract.mjs';
 import { turnLockedByLivePid } from './turnLock.mjs';
 import { createDeliveryReporter } from './workDelivery.mjs';
 import { createLiveMessages } from './workLiveMessages.mjs';
-import { killGroup } from './processGroup.mjs';
+import { interruptThenKill, 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';
@@ -76,6 +77,9 @@ export function createWorkSessionTurns({
   agyRegistryLookup,
   carryDirtyState,
   fetchAttachments,
+  // Each file landed or named as missed (workAttachments.mjs); a caller that
+  // hands only `fetchAttachments` (an older test) has its paths as landed.
+  fetchTabFiles = async (wt, attachments) => (await fetchAttachments(wt, attachments)).map((path) => ({ path })),
   makeNarrator,
   sayTurnDeferred,
   lastDeferSaid,
@@ -654,6 +658,17 @@ export function createWorkSessionTurns({
           // refused for want of an approval, by `server.tool`.
           let codexSpoke = false;
           const approvalRefused = [];
+          // WHAT THE CLI SAID OF ITS OWN RUN (2026-10-19): a failed result or
+          // error event, or an exit that was not a clean one. A usage limit, a
+          // signed-out CLI or a crash printed its words and settled as the
+          // tab's REPLY; they settle as the failure they are now, in the same
+          // words. Reset for the fresh retry, which is its own run.
+          let cliFailed = false;
+          let badExit = null;
+          // A Codex tab's contract and whether this turn sent it (codexContract.mjs).
+          const contractPath = rt.id === 'codex' ? sessionMetaPath(dir.wt, CODEX_CONTRACT_MARKER, job.sessionId) : null;
+          let turnSystem = '';
+          let contractSent = true;
           const spawned = []; // this turn's children, for the teardown registry
           // THE TURN'S TOOL LOG — see workToolLog.mjs for its shape rules.
           const turnLog = createToolLog(dir.wt);
@@ -675,12 +690,7 @@ export function createWorkSessionTurns({
             // Files first, then the message that references them: the agent
             // must be able to open what it is being told about. Only the ones
             // that actually landed are named.
-            const files = await fetchAttachments(dir.wt, job.attachments);
-            const filesNote = files.length
-              ? `[FILES THE HUMAN ATTACHED TO THIS MESSAGE — already on disk in this worktree]\n${files
-                  .map((f) => `- ${f}`)
-                  .join('\n')}`
-              : '';
+            const filesNote = tabFilesNote(await fetchTabFiles(dir.wt, job.attachments));
             const message = [job.body, filesNote, adoptNote, carryNote]
               .filter(Boolean)
               .join('\n\n');
@@ -689,8 +699,7 @@ export function createWorkSessionTurns({
                 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 note = tabFilesNote(await fetchTabFiles(dir.wt, followup.attachments));
                   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') });
@@ -728,11 +737,18 @@ export function createWorkSessionTurns({
                   // 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}` : ''),
+                  // …and a Codex thread that already holds it is sent none
+                  // (codexContract.mjs); `turnSystem` keeps the text for a
+                  // fresh retry and the marker.
+                  system: (() => {
+                    turnSystem = sessionTurnSystem(shape, {
+                      knowledgeDir,
+                      artifactsAccepted: getArtifactsAccepted(),
+                      runtime: rt.id,
+                    }) + (toolLog.baseline ? '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(toolLog.baseline) : '') + (artifactScan?.instructions ? `\n\n${artifactScan.instructions}` : '');
+                    contractSent = !codexContractKnown(contractPath, codexResumeId, turnSystem);
+                    return contractSent ? turnSystem : '';
+                  })(),
                   // 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.
@@ -774,6 +790,15 @@ export function createWorkSessionTurns({
               onModel: (m) => {
                 model = m;
               },
+              // The CLI's own context measure, live while the turn runs
+              // (claudeInput.mjs); the server clears it at settle.
+              onContext: (ctx) => narrator.context(ctx),
+              onCliFailure: () => {
+                cliFailed = true;
+              },
+              onExit: (code, signal) => {
+                badExit = signal || (code ? `exit ${code}` : null);
+              },
               // 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) —
@@ -871,9 +896,19 @@ export function createWorkSessionTurns({
              */
             if (
               !adopting &&
-              resumeRetriesFresh({ resume, out, runtime: rt.id, sawInit: Boolean(seenClaudeSession) })
+              resumeRetriesFresh({
+                resume,
+                out,
+                runtime: rt.id,
+                // The CLI's own word that it found the conversation: Claude's
+                // init, Codex's `thread.started` naming the pinned thread.
+                sawInit: rt.id === 'codex' ? Boolean(codexResumeId && seenThreadId === codexResumeId) : Boolean(seenClaudeSession),
+              })
             ) {
-              out = await runCli({ ...turnArgs, resume: false });
+              cliFailed = false;
+              badExit = null;
+              contractSent = true;
+              out = await runCli({ ...turnArgs, resume: false, system: turnSystem });
             }
           } finally {
             // The CLI has stopped printing, so stop relaying. The LINE itself
@@ -896,7 +931,10 @@ 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.
-          if (rt.id === 'codex' && seenThreadId && CODEX_THREAD_RE.test(seenThreadId)) pinId(sessionMetaPath(dir.wt, RESUME_MARKERS.codex, job.sessionId), CODEX_THREAD_RE, seenThreadId);
+          if (rt.id === 'codex' && seenThreadId && CODEX_THREAD_RE.test(seenThreadId)) {
+            pinId(sessionMetaPath(dir.wt, RESUME_MARKERS.codex, job.sessionId), CODEX_THREAD_RE, seenThreadId);
+            recordCodexContract(contractPath, seenThreadId, turnSystem, contractSent);
+          }
           /**
            * A PERSON INTERRUPTED IT. Whatever the CLI printed was cut off, so
            * it is not an answer: the turn settles `interrupted`, with what it
@@ -974,7 +1012,7 @@ export function createWorkSessionTurns({
               artifactFailure = `Artifact delivery is incomplete: ${error.message}`;
             }
           }
-          const spoke = answer.length > 0 && !loginFailure;
+          const spoke = answer.length > 0 && !loginFailure && !cliFailed && !badExit;
           await settleTurn(job.id, {
               ...attempt,
             ok: spoke && !artifactFailure,
@@ -997,6 +1035,7 @@ export function createWorkSessionTurns({
           });
           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 if (answer && (cliFailed || badExit)) warn(`the CLI reported its turn failed${badExit ? ` (${badExit})` : ''} — settled as failed, in its words`);
           else warn('session turn produced no output — settled as failed');
         } catch (e) {
           if (toolLog) toolLog.state = 'partial';
@@ -1072,7 +1111,7 @@ export function createWorkSessionTurns({
       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);
+        for (const ch of run.spawned) interruptThenKill(ch);
         continue;
       }
       if (pendingWorkReports.has(id) || settledRecently(id) || notRunningSaid.has(id)) continue;

package/bin/lib/worktreeDiff.mjs

@@ -191,14 +191,38 @@ function branchCommits(wt, base) {
         .split('\n')
         .filter(Boolean)
     );
+    // EVERY COMMIT ON THE BRANCH, NOT ONLY THE CARDED ONES (2026-10-19). A
+    // Terminal tab's prompt says a commit for no named card needs no trailer,
+    // so its own commits were never reported and the rail said "N commits
+    // ahead" with none of them listed or openable. One more exec names the
+    // rest — sha, author, date and the folded subject, NUL-separated (git
+    // allows a NUL in none of them) and one per line (`%s` folds its
+    // newlines), keyed by sha from the rev-list set with the first line
+    // winning, the same membership rule the trailered read keeps. No body and
+    // no numstat: the rail lists a commit by its subject, and its patch is the
+    // commit-diff job's.
+    const listed = new Map();
+    for (const line of git(['log', '--no-merges', '-n', String(MAX_COMMITS), '--format=%H%x00%an%x00%aI%x00%s', `${base}..HEAD`], wt).split('\n')) {
+      const [sha, author, at, subject] = line.split('\0');
+      if (real.includes(sha) && !listed.has(sha)) listed.set(sha, { author, at, subject });
+    }
     for (const sha of real) {
-      if (!named.has(sha)) continue;
       // A commit we cannot stat (a numstat past the pipe's buffer) still names
       // its cards — send it with zero counts rather than drop it, as before.
-      const rec = commitRecord(sha, wt, { numstat: true }) ?? commitRecord(sha, wt);
-      if (!rec) continue;
-      const taskIds = taskIdsFromMessage(stripDelims(rec.body));
-      if (taskIds.length === 0) continue;
+      const rec = named.has(sha) ? commitRecord(sha, wt, { numstat: true }) ?? commitRecord(sha, wt) : null;
+      const taskIds = rec ? taskIdsFromMessage(stripDelims(rec.body)) : [];
+      if (taskIds.length === 0) {
+        const row = listed.get(sha);
+        if (!row) continue;
+        out.push({
+          sha: sha.slice(0, 64),
+          subject: stripDelims(row.subject).slice(0, 200),
+          author: stripDelims(row.author).slice(0, 80),
+          at: stripDelims(row.at).slice(0, 40),
+          taskIds: [],
+        });
+        continue;
+      }
       out.push({
         // Clamped to the server's zod caps, same rule as everything else in
         // this file: one over-cap string 400s the whole batch.