flowviant 0.125.1 → 0.125.3

package/README.md

@@ -223,5 +223,8 @@ this package version, builds, attests and attaches the binaries and manifest.
 R2 publication remains opt-in through `PUBLISH_R2` and the `r2` environment.
 For a manual upload run `sh cli/scripts/upload-binaries.sh` from the root; it
 checks all four binaries against the manifest and publishes `latest.json` last.
-`(cd cli && npm publish)` retains the prepublish parity gate and npm shrinkwrap.
+`(cd cli && npm exec --yes --package=npm@11.17.0 -- npm publish)` retains
+the prepublish parity gate and includes the npm shrinkwrap. The publisher is
+pinned because [npm 12 removed shrinkwrap support](https://github.com/npm/cli/blob/latest/docs/lib/content/configuring-npm/package-lock-json.md#npm-shrinkwrapjson)
+and omits it from tarballs; npm 12 consumers also ignore that lockfile.
 No sibling repository or separate app deploy key is required.

package/bin/cli.mjs

@@ -80,6 +80,11 @@
 // answered here before anything else loads: no config, no update check, no
 // output but the hook's. An unknown hook exits 2, which Claude Code reads as a
 // refusal — the read guard's own rule for a hook that cannot judge.
+if (process.argv[2] === '__orchestrator-mcp') {
+  await (await import('./lib/orchestratorClient.mjs')).orchestratorMcpMain();
+  process.exit(process.exitCode ?? 0);
+}
+
 if (['__repository', '__repository-mcp'].includes(process.argv[2])) {
   await (await import('./lib/repositoryTool.mjs')).repositoryToolMain(process.argv[2] === '__repository-mcp');
   process.exit(process.exitCode ?? 0);
@@ -89,12 +94,17 @@ if (process.argv[2] === '__hook') {
   const HOOKS = {
     'read-guard': () => import('./lib/hooks/readGuard.mjs'),
     'mcp-allow': () => import('./lib/hooks/mcpAllow.mjs'),
+    'orchestrator': () => import('./lib/hooks/orchestrator.mjs'),
   };
   const load = Object.hasOwn(HOOKS, process.argv[3] ?? '') ? HOOKS[process.argv[3]] : null;
   if (!load) {
     process.stderr.write(`flowviant: no hook named '${String(process.argv[3] ?? '').slice(0, 40)}'\n`);
     process.exit(2);
   }
+  if (process.argv[3] === 'orchestrator') {
+    await (await load()).main();
+    process.exit(process.exitCode ?? 0);
+  }
   (await load()).main();
   // The hook ends the process itself, on its verdict.
   await new Promise(() => {});

package/bin/lib/agentAsk.mjs

@@ -21,7 +21,7 @@
  * would alter what the agent declared, the fence's own rule), and the
  * question goes through as plain text, exactly as it did before options
  * existed. So does a question too long for a fence, one that already carries
- * a fence of its own, or an answer the fence would push past the wire's cut.
+ * a fence of its own. Chat prose itself has no character allowance.
  *
  * STRICTER THAN THE PAGE, NEVER LOOSER. `ASK_BOUNDS` is the shared one (the
  * release gate, check-app-parity.mjs, compares them). `ASK_HOSTILE` is a
@@ -30,7 +30,6 @@
  * Refusing a label the page would have taken costs only the tiles.
  */
 
-import { scrubCut } from './uplinkScrub.mjs';
 
 /** The fence's bounds — the shared `ASK_BOUNDS`, key for key. */
 export const ASK_BOUNDS = Object.freeze({
@@ -52,10 +51,6 @@ const QUESTION_HOSTILE = new RegExp(`[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u00
 /** A fence already in the question, anchored as the page's reader anchors. */
 const HAS_FENCE = /^```[ \t]*flowviant-ask/m;
 
-/** The cut the turn's answer gets on its way to the wire
- *  (`workAgentTurnOutcome.mjs`): a fence past it would arrive broken. */
-export const ASK_ANSWER_MAX = 8000;
-
 /** One field, trimmed — or null when it is empty, oversize or hostile. */
 const line = (v, max) => {
   if (typeof v !== 'string') return null;
@@ -96,17 +91,16 @@ export function declaredOptions(raw, scrub = (s) => s) {
  * "a short heading over body-size context"). The blocked shape's optional
  * `context` — what the decision settles, findings, evidence — is written as
  * prose before the question, so the page draws the fence's one-line
- * `question` as the heading and this beneath it at body size. Scrubbed, then
- * cut at the wire's cap; one that carries a fence of its own declares nothing
- * and is written as the plain text it is.
+ * `question` as the heading and this beneath it at body size. Scrubbed whole;
+ * a context carrying its own fence keeps its prose without new choice tiles.
  */
 const contextOf = (v, scrub) => {
   if (typeof v?.context !== 'string') return '';
-  return scrubCut(v.context.trim(), ASK_ANSWER_MAX, scrub).trim();
+  return scrub(v.context.trim()).trim();
 };
 
 /**
- * THE ANSWER A BLOCKED TURN HANDS ON: `question` (already scrubbed and cut),
+ * THE ANSWER A BLOCKED TURN HANDS ON: `question` (already scrubbed),
  * after its `context` when there is one, then the fence built from
  * `v.options` and `v.multiSelect` when every rule above holds.
  */
@@ -119,5 +113,5 @@ export function blockedAnswer(question, v, scrub = (s) => s) {
   if (!q || q.length > ASK_BOUNDS.question || QUESTION_HOSTILE.test(q) || HAS_FENCE.test(prose)) return prose;
   const ask = { question: q, options, ...(v.multiSelect === true ? { multiSelect: true } : {}) };
   const answer = `${prose}\n\n\`\`\`flowviant-ask\n${JSON.stringify(ask)}\n\`\`\``;
-  return answer.length <= ASK_ANSWER_MAX ? answer : prose;
+  return answer;
 }

package/bin/lib/agentCards.mjs

@@ -37,31 +37,8 @@
  */
 
 import { appendFileSync, readFileSync } from 'node:fs';
-import { CARD_THREAD_RENDER_MAX } from './cardThread.mjs';
-import { CARD_FILES_RENDER_MAX } from './agentFiles.mjs';
-
-/**
- * How many card specs one agent may accumulate.
- *
- * A bound on a MACHINE — an agent's queue is a handful of cards, and this exists
- * so a pathological agent (a card re-delivered fifty times, an agent grown past
- * its budget) cannot turn a prompt into a file read. The NEWEST are kept, which
- * is the same tail-is-what-matters rule the trace keeps.
- */
-export const MAX_STASHED_CARDS = 40;
-/** The most one spec may contribute. A brief is written by whoever filed the
- *  card and the server caps it, but this file is composed into a prompt and a
- *  bound it owns is a bound that cannot be argued away upstream.
- *
- *  8,000 is the record's brief ceiling; since 0.106.0 the spec also carries
- *  the card's discussion, so the bound grows by the most a turn's discussion
- *  can render to (`CARD_THREAD_RENDER_MAX`). The discussion is printed LAST,
- *  and a stash that cut it would hand the pre-review a thread missing its
- *  newest words — the ones the agent read most recently. Since 0.112.0 the
- *  files on that discussion follow it (`CARD_FILES_RENDER_MAX`), and a cut
- *  there would hand the pre-review a card missing the screenshot its agent
- *  was shown. */
-export const MAX_SPEC_CHARS = 8_000 + CARD_THREAD_RENDER_MAX + CARD_FILES_RENDER_MAX;
+// Specs have no character or card-count allowance. Filesystem read/write
+// failures remain explicit missing-spec evidence for the optional precheck.
 
 /**
  * Write down the spec this turn is about to hand the agent.
@@ -83,7 +60,7 @@ export function stashCard(path, taskId, spec) {
   try {
     appendFileSync(
       path,
-      JSON.stringify({ taskId: id.slice(0, 64), prompt: text.slice(0, MAX_SPEC_CHARS) }) + '\n'
+      JSON.stringify({ taskId: id.slice(0, 64), prompt: text }) + '\n'
     );
     return true;
   } catch {
@@ -124,10 +101,8 @@ export function readStash(path) {
     const taskId = typeof v.taskId === 'string' ? v.taskId.trim() : '';
     const prompt = typeof v.prompt === 'string' ? v.prompt : '';
     if (!taskId || !prompt.trim()) continue;
-    byId.set(taskId, prompt.slice(0, MAX_SPEC_CHARS));
+    byId.set(taskId, prompt);
   }
   const all = [...byId].map(([taskId, prompt]) => ({ taskId, prompt }));
-  // The NEWEST cards when there are too many — a reviewer reading a grown
-  // agent's branch is reading the work at its end.
-  return all.slice(-MAX_STASHED_CARDS);
+  return all;
 }

package/bin/lib/agentFiles.mjs

@@ -38,7 +38,7 @@ export const AGENT_FILE_LINE_MAX = 160;
 
 /**
  * THE MOST THE CARD'S FILES CAN ADD TO A CARD SPEC, rendered — so the spec
- * stash (agentCards.mjs `MAX_SPEC_CHARS`) holds the note whole beside the
+ * stash (agentCards.mjs) holds the note whole beside the
  * discussion, and the pre-review is handed the files the agent was. A header
  * line and its blank line, then one line per file. `agentFiles.test.mjs`
  * renders the worst case against it.

package/bin/lib/agentFootprint.mjs

@@ -52,20 +52,20 @@ export function measureAgentFootprint({ placeId, baseDir, baseRef, readGit = git
   return result;
 }
 
-/** Card prose stays bounded and inside the kickoff's untrusted fence. */
+/** Complete card requirements stay scrubbed inside the kickoff's untrusted fence. */
 export function liveAgentContext(agent, footprint) {
   const text = (value, cap) => scrubCut(typeof value === 'string' ? value : '', cap);
   const count = value => typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.min(1_000_000, Math.floor(value))) : 0;
-  const ids = value => (Array.isArray(value) ? value : []).filter(id => typeof id === 'string' && id.length > 0 && id.length <= 64).slice(0, 100);
+  const ids = value => (Array.isArray(value) ? value : []).filter(id => typeof id === 'string' && id.length > 0 && id.length <= 64);
   const intended = agent?.intendedWork;
   return {
     id: text(agent?.id, 64), name: text(agent?.name, 80), status: text(agent?.status, 40),
     taskIds: ids(agent?.taskIds), changedFiles: footprint,
     intendedWork: intended && Array.isArray(intended.tasks) ? {
       taskIds: ids(intended.taskIds),
-      tasks: intended.tasks.slice(0, 20).filter(t => t && typeof t.id === 'string' && t.id.length <= 64 && ['queued', 'running'].includes(t.state)).map(t => ({
-        id: t.id, state: t.state, taskKind: agentTaskKindOf(t.taskKind), ...(agentTaskTypeFor(t) ? { taskType: agentTaskTypeFor(t) } : {}), truncated: t.truncated === true || (typeof t.brief === 'string' && t.brief.length > 1000) || (Array.isArray(t.criteria) && t.criteria.length > 8) || (Array.isArray(t.anchors) && t.anchors.length > 20), title: text(t.title, 300), brief: text(t.brief, 1000),
-        criteria: (Array.isArray(t.criteria) ? t.criteria : []).slice(0, 8).map(x => text(x, 300)),
+      tasks: intended.tasks.filter(t => t && typeof t.id === 'string' && t.id.length <= 64 && ['queued', 'running'].includes(t.state)).map(t => ({
+        id: t.id, state: t.state, taskKind: agentTaskKindOf(t.taskKind), ...(agentTaskTypeFor(t) ? { taskType: agentTaskTypeFor(t) } : {}), truncated: t.truncated === true, title: text(t.title, 300), brief: typeof t.brief === 'string' ? scrub(t.brief) : '',
+        criteria: (Array.isArray(t.criteria) ? t.criteria : []).filter(x => typeof x === 'string').map(x => scrub(x)),
         anchors: (Array.isArray(t.anchors) ? t.anchors : []).slice(0, 20).map(x => text(x, 200)),
       })),
       omitted: count(intended.omitted),

package/bin/lib/agentPlan.mjs

@@ -19,8 +19,8 @@
  * nobody can accept, and `null` — which the caller reports in the machine's own
  * words — beats rendering an empty board with an Accept button on it.
  *
- * Every string is CAPPED here rather than downstream. This text is model
- * output about untrusted card content, and it becomes a row.
+ * Structured proposal fields keep their existing shape bounds. Chat prose
+ * stays complete; native transport/storage refusals never shorten its tail.
  *
  * Run: node --test bin/lib/agentPlan.test.mjs
  */
@@ -71,9 +71,8 @@ const MAX_NOTE = 1000;
  * the machine moved: no poll, no lease renewal, no other lane. Three bounds,
  * none of which a real answer comes near:
  *
- *  · only the LAST `MAX_SCAN_CHARS` are scanned — every contract here puts the
- *    object LAST, and the fenced block is still looked for in the whole text,
- *    by a LINEAR scan (`fencedBody`) since 2026-10-10;
+ *  · top-level objects are scanned whole, including long un-fenced replies;
+ *    `fencedBody` and the brace scan are linear, with no prose-length slice;
  *  · each `{`'s closing brace is found ONCE (see `closers`), so the scan is a
  *    single right-to-left pass instead of one walk per brace;
  *  · only spans that can open an object (`{` then a key or `}`) are handed to
@@ -90,13 +89,12 @@ const MAX_NOTE = 1000;
  * delivered agent went to Stuck. The contract puts the answer LAST and at the
  * top level, which is the one span a budget must never cost.
  */
-const MAX_SCAN_CHARS = 256 * 1024;
 const MAX_NESTED_PARSES = 200;
 const MAX_NESTED_CHARS = 4 * 1024 * 1024;
 
 export function candidateObjects(text) {
   const fenced = fencedBody(text);
-  const raw = text.length > MAX_SCAN_CHARS ? text.slice(text.length - MAX_SCAN_CHARS) : text;
+  const raw = text;
   const bodies = [];
   if (fenced !== null) bodies.push(fenced);
   const close = closers(raw);
@@ -135,8 +133,7 @@ export function candidateObjects(text) {
  * `text.match(/```(?:json)?\s*([\s\S]*?)```/)[1]` answered, found in ONE
  * forward pass (2026-10-10, the audit's F079).
  *
- * That regex ran over the WHOLE text — the only search the `MAX_SCAN_CHARS`
- * bound above skipped — and it backtracks quadratically on an opening fence
+ * That regex ran over the WHOLE text and backtracks quadratically on an opening fence
  * followed by a long whitespace run with no closing fence: the greedy `\s*` and
  * the lazy body re-scan the run from every split. Measured: 80 KB took 0.6 s,
  * 320 KB nine seconds, of synchronous CPU in which no poll, lease or other
@@ -144,7 +141,7 @@ export function candidateObjects(text) {
  * answer, by `indexOf`: the first ``` anywhere, an optional `json`, the
  * whitespace after it skipped, and the body runs to the next ```. If that
  * opening has no closer, no later opening can have one either, so there is no
- * fence. The search stays over the whole text, as the bound above promises.
+ * fence. The search stays over the whole text.
  */
 const FENCE_SPACE = /\s*/y;
 function fencedBody(text) {
@@ -323,18 +320,10 @@ function uniqueTempIds(list) {
  * sent instead would be indistinguishable from an agent saying the branch now
  * amounts to nothing.
  *
- * AN ABSURDITY BOUND HERE, NOT THE DISPLAY CAP (corrected 2026-09-22, in
- * review). This sliced to the wire's own 1000 first, which quietly INVERTED the
- * order the caller's own comment claims to keep: `envScrub` replaces EXACT
- * values, so handing it a paragraph already cut at 1000 hands it a credential
- * cut in half — it matches nothing and the surviving prefix ships. The scrub is
- * the only thing standing between a model that pasted a secret into its own
- * summary and the wire, and a cap must never run ahead of it. So this is the
- * same absurdity bound `summary` takes one line up (8000): enough that nothing
- * a model writes reaches the caller unbounded, far enough above the 1000 the
- * wire cuts to that the scrub always sees whole values. `workAgentTurns.mjs` scrubs and
- * THEN cuts to 1000, and the server clamps again because the wire never trusts
- * a machine to have clamped.
+ * The running branch account is a separate, short display readout, not the
+ * chat answer. Its existing display policy stays below; the reply parser
+ * preserves summaries and blocked-question prose whole. Scrub this entire
+ * account before its display slice so a credential cannot straddle the cut.
  */
 const MAX_PROGRESS = 8000;
 const progressOf = (v, scrub) => {
@@ -405,8 +394,8 @@ export function parseTurnResult(text, scrub = envScrub) {
       const r = v.prerequisite;
       if (!r || typeof r.title !== 'string' || !r.title.trim() || typeof r.brief !== 'string' || !r.brief.trim()
         || typeof r.taskKind !== 'string' || !Object.hasOwn(AGENT_TASK_KINDS, r.taskKind)) continue;
-      return { outcome: 'question', answer: typeof v.summary === 'string' ? clean(v.summary, 8000) : 'Requested a prerequisite card.',
-        ...progressOf(v, scrub), prerequisite: { title: clean(r.title.trim(), 300), brief: clean(r.brief.trim(), 2000), taskKind: r.taskKind } };
+      return { outcome: 'question', answer: typeof v.summary === 'string' ? scrub(v.summary) : 'Requested a prerequisite card.',
+        ...progressOf(v, scrub), prerequisite: { title: clean(r.title.trim(), 300), brief: scrub(r.brief.trim()), taskKind: r.taskKind } };
     }
     if (v.status === 'blocked') {
       const question = typeof v.question === 'string' ? v.question.trim() : '';
@@ -417,7 +406,7 @@ export function parseTurnResult(text, scrub = envScrub) {
       // Its declared choices (2026-10-13) ride on as the one fence the page
       // reads, built here (agentAsk.mjs); malformed ones leave the question
       // as plain text.
-      return { outcome: 'question', answer: blockedAnswer(clean(question, 8000), v, scrub), ...progressOf(v, scrub) };
+      return { outcome: 'question', answer: blockedAnswer(scrub(question), v, scrub), ...progressOf(v, scrub) };
     }
     if (v.status === 'delivered') {
       return {
@@ -426,7 +415,7 @@ export function parseTurnResult(text, scrub = envScrub) {
         ...(Array.isArray(v.mergeOrder) ? { mergeOrder: v.mergeOrder.filter((id) => typeof id === 'string').slice(0, 64) } : {}),
         ...(typeof v.mergeOrderReason === 'string' ? { mergeOrderReason: clean(v.mergeOrderReason, 1000) } : {}),
         ...(Array.isArray(v.mergeOrders) ? { mergeOrders: v.mergeOrders.slice(0, 60) } : {}),
-        answer: typeof v.summary === 'string' ? clean(v.summary, 8000) : '',
+        answer: typeof v.summary === 'string' ? scrub(v.summary) : '',
         ...progressOf(v, scrub),
         raised: Array.isArray(v.raised)
           ? v.raised
@@ -435,7 +424,7 @@ export function parseTurnResult(text, scrub = envScrub) {
               .map((r) => ({
                 title: clean(r.title.trim(), 300),
                 ...(typeof r.brief === 'string' && r.brief.trim()
-                  ? { brief: clean(r.brief.trim(), 2000) }
+                  ? { brief: scrub(r.brief.trim()) }
                   : {}),
               }))
           : [],

package/bin/lib/cardThread.mjs

@@ -42,7 +42,7 @@ const OMITTED_MAX = 1_000_000;
 
 /**
  * THE MOST ONE TURN'S DISCUSSION CAN ADD TO A CARD SPEC, rendered — so the
- * spec stash (agentCards.mjs `MAX_SPEC_CHARS`) can hold a card with its
+ * complete spec stash (agentCards.mjs) can hold a card with its
  * discussion whole, and the pre-review reads what the agent read. The text is
  * at most `chars`; the renderer adds at most two characters and a newline per
  * text line (<= 3x the text), a header line per entry, and two lines of its

package/bin/lib/claudeStream.mjs

@@ -79,7 +79,8 @@ export function usageFromResult(ev) {
 // container that reports no spend, which is indistinguishable from an older
 // daemon by design. A callback that is silent when it breaks has to be called
 // directly by something.
-export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit, onUsage, onRateLimit, onModel }) {
+export function handleStreamLine(line, options) {
+  const { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit, onUsage, onRateLimit, onModel, subagents } = options;
   let ev;
   try {
     ev = JSON.parse(line);
@@ -88,10 +89,19 @@ export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, app
     emit(line + '\n');
     return;
   }
+  if (ev.type === 'progress' && ev.data?.type === 'agent_progress' && ev.parentToolUseID && ev.data.message) {
+    subagents?.link(ev.data.agentId, ev.parentToolUseID);
+    return handleStreamLine(JSON.stringify({ ...ev.data.message, parent_tool_use_id: ev.parentToolUseID }), options);
+  }
+  const agentId = subagents ? subagents.identify(ev) : ev.parent_tool_use_id ?? (ev.isSidechain ? ev.agentId ?? ev.agent_id ?? ev.sessionId : undefined);
+  if (subagents && !subagents.accept(ev, agentId)) return;
+  // A sidechain with no identity must never be attributed to the parent.
+  if (ev.isSidechain && !agentId) return;
+  subagents?.observe(ev);
   const push = (a) => {
     if (!a || !a.label) return;
     emit(a.label + '\n');
-    onActivity?.(a);
+    onActivity?.({ ...a, ...(agentId ? { agentId } : {}) });
   };
   if (ev.type === 'stream_event') {
     // Partial messages announce reasoning before the completed assistant
@@ -106,7 +116,7 @@ export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, app
     // THE MODEL THAT ANSWERED (2026-09-29, turnModel.mjs) — the fallback for an
     // init that named none. The turn's own messages only: a subagent's carry
     // `parent_tool_use_id`, and its model is not the turn's.
-    if (ev.parent_tool_use_id == null) {
+    if (!agentId) {
       const answered = turnModelOf(ev.message.model);
       if (answered) onModel?.(answered);
     }
@@ -138,7 +148,7 @@ export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, app
             : { kind: 'think', label: THINK_MARKER }
         );
       } else if (b.type === 'text' && b.text?.trim()) {
-        if (!answerFromResult) appendText(b.text + '\n');
+        if (!answerFromResult && !agentId) appendText(b.text + '\n');
         // `label` for the console and the pulse — one collapsed 160-char line,
         // byte-identical to what it has always printed. `full` for the trace:
         // a `say` is the agent NARRATING, several sentences at a time, and the
@@ -150,18 +160,19 @@ export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, app
         // The STRUCTURED form of the same event, for the transcript's tool
         // cards — raw name + input, so the collector can keep what the
         // one-line humanizer drops (an Edit's counts, the plan's items).
-        onToolEvent?.(b.name, b.input || {}, { id: b.id });
+        onToolEvent?.(b.name, b.input || {}, { id: b.id, ...(agentId ? { agentId } : {}) });
       }
     }
   } else if (ev.type === 'user' && Array.isArray(ev.message?.content)) {
     for (const b of ev.message.content) {
       if (b.type === 'tool_result') onToolEvent?.(null, {}, {
         id: b.tool_use_id, result: true, isError: b.is_error === true,
+        ...(agentId ? { agentId } : {}),
         output: typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.slice(0, 8).filter(x => x?.type === 'text' && typeof x.text === 'string').map(x => x.text).join('\n') : '',
         exitCode: ev.tool_use_result?.exit_code ?? ev.tool_use_result?.exitCode,
       });
     }
-  } else if (ev.type === 'system' && ev.subtype === 'init') {
+  } else if (ev.type === 'system' && ev.subtype === 'init' && !agentId) {
     // WHAT THIS MACHINE'S CLI CAN BE ASKED FOR BY NAME. The init event is the
     // CLI's OWN answer — it has already resolved personal skills, this repo's
     // skills, plugins and whatever the project settings enable or disable — so
@@ -197,7 +208,7 @@ export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, app
         tools: Array.isArray(ev.tools) ? ev.tools : undefined,
       });
     }
-  } else if (ev.type === 'result') {
+  } else if (ev.type === 'result' && !agentId) {
     /**
      * WHAT THE TURN SPENT, BEFORE ANYTHING ELSE IN THIS BRANCH.
      *

package/bin/lib/claudeSubagentProgress.mjs

@@ -0,0 +1,62 @@
+/** Claude persists agent_progress with the spawning parentToolUseID even
+ * when print-mode stdout carries only the parent. Follow this session alone. */
+import { open } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { claudeProjectDir } from './claudeSessions.mjs';
+import { CLAUDE_SESSION_RE } from './conversationIds.mjs';
+
+const MAX_READ = 4 * 1024 * 1024;
+const LINE_MAX = 256 * 1024;
+export function createClaudeSubagentProgress({ cwd, since = Date.now(), env = process.env, onLine }) {
+  let file, offset = null, rest = Buffer.alloc(0), skip = false, timer;
+  let chain = Promise.resolve();
+  const flush = () => {
+    chain = chain.then(async () => {
+      if (!file) return;
+      let fh;
+      try {
+        fh = await open(file, 'r');
+        const { size } = await fh.stat();
+        if (offset === null) { offset = Math.max(0, size - MAX_READ); skip = offset > 0; }
+        if (size < offset) { offset = 0; rest = Buffer.alloc(0); }
+        const end = Math.min(size, offset + MAX_READ);
+        while (offset < end) {
+          const buf = Buffer.alloc(Math.min(LINE_MAX, end - offset));
+          const { bytesRead } = await fh.read(buf, 0, buf.length, offset);
+          if (!bytesRead) break;
+          offset += bytesRead;
+          const data = Buffer.concat([rest, buf.subarray(0, bytesRead)]);
+          let start = 0, nl;
+          while ((nl = data.indexOf(10, start)) >= 0) {
+            const line = data.subarray(start, nl).toString('utf8'); start = nl + 1;
+            if (skip) { skip = false; continue; }
+            try {
+              const ev = JSON.parse(line);
+              if (ev.type !== 'progress' || ev.data?.type !== 'agent_progress' || !ev.parentToolUseID) continue;
+              const at = Date.parse(ev.timestamp ?? '');
+              if (!Number.isFinite(at) || at < since) continue;
+              onLine(line);
+            } catch { /* torn or unknown native row */ }
+          }
+          rest = data.subarray(start);
+          if (rest.length > LINE_MAX) { rest = Buffer.alloc(0); skip = true; }
+        }
+      } catch { /* the transcript can appear after init */ }
+      finally { await fh?.close().catch(() => {}); }
+    }).catch(() => {});
+    return chain;
+  };
+  return {
+    session(id) {
+      if (file || !CLAUDE_SESSION_RE.test(id ?? '')) return;
+      let actualCwd = cwd;
+      try { actualCwd = realpathSync(cwd); } catch { /* missing directory */ }
+      file = join(env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'projects', claudeProjectDir(actualCwd), `${id}.jsonl`);
+      timer = setInterval(() => void flush(), 1_000); timer.unref?.();
+    },
+    flush,
+    async stop() { clearInterval(timer); await flush(); },
+  };
+}

package/bin/lib/claudeSubagents.mjs

@@ -0,0 +1,77 @@
+/** Native tool-use ids are stable for the lifetime of an Agent/Task call. */
+export function createClaudeSubagents(report = () => {}) {
+  const calls = new Map();
+  const aliases = new Map();
+  const questions = new Map();
+  const seen = new Set();
+  const identify = ev => ev.parent_tool_use_id != null
+    ? aliases.get(ev.parent_tool_use_id) ?? ev.parent_tool_use_id
+    : ev.isSidechain ? aliases.get(ev.agentId ?? ev.agent_id ?? ev.sessionId) : undefined;
+  return {
+    identify,
+    link(nativeId, callId) {
+      if (nativeId && callId) {
+        const id = aliases.get(callId) ?? callId;
+        aliases.set(nativeId, id);
+        report({ id, nativeId });
+      }
+      if (aliases.size > 256) aliases.delete(aliases.keys().next().value);
+    },
+    accept(ev, id) {
+      if (!id || !ev.uuid) return true;
+      const key = `${id}:${ev.uuid}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      if (seen.size > 800) seen.delete(seen.values().next().value);
+      return true;
+    },
+    observe(ev) {
+      const agentId = identify(ev);
+      if (ev.type === 'assistant') {
+        for (const b of ev.message?.content ?? []) {
+          if (b.type === 'tool_use' && b.name === 'AskUserQuestion' && agentId) {
+            questions.set(b.id, agentId);
+            if (questions.size > 128) questions.delete(questions.keys().next().value);
+            report({ id: agentId, status: 'asked' });
+          }
+          if (b.type !== 'tool_use' || !['Agent', 'Task'].includes(b.name) || !b.id) continue;
+          const input = b.input ?? {};
+          const id = aliases.get(input.resume) ?? b.id;
+          calls.set(b.id, { id, input });
+          aliases.set(b.id, id);
+          if (calls.size > 128) calls.delete(calls.keys().next().value);
+          if (aliases.size > 256) aliases.delete(aliases.keys().next().value);
+          report({ id, kind: input.subagent_type ?? '', title: input.description ?? input.name ?? '',
+            brief: input.prompt ?? '', status: 'running', now: input.description ?? '' });
+        }
+      }
+      if (ev.type === 'user') {
+        for (const b of ev.message?.content ?? []) {
+          if (questions.has(b.tool_use_id)) {
+            report({ id: questions.get(b.tool_use_id), status: 'running' });
+            questions.delete(b.tool_use_id);
+          }
+          if (b.type !== 'tool_result' || !calls.has(b.tool_use_id)) continue;
+          const id = calls.get(b.tool_use_id).id;
+          const result = ev.tool_use_result ?? {};
+          const nativeId = result.agentId ?? result.agent_id;
+          if (nativeId) aliases.set(nativeId, id);
+          // Background launch is not completion; its notification closes it.
+          const background = result.status === 'async_launched' || result.isAsync === true || calls.get(b.tool_use_id).input.run_in_background === true;
+          report({ id, ...(nativeId ? { nativeId } : {}), status: b.is_error ? 'stopped' : background ? 'running' : 'done',
+            ...(typeof result.description === 'string' ? { now: result.description } : {}) });
+        }
+      }
+      if (ev.type === 'system' && ['task_started', 'task_progress', 'task_notification'].includes(ev.subtype)) {
+        // Other native background tasks (notably Bash) are not subagents.
+        const id = aliases.get(ev.tool_use_id) ?? aliases.get(ev.task_id);
+        if (id) {
+          if (ev.task_id) aliases.set(ev.task_id, id);
+          const status = ev.status === 'completed' ? 'done' : ['failed', 'stopped'].includes(ev.status) ? 'stopped' : 'running';
+          report({ id, status, ...(ev.description || ev.summary ? { now: ev.description ?? ev.summary } : {}) });
+        }
+      }
+      return agentId;
+    },
+  };
+}

package/bin/lib/codexRelay.mjs

@@ -20,7 +20,7 @@
  * classifier. The sentence names what was measured and the one remedy the
  * machine's own CLI offers; Codex's own words stay beside it.
  */
-import { scrub as envScrub, scrubCut } from './uplinkScrub.mjs';
+import { scrub as envScrub } from './uplinkScrub.mjs';
 import { CODEX_RUNTIME } from './runtimeCodex.mjs';
 
 const NO_LOGIN = /unexpected status 401 Unauthorized: Missing bearer or basic authentication/;
@@ -55,25 +55,9 @@ export function codexApprovalSentence(refused) {
   return `Codex on the machine refused ${n} tool call${n === 1 ? '' : 's'} in this turn${which} — "MCP tool call requires approval, but approval policy is never" — so nothing ${n === 1 ? 'it' : 'they'} would have done was done.`;
 }
 
-/**
- * WHAT A TERMINAL OR NEW TASK REPLY MAY CARRY BACK (2026-10-10, the audit's
- * final cleanup; F042's daemon half). The server's `SESSION_ANSWER_MAX`
- * (shared `fieldCaps.ts`): the settle route (`/fleet/work-turn-done`) cuts an
- * answer there and the session writer clamps every message to it. The daemon
- * cuts there too before it sends — `withRelay` below and the plain reply in
- * `workSessionTurns.mjs` — so nothing past it crosses the wire. It was a bare
- * `16000` in both; the release gate (`scripts/check-app-parity.mjs`, rule 29)
- * holds this copy equal to the shared one.
- */
-export const SESSION_ANSWER_MAX = 16_000;
-
-/** A reply with the sentence first and Codex's own words kept under it,
- *  scrubbed like every reply and cut to the lane's cap — the words scrubbed
- *  whole before they are trimmed, and the reply cut only after (`scrubCut`). */
-export function withRelay(sentence, raw, cap = SESSION_ANSWER_MAX) {
-  const reply = (s) => {
-    const words = envScrub(s).trim();
-    return words ? `${sentence}\n\n${words}` : sentence;
-  };
-  return scrubCut(raw, cap, reply);
+/** A refusal sentence with the CLI's complete scrubbed reply beneath it.
+ * No prose cap: a real transport/storage refusal must retain the reply. */
+export function withRelay(sentence, raw) {
+  const words = envScrub(String(raw ?? '')).trim();
+  return words ? `${sentence}\n\n${words}` : sentence;
 }

package/bin/lib/codexSubagentEvents.mjs

@@ -0,0 +1,34 @@
+const SUBAGENT_LIMIT = 32;
+const THREAD_ID = /^[a-zA-Z0-9-]{16,64}$/;
+const snake = s => String(s ?? '').replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+export const statusOf = (s) => ({ pending_init: 'waiting', running: 'running', completed: 'done',
+  interrupted: 'stopped', errored: 'stopped', shutdown: 'stopped', not_found: 'stopped',
+  waiting: 'waiting', asked: 'asked' })[snake(typeof s === 'string' ? s : s && Object.keys(s)[0])];
+
+export function codexSpawnResult(item) {
+  if (!['collab_tool_call', 'CollabAgentToolCall'].includes(item?.type ?? item?.item_type) || snake(item.tool) !== 'spawn_agent' || !item.id) return null;
+  if (['failed', 'errored'].includes(snake(item.status))) return { callId: item.id, success: false };
+  const nativeId = item.receiver_thread_ids?.[0];
+  return nativeId ? { callId: item.id, nativeId, success: true } : null;
+}
+
+export function codexCollabUpdates(item) {
+  if (!['collab_tool_call', 'CollabAgentToolCall'].includes(item?.type ?? item?.item_type)) return [];
+  const tool = snake(item.tool);
+  const states = item.agents_states ?? {};
+  const ids = [...new Set([...(item.receiver_thread_ids ?? []), ...Object.keys(states)])].slice(0, SUBAGENT_LIMIT);
+  return ids.flatMap(id => {
+    if (typeof id !== 'string' || !THREAD_ID.test(id)) return [];
+    const state = states[id];
+    const receiver = item.receiver_agents?.find(a => a.thread_id === id);
+    const status = statusOf(state?.status ?? state);
+    const message = state?.message ?? (typeof state?.completed === 'string' ? state.completed : null);
+    return [{ id, ...(tool === 'spawn_agent' ? { ...(item.id ? { callId: item.id } : {}), ...(typeof item.prompt === 'string' ? { brief: item.prompt } : {}),
+        ...(receiver?.agent_path || receiver?.agent_nickname || item.title ? { title: receiver?.agent_path ?? receiver?.agent_nickname ?? item.title } : {}),
+        ...(receiver?.agent_role || item.agent_type ? { kind: receiver?.agent_role ?? item.agent_type } : {}),
+      } : {}),
+      ...(status ? { status } : ['close_agent', 'interrupt_agent'].includes(tool) ? { status: 'stopped' } : {}),
+      ...(typeof message === 'string' ? { now: message, message } : {}),
+    }];
+  });
+}