flowviant 0.125.29 → 0.125.31

package/bin/lib/workAgentTurnExecution.mjs

@@ -30,6 +30,7 @@ import { finishRepositoryDelivery, allResolutionsCommitted } from './repositoryD
  */
 import { MODEL, PROJECT_ID } from './config.mjs';
 import { setRuntimeLimit } from './daemonState.mjs';
+import { limitResetAt } from './runtimeLimits.mjs';
 import { gitOrNull } from './git.mjs';
 import { assertWorktree } from './worktreeHealth.mjs';
 import { placeTurnLockedByLivePid, recordTurnLock } from './turnLock.mjs';
@@ -48,6 +49,7 @@ import { scrub as envScrub } from './uplinkScrub.mjs';
 import { canRun, runtimeById } from './runtimes.mjs';
 import { toolEventOf, CLAUDE_TOOL_PROSE_KINDS, scrubNativeText } from './runtimeEvents.mjs';
 import { makeTraceRelay } from './trace.mjs';
+import { createOutsideRuns } from './outsideCli.mjs';
 import { createWebsiteTrace } from './websiteTrace.mjs';
 import { prepareCardTools } from './workAgentTools.mjs';
 import { runTurnResumingOnce } from './resumeLost.mjs';
@@ -62,6 +64,7 @@ import { agentTurnResume } from './workAgentResume.mjs';
 import { createDeliveryReporter } from './workDelivery.mjs';
 import { createLiveMessages } from './workLiveMessages.mjs';
 import { createOrchestrator } from './orchestrator.mjs';
+import { crossCliFor } from './crossCliLaunch.mjs';
 import { claudeOrchestrationSafe } from './orchestratorHooks.mjs';
 import { ORCHESTRATED_POSTURES, orchestratesPosture } from './orchestratorPrompt.mjs';
 import { knownCodexModels } from './runtimeOfferings.mjs';
@@ -73,6 +76,12 @@ import { createVideoRender } from './videoRender.mjs';
 import { createManagedBrowser } from './managedBrowser.mjs';
 import { completeBrowserReview, browserHandoffPrompt } from './browserHandoff.mjs';
 import { withUiReview, appendUiReviewEvidence } from './uiReviewTurn.mjs';
+import { setupRepository } from './repositorySetup.mjs';
+import { readEnvironmentRecipe } from './reviewEnvironmentConfig.mjs';
+import { environmentInstructions, environmentOverlay, holdWorktreeEnvironment } from './reviewEnvironment.mjs';
+import { environmentCredentialNames } from './reviewDatabase.mjs';
+import { createRuntimeReview } from './runtimeReview.mjs';
+import { splitBrain, splitPolicy } from './splitGate.mjs';
 
 export function createAgentTurnExecution({
   admit,
@@ -105,6 +114,7 @@ export function createAgentTurnExecution({
   makeUiReview = createUiReview,
   makeVideoRender = createVideoRender,
   makeManagedBrowser = createManagedBrowser,
+  makeRuntimeReview = createRuntimeReview,
 }) {
   const reportDelivery = createDeliveryReporter();
   /** How long the final flush may hold the settle. Bounded because the settle
@@ -126,6 +136,7 @@ export function createAgentTurnExecution({
    *  `interruptAgentTurns`); absent, nothing can interrupt it. */
   const runAgentTurnInPlace = async (job, { turnId, agentId, place, releaseSlot, postAgentTurn, measured, run = { interrupted: false } }) => {
     let repositoryRun = null;
+    const environmentReleases = [];
     const setupController = new AbortController();
     run.abortSetup = () => setupController.abort();
     if (run.interrupted) setupController.abort();
@@ -286,7 +297,7 @@ export function createAgentTurnExecution({
 
     // Which conversation this turn resumes, and the kept Codex home it is
     // filed under: the agent's resume across turns (workAgentResume.mjs).
-    const agentResume = agentTurnResume({ rt, wt, agentId, sessionMetaPath });
+    const agentResume = agentTurnResume({ rt, wt, agentId, sessionMetaPath, turnId });
 
     /**
      * THE TURN'S FILES, ON DISK BEFORE THE PROMPT NAMES THEM (0.112.0) — the
@@ -363,7 +374,12 @@ export function createAgentTurnExecution({
       post: postAgentTrace,
       orchestrationVersion: orchestrating ? 2 : undefined,
       scrub: envScrub,
+      // Each child's CLI, and the turns a resumed one appeared in (S4.1).
+      cli: rt,
+      runsOf: agentResume.subagents.runsOf ?? undefined,
     });
+    // The lead's shell-outs to another CLI, shown as Outside rows (outsideCli.mjs).
+    const outsideRuns = createOutsideRuns(trace);
     // A live Send can choose its path as soon as the CLI starts, including a
     // silent solo turn. Do not leave a two-second first-flush race at spawn.
     if (orchestrating) await trace.flush(1_000);
@@ -398,6 +414,8 @@ export function createAgentTurnExecution({
     // run's children and contract: Claude always names --model (the daemon's
     // pin when the card has none); Codex's unpinned default is its own.
     const cardBrain = { model: brain.model ?? (rt === 'claude' ? MODEL : null), effort: brain.effort ?? null };
+    // The person's split answer or Always switch, when the server asks (splitGate.mjs).
+    const split = splitPolicy(job);
 
     let out = '';
     let child = null;
@@ -417,6 +435,8 @@ export function createAgentTurnExecution({
     let browserNote = '';
     let uiReviewNote = '';
     let uiReviewEvidence = '';
+    let environmentNote = '', reviewEnv = null;
+    let runtimeReview = null, runtimeNote = '', runtimeEvidence = '';
     // A video card's render tool (videoRender.mjs), and the words a turn
     // gets when it could not be held, so it stops rather than guesses.
     let videoRender = null;
@@ -430,6 +450,8 @@ export function createAgentTurnExecution({
       args = withUiReview(args, uiReviewNote, uiReview?.env);
       args = withUiReview(args, videoNote);
       args = withUiReview(args, browserNote, managedBrowser?.env);
+      args = withUiReview(args, environmentNote, reviewEnv);
+      args = withUiReview(args, runtimeNote, runtimeReview?.env);
       args.managedBrowser = Boolean(managedBrowser);
       return runTurnImpl(args);
     };
@@ -480,6 +502,22 @@ export function createAgentTurnExecution({
     let orchestrator = null;
     let intermediateDelivery = null;
     try {
+      if (posture === 'build') {
+        const sources = repositoryRun?.sources ?? [{ wt, repoRoot: worktreeRepo, baseRef: baseRef() }];
+        const administrativeNames = new Set();
+        for (const source of sources) {
+          const snapshot = readEnvironmentRecipe(source.repoRoot, source.baseRef);
+          if (!snapshot) continue;
+          const environment = await setupRepository(source.repoRoot, source.wt, { snapshot, signal: setupController.signal,
+            onSpawn: ch => { workChildren.set(ch, agentId); groupKillChildren?.add(ch); },
+            onClose: ch => { workChildren.delete(ch); groupKillChildren?.delete(ch); } });
+          environmentReleases.push(holdWorktreeEnvironment(environment));
+          environmentNote += '\n' + environmentInstructions(environment);
+          for (const name of environmentCredentialNames(snapshot.recipe)) administrativeNames.add(name);
+          if (source.wt === wt) reviewEnv = environmentOverlay(environment);
+        }
+        if (administrativeNames.size) reviewEnv = { ...reviewEnv, ...Object.fromEntries([...administrativeNames].map(name => [name, undefined])) };
+      }
       if (posture === 'build' && job.kind !== 'merge_resolve' && ['claude', 'codex'].includes(rt)) {
         try {
           managedBrowser = await makeManagedBrowser({ wt, turnId, signal: setupController.signal, onChild: ch => {
@@ -490,6 +528,14 @@ export function createAgentTurnExecution({
         } catch (error) { browserNote = `The managed browser could not start: ${envScrub(error.message)}. Report interactive browser checks unavailable.`; }
       }
       if (posture === 'build' && job.kind !== 'merge_resolve') {
+        try {
+          runtimeReview = await makeRuntimeReview({ wt, repoRoot: worktreeRepo, baseRef: baseRef(), sources: repositoryRun?.sources ?? [],
+            browser: managedBrowser, signal: setupController.signal, onChild: ch => {
+              workChildren.set(ch, agentId); groupKillChildren?.add(ch);
+              return () => { workChildren.delete(ch); groupKillChildren?.delete(ch); };
+            } });
+          runtimeNote = runtimeReview?.instructions ?? '';
+        } catch (error) { runtimeNote = `Configured runtime review is unavailable: ${envScrub(error.message)}. Use the repository’s existing checks and report unavailable runtime verification.`; }
         try {
           uiReview = await makeUiReview({ wt, signal: setupController.signal, onChild: ch => {
             workChildren.set(ch, agentId); groupKillChildren?.add(ch);
@@ -510,12 +556,19 @@ export function createAgentTurnExecution({
           assignmentContext: () => agentChildScope(job),
           // Codex's spawn takes only a catalog model (knownCodexModels, the
           // measured models_cache.json rows the roster already reports).
-          children: { access: ORCHESTRATED_POSTURES[posture], ...cardBrain, ...(rt === 'codex' ? { catalog: knownCodexModels() } : {}) },
+          children: { access: ORCHESTRATED_POSTURES[posture], ...cardBrain, ...splitBrain(split, rt, cardBrain).brain, split, ...(rt === 'codex' ? { catalog: knownCodexModels() } : {}) },
           // Whether the words reached the CLI; Codex reads its inbox from hooks.
           notify: message => liveInput ? run.live?.inject(message) === true : false,
-          taken: id => run.live?.onTaken(id) });
+          taken: id => run.live?.onTaken(id),
+          // Subagents on another CLI (crossCliLaunch.mjs), counted as live children while they run.
+          crossCli: crossCliFor({ rt, posture, wt, worktreeRepo, ledger: agentResume.subagents, trace, scrub: envScrub, onChild: ch => {
+            workChildren.set(ch, agentId); groupKillChildren?.add(ch);
+            return () => { workChildren.delete(ch); groupKillChildren?.delete(ch); };
+          } }) });
       }
-      const tools = prepareCardTools({ rt, posture, wt, repoRoot, baseRef, sources: repositoryRun?.sources ?? [], repositoryTool: repositoryRun?.tool ?? null, orchestratorConfig: orchestrator?.config ?? null, uiReviewConfig: uiReview?.config, videoConfig: videoRender?.config ?? null, browserConfig: managedBrowser?.config, orchestrated: Boolean(orchestrator), codexHome: agentResume.codexHome });
+      const tools = prepareCardTools({ rt, posture, wt, repoRoot, baseRef, sources: repositoryRun?.sources ?? [], repositoryTool: repositoryRun?.tool ?? null, orchestratorConfig: orchestrator?.config ?? null, uiReviewConfig: uiReview?.config, videoConfig: videoRender?.config ?? null, browserConfig: managedBrowser?.config, orchestrated: Boolean(orchestrator), codexHome: agentResume.codexHome,
+        runtimeConfig: runtimeReview?.config,
+        ...(reviewEnv ? { env: { ...process.env, ...reviewEnv } } : {}) });
       projectTools = tools.projectTools;
       localCleanup?.begin(turnId);
       const { toolsNote } = tools;
@@ -542,7 +595,7 @@ export function createAgentTurnExecution({
         intermediateFiles,
         researchIdentity: { projectId: PROJECT_ID, agentId, turnId, taskId: job.task?.id ?? job.repositoryTaskId },
         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 }),
+        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, split, crossCli: orchestrator.crossCli() } : null }),
         agentTools: projectTools,
         writableDirs: repositoryRun?.writableDirs,
         ...((tools.envNeeded || repositoryRun?.tool || orchestrator) ? { mcpEnv: { ...tools.env, ...(repositoryRun?.tool?.env ?? {}), ...(orchestrator?.env ?? {}) } } : {}),
@@ -560,7 +613,9 @@ export function createAgentTurnExecution({
         // build for code, the fenced design/research postures otherwise.
         profile: posture,
         cardTurn: Boolean(orchestrator),
-        onSubagent: (update) => orchestrator ? orchestrator.observe(update) : trace.agent(update),
+        onWorkflow: row => trace.workflow(row),
+        onSubagent: (update) => update.kind === 'workflow' || !orchestrator ? trace.agent(update) : orchestrator.observe(update),
+        ...(rt === 'codex' ? { knownSubagents: agentResume.subagents.codexTargets() } : {}),
         onSpawnResult: result => orchestrator?.spawnResult(result),
         cwd: wt,
         runtime: rt,
@@ -668,6 +723,7 @@ export function createAgentTurnExecution({
             }
             return;
           }
+          outsideRuns.observe(name, input, meta);
           brief?.append(meta?.result ? 'tool result' : 'tool call', meta?.result
             ? { id: meta.id, exitCode: meta.exitCode, isError: meta.isError, output: meta.output }
             : { name, input });
@@ -677,7 +733,7 @@ export function createAgentTurnExecution({
           trace.tool(toolEventOf(name, input, wt, envScrub));
         },
         // The CLI's own per-turn token counts, off the `result` event. One
-        // result per CLI invocation. Internal-wait recovery combines those
+        // cumulative report per CLI invocation. Internal-wait recovery combines those
         // counts before this callback; project accounting still happens
         // SERVER-side, behind the settle's idempotent win,
         // because a retried settle must not charge the same turn twice.
@@ -794,12 +850,15 @@ export function createAgentTurnExecution({
       // owned by its review tool, then bind evidence to the final source
       // before the existing artifact upload and delivery settlement.
       try { await videoRender?.close(); } catch { /* a closed listener */ }
+      try { await runtimeReview?.close(); } catch { /* turn teardown continues */ }
       try { await managedBrowser?.close(); } catch { /* turn teardown continues */ }
       try { await uiReview?.close(); }
       finally {
         try { uiReviewEvidence = uiReview?.finalize() ?? uiReviewEvidence; }
         catch (error) { uiReviewEvidence = `Local UI review final source/evidence measurement unavailable: ${envScrub(error.message)}. Earlier checks do not establish the final source.`; }
       }
+      try { runtimeEvidence = runtimeReview?.finalize() ?? ''; }
+      catch { runtimeEvidence = 'Runtime review final source could not be measured; earlier results do not verify final source.'; }
       await run.live?.stop();
       await orchestrator?.close(run.interrupted);
       await brief?.stop();
@@ -910,6 +969,7 @@ export function createAgentTurnExecution({
       modelExports: intermediateDelivery?.modelExports,
     });
     appendUiReviewEvidence(body, uiReviewEvidence);
+    appendUiReviewEvidence(body, runtimeEvidence);
     // The agent's own account of what it did not deliver, for the pre-review.
     if (job.kind === 'task' && job.task && body.outcome === 'delivered' && res?.gaps)
       stashGaps(sessionMetaPath(wt, 'flowviant-agent-cards', agentId), job.task.id, res.gaps);
@@ -931,6 +991,9 @@ export function createAgentTurnExecution({
     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);
     }
+    // The split this turn ran under, when the person approved it or Always is
+    // on: the batch's CLI, model and effort, as the job carried them.
+    if (orchestrator && split && split.mode !== 'ask') body.subagents = split;
     if (limit) {
       setRuntimeLimit(PROJECT_ID, rt, limit);
       // Every agent ON THIS CLI parks, because that account is shared: one
@@ -938,7 +1001,9 @@ export function createAgentTurnExecution({
       // a machine can hold a Claude login and a Codex login, and a Codex
       // limit is no reason to stop the Claude agents. The turn itself is
       // reported as `nothing` — it did not deliver and it did not ask.
-      await postAgentParked(limit, rt);
+      // With the CLI's measured reset, when it said one (runtimeLimits.mjs).
+      const codexEnv = agentResume.codexHome ? { ...process.env, CODEX_HOME: agentResume.codexHome } : undefined;
+      await postAgentParked(limit, rt, await limitResetAt(rt, { threadId: agentResume.threadNow(), env: codexEnv }));
     }
     if (job.kind === 'merge_resolve') {
       const resolution = () => repositoryRun
@@ -965,7 +1030,10 @@ export function createAgentTurnExecution({
     // hold the lock on — see `runReviewEntry`. Only after the settle that may
     // say delivered: the three `nothing` settles never opened it.
     if (final && reply?.review === true) await runReviewEntry(agentId, wt, job.agentName, undefined, job);
-    } finally { await repositoryRun?.tool?.close(); }
+    } finally {
+      for (const release of environmentReleases) release();
+      await repositoryRun?.tool?.close();
+    }
   };
 
   return { runAgentTurnInPlace };

package/bin/lib/workAgentTurnOutcome.mjs

@@ -35,6 +35,7 @@ import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 import { ANSWER_DELIVERED_USES, researchUseOf, withResearchHeader } from './researchUse.mjs';
 import { measuredModelExports } from './intermediateArtifacts.mjs';
 import { gapsMarkdown } from './turnGaps.mjs';
+import { blockedAnswer } from './agentAsk.mjs';
 
 /** Materialization runs only for a declared delivery; settlement remains the
  * sole parser and the sole authority deciding whether it really delivered. */
@@ -130,6 +131,16 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    */
   // Existing document deliveries default to the Markdown proof. Only an
   // explicit temporary-use declaration can deliver through the stored answer.
+  const required = res.gaps?.filter(g => g.disposition === 'required') ?? [];
+  if (res.outcome === 'delivered' && required.length && job.gapContinuationAccepted !== true) {
+    return report({ turnId, outcome: 'question',
+      answer: blockedAnswer('Required work remains. Should I finish it in this agent before delivery?', {
+        context: required.map(g => `${g.item}${g.why ? `: ${g.why}` : ''}`).join('\n\n'),
+        options: ['Finish the required work', 'Explain the remaining scope'],
+      }, envScrub),
+      ...(commits.length ? { commits } : {}), ...(usage ? { usage } : {}),
+      ...(res.progress ? { progress: envScrub(res.progress) } : {}), branch, worktree: wt });
+  }
   const briefUse = researchUseOf(job.task?.brief);
   const researchUse = kind.posture === 'research' ? briefUse ?? res.researchUse : null;
   const temporaryResearch = ANSWER_DELIVERED_USES.includes(researchUse);

package/bin/lib/workAgentTurnReports.mjs

@@ -148,7 +148,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS, baseDir = null }) {
     }
   };
 
-  const postAgentParked = async (reason, runtime) => {
+  const postAgentParked = async (reason, runtime, resetsAt = null) => {
     try {
       await fetch(AGENT_PARKED_URL, {
         method: 'POST',
@@ -156,7 +156,10 @@ export function createAgentTurnReports({ REJECT_RETRY_MS, baseDir = null }) {
         signal: AbortSignal.timeout(15_000),
         // `runtime` scopes the park to that CLI's agents; a server that does
         // not know the key parks every agent, which is what it always did.
-        body: JSON.stringify({ reason, ...(runtime ? { runtime } : {}) }),
+        // `resetsAt` is the CLI's measured reset (`limitResetAt`), sent only
+        // when measured: the server retries then, and an older server ignores
+        // the key and keeps its cooldown. A report, so no floor.
+        body: JSON.stringify({ reason, ...(runtime ? { runtime } : {}), ...(resetsAt ? { resetsAt } : {}) }),
       });
     } catch {
       /* the next turn will hit the same limit and try again */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.125.29",
+  "version": "0.125.31",
   "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": {