flowviant 0.125.30 → 0.125.31

package/bin/lib/turnSubagents.mjs

@@ -17,6 +17,11 @@
  * bounds and settles its own records, so only an unowned turn is counted
  * here; and native transcript reads are readouts, so the drain at close is
  * bounded and never holds the card's answer.
+ *
+ * EVERY UPDATE NAMES ITS CLI AND, ONCE KNOWN, ITS KEY (2026-11-06, S4.1):
+ * the identity the CLI itself keeps for the child across turns — Claude's
+ * native agent id, Codex's child thread id — so a child resumed in a later
+ * turn is the same record there (workAgentResume.mjs keeps which turns).
  */
 
 import { handleStreamLine } from './claudeStream.mjs';
@@ -24,35 +29,44 @@ import { createClaudeSubagents } from './claudeSubagents.mjs';
 import { createClaudeSubagentProgress } from './claudeSubagentProgress.mjs';
 import { createCodexSubagentReader } from './codexSubagents.mjs';
 import { humanizeClaudeTool } from './runtimeEvents.mjs';
-import { SUBAGENT_CAP } from './subagentBounds.mjs';
+import { SUBAGENT_CAP, SUBAGENT_KEY_MAX } from './subagentBounds.mjs';
+
+/** The child's stable identity, `<cli>:<native id>`, or nothing yet. */
+export function subagentKey(runtime, update) {
+  const native = runtime === 'codex' ? update.id : runtime === 'claude' ? update.nativeId : null;
+  const key = typeof native === 'string' && native ? `${runtime}:${native}` : null;
+  return key && key.length <= SUBAGENT_KEY_MAX ? key : null;
+}
 
 /**
  * `sinks` are the turn's own: its console, activity, tool-event and text
  * sinks, which a Claude child's transcript rows feed as its stream does.
  */
-export function createTurnSubagents({ runtime, cwd, since, env, owned, onSubagent, onSpawnResult, resumeThreadId,
+export function createTurnSubagents({ runtime, cwd, since, env, owned, onSubagent, onWorkflow, onSpawnResult, resumeThreadId, knownSubagents,
   sinks: { emit, onActivity, onToolEvent, appendText, onDetail } }) {
   // An orchestrator bounds its own records and settles them at close
   // (orchestrator.mjs). Counted here by stream id, refused retries used up
   // the 32 and later children's updates were dropped; the exit sweep
   // reported 'stopped' off stream state the controller had already settled.
   const agentStates = new Map();
-  const reportSubagent = (update) => {
-    if (!update?.id) return;
-    if (!owned) {
-      if (!agentStates.has(update.id) && agentStates.size >= SUBAGENT_CAP) return;
+  const reportSubagent = (raw) => {
+    if (!raw?.id) return;
+    const key = subagentKey(runtime, raw);
+    const update = { ...raw, cli: runtime, ...(key ? { key } : {}) };
+    // Past the cap a child is still handed on: the trace relay counts it as
+    // not recorded (its `notRecorded`), and the sweep does not follow it.
+    if (!owned && raw.kind !== 'workflow' && (agentStates.has(update.id) || agentStates.size < SUBAGENT_CAP))
       agentStates.set(update.id, update.status ?? agentStates.get(update.id) ?? 'running');
-    }
     onSubagent?.(update);
   };
-  const subagents = createClaudeSubagents(reportSubagent);
+  const subagents = createClaudeSubagents(reportSubagent, onWorkflow);
   const claudeProgress = runtime === 'claude' && onSubagent ? createClaudeSubagentProgress({
     cwd, since, env,
     onLine: line => handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText,
       answerFromResult: true, subagents, onDetail }),
   }) : null;
   const codexAgents = runtime === 'codex' && onSubagent ? createCodexSubagentReader({
-    since, env,
+    since, env, knownTargets: knownSubagents ?? null,
     onSubagent: reportSubagent,
     onActivity: (activity) => {
       emit(activity.kind === 'error' ? activity.full ?? activity.label : activity.label + '\n', activity);

package/bin/lib/wikiDraft.mjs

@@ -8,6 +8,7 @@ import { ensureRealSubdir } from './ownedDirs.mjs';
 import { isSafePath, assertWikiDraftFits } from './vaultDiff.mjs';
 
 import { wikiScalars as scalars, protectedWikiPage } from './wikiOwnership.mjs';
+import { SYSTEM_ARCHITECTURE_PATH, readSystemArchitecture } from './architectureReport.mjs';
 
 /** Never follow links into an imported vault. A partial read cannot be a draft
  * basis: fail before the CLI starts rather than infer missing pages as deleted. */
@@ -60,6 +61,14 @@ export function beginWikiDraft(vaultDir) {
     discard: () => rmSync(dir, { recursive: true, force: true }),
     publish({ sha, repoFullName }) {
       const candidate = pages(dir, '', new Map(), true);
+      const architecture = candidate.get(SYSTEM_ARCHITECTURE_PATH);
+      const oldArchitecture = before.get(SYSTEM_ARCHITECTURE_PATH);
+      if (!protectedWikiPage(SYSTEM_ARCHITECTURE_PATH, oldArchitecture ?? architecture ?? '')) {
+        const parsed = readSystemArchitecture(architecture ?? '');
+        if (parsed.status === 'invalid' || (oldArchitecture && readSystemArchitecture(oldArchitecture).status === 'available' && parsed.status !== 'available')) {
+          throw new Error('Architecture report is incomplete or invalid; last good wiki retained');
+        }
+      }
       const changes = new Map();
       for (const [path, text] of candidate) {
         const old = before.get(path);

package/bin/lib/workAgentResume.mjs

@@ -25,6 +25,7 @@
 import { existsSync, writeFileSync } from 'node:fs';
 import { CLAUDE_SESSION_RE, CODEX_THREAD_RE, RESUME_MARKERS } from './conversationIds.mjs';
 import { pinId, readPinnedId } from './resumeMarker.mjs';
+import { subagentLedger } from './subagentLedger.mjs';
 
 /**
  * One agent turn's resume. `sessionMetaPath` is the lane's (a path in the
@@ -32,9 +33,11 @@ import { pinId, readPinnedId } from './resumeMarker.mjs';
  * `resumeThreadId`, the kept `codexHome`, and what the run tells it as the
  * CLI speaks: `sawSession` (Claude's init), `sawThread` (Codex's
  * `thread.started`), `forgetThread` (a lost resume retried fresh), `threadNow`
- * and, once the turn is over, `persist`.
+ * and, once the turn is over, `persist`. `subagents` is the agent's subagent
+ * ledger for this turn (subagentLedger.mjs): which turns each child appeared
+ * in, written with the markers.
  */
-export function agentTurnResume({ rt, wt, agentId, sessionMetaPath }) {
+export function agentTurnResume({ rt, wt, agentId, sessionMetaPath, turnId }) {
   // ONE AGENT IS ONE DIRECTORY, so the CLI's own cwd-keyed resume is exactly
   // right here — the ambiguity that forced per-tab session pinning in the
   // Workbench (many tabs, one place) cannot arise. The marker is what
@@ -86,8 +89,13 @@ export function agentTurnResume({ rt, wt, agentId, sessionMetaPath }) {
   const codexAgentHome =
     rt === 'codex' ? sessionMetaPath(wt, 'flowviant-agent-codex-home', agentId) : null;
 
+  // Its children's turns, kept beside the markers (a child resumes only where
+  // its conversation does), per agent and per CLI: keys never cross CLIs.
+  const subagents = subagentLedger(sessionMetaPath(wt, `flowviant-agent-subagents-${rt}`, agentId), turnId);
+
   return {
     resume,
+    subagents,
     resumeThreadId: codexResumeId || claudeResumeId || undefined,
     codexHome: codexAgentHome,
     /** Claude's session id from its init, pinned at once (a Claude turn only). */
@@ -116,6 +124,7 @@ export function agentTurnResume({ rt, wt, agentId, sessionMetaPath }) {
       // id learned mid-turn is only true once the turn that learned it ends.
       // Best-effort — the next turn runs fresh.
       pinId(codexThreadMarker, CODEX_THREAD_RE, seenThreadId);
+      subagents.persist();
     },
   };
 }

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';
@@ -78,6 +81,7 @@ 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,
@@ -293,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
@@ -370,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);
@@ -405,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;
@@ -545,10 +556,15 @@ 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,
         runtimeConfig: runtimeReview?.config,
@@ -579,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 ?? {}) } } : {}),
@@ -597,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,
@@ -705,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 });
@@ -714,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.
@@ -972,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
@@ -979,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

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.30",
+  "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": {