flowviant 0.125.30 → 0.125.33

package/bin/lib/agentPlan.mjs

@@ -33,6 +33,7 @@ import { scrub as envScrub, scrubCut } from './uplinkScrub.mjs';
 import { groupDependencies } from './planDependencies.mjs';
 import { AGENT_TASK_KINDS } from './agentTaskKinds.mjs';
 import { blockedAnswer } from './agentAsk.mjs';
+import { splitAnswer } from './agentSplit.mjs';
 import { isResearchUse } from './researchUse.mjs';
 import { candidateObjects } from './modelJson.mjs';
 import { parseGaps } from './turnGaps.mjs';
@@ -258,6 +259,13 @@ export function parseTurnResult(text, scrub = envScrub) {
       // as plain text.
       return { outcome: 'question', answer: blockedAnswer(scrub(question), v, scrub), ...progressOf(v, scrub) };
     }
+    if (v.status === 'split') {
+      // A split proposal (2026-11-06, agentSplit.mjs) is a question: the agent
+      // freezes until the person answers Use N subagents or Do it yourself.
+      const answer = splitAnswer(v, scrub);
+      if (!answer) continue;
+      return { outcome: 'question', answer, ...progressOf(v, scrub) };
+    }
     if (v.status === 'delivered') {
       return {
         outcome: 'delivered',

package/bin/lib/agentQueueContext.mjs

@@ -17,6 +17,12 @@ requirements. The brief and criteria marked full are supplied without clipping.
 sourceChats are the person's exact words in the New task chat these cards were
 planned in, up to each card's landing; a brief is the planner's paraphrase of
 them, and links, references and file lists there are part of the request.
+${job.gapContinuationAccepted === true ? 'This server supports disposition=required: unfinished required work continues in this card before Review.' : 'This server has not advertised automatic gap continuation. Finish required work within this turn; if it remains unfinished, ask through a blocked reply instead of declaring delivery.'}
+relatedWork names sibling cards from the same request across agents, including
+completed cards. Outside this queue does not mean unowned. Link the actual
+ownerTaskId instead of proposing or implementing a sibling's work again.
+Only a card's observed completion is recorded; verify a reported recurrence
+instead of assuming an earlier Done card solved the current failure.
 Human messages are exact recorded words across this agent, with the preceding
 question when present. taskId on a message is where it was recorded, not an
 implicit scope restriction. target.kind=agent explicitly addresses the whole

package/bin/lib/agentSplit.mjs

@@ -0,0 +1,90 @@
+/**
+ * CLAUDE SUGGESTS SUBAGENTS (2026-11-06, D28–D31, epic E5): the split a card
+ * agent proposes instead of starting children that edit files, read off its
+ * final JSON and handed on as a QUESTION.
+ *
+ *     {"status": "split", "split": {"reason": "…", "parts": [
+ *        {"title": "Port gizmo shaders", "touches": ["src/gizmo.ts"], "edits": true},
+ *        {"title": "Audit textures", "touches": ["assets/**"], "edits": false}]},
+ *      "progress": "…"}
+ *
+ * The agent freezes on it as a native CLI freezes on its ask tool (D31): the
+ * turn settles `question`, the board says Needs you, and the person answers
+ * through the existing answer lane. So the answer is built as every blocked
+ * question's is (agentAsk.mjs): prose, then ONE ```flowviant-ask fence — here
+ * with the two options the server and the page key on, `Use N subagents` and
+ * `Do it yourself` (the shared `splitUseLabel` / `SPLIT_SOLO_LABEL`), and the
+ * parts under an extra `split` key the ask reader ignores. A screen that
+ * knows nothing of splits still draws an answerable question.
+ *
+ * BOUNDED, AND NEVER LOST. `SPLIT_BOUNDS` is the shared one, key for key. A
+ * proposal past any bound, or with a hostile character, loses its fence whole
+ * and goes on as a plain-text question listing what could be read, exactly as
+ * malformed options do: the person can still answer it in words.
+ */
+import { ASK_HOSTILE } from './agentAsk.mjs';
+
+/** The shared `SPLIT_BOUNDS` (packages/shared/src/schemas/subagentSplit.ts). */
+export const SPLIT_BOUNDS = Object.freeze({ parts: 12, title: 120, touches: 8, touch: 200, reason: 600 });
+export const SPLIT_SOLO_LABEL = 'Do it yourself';
+export const splitUseLabel = n => `Use ${n} subagent${n === 1 ? '' : 's'}`;
+export const SPLIT_QUESTION = 'Use subagents?';
+
+const one = (v, max, scrub) => {
+  if (typeof v !== 'string') return null;
+  const t = scrub(v).trim();
+  return t && t.length <= max && !ASK_HOSTILE.test(t) ? t : null;
+};
+
+/** The declared split → `{ parts, reason }`, or null when any part breaks a
+ *  bound. `scrub` runs before each field is measured. */
+export function declaredSplit(raw, scrub = s => s) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  if (!Array.isArray(raw.parts) || !raw.parts.length || raw.parts.length > SPLIT_BOUNDS.parts) return null;
+  const parts = [];
+  for (const p of raw.parts) {
+    if (!p || typeof p !== 'object' || Array.isArray(p) || typeof p.edits !== 'boolean') return null;
+    const title = one(p.title, SPLIT_BOUNDS.title, scrub);
+    const touches = p.touches === undefined ? [] : p.touches;
+    if (!title || !Array.isArray(touches) || touches.length > SPLIT_BOUNDS.touches) return null;
+    const kept = [];
+    for (const t of touches) { const k = one(t, SPLIT_BOUNDS.touch, scrub); if (!k) return null; kept.push(k); }
+    parts.push({ title, touches: kept, edits: p.edits });
+  }
+  let reason = null;
+  if (raw.reason !== undefined && raw.reason !== null) {
+    if (typeof raw.reason !== 'string') return null;
+    const r = scrub(raw.reason).trim();
+    if (r.length > SPLIT_BOUNDS.reason || ASK_HOSTILE.test(r.replace(/\n/g, ' '))) return null;
+    reason = r || null;
+  }
+  return { parts, reason };
+}
+
+const partLine = (p, i) => `${i + 1}. ${p.title}${p.touches.length ? ` — ${p.touches.join(', ')}` : ''} · ${p.edits ? 'edits' : 'read-only'}`;
+
+/**
+ * THE ANSWER A SPLIT TURN HANDS ON, or null when it declared no parts at all
+ * (then it is no answer, as a blocked turn with no question is not). The
+ * prose names the parts, so a surface that draws no fence still shows them.
+ */
+export function splitAnswer(v, scrub = s => s) {
+  const split = declaredSplit(v?.split, scrub);
+  if (!split) {
+    // Readable parts, past a bound: a plain question, answerable in words.
+    const titles = Array.isArray(v?.split?.parts) ? v.split.parts.map(p => typeof p?.title === 'string' ? scrub(p.title).trim().slice(0, SPLIT_BOUNDS.title) : '').filter(Boolean) : [];
+    if (!titles.length) return null;
+    return `${SPLIT_QUESTION} I would split this card into ${titles.length} parts:\n\n${titles.map((t, i) => `${i + 1}. ${t}`).join('\n')}`;
+  }
+  const n = split.parts.length;
+  const prose = `${split.reason ? `${split.reason}\n\n` : ''}${split.parts.map(partLine).join('\n')}\n\n${SPLIT_QUESTION}`;
+  const ask = {
+    question: SPLIT_QUESTION, header: 'Subagents',
+    options: [
+      { label: splitUseLabel(n), description: n === 1 ? 'Run this part as a subagent.' : 'Run the parts side by side.' },
+      { label: SPLIT_SOLO_LABEL, description: 'Claude does every part itself, one after another.' },
+    ],
+    split,
+  };
+  return `${prose}\n\n\`\`\`flowviant-ask\n${JSON.stringify(ask)}\n\`\`\``;
+}

package/bin/lib/architectureContract.mjs

@@ -0,0 +1,57 @@
+/** Generated by the existing vault-scoped reader; no new infrastructure access. */
+export const ARCHITECTURE_EXAMPLE = {
+  version: 1,
+  summary: 'A browser application calls an API. Production deployment is unknown.',
+  components: [
+    { id: 'web', name: 'Web app', kind: 'application', description: 'The browser interface.', evidence: 'confirmed', sources: [{ path: 'web/package.json', reason: 'Declares the browser application.' }] },
+    { id: 'api', name: 'API', kind: 'service', description: 'Handles application requests.', evidence: 'confirmed', sources: [{ path: 'api/server.ts', line: 1, reason: 'Defines the HTTP entry point.' }] },
+  ],
+  connections: [{ from: 'web', to: 'api', label: 'HTTP requests', evidence: 'confirmed', sources: [{ path: 'web/client.ts', reason: 'Calls the API base URL.' }] }],
+  unknowns: ['The repository does not establish which services are deployed.'],
+};
+
+export const SYSTEM_ARCHITECTURE_CONTRACT = `
+UNDERSTAND MY SYSTEM — docs/01-architecture.md also supplies the Architecture
+view. Full sweeps generate the report. Incremental re-grounds maintain it only
+when architecture-affecting changes are in scope; never expand an unrelated
+incremental pass into a full scan just to add this report. If no report exists
+and this pass cannot inspect the system, leave it absent. Inspect real entry
+points, workspace/package manifests, API clients,
+database/storage/queue adapters and deployment configuration before writing it.
+Map major applications, services, data stores, queues and external systems;
+do not turn every file, dependency or function into a node.
+
+Include exactly ONE fenced block tagged flowviant-architecture containing JSON
+in this version-1 format (this example is FORMAT ONLY, never project facts):
+\n\`\`\`flowviant-architecture
+${JSON.stringify(ARCHITECTURE_EXAMPLE, null, 2)}
+\`\`\`
+
+Kinds: application, service, database, queue, storage, external. Component ids
+are unique ASCII letters/digits/underscore/hyphen, starting with a letter or
+digit, at most 80 characters. Connections reference those ids. Every component
+and connection needs at least one source: a real repository-relative path you
+opened, an optional positive line number and a reason explaining the evidence.
+Never emit absolute paths, traversal or URLs as source paths. Confirmed means
+source explicitly establishes the claim; inferred means an interpretation, and
+the source reason must explain it. Neither means running, healthy or deployed.
+
+State scope in the summary: only this checked-out repository is inspected;
+other repositories, deployment state and external settings remain unknown unless
+actually inspected. Never imply project-wide or production completeness. Put
+unanswered questions and uninspected areas in unknowns. An empty/new repository
+has components: [], connections: [] and an explanation in unknowns; do not invent
+a proposed architecture. Never expose credentials, environment values, private
+hosts or secret material. Do not contact infrastructure, provision anything,
+install dependencies or run the application to construct this map.
+
+At most 80 components, 200 connections, 40 sources per finding and 80 unknowns.
+Names at most 160 characters, connection labels 200, source paths 1000 and
+summary/descriptions/reasons/questions 4000. Keep the chapter's readable prose,
+Mermaid overview, files: frontmatter and page-local provenance beside the report.
+This is source analysis by the coding CLI, not independent verification by
+Flowviant. Re-ground it when changed files affect system boundaries, config,
+entry points or connections, including additions/removals outside its old files:
+list. Re-read affected sources; retain unrelated findings without asserting a
+new verified commit for unchecked claims. Respect human/reference ownership.
+`;

package/bin/lib/architectureReport.mjs

@@ -0,0 +1,38 @@
+/** Standalone daemon counterpart of shared/systemArchitecture.ts. The release
+ * parity gate checks the same accepted/rejected reports on both readers. */
+export const SYSTEM_ARCHITECTURE_PATH = 'docs/01-architecture.md';
+export const SYSTEM_ARCHITECTURE_FENCE = 'flowviant-architecture';
+export const ARCHITECTURE_REPORT_DAEMON_VERSION = '0.125.31';
+
+const text = (value, max = 4000) => typeof value === 'string' && value.trim().length > 0 && value.trim().length <= max;
+const id = (value) => typeof value === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}$/.test(value);
+const source = (value) => value && typeof value.path === 'string' && value.path.length > 0 && value.path.length <= 1000 &&
+  !/^[\/\\]|[\\\x00-\x1f\x7f:#?]/.test(value.path) && value.path.split('/').every((part) => part && part !== '.' && part !== '..') &&
+  (value.line === undefined || (Number.isInteger(value.line) && value.line > 0)) && text(value.reason);
+const finding = (value) => value && ['confirmed', 'inferred'].includes(value.evidence) &&
+  Array.isArray(value.sources) && value.sources.length > 0 && value.sources.length <= 40 && value.sources.every(source);
+
+export function validArchitectureReport(value) {
+  if (!value || value.version !== 1 || !text(value.summary) || !Array.isArray(value.components) || value.components.length > 80 ||
+    !Array.isArray(value.connections) || value.connections.length > 200 || !Array.isArray(value.unknowns) || value.unknowns.length > 80 || !value.unknowns.every((question) => text(question))) return false;
+  const ids = new Set();
+  for (const component of value.components) {
+    if (!component || !id(component.id) || ids.has(component.id) || !text(component.name, 160) || !text(component.description) ||
+      !['application', 'service', 'database', 'queue', 'storage', 'external'].includes(component.kind) || !finding(component)) return false;
+    ids.add(component.id);
+  }
+  return (ids.size > 0 || value.unknowns.length > 0) && value.connections.every((connection) =>
+    connection && ids.has(connection.from) && ids.has(connection.to) && text(connection.label, 200) && finding(connection));
+}
+
+export function readSystemArchitecture(markdown) {
+  const blocks = [...markdown.matchAll(/^```flowviant-architecture[^\S\r\n]*\r?\n([\s\S]*?)^```[^\S\r\n]*\r?$/gm)];
+  if (blocks.length === 0) return { status: markdown.includes('```flowviant-architecture') ? 'invalid' : 'missing' };
+  if (blocks.length !== 1) return { status: 'invalid' };
+  try {
+    const report = JSON.parse(blocks[0][1]);
+    return validArchitectureReport(report) ? { status: 'available', report } : { status: 'invalid' };
+  } catch {
+    return { status: 'invalid' };
+  }
+}

package/bin/lib/artifactContracts.mjs

@@ -116,8 +116,27 @@ export const WHOLE_REQUEST = `THE WHOLE REQUEST, NOT ONLY THE BRIEF:
   delivered JSON object, one entry per item this card was meant to deliver
   that you did not build ("not built"), built in part ("partly") or did not
   check against the real thing ("unverified"), and per part of the request
-  that NO card in this run owns ("unowned"), so the person can file it:
-    "gaps": [{ "item": "what is missing", "status": "not built | partly | unverified | unowned", "why": "one sentence" }]
+  that NO card in this run owns ("unowned"). Outside this run does not mean
+  unowned in the project: check relatedWork and the current queue first.
+    "gaps": [{ "item": "what is missing", "status": "not built | partly | unverified | unowned", "why": "one sentence", "disposition": "required | owned | optional | decision", "ownerTaskId": "existing card id only when owned" }]
+  ROUTE FINDINGS BEFORE DELIVERY:
+  - Already assigned, queued, running or completed on another card: use
+    disposition "owned" and its actual ownerTaskId. Link it; do not repeat it
+    or stage another task. An older Done receipt is not proof a recurrence is fixed.
+  - Necessary to meet this card's approved outcome: finish it now in this same
+    worktree and verify the combined result. Record completed incidental repairs
+    through raised. If another work step is needed, report disposition "required"
+    with why it is necessary; the server queues the same card's next step before
+    Review. This does not authorize another card's work, a product-kind change,
+    optional improvements, merging or deployment. Keep commit attribution.
+  - Optional improvement: use disposition "optional". Describe it as an offer in
+    the agent's summary; the person may reply here to include it. It creates no
+    New task tab and does not block delivery of the approved scope.
+  - A requirement, ownership or scope decision only the person can settle:
+    use the existing blocked reply with a specific question and options. Stay in
+    this agent conversation. Never claim delivery while that decision is required.
+  - After a person says "Finish the current scope", retain declined additions as
+    optional and finish the approved request; do not ask the same scope question again.
   "gaps": [] says you walked the request and nothing is missing. Never recast
   a gap as a decision: a choice you made in place of the request is a gap
   ("partly") with its reason.

package/bin/lib/claudeInput.mjs

@@ -95,7 +95,7 @@ export function createClaudeInput(child, { onTaken = () => {}, onContext = null
       }
       if (event.type === 'system' && event.subtype === 'compact_boundary') { compacting = false; askContext(true); }
       if (event.type === 'system' && event.subtype === 'background_tasks_changed' && Array.isArray(event.tasks)) {
-        agents = event.tasks.filter(task => task?.task_type === 'local_agent').length;
+        agents = event.tasks.filter(task => ['local_agent', 'local_workflow'].includes(task?.task_type)).length;
         if (agents > 0) draining = false; // a drained message's turn started agents
       }
       if (event.type === 'result') {

package/bin/lib/claudeSubagents.mjs

@@ -1,11 +1,34 @@
 import { NATIVE_AGENT_TOOLS } from './nativeAgentTools.mjs';
+import { createClaudeWorkflows } from './claudeWorkflows.mjs';
+import { turnModelOf } from './turnModel.mjs';
 
-/** Native tool-use ids are stable for the lifetime of an Agent/Task call. */
-export function createClaudeSubagents(report = () => {}) {
+const textOf = content => typeof content === 'string' ? content
+  : Array.isArray(content) ? content.filter(b => b?.type === 'text' && typeof b.text === 'string').map(b => b.text).join('\n') : '';
+const bounded = (map, n) => { if (map.size > n) map.delete(map.keys().next().value); };
+
+/**
+ * Native tool-use ids are stable for the lifetime of an Agent/Task call.
+ *
+ * WHAT A CHILD SAYS OF ITSELF (2026-11-06, S4.1): its model off its own
+ * `message.model` (never the spawn's `model` input: what was asked is not
+ * what ran), its final words off its own sidechain `result`, else the
+ * foreground call's tool_result, else its last message once it is done; its
+ * parent is the stream the spawn rode (the lead, or a child that spawned
+ * one). Claude states no per-child effort, so none is reported.
+ */
+export function createClaudeSubagents(report = () => {}, onWorkflow = () => {}) {
+  const workflows = createClaudeWorkflows(report, onWorkflow);
   const calls = new Map();
   const aliases = new Map();
   const questions = new Map();
   const seen = new Set();
+  const models = new Map(), said = new Map(), resulted = new Set();
+  const finish = (id, result) => {
+    const text = typeof result === 'string' && result.trim() ? result : said.get(id);
+    if (!text || resulted.has(id)) return {};
+    resulted.add(id); bounded(resulted, 128);
+    return { result: text };
+  };
   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;
@@ -28,7 +51,18 @@ export function createClaudeSubagents(report = () => {}) {
       return true;
     },
     observe(ev) {
+      workflows.observe(ev);
       const agentId = identify(ev);
+      if (ev.type === 'assistant' && agentId) {
+        const model = turnModelOf(ev.message?.model);
+        if (model && models.get(agentId) !== model) { models.set(agentId, model); bounded(models, 128); report({ id: agentId, model }); }
+        const words = textOf(ev.message?.content);
+        if (words.trim()) { said.set(agentId, words); bounded(said, 128); }
+      }
+      if (ev.type === 'result' && agentId && !ev.is_error && typeof ev.result === 'string' && ev.result.trim()) {
+        resulted.delete(agentId);
+        report({ id: agentId, ...finish(agentId, ev.result) });
+      }
       if (ev.type === 'assistant') {
         for (const b of ev.message?.content ?? []) {
           if (b.type === 'tool_use' && NATIVE_AGENT_TOOLS.claude.ask.includes(b.name) && agentId) {
@@ -43,8 +77,11 @@ export function createClaudeSubagents(report = () => {}) {
           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);
+          // A resume names the child's native id: the identity it keeps across turns.
+          const resumed = typeof input.resume === 'string' && input.resume ? { nativeId: input.resume } : {};
+          resulted.delete(id);
           report({ id, kind: input.subagent_type ?? '', title: input.description ?? input.name ?? '',
-            brief: input.prompt ?? '', status: 'running', now: input.description ?? '' });
+            brief: input.prompt ?? '', status: 'running', now: input.description ?? '', parent: agentId ?? 'lead', ...resumed });
         }
       }
       if (ev.type === 'user') {
@@ -60,8 +97,10 @@ export function createClaudeSubagents(report = () => {}) {
           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 } : {}) });
+          const status = b.is_error ? 'stopped' : background ? 'running' : 'done';
+          report({ id, ...(nativeId ? { nativeId } : {}), status,
+            ...(typeof result.description === 'string' ? { now: result.description } : {}),
+            ...(status === 'done' ? finish(id, textOf(b.content)) : {}) });
         }
       }
       if (ev.type === 'system' && ['task_started', 'task_progress', 'task_notification'].includes(ev.subtype)) {
@@ -70,7 +109,8 @@ export function createClaudeSubagents(report = () => {}) {
         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 } : {}) });
+          report({ id, status, ...(ev.description || ev.summary ? { now: ev.description ?? ev.summary } : {}),
+            ...(status === 'done' ? finish(id) : {}) });
         }
       }
       return agentId;

package/bin/lib/claudeWorkflows.mjs

@@ -0,0 +1,94 @@
+/** Workflow children have no stdout of their own: task_progress carries snapshots. */
+import { turnModelOf } from './turnModel.mjs';
+import { WORKFLOW_AGENT_CAP, WORKFLOW_CAP } from './subagentBounds.mjs';
+
+const text = (s, n) => typeof s === 'string' ? s.slice(0, n) : '';
+const idOf = s => typeof s === 'string' && s.length > 0 && s.length <= 96 ? s : null;
+const instant = v => {
+  const n = typeof v === 'number' ? v : Date.parse(v);
+  return Number.isFinite(n) && Math.abs(n) < 8.64e15 ? new Date(n).toISOString() : undefined;
+};
+const count = v => Number.isSafeInteger(v) && v >= 0 ? v : undefined;
+const statusOf = s => s === 'done' || s === 'completed' ? 'done'
+  : s === 'failed' || s === 'stopped' || s === 'cancelled' ? 'stopped' : 'running';
+
+export function createClaudeWorkflows(reportAgent = () => {}, report = () => {}) {
+  const runs = new Map(), aliases = new Map(), launches = new Map();
+  return {
+    observe(ev) {
+      if (ev.type === 'assistant' && !ev.parent_tool_use_id && !ev.isSidechain) {
+        for (const b of ev.message?.content ?? []) if (b?.type === 'tool_use' && b.name === 'Workflow' && idOf(b.id)) {
+          launches.set(b.id, text(b.input?.description, 600));
+          if (launches.size > WORKFLOW_CAP) launches.delete(launches.keys().next().value);
+          report({ launcherId: b.id });
+        }
+      }
+      if (ev.type !== 'system' || !['task_started', 'task_progress', 'task_updated', 'task_notification'].includes(ev.subtype)) return;
+      const id = idOf(ev.run_id) ?? aliases.get(ev.task_id);
+      if (!id) return;
+      if (ev.subtype === 'task_started' && ev.task_type === 'local_workflow' && !runs.has(id)) {
+        if (runs.size >= WORKFLOW_CAP) return;
+        runs.set(id, { row: { id, key: `claude-workflow:${id}`, name: text(ev.workflow_name, 200),
+          description: text(ev.description ?? launches.get(ev.tool_use_id), 600), status: 'running',
+          startedAt: instant(ev.startedAt) ?? new Date().toISOString(), phases: [], notRecorded: 0 },
+          agents: new Map(), seen: new Set(), tool: ev.tool_use_id });
+        if (idOf(ev.task_id)) aliases.set(ev.task_id, id);
+      }
+      const run = runs.get(id);
+      if (!run) return;
+      const { row, agents, seen } = run;
+      const before = JSON.stringify(row);
+      const progress = Array.isArray(ev.workflow_progress) ? ev.workflow_progress.slice(0, 2000) : [];
+      for (const a of progress) {
+        if (a?.type !== 'workflow_agent' || !idOf(a.agentId)) continue;
+        seen.add(a.agentId);
+        if (seen.size > 4096) seen.delete(seen.values().next().value);
+        const previous = agents.get(a.agentId);
+        const status = statusOf(a.state);
+        const startedAt = instant(a.startedAt) ?? previous?.startedAt;
+        const endedAt = status !== 'running' ? instant(a.endedAt) ?? instant(
+          Number.isFinite(a.startedAt) && Number.isFinite(a.durationMs) ? a.startedAt + a.durationMs : a.lastProgressAt
+        ) ?? previous?.endedAt ?? new Date().toISOString() : undefined;
+        const next = { ...previous, id: a.agentId, nativeId: a.agentId, key: `claude:${a.agentId}`, cli: 'claude',
+          kind: 'workflow', parentKey: row.key, title: text(a.label, 200), status,
+          ...(typeof a.phaseTitle === 'string' ? { phase: text(a.phaseTitle, 200) } : {}),
+          ...(startedAt ? { startedAt } : {}), ...(endedAt ? { endedAt } : {}),
+          ...(turnModelOf(a.model) ? { model: turnModelOf(a.model) } : {}),
+          ...(a.lastToolName || a.lastToolSummary ? { now: [text(a.lastToolName, 80), text(a.lastToolSummary, 400)].filter(Boolean).join(' ').slice(0, 400) } : {}),
+          ...(typeof a.promptPreview === 'string' ? { brief: text(a.promptPreview, 24000), briefStatus: 'truncated' } : {}),
+          ...(typeof a.resultPreview === 'string' ? { result: text(a.resultPreview, 8000), resultStatus: 'truncated' } : {}),
+          ...(count(a.tokens) !== undefined ? { tokens: a.tokens } : {}),
+          ...(count(a.toolCalls) !== undefined ? { toolCalls: a.toolCalls } : {}) };
+        if (status === 'running') delete next.endedAt;
+        agents.set(a.agentId, next);
+      }
+      const newest = [...agents.values()].sort((a, b) => (b.startedAt ?? '').localeCompare(a.startedAt ?? ''));
+      for (const a of newest.slice(WORKFLOW_AGENT_CAP)) agents.delete(a.id);
+      row.notRecorded = Math.max(row.notRecorded, seen.size - agents.size);
+      if (progress.length) row.phases = progress.filter(p => p?.type === 'workflow_phase').slice(0, 64).map(p => {
+        const children = progress.filter(a => a?.type === 'workflow_agent' && a.phaseTitle === p.title);
+        return { title: text(p.title, 200), status: p.state ? statusOf(p.state)
+          : children.length && children.every(a => statusOf(a.state) === 'done') ? 'done' : 'running' };
+      });
+      if (count(ev.usage?.total_tokens) !== undefined) row.totalTokens = ev.usage.total_tokens;
+      if (count(ev.usage?.tool_uses) !== undefined) row.toolCalls = ev.usage.tool_uses;
+      if (ev.subtype === 'task_updated' && instant(ev.patch?.end_time)) run.endedAt = instant(ev.patch.end_time);
+      if (ev.subtype === 'task_notification') {
+        row.status = statusOf(ev.status);
+        row.endedAt = instant(ev.endedAt) ?? run.endedAt ?? new Date().toISOString();
+        row.phases = row.phases.map(p => ({ ...p, status: p.status === 'done' ? 'done' : row.status }));
+        for (const a of agents.values()) if (a.status === 'running') Object.assign(a, { status: row.status, endedAt: row.endedAt });
+      }
+      // Report only changed children, even though the CLI resends the whole snapshot.
+      for (const a of agents.values()) {
+        const signature = JSON.stringify(a);
+        if (run.sent?.get(a.id) !== signature) reportAgent(a);
+      }
+      // Signatures stay outside the record that travels on the wire.
+      run.sent ??= new Map();
+      for (const key of run.sent.keys()) if (!agents.has(key)) run.sent.delete(key);
+      for (const a of agents.values()) run.sent.set(a.id, JSON.stringify(a));
+      if (before !== JSON.stringify(row) || ev.subtype === 'task_started') report({ ...row, launcherId: run.tool });
+    },
+  };
+}

package/bin/lib/cliLimit.mjs

@@ -19,6 +19,11 @@ import { scrubCut } from './uplinkScrub.mjs';
  * attached, and is a perfectly survivable second-best.
  */
 const LIMIT_PHRASES = [
+  // Installed codex-cli 0.166.0 native binary, strings (2026-11-06):
+  // ~/.codex/packages/standalone/releases/0.166.0-x86_64-unknown-linux-musl/bin/codex
+  // Core error display: plain, model-specific ("for ..."), Plus, credits,
+  // and admin-request variants all share this exact literal prefix.
+  /you've hit your usage limit/i,
   /usage limit reached/i,
   /rate limit/i,
   /you've reached your .* limit/i,