flowviant 0.125.1 → 0.125.3

package/bin/lib/workAgentTurnExecution.mjs

@@ -30,7 +30,7 @@ import { AGENT_TASK_KINDS, agentTaskKindOf, unknownAgentTaskKind } from './agent
 import { knowledgeDirFor } from './knowledgeFiles.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { canRun, runtimeById } from './runtimes.mjs';
-import { toolEventOf, CLAUDE_TOOL_PROSE_KINDS } from './runtimeEvents.mjs';
+import { toolEventOf, CLAUDE_TOOL_PROSE_KINDS, scrubNativeText } from './runtimeEvents.mjs';
 import { makeTraceRelay } from './trace.mjs';
 import { mcpJsonServerNamesAbove, readBaseTools, prepareAgentTools } from './projectTools.mjs';
 import { TURN_PROFILES } from './turnProfile.mjs';
@@ -47,8 +47,11 @@ import { agentBrowserHome } from './noWindowEnv.mjs';
 import { CLAUDE_SESSION_RE, RESUME_MARKERS } from './conversationIds.mjs';
 import { createDeliveryReporter } from './workDelivery.mjs';
 import { createLiveMessages } from './workLiveMessages.mjs';
+import { createOrchestrator } from './orchestrator.mjs';
+import { ORCHESTRATOR_CONTRACT } from './orchestratorPrompt.mjs';
 
 export function createAgentTurnExecution({
+  admit,
   agentRepositories,
   makeBrief,
   baseRef,
@@ -395,8 +398,12 @@ export function createAgentTurnExecution({
       agentId,
       turnId,
       post: postAgentTrace,
+      orchestrationVersion: job.orchestrationVersion,
       scrub: envScrub,
     });
+    // 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 (job.orchestrationVersion === 2) await trace.flush(1_000);
     /**
      * Prose the structured event will carry anyway, dropped so a read does
      * not render twice — but ONLY on a runtime whose stream reaches
@@ -470,7 +477,14 @@ export function createAgentTurnExecution({
     const artifactInstructions = getArtifactsAccepted()
       ? await artifacts.prepare?.({ placeDir: wt, before: artifactsBefore, agentId }) ?? '' : '';
     let projectTools = null;
+    let orchestrator = null;
     try {
+      const orchestrated = job.orchestrationVersion === 2;
+      if (orchestrated && posture === 'build' && ['claude', 'codex'].includes(rt)) {
+        orchestrator = await createOrchestrator({ turnId, runtime: rt, trace, admit,
+          notify: message => { if (rt === 'claude') run.live?.inject(message); },
+          taken: id => run.live?.onTaken(id) });
+      }
       // A turn reads the base ref afresh. Changes the agent has made to its
       // own worktree cannot silently change the next turn's tools.
       const sources = repositoryRun?.sources ?? [];
@@ -480,7 +494,10 @@ export function createAgentTurnExecution({
         const base = readBaseTools(other.repoRoot, other.baseRef);
         snapshot.instructions.push(...[...base.instructions, ...base.skillFiles].map((file) => ({ ...file, path: `repositories/${other.folder}/${file.path}` })));
       }
-      projectTools = prepareAgentTools(snapshot, rt, process.env, wt, { codexHome: codexAgentHome, turnServers: repositoryRun?.tool ? { card_repositories: repositoryRun.tool.config } : {} });
+      projectTools = prepareAgentTools(snapshot, rt, process.env, wt, { codexHome: codexAgentHome, turnServers: {
+        ...(repositoryRun?.tool ? { card_repositories: repositoryRun.tool.config } : {}),
+        ...(orchestrator ? { card_orchestrator: orchestrator.config } : {}),
+      } });
       const mountsProjectMcp = TURN_PROFILES[posture]?.projectMcp === true && (rt === 'claude' || rt === 'codex');
       // A fenced posture on a runner that ignores its own file there (Codex's
       // `--ignore-user-config`) takes the servers as `fencedMount` instead.
@@ -501,11 +518,14 @@ export function createAgentTurnExecution({
         unmounted: [...projectTools.mcpUnmounted.map((u) => ({ ...u, source: 'project' })), ...(fencedMount ? fencedMount.unmounted : [])],
       });
       const agentTurnArgs = {
-        ...(rt === 'claude' ? { liveMessages: (run.live = makeLiveMessages({
+        ...((rt === 'claude' || orchestrator) ? { liveMessages: (run.live = makeLiveMessages({
           scope: 'agent', turnId, cwd: wt, sessionMetaPath, interrupted: () => run.interrupted,
+          observe: message => orchestrator?.note(message),
+          ...(rt === 'codex' ? { nativeIds: () => null } : {}),
           format: async (followup) => {
+            orchestrator?.note(followup);
             const attached = followup.attachments?.length ? await fetchAgentFiles(wt, followup.attachments.map((file) => ({ ...file, from: 'message' }))) : { message: [], card: [] };
-            return AGENT_HUMAN_KICKOFF({ agentName: job.agentName, message: followup.body + (followup.libraryPrompt ?? ''),
+            return AGENT_HUMAN_KICKOFF({ agentName: job.agentName, message: followup.body + (followup.libraryPrompt ?? '') + (orchestrator ? `\nMessage id: ${followup.id}. Choose and report its route with card_orchestrator.route_message.` : ''),
               askedByName: followup.askedByName, task: job.task, cardThread: job.cardThread,
               investigationContext: job.investigationContext, researchContext: job.researchContext,
               messageFiles: attached.message, cardFiles: files.card, position: job.position ?? 1, total: job.total ?? 1 });
@@ -556,10 +576,11 @@ export function createAgentTurnExecution({
           // ARTIFACTS (0.94.0), while the server can show one — an agent's
           // land on its page, under the facts row.
           artifacts: getArtifactsAccepted(),
-        }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (projectTools.instructions ? `\n\n${projectTools.instructions}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : ''),
+        }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (projectTools.instructions ? `\n\n${projectTools.instructions}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : '') + (orchestrator ? `\n\n${ORCHESTRATOR_CONTRACT}` : ''),
         agentTools: projectTools,
         writableDirs: repositoryRun?.writableDirs,
-        ...((projectTools.codexHome || fencedMount || repositoryRun?.tool) ? { mcpEnv: { ...(projectTools.codexHome ? { CODEX_HOME: projectTools.codexHome } : {}), ...(fencedMount?.env ?? {}), ...(repositoryRun?.tool?.env ?? {}) } } : {}),
+        ...((projectTools.codexHome || fencedMount || repositoryRun?.tool || orchestrator) ? { mcpEnv: { ...(projectTools.codexHome ? { CODEX_HOME: projectTools.codexHome } : {}), ...(fencedMount?.env ?? {}), ...(repositoryRun?.tool?.env ?? {}), ...(orchestrator?.env ?? {}) } } : {}),
+        orchestration: Boolean(orchestrator),
         // NOBODY IS AT THIS SCREEN (2026-09-29): no display, BROWSER=none, and
         // a browser profile of the agent's own, kept beside its Codex home —
         // so a Chrome it starts to look at its page never reaches the
@@ -578,15 +599,20 @@ export function createAgentTurnExecution({
         // The kind's posture, as the one turn profile (turnProfile.mjs):
         // build for code, the fenced design/research postures otherwise.
         profile: posture,
+        cardTurn: Boolean(orchestrator),
+        onSubagent: (update) => orchestrator ? orchestrator.observe(update) : trace.agent(update),
+        onSpawnResult: result => orchestrator?.spawnResult(result),
         cwd: wt,
         runtime: rt,
         resume,
         resumeThreadId: codexResumeId || claudeResumeId || undefined,
         onInit: (init) => {
+          orchestrator?.root(init.sessionId);
           if (claudeMarker && CLAUDE_SESSION_RE.test(init.sessionId ?? ''))
             try { writeFileSync(claudeMarker, init.sessionId); } catch { /* best effort */ }
         },
         onThreadId: (id) => {
+          orchestrator?.root(id);
           seenThreadId = String(id ?? '').trim() || seenThreadId;
         },
         onAnswer: (t) => {
@@ -600,6 +626,20 @@ export function createAgentTurnExecution({
         // narrator keeps: overwritten, never appended, and ignored by the
         // board past ~90 seconds.
         onActivity: (a) => {
+          if (a?.agentId) {
+            // Tool labels are already clipped. Their structured, scrubbed
+            // twin below supplies Now without leaking a credential prefix.
+            if (doubledKinds?.has(a.kind)) return;
+            const body = scrubNativeText(a.full ?? a.label, 4_000, envScrub);
+            const kind = a.kind;
+            const step = id => {
+              trace.agent({ id, now: body });
+              if (kind === 'doing') trace.doing(id, body);
+              else trace.prose(kind, body, id);
+            };
+            if (orchestrator) orchestrator.attributed(a.agentId, step); else step(a.agentId);
+            return;
+          }
           brief?.append(a?.kind ?? 'activity', a?.full ?? a?.label);
           let line = a?.label;
           if (!line) return;
@@ -632,6 +672,19 @@ export function createAgentTurnExecution({
         // the builder itself (bounded window BEFORE its caps; see
         // toolEventOf). A tool it does not know pushes nothing.
         onToolEvent: (name, input, meta) => {
+          if (meta?.agentId) {
+            if (!meta.result) {
+              const event = toolEventOf(name, input, wt, envScrub);
+              const now = event?.c ? `$ ${event.c}` : event?.p ?? event?.q;
+              const step = id => {
+                if (now) trace.agent({ id, now });
+                trace.tool(event, id);
+                if (name === 'Bash' && now) trace.doing(id, now);
+              };
+              if (orchestrator) orchestrator.attributed(meta.agentId, step); else step(meta.agentId);
+            }
+            return;
+          }
           brief?.append(meta?.result ? 'tool result' : 'tool call', meta?.result
             ? { id: meta.id, exitCode: meta.exitCode, isError: meta.isError, output: meta.output }
             : { name, input });
@@ -660,6 +713,7 @@ export function createAgentTurnExecution({
         // (runTurn.mjs, `initHarvestFor`). An agent-only box learns from the
         // startup probe and its Terminal tabs.
         onSpawn: (ch) => {
+          if (orchestrator && rt === 'codex') run.live?.connect((id, body) => orchestrator.input(id, body));
           if (rt !== 'claude') reportDelivery('agent', job, 'taken');
           brief?.running(true);
           ch.once('close', () => { if (child === ch) brief?.running(false); });
@@ -732,6 +786,12 @@ export function createAgentTurnExecution({
         },
       });
     } finally {
+      // The loopback capability stays registered until every retained CLI
+      // answer is scrubbed; then it can leave the machine's secret set.
+      out = envScrub(out);
+      if (lastAnswer) lastAnswer = envScrub(lastAnswer);
+      await run.live?.stop();
+      await orchestrator?.close(run.interrupted);
       await brief?.stop();
       // What the CLI counted, for the lane's catch if anything below throws.
       measured.usage = usage;
@@ -749,7 +809,24 @@ export function createAgentTurnExecution({
        * uplink that will not answer costs the tail and nothing else.
        */
       trace.stop();
-      await trace.flush(TRACE_FINAL_FLUSH_MS);
+      // Trace reports remain turn-scoped and the API accepts their late tail.
+      // An interrupted process has already exited: a slow trace uplink must
+      // not delay its settlement or the queued prompt's continuation.
+      const tail = trace.flush(TRACE_FINAL_FLUSH_MS);
+      if (!setupController.signal.aborted) {
+        let releaseWait;
+        try {
+          // An interrupt may arrive after the CLI exited, while an ordinary
+          // final flush is already waiting. The same run cancellation signal
+          // releases that wait without cancelling the turn-scoped upload.
+          await Promise.race([tail, new Promise(resolve => {
+            releaseWait = () => resolve();
+            setupController.signal.addEventListener('abort', releaseWait, { once: true });
+          })]);
+        } finally {
+          setupController.signal.removeEventListener('abort', releaseWait);
+        }
+      }
       for (const ch of spawnedChildren) workChildren.delete(ch);
       if (agentChildren.get(place) === child) agentChildren.delete(place);
       if (ranMarker && rt === 'claude') {

package/bin/lib/workAgentTurnOutcome.mjs

@@ -6,7 +6,7 @@
  * that follow a CLI (a limit, no declared outcome, a missing artifact, the
  * parsed result) are one decision with its own rules — a limit only when the
  * turn declared nothing, an artifact kind delivered only once its file is
- * measured, every relayed string scrubbed BEFORE it is cut — and the run that
+ * measured, and every relayed string scrubbed without prose truncation — and the run that
  * feeds it (workAgentTurnExecution.mjs) changes for reasons none of those
  * rules share. Pure but for one read-only artifact scan, so each rule is a
  * unit test here instead of a source pin behind a CLI nobody spawns in tests.
@@ -55,7 +55,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
     return report({
       turnId,
       outcome: 'nothing',
-      answer: limit,
+      answer: readableOut.trim() === limit ? limit : `${limit}\n\n${envScrub(readableOut)}`,
       ...(usage ? { usage } : {}),
       branch,
       worktree: wt,
@@ -71,7 +71,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       // The CLI's own words when it produced any. A turn that explained why
       // it stopped is far more use than "the agent stopped".
       answer: raw.trim()
-        ? readable.trim() ? envScrub(readable).slice(-1500)
+        ? readable.trim() ? envScrub(readable)
           : 'The turn returned an unreadable outcome declaration. This work has not been delivered.'
         : 'the turn produced no output on the machine — its CLI may be signed out',
       ...(commits.length ? { commits } : {}),
@@ -120,8 +120,8 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
   const briefUse = /^Research intended use: (tasks|context|document)(?:\r?\n|$)/.exec(job.task?.brief ?? '')?.[1];
   const researchUse = kind.posture === 'research' ? briefUse ?? res.researchUse : null;
   const temporaryResearch = ['tasks', 'context'].includes(researchUse);
-  if (res.outcome === 'delivered' && temporaryResearch && (!res.answer?.trim() || res.answer.length > 7500)) {
-    return report({ turnId, outcome: 'nothing', answer: res.answer?.trim() ? 'Keep the research findings, sources and uncertainties within 7500 characters so the full answer can be retained.' : 'The research turn returned no findings.', branch, worktree: wt });
+  if (res.outcome === 'delivered' && temporaryResearch && !res.answer?.trim()) {
+    return report({ turnId, outcome: 'nothing', answer: 'The research turn returned no findings.', branch, worktree: wt });
   }
   if (res.outcome === 'delivered' && kind.artifact && !temporaryResearch) {
     const want = kind.artifact.match;
@@ -154,7 +154,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       ...(prerequisite && !cannotRequest ? { prerequisite } : {}),
       outcome: res.outcome,
       answer: cannotRequest ?? envScrub(kind.posture === 'research' && researchUse
-        ? `Research intended use: ${researchUse}\n\n${res.answer ?? ''}` : res.answer ?? '').slice(0, 8000),
+        ? `Research intended use: ${researchUse}\n\n${res.answer ?? ''}` : res.answer ?? ''),
       ...(commits.length ? { commits } : {}),
       // SCRUBBED like the answer beside it: a raised card lands in the
       // project doc every member reads, and a brief quoting the `.env` the
@@ -164,7 +164,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
         ? {
             raised: res.raised.map((r) => ({
               title: envScrub(r.title).slice(0, 300),
-              ...(r.brief ? { brief: envScrub(r.brief).slice(0, 2000) } : {}),
+              ...(r.brief ? { brief: envScrub(r.brief) } : {}),
             })),
           }
         : {}),
@@ -228,7 +228,7 @@ export function failedTurnSettlement({ turnId, error, commits = [], usage = null
     outcome: 'nothing',
     answer: envScrub(
       why ? `This machine could not finish the turn: ${why}` : 'This machine could not finish the turn.'
-    ).slice(0, 1500),
+    ),
     ...(commits.length ? { commits } : {}),
     ...(usage ? { usage } : {}),
     ...(model ? { model } : {}),

package/bin/lib/workAgentTurns.mjs

@@ -112,6 +112,7 @@ export function createWorkAgentTurns({
   const stoppedFor = new Map(); // agentId -> when
 
   const { runAgentTurnInPlace, commitsBetween } = createAgentTurnExecution({
+    admit,
     agentRepositories,
     makeBrief,
     baseRef,
@@ -415,6 +416,7 @@ export function createWorkAgentTurns({
       const run = agentRuns.get(id);
       if (run) {
         if (!run.interrupted) note(`${c.cyan('agent')} ${c.dim('— interrupting the running turn')}`);
+        if (!run.interrupted) reportDelivery('agent', { id }, 'interrupting');
         run.interrupted = true;
         run.abortSetup?.();
         const child = agentChildren.get(run.place);

package/bin/lib/workChildren.mjs

@@ -3,6 +3,10 @@
  * to, the teardown that SIGTERMs them, the count the concurrency ceiling is
  * on, and the admission built over that count.
  *
+ * This manager is project-scoped. Native card children hold reservations in
+ * the same admission while live (orchestrator.mjs); other projects have their
+ * own pool, per the owner's 2026-10-15 ruling.
+ *
  * Split out of work.mjs (2026-09-26, SOLID F037). Six lanes write
  * `workChildren` (tab turns, agent turns, plans, the check, the pre-review)
  * and three things read it (teardown, `liveTurnCount`, the machine snapshot's

package/bin/lib/workLiveMessages.mjs

@@ -9,7 +9,7 @@ import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
 import { DAEMON_INSTANCE, FLEET_URL } from './config.mjs';
 import { messageIdsForSession } from './claudeSessions.mjs';
 
-export function createLiveMessages({ scope, turnId, attempt, cwd, sessionMetaPath, format, interrupted = () => false,
+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 file = sessionMetaPath(cwd, 'flowviant-live-messages', turnId);
@@ -73,6 +73,7 @@ export function createLiveMessages({ scope, turnId, attempt, cwd, sessionMetaPat
       if (!result.json?.data?.active) return;
       const seen = sessionId ? nativeIds(cwd, sessionId) : null;
       for (const message of result.json.data.messages ?? []) {
+        observe(message);
         if (stopped || interrupted()) break;
         if (taken.has(message.id) || seen?.has(message.id)) { onTaken(message.id); continue; }
         if (sent.has(message.id)) continue;
@@ -83,6 +84,11 @@ export function createLiveMessages({ scope, turnId, attempt, cwd, sessionMetaPat
     return flight;
   };
   return {
+    inject(prompt) {
+      if (stopped || interrupted() || !send) return false;
+      const id = randomUUID(); initialIds.add(id);
+      return send(id, prompt) === true;
+    },
     turnId, onTaken, tick,
     connected: () => Boolean(send) && !stopped,
     get initialId() { return initialId; },

package/bin/lib/workSessionTurns.mjs

@@ -41,7 +41,7 @@ import { AGY_CONV_RE, CLAUDE_SESSION_RE, CODEX_THREAD_RE, RESUME_MARKERS } from
 import { sessionTurnKickoff, sessionTurnShape, sessionTurnSystem } from './workTurnShape.mjs';
 import { createToolLog } from './workToolLog.mjs';
 import { createCommandAudit } from './workCommandAudit.mjs';
-import { APPROVAL_REFUSED, codexApprovalSentence, codexLoginFailure, codexLoginSentence, SESSION_ANSWER_MAX, withRelay } from './codexRelay.mjs';
+import { APPROVAL_REFUSED, codexApprovalSentence, codexLoginFailure, codexLoginSentence, withRelay } from './codexRelay.mjs';
 
 /**
  * HOW LONG, AND HOW MANY, SETTLED TURNS THE LANE REMEMBERS (2026-09-29) — see
@@ -1035,7 +1035,7 @@ export function createWorkSessionTurns({
                 ? refusedLine
                   ? withRelay(refusedLine, answer)
                   : // Scrub: a reply can quote config or env-adjacent code.
-                    envScrub(answer).slice(0, SESSION_ANSWER_MAX)
+                    envScrub(answer)
                 : (refusedLine ?? noWords),
             // Only a turn that actually SPOKE proves a conversation lives
             // here. Recording the path unconditionally is how a crashed first
@@ -1062,7 +1062,7 @@ export function createWorkSessionTurns({
             // Scrub, like every string that leaves this machine: an exception
             // routinely quotes command output, and command output can quote a
             // synced secret.
-            answer: envScrub(String(e?.message ?? 'the session turn failed')).slice(0, 2000),
+            answer: envScrub(String(e?.message ?? 'the session turn failed')),
             // "What did it do before it failed" is exactly the question a
             // crashed turn's log answers, and a turn that threw after its CLI
             // ran still spent what it spent — the main settle's own spread.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "flowviant",
-  "version": "0.125.1",
-  "description": "Run your own coding CLIs as build agents for Flowviant — Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
+  "version": "0.125.3",
+  "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": {
     "flowviant": "bin/cli.mjs"