flowviant 0.125.5 → 0.125.7

package/bin/lib/codexPersonal.mjs

@@ -56,7 +56,7 @@
  */
 import { readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { toml } from './projectToolRuntimes.mjs';
+import { isTable, newTable, parseCodexToml, tomlValue } from './codexToml.mjs';
 import { codexHome } from './codexHome.mjs';
 
 /** Where the login lives and which endpoint it signs into — top-level keys,
@@ -104,259 +104,6 @@ export const CODEX_HEADER_ENV_PREFIX = 'FLOWVIANT_CODEX_SECRET_HEADER_';
 
 /** Far past any real config.toml; a bigger one is not read. */
 const CONFIG_MAX_BYTES = 1024 * 1024;
-/** Arrays and inline tables nest no deeper than this in a file we read. */
-const MAX_DEPTH = 32;
-
-/** A number, date or time, kept as written so it is carried as written. */
-export class TomlRaw {
-  constructor(text) {
-    this.text = text;
-  }
-}
-const newTable = () => Object.create(null);
-const isTable = (v) => v !== null && typeof v === 'object' && !Array.isArray(v) && !(v instanceof TomlRaw);
-
-const BARE = /[A-Za-z0-9_-]+/y;
-// First match wins, so the forms that begin like an integer come first.
-const SCALAR =
-  /[+-]?(?:inf|nan)|0x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|\d{4}-\d{2}-\d{2}(?:[Tt ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:[Zz]|[+-]\d{2}:\d{2})?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?|[+-]?\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?/y;
-
-/**
- * A BOUNDED TOML READER — the repo carries no TOML library, and the one file
- * it reads is Codex's own config. Whole documents: tables, arrays of tables
- * (the daemon's own `[[skills.config]]` in an agent's home), dotted and quoted
- * keys, the four string forms, arrays, inline tables, booleans, and numbers,
- * dates and times kept as written. Anything else throws, and the caller
- * carries nothing — a partial read is never a license to guess.
- */
-export function parseCodexToml(text) {
-  const src = String(text).replace(/^/, '');
-  const n = src.length;
-  let i = 0;
-  const fail = (why) => {
-    throw new Error(`config.toml: ${why} at offset ${i}`);
-  };
-  const ws = () => {
-    while (i < n && (src[i] === ' ' || src[i] === '\t')) i++;
-  };
-  const comment = () => {
-    if (src[i] === '#') while (i < n && src[i] !== '\n') i++;
-  };
-  const newline = () => {
-    if (src[i] === '\n') return (i += 1), true;
-    if (src[i] === '\r' && src[i + 1] === '\n') return (i += 2), true;
-    return false;
-  };
-  /** Blank lines, comments and whitespace, as between array items. */
-  const gap = () => {
-    for (;;) {
-      ws();
-      comment();
-      if (!newline()) return;
-    }
-  };
-  const endOfLine = () => {
-    ws();
-    comment();
-    if (i < n && !newline()) fail('expected the end of the line');
-  };
-  const hexChar = (len) => {
-    const h = src.slice(i, i + len);
-    if (h.length !== len || !/^[0-9A-Fa-f]+$/.test(h)) fail('bad escape');
-    i += len;
-    const cp = parseInt(h, 16);
-    if (cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) fail('bad escape');
-    return String.fromCodePoint(cp);
-  };
-  const escape = () => {
-    const e = src[i + 1];
-    i += 2;
-    switch (e) {
-      case 'b': return '\b';
-      case 't': return '\t';
-      case 'n': return '\n';
-      case 'f': return '\f';
-      case 'r': return '\r';
-      case 'e': return '\x1b';
-      case '"': return '"';
-      case '\\': return '\\';
-      case 'x': return hexChar(2);
-      case 'u': return hexChar(4);
-      case 'U': return hexChar(8);
-      default: return fail('bad escape');
-    }
-  };
-  const basicString = () => {
-    i += 1;
-    let s = '';
-    for (;;) {
-      if (i >= n) fail('unterminated string');
-      const ch = src[i];
-      if (ch === '"') return (i += 1), s;
-      if (ch === '\n' || ch === '\r') fail('newline in a string');
-      if (ch === '\\') s += escape();
-      else (s += ch), (i += 1);
-    }
-  };
-  const literalString = () => {
-    const end = src.indexOf("'", i + 1);
-    if (end < 0) fail('unterminated string');
-    const s = src.slice(i + 1, end);
-    if (/[\r\n]/.test(s)) fail('newline in a string');
-    i = end + 1;
-    return s;
-  };
-  const LINE_END_BACKSLASH = /\\[ \t]*\r?\n/y;
-  const multiline = (quote, escapes) => {
-    i += 3;
-    newline(); // a newline straight after the opening quotes is not content
-    let s = '';
-    for (;;) {
-      if (i >= n) fail('unterminated string');
-      if (src.startsWith(quote.repeat(3), i)) {
-        let q = 3;
-        while (q < 5 && src[i + q] === quote) q++; // up to two belong to the content
-        s += quote.repeat(q - 3);
-        i += q;
-        return s;
-      }
-      if (escapes && src[i] === '\\') {
-        LINE_END_BACKSLASH.lastIndex = i;
-        if (LINE_END_BACKSLASH.test(src)) {
-          i = LINE_END_BACKSLASH.lastIndex;
-          while (i < n && /[ \t\r\n]/.test(src[i])) i++;
-        } else s += escape();
-      } else (s += src[i]), (i += 1);
-    }
-  };
-  const key = () => {
-    const parts = [];
-    for (;;) {
-      ws();
-      if (src[i] === '"') {
-        if (src.startsWith('"""', i)) fail('a multi-line key');
-        parts.push(basicString());
-      } else if (src[i] === "'") {
-        if (src.startsWith("'''", i)) fail('a multi-line key');
-        parts.push(literalString());
-      } else {
-        BARE.lastIndex = i;
-        const m = BARE.exec(src);
-        if (!m) fail('expected a key');
-        parts.push(m[0]);
-        i = BARE.lastIndex;
-      }
-      ws();
-      if (src[i] !== '.') return parts;
-      i += 1;
-    }
-  };
-  const assign = (target, path, v) => {
-    let t = target;
-    for (const k of path.slice(0, -1)) {
-      if (!Object.hasOwn(t, k)) t[k] = newTable();
-      else if (!isTable(t[k])) fail(`"${k}" is not a table`);
-      t = t[k];
-    }
-    const last = path.at(-1);
-    if (Object.hasOwn(t, last)) fail(`"${last}" is defined twice`);
-    t[last] = v;
-  };
-  let depth = 0;
-  const nested = (open) => {
-    if (++depth > MAX_DEPTH) fail('nested too deep');
-    try {
-      return open();
-    } finally {
-      depth -= 1;
-    }
-  };
-  const array = () => {
-    i += 1;
-    const out = [];
-    for (;;) {
-      gap();
-      if (src[i] === ']') return (i += 1), out;
-      out.push(value());
-      gap();
-      if (src[i] === ',') i += 1;
-      else if (src[i] === ']') return (i += 1), out;
-      else fail('expected , or ]');
-    }
-  };
-  const inlineTable = () => {
-    i += 1;
-    const t = newTable();
-    for (;;) {
-      gap();
-      if (src[i] === '}') return (i += 1), t;
-      keyValue(t);
-      gap();
-      if (src[i] === ',') i += 1;
-      else if (src[i] === '}') return (i += 1), t;
-      else fail('expected , or }');
-    }
-  };
-  const word = (w) => src.startsWith(w, i) && !/[A-Za-z0-9_-]/.test(src[i + w.length] ?? '');
-  const value = () => {
-    const ch = src[i];
-    if (ch === '"') return src.startsWith('"""', i) ? multiline('"', true) : basicString();
-    if (ch === "'") return src.startsWith("'''", i) ? multiline("'", false) : literalString();
-    if (ch === '[') return nested(array);
-    if (ch === '{') return nested(inlineTable);
-    if (word('true')) return (i += 4), true;
-    if (word('false')) return (i += 5), false;
-    SCALAR.lastIndex = i;
-    const m = SCALAR.exec(src);
-    if (!m) fail('a value this reader does not know');
-    i = SCALAR.lastIndex;
-    if (/[A-Za-z0-9_.:+-]/.test(src[i] ?? '')) fail('a value this reader does not know');
-    return new TomlRaw(m[0]);
-  };
-  const keyValue = (target) => {
-    const path = key();
-    if (src[i] !== '=') fail('expected =');
-    i += 1;
-    ws();
-    assign(target, path, value());
-  };
-
-  const root = newTable();
-  let current = root;
-  for (;;) {
-    gap();
-    if (i >= n) return root;
-    if (src[i] !== '[') {
-      keyValue(current);
-      endOfLine();
-      continue;
-    }
-    const many = src[i + 1] === '[';
-    i += many ? 2 : 1;
-    const path = key();
-    if (many ? !src.startsWith(']]', i) : src[i] !== ']') fail('an unclosed table header');
-    i += many ? 2 : 1;
-    endOfLine();
-    let t = root;
-    for (const k of path.slice(0, -1)) {
-      if (!Object.hasOwn(t, k)) t[k] = newTable();
-      const v = Array.isArray(t[k]) ? t[k].at(-1) : t[k];
-      if (!isTable(v)) fail(`"${k}" is not a table`);
-      t = v;
-    }
-    const last = path.at(-1);
-    if (many) {
-      if (!Object.hasOwn(t, last)) t[last] = [];
-      if (!Array.isArray(t[last])) fail(`"${last}" is not an array of tables`);
-      current = newTable();
-      t[last].push(current);
-    } else {
-      if (!Object.hasOwn(t, last)) t[last] = newTable();
-      else if (!isTable(t[last])) fail(`"${last}" is not a table`);
-      current = t[last];
-    }
-  }
-}
 
 /**
  * The person's config.toml, where the turn's Codex would look —
@@ -374,17 +121,6 @@ export function readPersonalCodexConfig(env = process.env) {
   }
 }
 
-/** One value as TOML, as a `-c` override's value is parsed. */
-const bareKeyOr = (k) => (/^[A-Za-z0-9_-]+$/.test(k) ? k : toml(k));
-export function tomlValue(v) {
-  if (typeof v === 'string') return toml(v);
-  if (typeof v === 'boolean') return String(v);
-  if (v instanceof TomlRaw) return v.text;
-  if (Array.isArray(v)) return `[${v.map(tomlValue).join(',')}]`;
-  if (isTable(v)) return `{${Object.keys(v).map((k) => `${bareKeyOr(k)}=${tomlValue(v[k])}`).join(',')}}`;
-  throw new Error('not a TOML value');
-}
-
 const isString = (v) => typeof v === 'string';
 const isStringList = (v) => Array.isArray(v) && v.every(isString);
 const nonEmpty = (v) => typeof v === 'string' && v.trim() !== '';

package/bin/lib/codexProjectRead.mjs

@@ -6,16 +6,17 @@ import { execFileSync } from 'node:child_process';
 import { lstatSync, readdirSync, realpathSync } from 'node:fs';
 import { isAbsolute, join, dirname } from 'node:path';
 import { git } from './git.mjs';
-import { codexResearchHelper } from './codexResearch.mjs';
+import { CODEX_HELPER_MIN, codexResearchHelper } from './codexResearch.mjs';
+import { versionAtLeast } from './versionOrder.mjs';
 import { unattendedEnv } from './noWindowEnv.mjs';
 
 export function projectReadBoundary({ cwd, knowledgeDir, env = process.env }) {
   if (process.platform !== 'linux') throw new Error('Project-scoped Codex reads require Linux or WSL.');
   if (!isAbsolute(cwd ?? '')) throw new Error('Project-scoped Codex reads require an absolute project directory.');
   const helper = codexResearchHelper(env);
-  const version = execFileSync(helper, ['--version'], { encoding: 'utf8', timeout: 10000, env: unattendedEnv(env) }).match(/^codex-cli (\d+)\.(\d+)\.(\d+)/);
-  if (!version || version.slice(1).map(Number).reduce((n, v) => n * 1000 + v, 0) < 159002)
-    throw new Error('Project-scoped reads need Codex CLI 0.159.2 or newer. Update Codex before retrying.');
+  const version = execFileSync(helper, ['--version'], { encoding: 'utf8', timeout: 10000, env: unattendedEnv(env) }).match(/^codex-cli (\d+\.\d+\.\d+)/);
+  if (!version || !versionAtLeast(version[1], CODEX_HELPER_MIN))
+    throw new Error(`Project-scoped reads need Codex CLI ${CODEX_HELPER_MIN} or newer. Update Codex before retrying.`);
   const project = realpathSync(cwd);
   // Resolve both: linked worktrees have their own HEAD/index and shared
   // objects/refs in the common directory. Never grant the parent checkout.

package/bin/lib/codexResearch.mjs

@@ -10,6 +10,7 @@ import { ensureRealSubdir, realDirState } from './ownedDirs.mjs';
 import { closeSync, constants, copyFileSync, existsSync, fstatSync, openSync, readFileSync, readSync, lstatSync, mkdirSync, readdirSync, realpathSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { versionAtLeast } from './versionOrder.mjs';
 
 const MAX_FILES = 20_000;
 const MAX_BYTES = 128 * 1024 * 1024;
@@ -51,6 +52,11 @@ export function copyResearchView(source, destination, budget = { files: 0, bytes
   }
 }
 
+/** The helper both the research fence and project-scoped reads need
+ * (codexProjectRead.mjs): one floor, so neither runs on a Codex the other
+ * refuses. */
+export const CODEX_HELPER_MIN = '0.159.2';
+
 /** Resolve the actual sandbox helper without granting the person's bin/home.
  * Support native installs and the npm wrapper's platform package. Unknown
  * installations refuse; granting the whole home to find a helper is no fence.
@@ -147,9 +153,9 @@ export async function runIsolatedResearch(opts, run, {
   if (process.platform !== 'linux') throw new Error('Isolated Codex research requires Linux or WSL.');
   const original = realpathSync(opts.cwd);
   const helper = resolveHelper();
-  const version = readVersion(helper).match(/codex-cli (\d+)\.(\d+)\.(\d+)/);
-  if (!version || version.slice(1).map(Number).reduce((n, v) => n * 1000 + v, 0) < 159002)
-    throw new Error('Isolated research needs Codex CLI 0.159.2 or newer. Restart after updating Codex.');
+  const version = readVersion(helper).match(/codex-cli (\d+\.\d+\.\d+)/);
+  if (!version || !versionAtLeast(version[1], CODEX_HELPER_MIN))
+    throw new Error(`Isolated research needs Codex CLI ${CODEX_HELPER_MIN} or newer. Restart after updating Codex.`);
   // Both publication parents must be real directories in this checkout, or
   // absent — never a link, dangling or not (ownedDirs.mjs).
   for (const dir of [join(original, '.flowviant'), join(original, '.flowviant/artifacts')])

package/bin/lib/codexSubagentEvents.mjs

@@ -1,24 +1,28 @@
-const SUBAGENT_LIMIT = 32;
-const THREAD_ID = /^[a-zA-Z0-9-]{16,64}$/;
+import { CODEX_CHILD_THREAD_RE } from './conversationIds.mjs';
+import { NATIVE_AGENT_TOOLS } from './nativeAgentTools.mjs';
+import { SUBAGENT_CAP } from './subagentBounds.mjs';
+
 const snake = s => String(s ?? '').replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+// A collab item as exec (`collab_tool_call`) or a rollout (`CollabAgentToolCall`) spells it.
+const isCollabItem = item => ['collab_tool_call', 'CollabAgentToolCall'].includes(item?.type ?? item?.item_type);
 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 (!isCollabItem(item) || 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 [];
+  if (!isCollabItem(item)) 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);
+  const ids = [...new Set([...(item.receiver_thread_ids ?? []), ...Object.keys(states)])].slice(0, SUBAGENT_CAP);
   return ids.flatMap(id => {
-    if (typeof id !== 'string' || !THREAD_ID.test(id)) return [];
+    if (typeof id !== 'string' || !CODEX_CHILD_THREAD_RE.test(id)) return [];
     const state = states[id];
     const receiver = item.receiver_agents?.find(a => a.thread_id === id);
     const status = statusOf(state?.status ?? state);
@@ -27,7 +31,7 @@ export function codexCollabUpdates(item) {
         ...(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' } : {}),
+      ...(status ? { status } : NATIVE_AGENT_TOOLS.codex.stop.includes(tool) ? { status: 'stopped' } : {}),
       ...(typeof message === 'string' ? { now: message, message } : {}),
     }];
   });

package/bin/lib/codexSubagents.mjs

@@ -3,15 +3,22 @@
  * rollouts named by this turn's native spawn receipts, never a global latest.
  * rust-v0.160.0: exec_events.rs CollabToolCallItem; core/agent/child_config.rs
  * reapplies the live turn's approval and permission profile after role config.
+ * V2 rollout shapes measured on codex-cli 0.163.0 (codexSubagents.test.mjs).
  */
 import { open } from 'node:fs/promises';
 import { codexRolloutFile } from './runtimeLimits.mjs';
+import { CODEX_CHILD_THREAD_RE } from './conversationIds.mjs';
+import { followJsonl } from './jsonlTail.mjs';
 import { codexCollabUpdates, codexSpawnResult, statusOf } from './codexSubagentEvents.mjs';
+import { NATIVE_AGENT_TOOLS } from './nativeAgentTools.mjs';
+import { SUBAGENT_CAP } from './subagentBounds.mjs';
 
-export const SUBAGENT_LIMIT = 32;
-const READ_BYTES = 256 * 1024;
-const INITIAL_SCAN = 4 * 1024 * 1024;
-const THREAD_ID = /^[a-zA-Z0-9-]{16,64}$/;
+const CODEX = NATIVE_AGENT_TOOLS.codex;
+// A rollout shows a superset of what the gate sees: send_message and the
+// stop tools too.
+const COLLAB_CALLS = [...CODEX.spawn, ...CODEX.followup, ...CODEX.message, ...CODEX.stop];
+// The calls whose output names a child's receipt.
+const RECEIPT_CALLS = [...CODEX.spawn, ...CODEX.followup];
 
 export function createCodexSubagentReader({ since = Date.now(), env = process.env, onSubagent, onActivity, onToolEvent, onSpawnResult,
   findFile = codexRolloutFile } = {}) {
@@ -24,8 +31,9 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
   let stopped = false;
   let chain = Promise.resolve();
   const report = update => {
-    if (!update?.id || !THREAD_ID.test(update.id)) return;
-    if (!readers.has(update.id) && readers.size >= SUBAGENT_LIMIT + 1) return;
+    if (!update?.id || !CODEX_CHILD_THREAD_RE.test(update.id)) return;
+    // The root thread plus the run's children.
+    if (!readers.has(update.id) && readers.size >= SUBAGENT_CAP + 1) return;
     if (!readers.has(update.id))
       readers.set(update.id, { offset: null, rest: Buffer.alloc(0), seen: new Set(), live: false });
     const { message, ...record } = update;
@@ -35,7 +43,7 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
     targets.set(path, id);
     if (targets.size > 128) targets.delete(targets.keys().next().value);
   };
-  const targetId = value => targets.get(value) ?? (THREAD_ID.test(value ?? '') ? value : null);
+  const targetId = value => targets.get(value) ?? (CODEX_CHILD_THREAD_RE.test(value ?? '') ? value : null);
 
   function observe(ev, owner) {
     const at = Date.parse(ev?.timestamp ?? '');
@@ -68,40 +76,52 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
         if (command) step(p.call_id, Array.isArray(command) ? command.join(' ') : command);
         return;
       }
-      if (owner !== root && name === 'request_user_input') {
+      if (owner !== root && CODEX.ask.includes(name)) {
         questions.set(p.call_id, owner);
         if (questions.size > 128) questions.delete(questions.keys().next().value);
         report({ id: owner, status: 'asked' }); return;
       }
-      if (!['spawn_agent', 'send_input', 'send_message', 'followup_task', 'resume_agent', 'close_agent', 'interrupt_agent'].includes(name)) return;
+      if (!COLLAB_CALLS.includes(name)) return;
       let args;
       try { args = JSON.parse(p.arguments); } catch { return; }
       calls.set(p.call_id, { name, args });
       if (calls.size > 128) calls.delete(calls.keys().next().value);
       const id = targetId(args.target ?? args.id);
       if (id && name !== 'spawn_agent') {
-        const stopped = name === 'close_agent' || name === 'interrupt_agent';
+        const stopped = CODEX.stop.includes(name);
         report({ id, ...(stopped ? { status: 'stopped' } : name === 'followup_task' ? { status: 'running' } : {}) });
       }
     }
     if (ev.type === 'response_item' && p.type === 'function_call_output') {
       if (questions.has(p.call_id)) { report({ id: questions.get(p.call_id), status: 'running' }); questions.delete(p.call_id); }
       const call = calls.get(p.call_id);
-      if (!['spawn_agent', 'followup_task', 'resume_agent', 'send_input'].includes(call?.name)) return;
-      let output;
+      if (!RECEIPT_CALLS.includes(call?.name)) return;
+      let output = null;
       try {
         const body = Array.isArray(p.output) ? p.output.map(b => b.text ?? '').join('') : p.output;
         output = typeof body === 'string' ? JSON.parse(body) : body;
-      } catch { onSpawnResult?.({ callId: p.call_id, success: false }); return; }
-      const id = output?.agent_id ?? output?.thread_id;
-      const receipt = id ?? output?.agent_path ?? (call.name !== 'spawn_agent' && (output?.submission_id || output?.status) ? call.args.target ?? call.args.id : null);
-      onSpawnResult?.({ callId: p.call_id, success: Boolean(receipt), ...(receipt ? { nativeId: receipt } : {}) });
+      } catch { /* the tool's own words */ }
+      // ONLY AN EXPLICIT FAILURE FREES A SLOT (2026-10-17). These tools answer
+      // JSON on success (their output schemas), so plain text is the native
+      // error ("collab spawn failed: …"); V2 followup_task declares no output,
+      // and a JSON answer naming no receipt is unknown. Neither is a failure.
+      if (!output || typeof output !== 'object') {
+        if (call.name !== 'followup_task') onSpawnResult?.({ callId: p.call_id, success: false });
+        return;
+      }
+      // V2 (measured on 0.163) answers only the canonical task path; the
+      // thread arrived first, on the spawn's SubAgentActivity.
+      const path = output.task_name ?? output.agent_path;
+      const id = output.agent_id ?? output.thread_id ?? (typeof path === 'string' ? targets.get(path) : undefined);
+      const receipt = call.name === 'spawn_agent' ? output.agent_id ?? output.thread_id ?? path
+        : output.submission_id || output.status ? call.args.target ?? call.args.id : null;
+      if (receipt) onSpawnResult?.({ callId: p.call_id, success: true, nativeId: receipt });
       if (call.name !== 'spawn_agent') return;
       if (!id) return;
       const args = call.args;
       const title = args.task_name ?? args.description ?? output.agent_nickname ?? '';
       if (args.task_name) rememberTarget(args.task_name, id);
-      if (output.agent_path) rememberTarget(output.agent_path, id);
+      if (typeof path === 'string') rememberTarget(path, id);
       report({ id, kind: args.agent_type ?? '', title, brief: args.message ?? '', status: 'running', now: '' });
       return;
     }
@@ -112,7 +132,13 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
     if (ev.type !== 'event_msg') return;
     const activityState = item => {
       const kind = String(item.kind ?? '').toLowerCase();
-      if (item.agent_thread_id) report({ id: item.agent_thread_id, title: item.agent_path,
+      if (!item.agent_thread_id) return;
+      if (item.agent_path) rememberTarget(item.agent_path, item.agent_thread_id);
+      // A start carries the spawn's own call id (measured on 0.163): the
+      // controller binds the native thread to the record that call reserved.
+      const callId = kind === 'started' ? item.call_id ?? item.id : null;
+      report({ id: item.agent_thread_id, title: item.agent_path,
+        ...(typeof callId === 'string' && callId ? { callId } : {}),
         ...(['started', 'completed', 'interrupted'].includes(kind) ? {
           status: kind === 'completed' ? 'done' : kind === 'interrupted' ? 'stopped' : 'running',
         } : {}),
@@ -163,41 +189,18 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
       if (!file) return;
       state.file = file;
       fh = await open(file, 'r');
-      const { size } = await fh.stat();
       const initial = state.offset === null;
       const initialEvents = [];
-      if (initial) {
-        state.offset = Math.max(0, size - INITIAL_SCAN);
-        state.skip = state.offset > 0;
-      }
-      if (size < state.offset) { state.offset = 0; state.rest = Buffer.alloc(0); }
-      // Bounded work per poll, including an immediately completed child.
-      const end = Math.min(size, state.offset + INITIAL_SCAN);
-      while (state.offset < end) {
-        const buffer = Buffer.alloc(Math.min(READ_BYTES, end - state.offset));
-        const { bytesRead } = await fh.read(buffer, 0, buffer.length, state.offset);
-        if (!bytesRead) break;
-        state.offset += bytesRead;
-        const data = Buffer.concat([state.rest, buffer.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 (state.skip) { state.skip = false; continue; }
-          try {
-            const ev = JSON.parse(line);
-            if (initial && id !== root) initialEvents.push(ev);
-            else if (id === root || state.live || ev.type === 'session_meta') observe(ev, id);
-            else if (ev.type === 'event_msg' && ['task_started', 'turn_started'].includes(ev.payload?.type)) {
-              state.live = true; observe(ev, id);
-            }
-          } catch { /* non-JSON/unknown native events */ }
-        }
-        // Keep bytes across UTF-8 and partial-line boundaries. Oversized lines
-        // are discarded through their newline rather than reparsed as a suffix.
-        state.rest = data.subarray(start);
-        if (state.rest.length > READ_BYTES) { state.rest = Buffer.alloc(0); state.skip = true; }
-      }
+      await followJsonl(fh, state, line => {
+        try {
+          const ev = JSON.parse(line);
+          if (initial && id !== root) initialEvents.push(ev);
+          else if (id === root || state.live || ev.type === 'session_meta') observe(ev, id);
+          else if (ev.type === 'event_msg' && ['task_started', 'turn_started'].includes(ev.payload?.type)) {
+            state.live = true; observe(ev, id);
+          }
+        } catch { /* non-JSON/unknown native events */ }
+      });
       if (initial && id !== root) {
         // A fork copies the parent's old EventMsgs. Only the child's newest
         // native turn belongs to this card; inherited history is never replayed.
@@ -219,7 +222,7 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
   };
   return {
     thread(id) {
-      if (!THREAD_ID.test(id ?? '') || root) return;
+      if (!CODEX_CHILD_THREAD_RE.test(id ?? '') || root) return;
       root = id;
       readers.set(id, { offset: null, rest: Buffer.alloc(0), seen: new Set(), live: false });
       if (!stopped) { timer = setInterval(() => void flush(), 1_000); timer.unref?.(); }