flowviant 0.125.30 → 0.125.31

package/bin/lib/runtimeLimits.mjs

@@ -8,7 +8,9 @@
  * plan window is not Flowviant's capacity — it is the VENDOR measuring its own
  * plan, and this file only carries that measurement to Project settings ›
  * Machines, where it reads as "used", never "left" or "free". Nothing here
- * decides, gates, parks or schedules anything off these numbers.
+ * decides, gates or parks anything off these numbers; the one other relay is
+ * a hit limit's own reset, carried on the park (`limitResetAt`, 2026-11-06)
+ * so the server retries when the CLI said, not on a guess.
  *
  * TWO SOURCES, ONE SHAPE:
  *
@@ -135,6 +137,8 @@ export function recordClaudeRateLimit(info, now = Date.now()) {
   capWindows(state.windows);
   state.status = CLAUDE_STATUSES.has(info.status) ? info.status : 'other';
   state.at = at;
+  // The binding window's reset rides the event itself beside a rejection.
+  state.rejectedResetsAt = state.status === 'rejected' ? isoFromStamp(info.resetsAt) : null;
 }
 
 /**
@@ -370,6 +374,60 @@ export function runtimeLimitsReport({ detected, plan, now = Date.now() } = {}) {
   return Object.keys(out).length ? fitRuntimeLimits(out) : null;
 }
 
+/** A park's reset is relayed only past now and within this (the longest plan
+ *  window is a week); the server applies the same bound (`PARK_RESET_MAX_MS`). */
+export const PARK_RESET_MAX_MS = 8 * 24 * 60 * 60_000;
+/** A rejection older than this is not the one this turn hit. */
+const LIMIT_READING_FRESH_MS = 30 * 60_000;
+
+/** An ISO reset after `now` and within the bound, or null. */
+export function boundedResetAt(iso, now = Date.now()) {
+  const t = typeof iso === 'string' ? Date.parse(iso) : NaN;
+  return Number.isFinite(t) && t > now && t - now <= PARK_RESET_MAX_MS ? new Date(t).toISOString() : null;
+}
+
+/** The latest reset among windows the CLI measured as full (≥ 100% used):
+ *  the account carries on only once every full window has reset. */
+const fullWindowsReset = (windows) => {
+  let latest = null;
+  for (const w of windows?.values?.() ?? []) {
+    if (w.usedPct != null && w.usedPct >= 100 && w.resetsAt && (!latest || w.resetsAt > latest)) latest = w.resetsAt;
+  }
+  return latest;
+};
+
+/**
+ * WHEN THE LIMIT THIS TURN HIT RESETS, IN THE CLI'S OWN MEASURE (2026-11-06) —
+ * ISO, or null. Relayed on the park (`/fleet/agent-parked` `resetsAt`) so the
+ * server retries then instead of after its fixed cooldown.
+ *
+ * Only a REJECTION read fresh: Claude's `rate_limit_event` with status
+ * `rejected` (its own `resetsAt`, else a full window's), or a Codex rollout
+ * naming the limit reached — read now, off this turn's thread under the
+ * agent's CODEX_HOME (`env`), because the after-close read in runTurn.mjs is
+ * not awaited — with a full window's `resets_at`. Anything unmeasured, stale,
+ * past or past the bound is null, and the server's cooldown stands. Never
+ * throws.
+ */
+export async function limitResetAt(runtime, { threadId, env, now = Date.now() } = {}) {
+  try {
+    const fresh = (st) => st?.status === 'rejected' && now - Date.parse(st.at) <= LIMIT_READING_FRESH_MS;
+    if (runtime === 'claude' || !runtime) {
+      if (!fresh(claudeState)) return null;
+      return boundedResetAt(claudeState.rejectedResetsAt ?? fullWindowsReset(claudeState.windows), now);
+    }
+    if (runtime === 'codex') {
+      // The agent's own home first, then the person's (its sessions link there).
+      if (threadId && !(await learnCodexLimits(threadId, { env, now })) && env) await learnCodexLimits(threadId, { now });
+      if (!fresh(codexState)) return null;
+      return boundedResetAt(fullWindowsReset(codexState.windows), now);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 /** Test-only: forget everything learned, the plan memo and the path cache. */
 export function resetRuntimeLimitsForTest() {
   claudeState = null;

package/bin/lib/splitGate.mjs

@@ -0,0 +1,115 @@
+/**
+ * THE PERSON'S YES BEFORE CHILDREN EDIT FILES (2026-11-06, D13/D28–D31, E5).
+ *
+ * A card turn's job carries `subagents` (`SubagentSplitJob`, shared
+ * subagentSplit.ts, `DAEMON_SUBAGENT_SPLIT_MIN`) from a server that asks:
+ *  - `ask`: a child that edits files waits for an approved split. The gate
+ *    refuses its spawn in words that tell the model to propose the split
+ *    (agentSplit.mjs) and stop. A read-only lookup on the agent's own CLI
+ *    starts without asking (D13).
+ *  - `approved`: this turn is the person's "Use N subagents".
+ *  - `always`: the agent's Always switch (D29). It only skips this question;
+ *    Claude's own workflow/ultracode modes stay separate (D14).
+ * ABSENT IS THE OLD SERVER, and the old behaviour stands: nothing is held and
+ * nothing is proposed. A research card's children only read already (the
+ * gate fences them), so nothing there waits either.
+ *
+ * WHETHER A CHILD EDITS, per CLI, conservatively — unknown is editing:
+ *  - Claude's Agent/Task: by `subagent_type`. Only the built-in read-only
+ *    types (Explore, Plan: no Edit/Write/NotebookEdit tools) read; general-
+ *    purpose, a project's own type, or none named, edit. The gate also refuses
+ *    such a child's file-write tools (orchestrator.mjs), since a type is the
+ *    model's word; its shell is not fenced.
+ *  - Codex's spawn_agent: by a declared read-only sandbox on the spawn, which
+ *    no measured Codex input carries today, so every Codex spawn waits.
+ * Pure: no record, slot or request is read here.
+ */
+import { isBackgroundSpawnTool, isSpawnTool } from './nativeAgentTools.mjs';
+import { CLAUDE_CHILD_MODELS, claudeFamily } from './orchestratorNative.mjs';
+import { SPLIT_SOLO_LABEL } from './agentSplit.mjs';
+
+export const SPLIT_MODES = Object.freeze(['ask', 'approved', 'always']);
+/** Claude Code's built-in subagent types whose tools exclude file writes. */
+export const CLAUDE_READ_ONLY_TYPES = Object.freeze(['Explore', 'Plan']);
+const READ_ONLY_SANDBOX = /^read[-_ ]?only$/i;
+
+/** The job's split field, or null when absent or unreadable (the old path). */
+export function splitPolicy(job) {
+  const s = job?.subagents;
+  if (!s || typeof s !== 'object' || !SPLIT_MODES.includes(s.mode)) return null;
+  const str = v => typeof v === 'string' && v.trim() ? v.trim() : null;
+  return { mode: s.mode, runtime: str(s.runtime), model: str(s.model), effort: str(s.effort) };
+}
+
+/** Whether this spawn's child may edit files; true whenever it cannot tell. */
+export function childEdits(event, input = event?.tool_input ?? {}) {
+  if (isBackgroundSpawnTool(event?.tool_name)) return !CLAUDE_READ_ONLY_TYPES.includes(input.subagent_type);
+  if (isSpawnTool(event?.tool_name)) return ![input.sandbox, input.sandbox_mode, input.sandbox_policy].some(v => typeof v === 'string' && READ_ONLY_SANDBOX.test(v));
+  return true;
+}
+
+export const splitRefusal = runtime => `This child may edit files, and the person has not approved a split, so it was not started. Propose the split instead: end your turn with the split JSON (status "split") naming each part, the paths it touches and whether it edits files, then stop and wait for the person's answer. ${runtime === 'codex' ? 'On Codex every spawn waits for that answer; do read-only lookups yourself.' : 'A read-only lookup starts without asking: spawn it with the Explore or Plan agent type.'} Or do this part yourself.`;
+
+/** The deny words for a spawn the split holds, or null when it may start. */
+export function splitHold(policy, event, spawn, { runtime, access }) {
+  if (!policy || policy.mode !== 'ask' || access === 'read') return null;
+  return childEdits(event, spawn?.input) ? splitRefusal(runtime) : null;
+}
+
+/** Whether the gate admitted this spawn as a read-only lookup (ask mode). */
+export const readOnlyLookup = (policy, event, spawn, access) => Boolean(policy && policy.mode === 'ask' && access !== 'read' && !childEdits(event, spawn?.input));
+
+/**
+ * The children's model and effort under an approved or Always split: the
+ * person's batch choice, where they named one, over the card's. On Claude the
+ * Agent tool takes only a family alias; a choice outside the known families
+ * is not honourable there, and the card's model stands (`unhonoured`).
+ */
+export function splitBrain(policy, runtime, card = {}) {
+  if (!policy || policy.mode === 'ask') return { brain: {}, unhonoured: [] };
+  // A batch on another CLI (E7) chose that CLI's model: native children keep the card's.
+  if (policy.runtime && policy.runtime !== runtime) return { brain: {}, unhonoured: [] };
+  const brain = {}, unhonoured = [];
+  if (policy.model) {
+    if (runtime === 'claude' && !CLAUDE_CHILD_MODELS.includes(claudeFamily(policy.model))) unhonoured.push(`Claude's Agent tool names only ${CLAUDE_CHILD_MODELS.join(', ')}, so children run on ${card.model ?? 'the card’s model'}, not ${policy.model}`);
+    else brain.model = policy.model;
+  }
+  if (policy.effort) brain.effort = policy.effort;
+  return { brain, unhonoured };
+}
+
+const choiceWords = (policy, runtime, card) => {
+  const { brain, unhonoured } = splitBrain(policy, runtime, card);
+  const model = brain.model ?? card.model, effort = brain.effort ?? card.effort;
+  const at = `${model ?? 'the card’s model'}${effort ? ` at ${effort} effort` : ''}`;
+  const codex = runtime === 'codex' && brain.model ? ' On Codex a model outside this machine’s catalog cannot be named for a child; it then inherits the card’s.' : '';
+  return `Run every child on ${at}: the person chose it for the whole batch, so name no other model or effort for a child.${unhonoured.length ? ` ${unhonoured.join('. ')}.` : ''}${codex}`;
+};
+
+const CLI_LABEL = { claude: 'Claude Code', codex: 'Codex' };
+
+/**
+ * A BATCH ON ANOTHER CLI (2026-11-06, D21/D30, E7): the person chose the other
+ * CLI for every child, so each part starts with card_orchestrator's
+ * start_cli_agent instead of a native spawn — when this machine has that CLI
+ * ready (`crossCli`, the CLIs the controller offers); otherwise the parts are
+ * the lead's own, and it says why.
+ */
+const otherCliWords = (policy, crossCli) => {
+  const cli = policy.runtime, name = CLI_LABEL[cli] ?? cli;
+  if (!crossCli.includes(cli)) return `The person chose ${name} for the children, and ${name} is not ready on this machine, so no child can start on it: do the parts yourself, and say so in your update.`;
+  const at = [policy.model, policy.effort && `${policy.effort} effort`].filter(Boolean).join(' at ');
+  return `Run every child on ${name}${at ? `, ${at}` : ''}: the person chose it for the whole batch. Start each part with card_orchestrator.start_cli_agent (cli "${cli}", a title, its kind and the whole brief, naming no other model or effort), never with a native spawn, then read each with cli_agent_result until it is done, stopped or limited. A limited child hit ${name}'s own plan limit: its words say so; retry it later with followup_cli_agent or do its part yourself.`;
+};
+
+/** The words this run's split policy adds to the orchestrator's contract. */
+export function splitContract(policy, { runtime = 'claude', model = null, effort = null, crossCli = [] } = {}) {
+  if (!policy) return '';
+  const card = { model, effort };
+  const batch = () => policy.runtime && policy.runtime !== runtime ? otherCliWords(policy, crossCli) : choiceWords(policy, runtime, card);
+  if (policy.mode === 'approved') return `THE PERSON APPROVED YOUR SPLIT for this turn: start the parts you proposed ${policy.runtime && policy.runtime !== runtime ? 'now' : 'as native subagents now, as above'}. ${batch()}`;
+  if (policy.mode === 'always') return `SPLITS ARE PRE-APPROVED ON THIS AGENT (its Always use subagents switch): split independent parts as above without proposing first. ${batch()} This switch starts no workflow or other mode of the CLI; it only skips the person's question.`;
+  return `SUBAGENTS THAT EDIT FILES NEED THE PERSON'S YES. For children that edit files this replaces "this contract is the authorization" above. When parts of the card's work can run side by side and would edit files, do not spawn them: write any code they share first, as above, then propose the split and stop. End your turn with this JSON as your final answer, in place of delivered or blocked:
+{"status":"split","split":{"reason":"one or two sentences on why these parts can run side by side","parts":[{"title":"Port gizmo shaders","touches":["src/gizmo.frag","src/gizmo.ts"],"edits":true},{"title":"Audit textures","touches":["assets/textures/**"],"edits":false}]},"progress":"…"}
+Name every part you would give a child (at most 12), the paths or areas it touches (at most 8), and whether it edits files or only reads. The person answers "Use N subagents" — your next turn then says the split is approved and which model and effort the children run on — or "${SPLIT_SOLO_LABEL}", which means: do every part yourself with no child that edits files, and do not propose this split again. ${runtime === 'codex' ? 'On Codex the gate cannot tell a reading child from an editing one, so every spawn waits for that answer: do lookups yourself.' : 'A read-only lookup needs no approval: spawn it with the Explore or Plan agent type; the gate holds every other spawn.'} Children already running keep going: write the proposal as your final answer once they finish. A split is not a question for blocked JSON.`;
+}

package/bin/lib/subagentBounds.mjs

@@ -13,8 +13,34 @@
  *  shared `SUBAGENT_STATUSES`. */
 
 export const SUBAGENT_CAP = 32;
+export const WORKFLOW_AGENT_CAP = 200;
+export const WORKFLOW_CAP = 32;
 /** In the order the trace relay sends them. */
 export const SUBAGENT_FIELD_CAPS = Object.freeze({ kind: 80, title: 200, now: 400, brief: 24_000 });
 export const SUBAGENT_STATUSES = Object.freeze(['running', 'waiting', 'asked', 'stopped', 'done']);
 /** A child that has finished or been stopped: the controller revives neither. */
 export const SETTLED_SUBAGENT_STATUSES = Object.freeze(['done', 'stopped']);
+
+/** WHAT EACH CHILD'S RECORD CARRIES BEYOND ITS DESCRIPTOR (2026-11-06, S4.1),
+ *  and its own step budget. Before this a child was id/kind/title/brief/now
+ *  and a status, its steps shared the turn's 400 with the lead and every
+ *  sibling, and a 33rd child vanished without a count. The server keeps the
+ *  same numbers (`agentTraceAgents.ts`, check-app-parity rule 38):
+ *   · `SUBAGENT_STEP_CAP` — the newest steps each child keeps of its own,
+ *     past which its oldest are said as "N earlier not kept";
+ *   · `SUBAGENT_RESULT_CAP` — its final message, as its CLI handed it back;
+ *   · `SUBAGENT_RUNS_CAP` — the turns one resumed child is remembered in;
+ *   · `SUBAGENT_KEY_MAX` — its stable identity across turns;
+ *   · `SUBAGENT_CLIS` — the CLIs whose children are recorded (a CLI outside
+ *     the list is unknown and the field is absent).
+ *  `OUTSIDE_*` bounds the lead's shell-outs to another CLI ("Outside" rows,
+ *  D23): shown, never blocked, never counted toward the 32. */
+export const SUBAGENT_STEP_CAP = 120;
+export const SUBAGENT_RESULT_CAP = 8_000;
+export const SUBAGENT_RUNS_CAP = 16;
+export const SUBAGENT_KEY_MAX = 160;
+export const SUBAGENT_CLIS = Object.freeze(['claude', 'codex']);
+export const OUTSIDE_CAP = 32;
+export const OUTSIDE_COMMAND_CAP = 600;
+export const OUTSIDE_CLIS = Object.freeze(['claude', 'codex', 'gemini']);
+export const OUTSIDE_STATUSES = Object.freeze(['running', 'done', 'failed']);

package/bin/lib/subagentLedger.mjs

@@ -0,0 +1,110 @@
+/**
+ * WHICH TURNS EACH OF AN AGENT'S SUBAGENTS APPEARED IN (2026-11-06, S4.1,
+ * D26). A child resumed in a later turn — Claude's `Agent({ resume })` of
+ * its native agent id, a Codex follow-up to its child thread — is the same
+ * child, and the chat shows it once ("continued in run 3"). Each turn's
+ * trace keeps its own bounded record; this ledger is how that record knows
+ * the earlier turns, by the stable `key` turnSubagents.mjs gives it.
+ *
+ * Kept beside the agent's resume markers, in the worktree's private git dir
+ * (workAgentResume.mjs): a child can only be resumed where its conversation
+ * is, so this is exactly as durable as the resume it describes. Codex
+ * children also keep the task paths they answered to, so a follow-up by
+ * path reaches its thread in a later turn (codexSubagents.mjs
+ * `knownTargets`).
+ *
+ * BEST EFFORT BOTH WAYS, like the markers: unreadable is unknown (runs
+ * carry no field), unwritable costs the next turn its history.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { CLAUDE_SESSION_RE, CODEX_THREAD_RE, CODEX_CHILD_THREAD_RE } from './conversationIds.mjs';
+import { SUBAGENT_KEY_MAX, SUBAGENT_RUNS_CAP } from './subagentBounds.mjs';
+
+/** Children remembered per agent; the oldest go first. */
+export const LEDGER_KEYS = 128;
+const LEDGER_BYTES = 256 * 1024;
+const NAMES = 4;
+const TURN_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+function readLedger(path) {
+  if (!path || !existsSync(path)) return new Map();
+  try {
+    const raw = readFileSync(path, 'utf8');
+    if (raw.length > LEDGER_BYTES) return null;
+    const v = JSON.parse(raw);
+    if (!v || typeof v !== 'object' || Array.isArray(v)) return null;
+    const out = new Map();
+    for (const [key, entry] of Object.entries(v).slice(-LEDGER_KEYS)) {
+      if (key.length > SUBAGENT_KEY_MAX || !entry || typeof entry !== 'object') continue;
+      const r = Array.isArray(entry.r) ? entry.r.filter(t => typeof t === 'string' && TURN_RE.test(t)).slice(-SUBAGENT_RUNS_CAP) : [];
+      const n = Array.isArray(entry.n) ? entry.n.filter(s => typeof s === 'string' && s.length <= 160).slice(-NAMES) : [];
+      const c = entry.c;
+      const valid = c && ['codex', 'claude'].includes(c.cli) &&
+        (c.cli === 'codex' ? CODEX_THREAD_RE : CLAUDE_SESSION_RE).test(c.native ?? '') &&
+        key === `${c.cli}:${c.native}` && typeof c.wt === 'string' && c.wt.startsWith('/') && c.wt.length <= 4096;
+      out.set(key, { r, n, ...(valid ? { c } : {}) });
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+/** One turn's view of the agent's ledger at `path` (null: no git dir). */
+export function subagentLedger(path, turnId) {
+  const ledger = path ? readLedger(path) : null;
+  let dirty = false;
+  return {
+    /** Null when the ledger is unknown: the trace then sends no runs. */
+    runsOf: ledger && TURN_RE.test(turnId ?? '') ? (key, { title } = {}) => {
+      if (typeof key !== 'string' || !key || key.length > SUBAGENT_KEY_MAX) return null;
+      const entry = ledger.get(key) ?? { r: [], n: [] };
+      if (!entry.r.includes(turnId)) { entry.r = [...entry.r, turnId].slice(-SUBAGENT_RUNS_CAP); dirty = true; }
+      if (typeof title === 'string' && title && title.length <= 160 && !entry.n.includes(title)) { entry.n = [...entry.n, title].slice(-NAMES); dirty = true; }
+      // Most recently seen last, so the bound sheds the longest unheard.
+      ledger.delete(key); ledger.set(key, entry);
+      while (ledger.size > LEDGER_KEYS) ledger.delete(ledger.keys().next().value);
+      return [...entry.r];
+    } : null,
+    /** A Codex child's earlier names → its thread, for this turn's reader. */
+    codexTargets() {
+      const out = new Map();
+      for (const [key, { n }] of ledger ?? []) {
+        const thread = key.startsWith('codex:') ? key.slice(6) : '';
+        if (!CODEX_CHILD_THREAD_RE.test(thread)) continue;
+        for (const name of n) out.set(name, thread);
+      }
+      return out;
+    },
+    /** Cross-CLI identity is measured at init, never reconstructed from a title. */
+    rememberCli(key, child) {
+      if (!ledger || !key || key.length > SUBAGENT_KEY_MAX) return;
+      const entry = ledger.get(key) ?? { r: [], n: [] };
+      entry.c = { ...child, id: entry.c?.id ?? child.id };
+      ledger.delete(key); ledger.set(key, entry);
+      while (ledger.size > LEDGER_KEYS) ledger.delete(ledger.keys().next().value);
+      dirty = true;
+      this.persist();
+    },
+    cliChild(id, wt) {
+      for (const [key, entry] of ledger ?? []) {
+        if (entry.c?.wt === wt && (key === id || entry.c.id === id)) return { ...entry.c, key };
+      }
+      return null;
+    },
+    persist() {
+      if (!dirty || !path || !ledger) return;
+      try {
+        let data = JSON.stringify(Object.fromEntries(ledger));
+        while (Buffer.byteLength(data) > LEDGER_BYTES && ledger.size) {
+          ledger.delete(ledger.keys().next().value);
+          data = JSON.stringify(Object.fromEntries(ledger));
+        }
+        writeFileSync(path, data);
+        dirty = false;
+      } catch {
+        /* the next turn's children carry no history */
+      }
+    },
+  };
+}

package/bin/lib/trace.mjs

@@ -62,7 +62,8 @@
 import { THINK_MARKER, scrubNativeText } from './runtimeEvents.mjs';
 import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 import { MAX_MCP_SERVERS, MCP_NAME_MAX, MCP_STATUSES } from './mcpReportBounds.mjs';
-import { SUBAGENT_CAP, SUBAGENT_FIELD_CAPS, SUBAGENT_STATUSES } from './subagentBounds.mjs';
+import { WORKFLOW_AGENT_CAP, WORKFLOW_CAP, OUTSIDE_CAP, OUTSIDE_COMMAND_CAP, OUTSIDE_STATUSES, SETTLED_SUBAGENT_STATUSES, SUBAGENT_CAP, SUBAGENT_CLIS, SUBAGENT_FIELD_CAPS,
+  SUBAGENT_KEY_MAX, SUBAGENT_RESULT_CAP, SUBAGENT_RUNS_CAP, SUBAGENT_STATUSES } from './subagentBounds.mjs';
 
 /** One batch every two seconds — the discipline the tab's narrator keeps, for
  *  the same reason: a turn emits hundreds of entries and nobody is reading them
@@ -111,7 +112,18 @@ function newRunId() {
  * with no such route, a body the server will never accept). Resolving falsy
  * keeps them queued for the next flush.
  */
-export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run = newRunId(), orchestrationVersion }) {
+/** One native window a brief or result is scrubbed over before its cap. */
+const NATIVE_WINDOW = 65_536;
+const EFFORT_RE = /^[a-z]{1,24}$/;
+const RUN_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+/**
+ * `cli` is the runtime whose children this turn records. `runsOf(key)` is
+ * the agent's subagent ledger (workAgentResume.mjs): the turns a child of
+ * that stable key appeared in, this one included; absent, a child's runs are
+ * unknown and carry no field.
+ */
+export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run = newRunId(), orchestrationVersion, cli, runsOf }) {
   /** Entries not yet delivered. `base` is the ABSOLUTE index of queue[0] in
    *  THIS RUN's stream, so `base + queue.length` is everything this relay has
    *  ever accepted — sent, queued or shed. Absolute for the TURN is the
@@ -124,6 +136,19 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
    *  by the bare-marker collapse in `prose()` and nothing else. */
   let lastEntry = null;
   const agentReadings = new Map();
+  /** Each child's own steps, sent or shed: its record's `steps`, against
+   *  which the server says "N earlier not kept" past its own budget. */
+  const childSteps = new Map();
+  /** Children past the 32, counted and never recorded (bounded: a count). */
+  const unrecorded = new Set();
+  let notRecorded = 0;
+  /** The lead's own entries this run, sent or shed: where a child or an
+   *  Outside row sits in the lead's thread (its `position`). */
+  let leadCount = 0;
+  /** The lead's shell-outs to another CLI ("Outside", D23), by call id. */
+  const outsideRows = new Map();
+  const workflowRows = new Map(), workflowPositions = new Map();
+  let extrasPending = false;
   const mcpSaid = new Set();
   let dirty = orchestrationVersion === 2;
   let markerPending = dirty;
@@ -145,6 +170,8 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
   const push = (entry) => {
     if (stopped || !entry) return;
     lastEntry = entry;
+    if (entry.agentId) childSteps.set(entry.agentId, (childSteps.get(entry.agentId) ?? 0) + 1);
+    else if (entry.k !== 'agent') leadCount += 1;
     queue.push(entry);
     while (queue.length > TRACE_BUFFER) {
       queue.shift();
@@ -156,7 +183,7 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
 
   const drain = async (deadlineMs) => {
     const until = deadlineMs > 0 ? Date.now() + deadlineMs : 0;
-    while (queue.length || markerPending) {
+    while (queue.length || markerPending || extrasPending) {
       if (until && Date.now() > until) {
         dirty = true;
         return;
@@ -164,10 +191,17 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
       const entries = queue.slice(0, TRACE_BATCH);
       const seq = base;
       dirty = false;
+      // The turn's counts and Outside rows ride beside the stream, whole: they
+      // take no seq, so an older server ignoring them sheds no step.
+      const extras = extrasPending;
+      extrasPending = false;
       let ok = false;
       try {
         ok = (await post({ agentId, turnId, run, seq, entries,
           ...(orchestrationVersion === 2 ? { orchestrationVersion } : {}),
+          ...(extras && notRecorded > 0 ? { notRecorded } : {}),
+          ...(extras && outsideRows.size ? { outside: [...outsideRows.values()] } : {}),
+          ...(extras && workflowRows.size ? { workflows: [...workflowRows.values()] } : {}),
         })) !== false;
       } catch {
         ok = false;
@@ -176,6 +210,7 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
         // Held, at the SAME seq: a retry the server has already seen is
         // trimmed against its high-water mark rather than doubled.
         dirty = true;
+        extrasPending ||= extras;
         return;
       }
       markerPending = false;
@@ -201,6 +236,30 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
   // The first report stamps even a silent or immediately failed CLI invocation.
   schedule();
   const scoped = (id) => id ? `${run}:${scrubNativeText(id, 96, scrub)}` : undefined;
+  /** A child's S4.1 detail, each field present only when its source said it. */
+  const cleanKey = v => scrubNativeText(v, SUBAGENT_KEY_MAX, scrub);
+  const detailOf = (update) => {
+    const out = {};
+    const childCli = update.cli ?? cli;
+    if (SUBAGENT_CLIS.includes(childCli)) out.cli = childCli;
+    if (typeof update.key === 'string' && update.key && update.key.length <= SUBAGENT_KEY_MAX) out.key = scrubNativeText(update.key, SUBAGENT_KEY_MAX, scrub);
+    if (update.parent === 'lead') out.parent = 'lead';
+    else if (typeof update.parent === 'string' && update.parent && update.parent !== update.id) out.parent = scoped(update.parent);
+    if (typeof update.model === 'string' && update.model) out.model = scrubNativeText(update.model, 80, scrub);
+    if (typeof update.effort === 'string' && EFFORT_RE.test(update.effort)) out.effort = update.effort;
+    // A subagent on another CLI stopped by its CLI's plan limit (E7 S7.5), cleared when it runs again.
+    if (typeof update.limited === 'boolean') out.limited = update.limited;
+    if (typeof update.parentKey === 'string') out.parentKey = cleanKey(update.parentKey);
+    if (typeof update.phase === 'string') out.phase = scrubNativeText(update.phase, 200, scrub);
+    for (const k of ['tokens', 'toolCalls']) if (Number.isSafeInteger(update[k]) && update[k] >= 0) out[k] = update[k];
+    for (const k of ['startedAt', 'endedAt']) if (typeof update[k] === 'string' && Number.isFinite(Date.parse(update[k]))) out[k] = update[k];
+    if (typeof update.result === 'string' && update.result.trim()) {
+      const full = scrubNativeText(update.result, NATIVE_WINDOW, scrub, NATIVE_WINDOW);
+      out.result = full.slice(0, SUBAGENT_RESULT_CAP);
+      out.resultStatus = update.resultStatus === 'truncated' || update.result.length > NATIVE_WINDOW || full.length > SUBAGENT_RESULT_CAP ? 'truncated' : 'complete';
+    }
+    return out;
+  };
   return {
     agentId: scoped,
     /**
@@ -283,11 +342,44 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
       }
       if (typeof fields.now === 'string') fields.now = fields.now.replace(/\s+/g, ' ').trim();
       if (SUBAGENT_STATUSES.includes(update.status)) fields.status = update.status;
+      Object.assign(fields, detailOf(update));
       const previous = agentReadings.get(update.id) ?? {};
-      if (agentReadings.has(update.id) && Object.entries(fields).every(([k, v]) => previous[k] === v)) return;
-      if (!agentReadings.has(update.id) && agentReadings.size >= SUBAGENT_CAP) return;
+      if (!agentReadings.has(update.id) && fields.kind !== 'workflow' && [...agentReadings.values()].filter(a => a.kind !== 'workflow').length >= SUBAGENT_CAP) {
+        // A 33rd child runs; its record does not (D25): the turn says how many.
+        if (!unrecorded.has(update.id)) {
+          notRecorded += 1;
+          if (unrecorded.size < 4_096) unrecorded.add(update.id);
+          extrasPending = true; dirty = true; schedule();
+        }
+        return;
+      }
+      if (!agentReadings.has(update.id)) {
+        // Where the lead stood when the child was first seen, and when.
+        fields.position = leadCount;
+        fields.startedAt ??= new Date().toISOString();
+      }
+      const key = fields.key ?? previous.key, title = fields.title ?? previous.title;
+      // The ledger learns a child's key (and the names a Codex follow-up may
+      // use for it) and answers the turns it appeared in, this one included.
+      if (key && (key !== previous.key || title !== previous.title) && typeof runsOf === 'function') {
+        let runs = null;
+        try { runs = runsOf(key, { title }); } catch { /* the ledger is a readout */ }
+        if (Array.isArray(runs)) fields.runs = runs.filter(r => typeof r === 'string' && RUN_ID_RE.test(r)).slice(-SUBAGENT_RUNS_CAP);
+      }
+      const status = fields.status ?? previous.status;
+      if (SETTLED_SUBAGENT_STATUSES.includes(status)) { if (!previous.endedAt) fields.endedAt ??= new Date().toISOString(); }
+      const same = (k, v) => k === 'endedAt' ? Boolean(previous.endedAt) : k === 'runs' ? JSON.stringify(previous.runs) === JSON.stringify(v) : previous[k] === v;
+      if (agentReadings.has(update.id) && Object.entries(fields).every(([k, v]) => same(k, v))) return;
       const reading = { ...previous, ...fields };
+      // A child running again (a follow-up) has not ended.
+      if (!SETTLED_SUBAGENT_STATUSES.includes(status)) delete reading.endedAt;
       agentReadings.set(update.id, reading);
+      if (reading.kind === 'workflow') {
+        const siblings = [...agentReadings].filter(([, a]) => a.kind === 'workflow' && a.parentKey === reading.parentKey)
+          .sort((a, b) => (b[1].startedAt ?? '').localeCompare(a[1].startedAt ?? ''));
+        for (const [id] of siblings.slice(WORKFLOW_AGENT_CAP)) agentReadings.delete(id);
+        if (!agentReadings.has(update.id)) return;
+      }
       // A later update repairs metadata whose first report was shed while
       // offline; a delta alone cannot recover the child's prompt or title.
       push({ k: 'agent', id: scoped(update.id), ...reading });
@@ -319,6 +411,38 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
       }
       if (fresh.length) push({ k: 'note', t: scrub(`The CLI reported MCP servers that are not connected: ${fresh.join(', ')}.`).slice(0, TRACE_PROSE_CAP) });
     },
+    /**
+     * ONE SHELL COMMAND THE LEAD RAN THAT STARTS ANOTHER CLI (D23): its row
+     * by call id, updated at its result. Shown and never blocked, never a
+     * subagent and never counted toward the 32. `row` is outsideCli.mjs's.
+     */
+    outside(id, row) {
+      if (stopped || typeof id !== 'string' || !id || !row) return;
+      const previous = outsideRows.get(id);
+      if (!previous && outsideRows.size >= OUTSIDE_CAP) return;
+      const next = { ...(previous ?? {
+        id: scrubNativeText(id, 96, scrub), position: leadCount, startedAt: new Date().toISOString(),
+      }) };
+      if (typeof row.cli === 'string') next.cli = row.cli;
+      if (typeof row.model === 'string' && row.model) next.model = scrubNativeText(row.model, 80, scrub);
+      if (typeof row.command === 'string') next.command = scrubNativeText(row.command, OUTSIDE_COMMAND_CAP, scrub);
+      if (OUTSIDE_STATUSES.includes(row.status)) next.status = row.status;
+      if (next.status && next.status !== 'running' && !next.endedAt) next.endedAt = new Date().toISOString();
+      if (previous && JSON.stringify(previous) === JSON.stringify(next)) return;
+      outsideRows.set(id, next);
+      extrasPending = true; dirty = true; schedule();
+    },
+    workflow(row) {
+      if (stopped || !row) return;
+      if (row.launcherId && workflowPositions.size < WORKFLOW_CAP && !workflowPositions.has(row.launcherId)) workflowPositions.set(row.launcherId, leadCount);
+      if (!row.id || (!workflowRows.has(row.id) && workflowRows.size >= WORKFLOW_CAP)) return;
+      const { launcherId, ...next } = row;
+      next.position = workflowRows.get(row.id)?.position ?? workflowPositions.get(launcherId) ?? leadCount;
+      for (const k of ['id', 'key', 'name', 'description']) if (typeof next[k] === 'string') next[k] = scrubNativeText(next[k], k === 'description' ? 600 : 200, scrub);
+      next.phases = (next.phases ?? []).slice(0, 64).map(p => ({ ...p, title: scrubNativeText(p.title, 200, scrub) }));
+      workflowRows.set(row.id, next);
+      extrasPending = true; dirty = true; schedule();
+    },
     flush,
     /** No more entries, no more timers. The queue survives so a final flush can
      *  still deliver it. */
@@ -326,8 +450,12 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
       if (!stopped && orchestrationVersion === 2) {
         // Even a quiet child retains its identity after another child's noisy
         // stream overflowed the relay. These snapshots remain sequence-safe.
-        for (const [id, reading] of agentReadings) push({ k: 'agent', id: scoped(id), ...reading });
+        for (const [id, reading] of agentReadings) {
+          const steps = childSteps.get(scoped(id));
+          push({ k: 'agent', id: scoped(id), ...reading, ...(steps ? { steps } : {}) });
+        }
       }
+      if (!stopped && (notRecorded > 0 || outsideRows.size || workflowRows.size)) extrasPending = true;
       stopped = true;
       if (timer) {
         clearTimeout(timer);

package/bin/lib/turnDeclaration.mjs

@@ -4,7 +4,7 @@
  * inside prose or another language's fence stay as the CLI wrote them. */
 import { jsonObjectClosers } from './modelJson.mjs';
 
-const statuses = new Set(['delivered', 'blocked', 'prerequisite', 'nothing']);
+const statuses = new Set(['delivered', 'blocked', 'prerequisite', 'split', 'nothing']);
 function declaration(body) {
   const raw = body.trim();
   if (!raw.startsWith('{')) return false;
@@ -13,13 +13,13 @@ function declaration(body) {
     return value && typeof value === 'object' && !Array.isArray(value)
       && ((Object.hasOwn(value, 'summary') && Object.hasOwn(value, 'progress'))
         || (typeof value.status === 'string'
-          && (statuses.has(value.status) || ['summary', 'progress', 'question'].some(key => Object.hasOwn(value, key)))));
+          && (statuses.has(value.status) || ['summary', 'progress', 'question', 'split'].some(key => Object.hasOwn(value, key)))));
   } catch {
     // A truncated/invalid declaration must not fall through as an answer.
     // Require a protocol key at the root's opening and the declared status;
     // arbitrary malformed JSON remains useful diagnostic output.
-    return /^\{\s*"(?:status|summary|progress|question)"\s*:/.test(raw)
-      && /"status"\s*:\s*"(?:delivered|blocked|prerequisite|nothing)"/.test(raw);
+    return /^\{\s*"(?:status|summary|progress|question|split)"\s*:/.test(raw)
+      && /"status"\s*:\s*"(?:delivered|blocked|prerequisite|split|nothing)"/.test(raw);
   }
 }
 

package/bin/lib/turnGaps.mjs

@@ -16,6 +16,7 @@
  * listed. A malformed entry costs that entry alone.
  */
 export const GAP_STATUSES = ['not built', 'partly', 'unverified', 'unowned'];
+export const GAP_DISPOSITIONS = ['required', 'owned', 'optional', 'decision'];
 export const MAX_GAPS = 40;
 export const MAX_GAP_ITEM = 300;
 export const MAX_GAP_WHY = 800;
@@ -32,7 +33,10 @@ export function parseGaps(raw, scrub) {
     const status = typeof g.status === 'string' ? g.status.trim().toLowerCase() : '';
     if (!GAP_STATUSES.includes(status)) continue;
     const why = typeof g.why === 'string' && g.why.trim() ? cut(scrub(g.why.trim()), MAX_GAP_WHY) : null;
-    out.push({ item: cut(scrub(g.item.trim()), MAX_GAP_ITEM), status, ...(why ? { why } : {}) });
+    const disposition = GAP_DISPOSITIONS.includes(g.disposition) ? g.disposition : null;
+    const ownerTaskId = typeof g.ownerTaskId === 'string' && /^[a-zA-Z0-9_-]{1,100}$/.test(g.ownerTaskId) ? g.ownerTaskId : null;
+    out.push({ item: cut(scrub(g.item.trim()), MAX_GAP_ITEM), status, ...(why ? { why } : {}),
+      ...(disposition ? { disposition } : {}), ...(ownerTaskId ? { ownerTaskId } : {}) });
   }
   return out;
 }
@@ -41,7 +45,7 @@ export function parseGaps(raw, scrub) {
 export function gapsMarkdown(gaps) {
   if (!Array.isArray(gaps)) return null;
   if (!gaps.length) return '**Gaps against the request:** none reported.';
-  return ['**Gaps against the request**', ...gaps.map((g) => `- **${g.status}** — ${oneLine(g.item)}${g.why ? `: ${oneLine(g.why)}` : ''}`)].join('\n');
+  return ['**Gaps against the request**', ...gaps.map((g) => `- **${g.status}** — ${oneLine(g.item)}${g.why ? `: ${oneLine(g.why)}` : ''}${g.disposition ? ` (${g.disposition}${g.ownerTaskId ? `: card ${g.ownerTaskId}` : ''})` : ''}`)].join('\n');
 }
 
 const oneLine = (s) => s.replace(/\s*\n\s*/g, ' ');