flowviant 0.125.12 → 0.125.15

package/bin/lib/workAgentTurnExecution.mjs

@@ -47,7 +47,7 @@ import { runAgentWithInternalWaits } from './agentInternalWait.mjs';
 import { brainFor } from './workBrain.mjs';
 import { refreshRestartBase } from './workAgentRecovery.mjs';
 import { begunTurnRefusal } from './workAgentTurnBegun.mjs';
-import { agentTurnSettlement, interruptedTurnSettlement } from './workAgentTurnOutcome.mjs';
+import { agentDeclaredDelivery, agentTurnSettlement, interruptedTurnSettlement } from './workAgentTurnOutcome.mjs';
 import { ensureArtifactDir, ensureFenceScratch } from './artifacts.mjs';
 import { agentBrowserHome } from './noWindowEnv.mjs';
 import { agentTurnResume } from './workAgentResume.mjs';
@@ -59,6 +59,7 @@ import { ORCHESTRATED_POSTURES, orchestratesPosture } from './orchestratorPrompt
 import { knownCodexModels } from './runtimeOfferings.mjs';
 import { codexSubagentsSafe } from './runtimeCodex.mjs';
 import { measuredRuntimeVersion } from './runtimeDetection.mjs';
+import { createIntermediateArtifacts } from './intermediateArtifacts.mjs';
 
 export function createAgentTurnExecution({
   admit,
@@ -76,6 +77,7 @@ export function createAgentTurnExecution({
   reportSessionWorktree,
   artifacts,
   runReviewEntry,
+  runMergeCheck,
   workChildren,
   agentChildren,
   postAgentTrace,
@@ -84,6 +86,8 @@ export function createAgentTurnExecution({
   postAgentParked,
   fetchAgentFiles,
   makeLiveMessages = createLiveMessages,
+  runTurnImpl = runTurn,
+  exportModel,
 }) {
   const reportDelivery = createDeliveryReporter();
   /** How long the final flush may hold the settle. Bounded because the settle
@@ -276,6 +280,10 @@ export function createAgentTurnExecution({
      * prompt is byte-for-byte what it was.
      */
     await fetchResultInputs(wt, job.resultInputs);
+    const intermediate = createIntermediateArtifacts({ wt, agentId,
+      path: sessionMetaPath(wt, 'flowviant-agent-artifacts', agentId),
+      ...(exportModel ? { exportPage: exportModel } : {}) });
+    const intermediateFiles = intermediate.inputs();
     const files =
       Array.isArray(job.attachments) && job.attachments.length > 0
         ? await fetchAgentFiles(wt, job.attachments)
@@ -380,7 +388,7 @@ export function createAgentTurnExecution({
     const spawnedChildren = new Set();
     /** The CLI, unless a person already asked to stop this turn (Interrupt
      *  now): then nothing starts — no fresh retry, no continuation. */
-    const runCli = (args) => (run.interrupted ? Promise.resolve('') : runTurn(args));
+    const runCli = (args) => (run.interrupted ? Promise.resolve('') : runTurnImpl(args));
     /**
      * WHAT THIS TURN SPENT, AS THE CLI COUNTED IT (2026-09-19).
      *
@@ -420,6 +428,7 @@ export function createAgentTurnExecution({
     }
     let projectTools = null;
     let orchestrator = null;
+    let intermediateDelivery = null;
     try {
       if (orchestrating) {
         orchestrator = await createOrchestrator({ turnId, runtime: rt, trace, admit,
@@ -441,15 +450,16 @@ export function createAgentTurnExecution({
           format: async (followup) => {
             orchestrator?.note(followup);
             const attached = followup.attachments?.length ? await fetchAgentFiles(wt, followup.attachments.map((file) => ({ ...file, from: 'message' }))) : { message: [], card: [] };
-            return agentFollowupKickoff(job, followup, { messageFiles: attached.message, cardFiles: files.card, orchestrated: Boolean(orchestrator) });
+            return agentFollowupKickoff(job, followup, { messageFiles: attached.message, cardFiles: files.card, intermediateFiles, orchestrated: Boolean(orchestrator) });
           },
         })) } : {}),
         // The kickoff and the system prompt, composed by the agent lane's
         // shape (workAgentTurnShape.mjs) from what this run measured.
         researchHandoff: job.researchHandoff,
         resultInputs: job.resultInputs,
+        intermediateFiles,
         researchIdentity: { projectId: PROJECT_ID, agentId, turnId, taskId: job.task?.id ?? job.repositoryTaskId },
-        prompt: agentKickoff(job, { cardFiles: files.card, messageFiles: files.message }),
+        prompt: agentKickoff(job, { cardFiles: files.card, messageFiles: files.message, intermediateFiles }),
         system: agentTurnSystem({ taskKind, taskType: job.task?.taskType, runtimeLabel: runtimeById(rt)?.label, prerequisitesAccepted: job.prerequisitesAccepted === true, knowledgeDir: knowledgeDirFor(repoRoot), artifactsAccepted: getArtifactsAccepted(), toolsNote, artifactInstructions, toolInstructions: projectTools.instructions, repositoryRun, orchestration: orchestrator ? { posture, runtime: rt, ...cardBrain } : null }),
         agentTools: projectTools,
         writableDirs: repositoryRun?.writableDirs,
@@ -733,7 +743,18 @@ export function createAgentTurnExecution({
       void reportSessionWorktree(place).catch(() => {});
       // A file card delivers uploaded bytes, not an in-memory retry. Otherwise
       // its dependent card can start while Review has nothing to show.
-      await artifacts.report({ placeDir: wt, before: artifactsBefore, agentId, turnId, requireStored: kind.artifact != null });
+      if (!run.interrupted && agentDeclaredDelivery(out, lastAnswer)) {
+        try { intermediateDelivery = await intermediate.prepare({ job, turnId, taskKind, before: artifactsBefore, signal: setupController.signal }); }
+        catch (error) {
+          if (run.interrupted) throw error;
+          // The failed page still has its preview/files for repair. Reporting
+          // those bytes cannot turn a failed export into a delivered card.
+          try { await artifacts.report({ placeDir: wt, before: artifactsBefore, agentId, turnId, requireStored: kind.artifact != null }); }
+          catch (uploadError) { throw new Error(`${error.message}; artifact reporting also failed: ${uploadError.message}`); }
+          throw error;
+        }
+      }
+      await artifacts.report({ placeDir: wt, before: intermediateDelivery?.uploadBefore ?? artifactsBefore, agentId, turnId, requireStored: kind.artifact != null });
     }
 
 
@@ -766,7 +787,9 @@ export function createAgentTurnExecution({
       artifactsBefore,
       branch,
       wt,
+      modelExports: intermediateDelivery?.modelExports,
     });
+    if (body.outcome === 'delivered') intermediateDelivery?.commit();
     if (res) setRuntimeLimit(PROJECT_ID, rt, null);
     if (body.outcome === 'delivered' && job.task?.taskType === 'tests' && res?.testFindings) {
       body.testFindings = measureTestFindings(res.testFindings, repositoryRun?.sourcesNow() ?? [{ wt, baseRef: baseRef(), id: job.repos?.length === 1 ? job.repos[0] : null }], envScrub);
@@ -789,7 +812,7 @@ export function createAgentTurnExecution({
         const rows = repositoryRun?.sourcesNow() ?? [{ wt }];
         for (const r of rows) {
           const head = gitOrNull(['rev-parse', 'HEAD'], r.wt);
-          const check = await runReviewEntry(agentId, r.wt, job.agentName, repositoryRun ? r : undefined);
+          const check = await runMergeCheck(agentId, r.wt, repositoryRun ? r : undefined);
           if (check?.status === 'failed') {
             body.mergeResolved = false;
             body.mergeDetail = relayedText(check.text || check.output || 'The repository check failed during merge recovery.').slice(0, 2000);

package/bin/lib/workAgentTurnOutcome.mjs

@@ -33,8 +33,14 @@ import { scrub as envScrub } from './uplinkScrub.mjs';
 import { usableImageArtifact } from './imageArtifact.mjs';
 import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 import { ANSWER_DELIVERED_USES, researchUseOf, withResearchHeader } from './researchUse.mjs';
+import { measuredModelExports } from './intermediateArtifacts.mjs';
 
-export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, model = null, commits, artifactsBefore, branch, wt }) {
+/** Materialization runs only for a declared delivery; settlement remains the
+ * sole parser and the sole authority deciding whether it really delivered. */
+export const agentDeclaredDelivery = (out, lastAnswer) =>
+  ((lastAnswer && parseTurnResult(lastAnswer)) || parseTurnResult(out))?.outcome === 'delivered';
+
+export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, model = null, commits, artifactsBefore, branch, wt, modelExports = [] }) {
   const res = (lastAnswer && parseTurnResult(lastAnswer)) || parseTurnResult(out);
   /**
    * A LIMIT IS ONLY A LIMIT WHEN THE TURN PRODUCED NOTHING.
@@ -94,7 +100,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    * Its product is under `.flowviant/artifacts/`, and the kind's table
    * (agentTaskKinds.mjs) says which file proves it: a `.html` mockup for
    * design, a `.html` deck, a `.md` write-up for research, and a `.html`
-   * page for a 3D model (the model is built in it, 0.107.0). A turn that
+   * page for a 3D model plus its measured page-bound local GLB export. A turn that
    * says "delivered" without having written one would land the agent in Review
    * with nothing to look at and a summary describing a page that does not
    * exist — so it settles `nothing` with the measured sentence, and the
@@ -135,7 +141,8 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       && (kind.posture !== 'image' || usableImageArtifact(e)));
     const standing = scanArtifacts(wt);
     const wrote = has(changedArtifacts(artifactsBefore, standing));
-    const present = wrote || ((job.kind !== 'task' || job.redo === true) && has(standing));
+    const exported = kind.exportModel && measuredModelExports(wt, modelExports);
+    const present = wrote || exported || ((job.kind !== 'task' || job.redo === true) && has(standing));
     if (!present) {
       return report({
         turnId,
@@ -147,6 +154,11 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
         worktree: wt,
       });
     }
+    if (kind.exportModel && !exported) {
+      return report({ turnId, outcome: 'nothing',
+        answer: 'The model page has no verified local .glb export. Retry this producer card to export its exact page before dependent work starts; no manual download or Library keeping is required.',
+        ...(usage ? { usage } : {}), branch, worktree: wt });
+    }
   }
   const prerequisite = res.prerequisite;
   const cannotRequest = prerequisite && job.prerequisitesAccepted !== true

package/bin/lib/workAgentTurnShape.mjs

@@ -25,6 +25,7 @@
 import { AGENT_TASK_KICKOFF, AGENT_HUMAN_KICKOFF, SYSTEM_AGENT_FOR, withProjectContext } from './prompts.mjs';
 import { INTERNAL_WAIT_CONTRACT } from './agentInternalWait.mjs';
 import { orchestratorContract } from './orchestratorPrompt.mjs';
+import { intermediateArtifactContext } from './intermediateArtifacts.mjs';
 
 /** What every kickoff of this job is handed: the agent, the card and its
  *  discussion, the job's context handoffs, the card's files, the place in
@@ -43,8 +44,8 @@ const shared = (job, cardFiles) => ({
 
 /** The turn's first prompt: the card, on a task turn; the person's words
  *  otherwise. `cardFiles` and `messageFiles` are the files already on disk. */
-export const agentKickoff = (job, { cardFiles, messageFiles }) =>
-  job.kind === 'task' && job.task
+export const agentKickoff = (job, { cardFiles, messageFiles, intermediateFiles }) =>
+  (job.kind === 'task' && job.task
     ? AGENT_TASK_KICKOFF({
         // The card's discussion (0.106.0), printed inside THE CARD by
         // the same builder the run's stash wrote down — and the files
@@ -63,17 +64,17 @@ export const agentKickoff = (job, { cardFiles, messageFiles }) =>
         // The files (0.112.0): the person's inside their words, the
         // card's at the foot of its discussion.
         messageFiles,
-      });
+      })) + intermediateArtifactContext(intermediateFiles);
 
 /** A live message sent while the turn runs, as the CLI is handed it — on an
  *  orchestrated card with its id, so the route it takes is reported. */
-export const agentFollowupKickoff = (job, followup, { cardFiles, messageFiles, orchestrated }) =>
+export const agentFollowupKickoff = (job, followup, { cardFiles, messageFiles, intermediateFiles, orchestrated }) =>
   AGENT_HUMAN_KICKOFF({
     ...shared(job, cardFiles),
     message: followup.body + (followup.libraryPrompt ?? '') + (orchestrated ? `\nMessage id: ${followup.id}. Choose and report its route with card_orchestrator.route_message.` : ''),
     askedByName: followup.askedByName,
     messageFiles,
-  });
+  }) + intermediateArtifactContext(intermediateFiles);
 
 /** The turn's system prompt, in its fixed section order. `orchestration` is
  *  null on a solo run, else what the contract names: `{ posture, runtime,

package/bin/lib/workAgentTurns.mjs

@@ -48,6 +48,7 @@ export function createWorkAgentTurns({
   reportSessionWorktree,
   artifacts,
   runReviewEntry,
+  runMergeCheck,
   publishAgentBranch,
   stopAgentPublishing = () => {},
   admit,
@@ -59,6 +60,7 @@ export function createWorkAgentTurns({
   makeBrief = createAgentBriefRunner({ admit, workChildren }),
   /** The run's live-message relay (workLiveMessages.mjs); a test's stand-in. */
   makeLiveMessages,
+  exportModel,
 }) {
   const reportDelivery = createDeliveryReporter();
   const {
@@ -133,6 +135,8 @@ export function createWorkAgentTurns({
     reportSessionWorktree,
     artifacts,
     runReviewEntry,
+    runMergeCheck,
+    exportModel,
     workChildren,
     agentChildren,
     postAgentTrace,

package/bin/lib/workAttachments.mjs

@@ -17,7 +17,7 @@ import { excludeInWorktree } from './git.mjs';
 import { FLOWVIANT_OWN_PATHS } from './knowledgeLibrary.mjs';
 import { safeFileName } from './safeFileName.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
-import { readAgentFiles } from './agentFiles.mjs';
+import { AGENT_FILES_PER_MESSAGE_MAX, readAgentFiles } from './agentFiles.mjs';
 
 /**
  * ONE FILE'S CEILING, for both lanes (0.113.0, the owner 2026-09-29: "20 MB
@@ -27,6 +27,8 @@ import { readAgentFiles } from './agentFiles.mjs';
  * is what 0.112.0's 10 MB did to anything bigger, and why the server floors a
  * file over 10 MB at this release (`DAEMON_LARGE_FILES_MIN`).
  */
+export const SESSION_ATTACHMENTS_PER_TURN_MAX = AGENT_FILES_PER_MESSAGE_MAX;
+
 export const ATTACHMENT_MAX_BYTES = 20 * 1024 * 1024;
 
 export function createWorkAttachments() {
@@ -206,7 +208,7 @@ export function createWorkAttachments() {
    */
   const fetchTabFiles = async (wt, attachments) => {
     if (!Array.isArray(attachments) || attachments.length === 0) return [];
-    const list = attachments.slice(0, 8);
+    const list = attachments.slice(0, SESSION_ATTACHMENTS_PER_TURN_MAX);
     const landed = await landFiles(wt, list, 'attachment', false);
     return list.map((a, i) => (landed[i] ? { path: landed[i] } : { missed: safeUploadName(a?.name) }));
   };

package/bin/lib/workCappedTurn.mjs

@@ -73,6 +73,7 @@ export async function runCappedTurn({
   let timer = null;
   let wedged = false;
   let sessionId = null;
+  let finished = false;
   let stopWaiting = () => {};
   const capped = new Promise((resolve) => {
     stopWaiting = resolve;
@@ -88,10 +89,12 @@ export async function runCappedTurn({
     const turn = runTurn({
       ...turnArgs,
       onInit: (i) => {
+        if (finished) return;
         if (typeof i?.sessionId === 'string' && i.sessionId.trim()) sessionId = i.sessionId.trim();
         onInit(i);
       },
       onSpawn: (ch) => {
+        if (finished) { try { if (killChild) killChild(ch); else ch?.kill('SIGKILL'); } catch { /* already gone */ } return; }
         child = ch;
         workChildren.set(ch, null);
         releaseSlot();
@@ -112,6 +115,7 @@ export async function runCappedTurn({
     const out = await Promise.race([turn, capped]);
     return { out, wedged, spawned: child !== null, sessionId };
   } finally {
+    finished = true;
     signal?.removeEventListener('abort', cancel);
     if (timer) clearTimeout(timer);
     if (child) workChildren.delete(child);

package/bin/lib/workLiveMessages.mjs

@@ -6,12 +6,12 @@ import { readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { fleetRequest } from './fleetPost.mjs';
 import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
-import { DAEMON_INSTANCE, FLEET_URL } from './config.mjs';
+import { DAEMON_INSTANCE, FLEET_URL, VERSION } from './config.mjs';
 import { messageIdsForSession } from './claudeSessions.mjs';
 
 export function createLiveMessages({ scope, turnId, attempt, cwd, sessionMetaPath, format, observe = () => {}, interrupted = () => false,
   request = fleetRequest, nativeIds = messageIdsForSession, setTimer = setInterval, clearTimer = clearInterval, finalFlushMs = 1_000 }) {
-  const identity = { scope, turnId, instance: DAEMON_INSTANCE, ...(attempt !== undefined ? { attempt } : {}) };
+  const identity = { scope, turnId, daemonVersion: VERSION, instance: DAEMON_INSTANCE, ...(attempt !== undefined ? { attempt } : {}) };
   const file = sessionMetaPath(cwd, 'flowviant-live-messages', turnId);
   let sessionId = null;
   let timer = null;

package/bin/lib/workNarration.mjs

@@ -35,7 +35,7 @@ export function createWorkNarration() {
    *  line over the finished reply — the server drops narration for a turn
    *  that is no longer pending. (A session-level pending count can't tell the
    *  settled turn's stale line from the queued NEXT turn's fresh one.) */
-  const makeNarrator = (sessionId, turnId, getTools) => {
+  const makeNarrator = (sessionId, turnId, getTools, identity = {}) => {
     const recent = [];
     let lastSent = 0;
     let dirty = false;
@@ -60,6 +60,7 @@ export function createWorkNarration() {
           body: JSON.stringify({
             sessionId,
             turnId,
+            ...identity,
             lines,
             // The structured tool log so far, riding the same throttled beat.
             // Same lifecycle as the lines: overwritten as the turn moves,
@@ -101,7 +102,7 @@ export function createWorkNarration() {
               'Content-Type': 'application/json',
             },
             signal: AbortSignal.timeout(10_000),
-            body: JSON.stringify({ sessionId, turnId, lines: [], context }),
+            body: JSON.stringify({ sessionId, turnId, ...identity, lines: [], context }),
           });
         } catch {
           /* a readout is decoration, like the line */

package/bin/lib/workPlanRecovery.mjs

@@ -1,14 +1,13 @@
 /** The person's own CLI diagnoses planning, under the ordinary consult fence. */
 import { candidateObjects } from './modelJson.mjs';
 import { scrub } from './uplinkScrub.mjs';
-import { fleetRequest } from './fleetPost.mjs';
-import { DAEMON_INSTANCE } from './config.mjs';
+export { watchReadOnlyAttempt as watchPlanAttempt } from './readOnlyRun.mjs';
 
 export const PLAN_RECOVERY_SYSTEM = `You are recovering the person's retained Plan press.
 Read the original selection, failure, retained evidence, answers and repository.
 Establish the cause before claiming a repair. Diagnose/debug the planning failure
 with the available read-only tools. Repair the planning approach, context or output
-instructions. Do not change repository files, start agents or approve work.
+instructions. Do not change repository files, start Board work or approve work.
 Retry count is never a reason to ask the person to click Plan again.
 Only ask for an answer, credential action or changed-scope decision that reading
 and diagnosis cannot supply. Ask one specific question and explain what it settles.
@@ -30,21 +29,3 @@ export function parsePlanDiagnosis(out) {
   }
   return null;
 }
-
-/** Unknown transport state never means Stop. Only an answered holder read does. */
-export async function watchPlanAttempt(url, job) {
-  const controller = new AbortController();
-  let busy = false;
-  const check = async () => {
-    if (busy) return;
-    busy = true;
-    try {
-      const r = await fleetRequest(url, { body: { id: job.id, attempt: job.attempt, instance: DAEMON_INSTANCE }, timeoutMs: 15_000 });
-      if (r.ok && r.json?.data?.active === false) controller.abort();
-    } finally { busy = false; }
-  };
-  await check();
-  const timer = setInterval(check, 5_000);
-  timer.unref?.();
-  return { signal: controller.signal, check, stop: () => clearInterval(timer) };
-}

package/bin/lib/workSessionTurns.mjs

@@ -46,6 +46,15 @@ import { sessionTurnKickoff, sessionTurnShape, sessionTurnSystem } from './workT
 import { createToolLog } from './workToolLog.mjs';
 import { createCommandAudit } from './workCommandAudit.mjs';
 import { APPROVAL_REFUSED, codexApprovalSentence, codexLoginFailure, codexLoginSentence, withRelay } from './codexRelay.mjs';
+import { createReadOnlyCoordination, readOnlyCoordinationSafe, watchReadOnlyAttempt } from './readOnlyRun.mjs';
+import { createCaptureAuthority } from './captureAuthority.mjs';
+import { captureOrchestratorContract } from './orchestratorPrompt.mjs';
+import { runCappedTurn } from './workCappedTurn.mjs';
+import { measuredRuntimeVersion } from './runtimeDetection.mjs';
+import { knownCodexModels } from './runtimeOfferings.mjs';
+import { FLEET_URL, DAEMON_INSTANCE, MODEL } from './config.mjs';
+import { fleetEndpoint } from './fleetWire.mjs';
+const defaultWatchCapture = job => watchReadOnlyAttempt(fleetEndpoint('capture-run-state', FLEET_URL), job);
 
 /**
  * HOW LONG, AND HOW MANY, SETTLED TURNS THE LANE REMEMBERS (2026-09-29) — see
@@ -91,6 +100,9 @@ export function createWorkSessionTurns({
   // The real CLI driver; injectable only so the lane can be driven in a test
   // without spending a model turn (the wiki runner's shape).
   runTurn = defaultRunTurn,
+  runtimeVersion = id => measuredRuntimeVersion(id)?.version,
+  coordinate = createReadOnlyCoordination,
+  watchCapture = defaultWatchCapture,
   // The clock `settledHere` ages by; injectable only for its bound's test.
   now = Date.now,
   makeLiveMessages = createLiveMessages,
@@ -140,14 +152,17 @@ export function createWorkSessionTurns({
    * be delivered by `pendingWorkReports`, and this covers the one that was.
    */
   const settledHere = new Map(); // turnId -> when this lane settled it, oldest first
+  const settledAttempts = new Map(); // only measured execution generations
   const forgetStale = (at) => {
     for (const [id, when] of settledHere) {
       if (settledHere.size <= SETTLED_HERE_MAX && at - when < SETTLED_HERE_TTL_MS) break;
       settledHere.delete(id);
+      settledAttempts.delete(id);
     }
   };
-  const settledRecently = (turnId) => {
+  const settledRecently = (turnId, attempt) => {
     forgetStale(now());
+    if (Number.isInteger(attempt) && settledAttempts.has(turnId) && settledAttempts.get(turnId) !== attempt) return false;
     return settledHere.has(turnId);
   };
   const settleTurn = (turnId, payload) => {
@@ -156,6 +171,7 @@ export function createWorkSessionTurns({
     const at = now();
     settledHere.delete(turnId); // re-inserted at the end: the map stays in time order
     settledHere.set(turnId, at);
+    if (Number.isInteger(run?.job?.attempt)) settledAttempts.set(turnId, run.job.attempt);
     forgetStale(at);
     const liveMessages = runs.get(turnId)?.live?.receipts();
     return settleWorkTurn(turnId, { ...payload, ...(liveMessages?.ids.length ? { liveMessages } : {}) });
@@ -185,13 +201,18 @@ export function createWorkSessionTurns({
       if (!job || typeof job.id !== 'string' || !job.body || !job.sessionId) continue;
       if (rosterInterrupts.has(job.id)) continue;
       if (workAnswering.has(job.id)) {
-        const reason = runs.get(job.id)?.waitingReason;
+        const previous = runs.get(job.id);
+        if (job.captureOrchestrationVersion === 1 && Number.isInteger(job.attempt) && Number.isInteger(previous?.job.attempt) && job.attempt !== previous.job.attempt) {
+          previous.interrupted = true; previous.abort.abort();
+          for (const child of previous.spawned) interruptThenKill(child);
+        }
+        const reason = previous?.waitingReason;
         if (reason) reportDelivery('session', job, 'queued', reason);
         continue;
       }
       // Settled by this lane already: a roster read from before the settle
       // landed. See `settledHere`.
-      if (settledRecently(job.id)) continue;
+      if (settledRecently(job.id, job.attempt)) continue;
       // The turn already RAN and its answer sits in the delivery queue — never
       // run it again while the report is merely undelivered.
       if (pendingWorkReports.has(job.id)) continue;
@@ -225,9 +246,10 @@ export function createWorkSessionTurns({
         continue;
       }
       const releaseSlot = admit.reserve();
+      if (Number.isInteger(job.attempt) && settledAttempts.has(job.id) && settledAttempts.get(job.id) !== job.attempt) workAttempts.delete(job.id);
       lastDeferSaid.delete(job.sessionId);
       workAnswering.add(job.id);
-      const run = { interrupted: false, spawned: [], sessionId: job.sessionId, live: null, job };
+      const run = { interrupted: false, spawned: [], sessionId: job.sessionId, live: null, job, abort: new AbortController() };
       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. */
@@ -644,17 +666,29 @@ export function createWorkSessionTurns({
           // 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 };
+          let mcp = { 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.
           const brain = brainFor(job, rt.id);
+          const childBrain = { ...brain, runtime: rt.id, model: brain.model ?? (rt.id === 'claude' ? MODEL : null),
+            ...(rt.id === 'codex' ? { catalog: knownCodexModels() } : {}) };
+          const version = shape.capture && job.captureOrchestrationVersion === 1 ? runtimeVersion(rt.id) : null;
+          const delegated = shape.capture && job.captureOrchestrationVersion === 1 && Number.isSafeInteger(job.attempt)
+            && job.attempt >= 0 && readOnlyCoordinationSafe(rt.id, version);
+          let coordination = null, control = null;
+          let captureSignal = run.abort.signal;
+          const makeCoordination = () => coordinate({ enabled: true, runtime: rt.id, version, admit,
+            identity: { scope: 'capture', id: job.id, attempt: job.attempt }, signal: captureSignal,
+            children: childBrain,
+            rootTools: createCaptureAuthority({ url: getMcpUrl(), token: mint.token, sessionId: job.sessionId,
+              turnId: job.id, attempt: job.attempt, signal: captureSignal }),
+          });
           // Attempts count RUNS: the infra refusals above consumed nothing and
           // settled on their own terms.
           workAttempts.set(job.id, tries + 1);
           let out;
+          let turnReturned = false;
           let seenThreadId = null; // codex's conversation id, off thread.started
           let seenClaudeSession = null; // claude's own conversation id, off system.init
           // What a Codex turn's own events say went wrong (codexRelay.mjs):
@@ -678,9 +712,8 @@ export function createWorkSessionTurns({
           const turnLog = createToolLog(dir.wt);
           toolLog = turnLog.toolLog;
           const { pushToolEvent } = turnLog;
-          const narrator = makeNarrator(job.sessionId, job.id, () =>
-            toolLog
-          );
+          const narrator = makeNarrator(job.sessionId, job.id, () => toolLog,
+            delegated ? { attempt: job.attempt, instance: DAEMON_INSTANCE } : {});
 
 
           // THE COMMAND AUDIT — see workCommandAudit.mjs.
@@ -691,6 +724,19 @@ export function createWorkSessionTurns({
             cwd: dir.wt,
           });
           try {
+            if (delegated) {
+              control = await watchCapture(job);
+              captureSignal = AbortSignal.any([run.abort.signal, control.signal]);
+              const stopped = () => { run.interrupted = true; run.abort.abort(); };
+              if (captureSignal.aborted) stopped();
+              else control.signal.addEventListener('abort', stopped, { once: true });
+              if (!run.interrupted) coordination = await makeCoordination();
+            }
+            // A safe native gate replaces the credential mount, keeping the
+            // actual capture credential entirely outside the CLI's children.
+            // Unsupported/gate-unavailable turns retain the original solo path.
+            if (!coordination && shape.mountMcp) mcp = mcpFor(rt.id, mint.token, getMcpUrl());
+            const captureContract = coordination ? captureOrchestratorContract(childBrain) : '';
             // 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.
@@ -750,7 +796,7 @@ export function createWorkSessionTurns({
                       knowledgeDir,
                       artifactsAccepted: getArtifactsAccepted(),
                       runtime: rt.id,
-                    }) + (toolLog.baseline ? '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(toolLog.baseline) : '') + (artifactScan?.instructions ? `\n\n${artifactScan.instructions}` : '');
+                    }) + (toolLog.baseline ? '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(toolLog.baseline) : '') + (artifactScan?.instructions ? `\n\n${artifactScan.instructions}` : '') + (captureContract ? `\n\n${captureContract}` : '');
                     contractSent = !codexContractKnown(contractPath, codexResumeId, turnSystem);
                     return contractSent ? turnSystem : '';
                   })(),
@@ -862,7 +908,43 @@ export function createWorkSessionTurns({
                 }
               },
             };
-            out = await runCli({
+            const invoke = async (args, retry = false) => {
+              if (run.interrupted) return '';
+              if (!captureContract) return runCli(args);
+              let releaseRetry = () => {};
+              if (retry) {
+                // The prior process no longer counts. Reserve its replacement
+                // against the SAME pool before awaiting a new local gate.
+                while (!run.interrupted) {
+                  const hold = admit('interactive');
+                  if (!hold) { releaseRetry = admit.reserve(); break; }
+                  narrator.line(hold.reason);
+                  await new Promise(resolve => setTimeout(resolve, 1_000));
+                }
+              }
+              try {
+                if (retry && !run.interrupted) coordination = await makeCoordination();
+                if (run.interrupted) return '';
+                if (!coordination) {
+                  if (!mcp.env) mcp = mcpFor(rt.id, mint.token, getMcpUrl());
+                  return await runCli({ ...args, mcpArgs: mcp.args, mcpEnv: mcp.env,
+                    onSpawn: ch => { releaseRetry(); args.onSpawn?.(ch); } });
+                }
+                const { onSpawn, onInit, ...turnArgs } = coordination.wrap({ ...args, mcpArgs: [], mcpEnv: null });
+                const result = await runCappedTurn({ runTurn: runCli, turnArgs, capMs: 15 * 60_000, workChildren,
+                  releaseSlot: () => { releaseSlot(); releaseRetry(); }, onSpawn, onInit,
+                  signal: captureSignal, killChild: coordination.kill,
+                  // This is the ongoing conversation, never a scratch consult.
+                  removeTranscript: () => {},
+                });
+                if (result.wedged && !run.interrupted) { cliFailed = true; return 'The capture turn timed out. Continue in this conversation; read list_staged before changing any proposals.'; }
+                return envScrub(result.out);
+              } finally {
+                releaseRetry();
+                await coordination?.close(run.interrupted); coordination = null;
+              }
+            };
+            out = await invoke({
               ...turnArgs,
               resume,
               resumeThreadId: codexResumeId || claudeResumeId || undefined,
@@ -913,9 +995,15 @@ export function createWorkSessionTurns({
               cliFailed = false;
               badExit = null;
               contractSent = true;
-              out = await runCli({ ...turnArgs, resume: false, system: turnSystem });
+              out = await invoke({ ...turnArgs, resume: false, system: turnSystem }, true);
             }
+            turnReturned = true;
           } finally {
+            await coordination?.close(run.interrupted);
+            control?.stop();
+            // The cap can resolve before a wedged provider closes stdout.
+            // Its live-input relay must not keep taking the next prompt.
+            if (delegated) await run.live?.stop();
             // The CLI has stopped printing, so stop relaying. The LINE itself
             // is cleared server-side at settle — clearing it here would race
             // the settle and blank the tab a beat before the reply lands.
@@ -930,15 +1018,13 @@ export function createWorkSessionTurns({
               }
             }
             if (mcp.dir) rmSync(mcp.dir, { recursive: true, force: true });
-          }
-          // Persist the codex thread id AFTER the turn ends, so the next turn
-          // resumes exactly the conversation that just spoke. Shape-guarded
-          // 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);
-            recordCodexContract(contractPath, seenThreadId, turnSystem, contractSent);
+            // Keep the exact native conversation on failures too. A later
+            // capture continuation must reconcile its own staged rows, not
+            // silently start a second conversation after a provider throws.
+            if ((shape.capture || turnReturned) && 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
@@ -1116,6 +1202,7 @@ export function createWorkSessionTurns({
       if (run) {
         if (!run.interrupted) note(`${c.cyan('tab')} ${c.dim('— interrupting the running turn')}`);
         run.interrupted = true;
+        run.abort.abort();
         for (const ch of run.spawned) interruptThenKill(ch);
         continue;
       }

package/bin/lib/workToolLog.mjs

@@ -84,6 +84,8 @@ export function createToolLog(cwd) {
     // past the server's limits (review, 2026-09-01).
     const e = toolEventOf(name, input, cwd, envScrub);
     if (!e) return;
+    if (typeof meta.agentId === 'string' && meta.agentId) e.agentId = scrubCut(meta.agentId, 160);
+    if (e.agentId && typeof meta.agentTitle === 'string' && meta.agentTitle) e.agentTitle = scrubCut(meta.agentTitle, 120);
     if (e.t !== 'plan') {
       if (id) { e.id = scrubCut(id, 160); correlated.set(id, e); }
       if (name === 'Read') for (const key of ['offset', 'limit']) {
@@ -106,6 +108,7 @@ export function createToolLog(cwd) {
       const last = toolLog.ev[toolLog.ev.length - 1];
       const sameKey =
         last &&
+        last.agentId === e.agentId &&
         !id && !last.id &&
         last.outcome === e.outcome &&
         last.exitCode === e.exitCode &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.125.12",
+  "version": "0.125.15",
   "description": "Run your own coding CLIs as build agents for Flowviant \u2014 Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {