flowviant 0.125.13 → 0.125.16

package/bin/lib/workAgentCheck.mjs

@@ -120,6 +120,19 @@ export function checkEnv(env = process.env, browserHome = null) {
  * child whose 'close' never comes, which a real process only shows with a
  * survivor outside its group holding the pipe.
  */
+/** The repository's declared check, `.flowviant/check.json`'s `command` —
+ *  read once here for the check and the batch merge's coordinator alike. */
+export function readConfiguredCheck(root) {
+  try {
+    const raw = readFileSync(join(root, '.flowviant', 'check.json'), 'utf8');
+    const cfg = JSON.parse(raw);
+    const cmd = typeof cfg?.command === 'string' ? cfg.command.trim() : '';
+    return cmd ? cmd.slice(0, 500) : null;
+  } catch {
+    return null; // absent, unreadable or not JSON — all mean "no check"
+  }
+}
+
 export function createWorkAgentCheck({
   repoRoot,
   postBestEffort,
@@ -150,16 +163,7 @@ export function createWorkAgentCheck({
   const CHECK_TIMEOUT_MS = 10 * 60_000;
   const CHECK_OUTPUT_CAP = 4000;
 
-  const readCheckCommand = (root = repoRoot) => {
-    try {
-      const raw = readFileSync(join(root, '.flowviant', 'check.json'), 'utf8');
-      const cfg = JSON.parse(raw);
-      const cmd = typeof cfg?.command === 'string' ? cfg.command.trim() : '';
-      return cmd ? cmd.slice(0, 500) : null;
-    } catch {
-      return null; // absent, unreadable or not JSON — all mean "no check"
-    }
-  };
+  const readCheckCommand = (root = repoRoot) => readConfiguredCheck(root);
 
   const postCheck = async (body) => {
     // Same bounded retry as postAgentPlan — see postBestEffort. On the

package/bin/lib/workAgentPlans.mjs

@@ -6,7 +6,7 @@ import { discoveryGuide } from './discoveryContract.mjs';
 import { compareRepositoryBaselines, measureRepositoryBaseline, repositoryBaselineOf } from './repositoryBaseline.mjs';
 import { knowledgeDirFor } from './knowledgeFiles.mjs';
 import { createToolLog } from './workToolLog.mjs';
-import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
+import { FLEET_URL, DAEMON_INSTANCE, MODEL } from './config.mjs';
 import { measureAgentFootprint, liveAgentContext } from './agentFootprint.mjs';
 import { parseProposal } from './agentPlan.mjs';
 import { c, note } from './ui.mjs';
@@ -14,9 +14,11 @@ import { runTurn as defaultRunTurn } from './runTurn.mjs';
 import { SYSTEM_PLAN, AGENT_PLAN_KICKOFF, withProjectContext, REPOSITORY_BASELINE_PARAGRAPH } from './prompts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { canRun, runtimeById, runtimeLabel } from './runtimes.mjs';
-import { detectRuntimes as defaultDetectRuntimes, pickRuntimeFor as defaultPickRuntimeFor } from './runtimeDetection.mjs';
+import { detectRuntimes as defaultDetectRuntimes, pickRuntimeFor as defaultPickRuntimeFor, measuredRuntimeVersion } from './runtimeDetection.mjs';
 import { brainFor } from './workBrain.mjs';
-import { runCappedTurn } from './workCappedTurn.mjs';
+import { runReadOnlyConsult } from './readOnlyRun.mjs';
+import { planningOrchestratorContract } from './orchestratorPrompt.mjs';
+import { knownCodexModels } from './runtimeOfferings.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { claimFleetLease, fleetHeaders } from './fleetPost.mjs';
 import { REPO_PLACE } from './workPlaces.mjs';
@@ -37,6 +39,8 @@ export function createWorkAgentPlans({
   pickRuntimeFor = defaultPickRuntimeFor,
   detectRuntimes = defaultDetectRuntimes,
   authStatus = readClaudeAuthStatus,
+  runtimeVersion = id => measuredRuntimeVersion(id)?.version,
+  runConsult = runReadOnlyConsult,
 }) {
   const AGENT_PLAN_DONE_URL = fleetEndpoint('agent-plan-done', FLEET_URL);
   const AGENT_PLAN_ACTIVITY_URL = fleetEndpoint('agent-plan-activity', FLEET_URL);
@@ -55,10 +59,10 @@ export function createWorkAgentPlans({
   // the CLI path-validates itself, and the `git` readers, which it does not —
   // their path fence is the read guard's refusal (hooks/readGuard.mjs), of
   // `--no-index` and of any git argument aimed off the checkout — and no
-  // Write, no Edit, no mkdir, no rm) and NO MCP is passed at all, so this
-  // turn has no control plane to reach even if the repository it reads tries
-  // to steer it. The proposal comes back as the turn's final message rather
-  // than through a tool, which is exactly what lets that permission set be
+  // Write, no Edit, no mkdir, no rm). Compatible held attempts may receive
+  // only a local read-only coordination capability. No board/staging token,
+  // project/personal server or extra network access is supplied. The proposal
+  // comes back as the turn's final message rather than through a tool, which lets that permission set be
   // this narrow.
   //
   // It takes the checkout's place lock as a READER, beside the operator's own
@@ -287,49 +291,71 @@ export function createWorkAgentPlans({
         discovery.toolLog.baseline = measureRepositoryBaseline({ cwd: repoRoot, baseRef, knowledgeDir });
         discovery.toolLog.captureBaseline = repositoryBaselineOf(job.captureBaseline);
         discovery.toolLog.reconciliation = compareRepositoryBaselines(discovery.toolLog.baseline, discovery.toolLog.captureBaseline);
-        const consult = async (prompt, system) => await runCappedTurn({
-          runTurn,
-          signal: control?.signal,
-          capMs: PLAN_TURN_TIMEOUT_MS,
-          workChildren,
-          releaseSlot,
-          transcriptCwd: repoRoot,
-          turnArgs: {
-            diagnosticPlanId: id,
-            prompt,
-            system,
-            knowledgeDir,
-            // READ-ONLY, and no MCP: `mcpArgs` is omitted entirely rather than
-            // passed empty, so there is no control plane on this turn at all.
-            profile: 'consult',
-            cwd: repoRoot,
-            runtime: rt,
-            ...brainFor(job, rt),
-            answerFromResult: true,
-            work: planWork(job),
-            // The CLI's own tail, forwarded to the press. Same rule as an agent
-            // turn's: throttled, overwritten rather than appended, and never
-            // awaited by the turn.
-            onActivity: (a) => {
-              if (a?.label) narrate(String(a.label));
+        const brain = brainFor(job, rt);
+        let consults = 0;
+        const consult = async (prompt, system, diagnosing = false) => {
+          let rootSlot = releaseSlot;
+          if (consults++ > 0) {
+            // Diagnosis ended its CLI and released its children. A fresh
+            // paid consult must ask the pool again, like every other root.
+            while (admit('churn')) {
+              if (control?.signal.aborted) return { out: '', wedged: false };
+              await new Promise(resolve => setTimeout(resolve, 1_000));
+            }
+            rootSlot = admit.reserve();
+          }
+          return await runConsult({
+            enabled: job.readOnlyOrchestrationVersion === 1 && job.recoveryEnabled === true,
+            identity: { scope: 'plan', id, attempt: job.attempt },
+            version: runtimeVersion(rt),
+            admit,
+            children: { ...brain, model: brain.model ?? (rt === 'claude' ? MODEL : null),
+              ...(rt === 'codex' ? { catalog: knownCodexModels() } : {}) },
+            contract: planningOrchestratorContract({ diagnosis: diagnosing, runtime: rt, ...brain, model: brain.model ?? (rt === 'claude' ? MODEL : null) }),
+            onUnavailable: error => say(`Native investigation coordination unavailable: ${error.message}`),
+            runTurn,
+            signal: control?.signal,
+            capMs: PLAN_TURN_TIMEOUT_MS,
+            workChildren,
+            releaseSlot: rootSlot,
+            transcriptCwd: repoRoot,
+            turnArgs: {
+              diagnosticPlanId: id,
+              prompt,
+              system,
+              knowledgeDir,
+              // The consult fence stays intact. runReadOnlyConsult may mount
+              // only the attempt's local coordination tool, never a board token.
+              profile: 'consult',
+              cwd: repoRoot,
+              runtime: rt,
+              ...brain,
+              answerFromResult: true,
+              work: planWork(job),
+              // The CLI's own tail, forwarded to the press. Same rule as an agent
+              // turn's: throttled, overwritten rather than appended, and never
+              // awaited by the turn.
+              onActivity: (a) => {
+                if (a?.label) narrate(String(a.label));
+              },
+              onToolEvent: discovery.pushToolEvent,
+              // Tagged with the CLI that counted it; one turn, so the sum is the
+              // one report (turnUsage.mjs keeps it null-safe).
+              onUsage: (u) => {
+                usage = addUsage(usage, { ...u, runtime: rt });
+              },
             },
-            onToolEvent: discovery.pushToolEvent,
-            // Tagged with the CLI that counted it; one turn, so the sum is the
-            // one report (turnUsage.mjs keeps it null-safe).
-            onUsage: (u) => {
-              usage = addUsage(usage, { ...u, runtime: rt });
+            onSpawn: () => {
+              say(`${runtimeLabel(rt)} started on this machine`);
             },
-          },
-          onSpawn: () => {
-            say(`${runtimeLabel(rt)} started on this machine`);
-          },
-        });
+          });
+        };
         let context = AGENT_PLAN_KICKOFF({ tasks, liveAgents, agentCap: Number.isInteger(job.agentCap) && job.agentCap > 0 ? job.agentCap : 3 });
         if (job.recovery?.start) context += '\nSTART REPAIR: This is a supporting diagnosis for an already approved Start. Return exactly ONE group with the same ordered taskIds, attachment target (or absence) and CLI. Preserve the approval; do not start an unapproved sibling. Diagnose admission/pickup errors and repair planning evidence/context. Ask only a genuine person-only question in the diagnostic JSON. Approval and source revision (data): ' + JSON.stringify(job.recovery.start);
         const system = withProjectContext(SYSTEM_PLAN, { knowledgeDir }) + '\n\n' + discoveryGuide(rt, 'planning') + '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(discovery.toolLog.baseline, discovery.toolLog.captureBaseline, discovery.toolLog.reconciliation);
         if (job.recovery) {
           say(`Diagnosing the failed Plan: ${job.recovery.reason}`);
-          const diagnostic = await consult(context + '\nRetained recovery context (data): ' + JSON.stringify(job.recovery), withProjectContext(PLAN_RECOVERY_SYSTEM, { knowledgeDir }) + '\n' + discoveryGuide(rt, 'planning'));
+          const diagnostic = await consult(context + '\nRetained recovery context (data): ' + JSON.stringify(job.recovery), withProjectContext(PLAN_RECOVERY_SYSTEM, { knowledgeDir }) + '\n' + discoveryGuide(rt, 'planning'), true);
           if (control?.signal.aborted) return;
           if (diagnostic.wedged) { wedged = true; return; }
           const result = parsePlanDiagnosis(diagnostic.out);

package/bin/lib/workAgentTurnExecution.mjs

@@ -754,7 +754,8 @@ export function createAgentTurnExecution({
           throw error;
         }
       }
-      await artifacts.report({ placeDir: wt, before: intermediateDelivery?.uploadBefore ?? artifactsBefore, agentId, turnId, requireStored: kind.artifact != null });
+      await artifacts.report({ placeDir: wt, before: intermediateDelivery?.uploadBefore ?? artifactsBefore, agentId, turnId,
+        requireStored: kind.artifact != null, requiredOutputs: intermediateDelivery?.requiredOutputs });
     }
 
 
@@ -784,7 +785,7 @@ export function createAgentTurnExecution({
       usage,
       model,
       commits,
-      artifactsBefore,
+      artifactsBefore: intermediateDelivery?.uploadBefore ?? artifactsBefore,
       branch,
       wt,
       modelExports: intermediateDelivery?.modelExports,

package/bin/lib/workAgentTurnOutcome.mjs

@@ -139,7 +139,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
     const want = kind.artifact.match;
     const has = (l) => l.some((e) => want.test(e.name)
       && (kind.posture !== 'image' || usableImageArtifact(e)));
-    const standing = scanArtifacts(wt);
+    const standing = scanArtifacts(wt, { all: true });
     const wrote = has(changedArtifacts(artifactsBefore, standing));
     const exported = kind.exportModel && measuredModelExports(wt, modelExports);
     const present = wrote || exported || ((job.kind !== 'task' || job.redo === true) && has(standing));

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/workMergeBatch.mjs

@@ -18,6 +18,7 @@ import { scrub } from './uplinkScrub.mjs';
 import { relayedText } from './prWorkflow.mjs';
 import { isSafePathSegment, stripUrlUserinfo } from './git.mjs';
 import { killGroup } from './processGroup.mjs';
+import { readConfiguredCheck } from './workAgentCheck.mjs';
 
 export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPlace, runCheck, workChildren, groupKillChildren, admit, onRepoChanged, landed, runCli = runTurn }) {
   const request = async (route, body) => {
@@ -48,6 +49,7 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
         integrated = await integrateMergeBatch({ spec, progress: claim.progress ?? job.batch.progress, previousError: claim.previousError ?? job.batch.previousError, baseDir,
           rootFor: (id) => repositoryPlaces?.rootFor?.(id) ?? (spec.repositories.length === 1 ? repoRoot : null),
           setup: trackedRepositorySetup(workChildren, groupKillChildren),
+          checkCommand: (r) => readConfiguredCheck(r.wt),
           entries: (member) => {
             const rows = repositoryPlaces?.entries(member.placeId) ?? [];
             if (rows.length) return rows;
@@ -81,6 +83,8 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
             // Run configured checks too; a coordinator cannot replace them with a weaker command.
             const configured = await runCheck(leader.agentId, r.wt, r);
             if (!['passed', 'none'].includes(configured?.status)) throw new Error(`${r.name}: the configured combined check failed or could not run.\n${configured?.text || ''}`);
+            // The same command twice is one validation (2026-10-22).
+            if (r.command.trim() === readConfiguredCheck(r.wt)) return;
             const measured = await runCheck(leader.agentId, r.wt, r, r.command);
             if (measured?.status !== 'passed') throw new Error(`${r.name}: combined validation failed. Retry the batch to resolve it.\n${measured?.text || ''}`);
           },

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.13",
+  "version": "0.125.16",
   "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": {