@hearsay-tools/squawk 0.0.0-stage → 0.17.0-dev.5682

package/scripts/mock-codex-coalesce-steer.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// #486 review: buffers each `turn/steer` RPC response and writes it in the SAME
+// stdout write as the following `turn/completed` (or `turn/failed`) notification,
+// preserving order. Reproduces Codex humanPromptsPending lagging a coalesced chunk.
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const child = spawn(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'mock-codex-app-server.mjs'), ...process.argv.slice(2)], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: process.env,
+});
+const steerIds = new Set();
+let stdinBuf = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  child.stdin.write(chunk);
+  stdinBuf += chunk;
+  let idx;
+  while ((idx = stdinBuf.indexOf('\n')) >= 0) {
+    const line = stdinBuf.slice(0, idx);
+    stdinBuf = stdinBuf.slice(idx + 1);
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method === 'turn/steer' && typeof msg.id === 'number') steerIds.add(msg.id);
+    } catch { /* ignore a partial or non-JSON line */ }
+  }
+});
+process.stdin.on('end', () => child.stdin.end());
+
+let outBuf = '';
+const held = [];
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', chunk => {
+  outBuf += chunk;
+  let idx;
+  while ((idx = outBuf.indexOf('\n')) >= 0) {
+    const line = outBuf.slice(0, idx + 1);
+    outBuf = outBuf.slice(idx + 1);
+    let msg;
+    try { msg = JSON.parse(line); } catch { process.stdout.write(line); continue; }
+    if (typeof msg.id === 'number' && steerIds.has(msg.id) && (msg.result !== undefined || msg.error !== undefined)) {
+      steerIds.delete(msg.id);
+      held.push(line);
+      continue;
+    }
+    if ((msg.method === 'turn/completed' || msg.method === 'turn/failed') && held.length) {
+      process.stdout.write(held.splice(0).join('') + line);
+      continue;
+    }
+    process.stdout.write(line);
+  }
+});
+child.on('exit', (code, signal) => {
+  if (outBuf) process.stdout.write(outBuf);
+  if (held.length) process.stdout.write(held.join(''));
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});

package/scripts/mock-codex-reverse-steer.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+// #486 review round 2: buffers each `turn/steer` RPC response and writes it AFTER
+// the following `turn/completed` (or `turn/failed`) notification. Codex reads
+// stdout with `for await`, so microtasks run between those lines: the completed
+// boundary settles before startOrSteerTurn sees the steer result.
+// Do not wrap mock:steer-race / mock:steer-strand — those already emit completed
+// then the steer response; this wrapper would hold that response until a later turn.
+//
+// Default (unread): drop the in-turn userMessage/agentMessage echo of the held
+// steer so the follow-up was accepted and never read. CEZ_MOCK_REVERSE_ECHO=1
+// keeps those echoes (read-in-turn) and still delays the steer response.
+// CEZ_MOCK_DELAY_TURN_STARTED_MS holds stdout after a follow-up turn/start
+// response so turn/started arrives later (review round 4).
+//
+// A steer that lands after this turn already completed (release() before the
+// RPC was on the wire) must not be held for a later completed that never
+// comes — that deadlocked holdsHumanInput() until teardown (#486 round 5).
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const echoInTurn = process.env.CEZ_MOCK_REVERSE_ECHO === '1';
+const delayTurnStartedMs = Number.parseInt(process.env.CEZ_MOCK_DELAY_TURN_STARTED_MS ?? '0', 10) || 0;
+const child = spawn(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'mock-codex-app-server.mjs'), ...process.argv.slice(2)], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: process.env,
+});
+const steerIds = new Set();
+const steeredClientIds = new Set();
+const steeredTexts = new Set();
+const followUpStartIds = new Set();
+let turnStartCount = 0;
+let forwardedCompleted = false;
+let stdinBuf = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  child.stdin.write(chunk);
+  stdinBuf += chunk;
+  let idx;
+  while ((idx = stdinBuf.indexOf('\n')) >= 0) {
+    const line = stdinBuf.slice(0, idx);
+    stdinBuf = stdinBuf.slice(idx + 1);
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method === 'turn/steer' && typeof msg.id === 'number') {
+        steerIds.add(msg.id);
+        const clientId = msg.params?.clientUserMessageId;
+        if (typeof clientId === 'string') steeredClientIds.add(clientId);
+        const text = msg.params?.input?.map?.((part) => part.text ?? '').join('\n') ?? '';
+        if (text) steeredTexts.add(text);
+      } else if (msg.method === 'turn/start' && typeof msg.id === 'number') {
+        turnStartCount += 1;
+        if (turnStartCount > 1) followUpStartIds.add(msg.id);
+      }
+    } catch { /* ignore a partial or non-JSON line */ }
+  }
+});
+process.stdin.on('end', () => child.stdin.end());
+
+let outBuf = '';
+const held = [];
+let stdoutPaused = false;
+const pausedChunks = [];
+let resumeTimer;
+const resumeStdout = () => {
+  stdoutPaused = false;
+  resumeTimer = undefined;
+  const pending = pausedChunks.splice(0);
+  for (const chunk of pending) process.stdout.write(chunk);
+};
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', chunk => {
+  outBuf += chunk;
+  let idx;
+  while ((idx = outBuf.indexOf('\n')) >= 0) {
+    const line = outBuf.slice(0, idx + 1);
+    outBuf = outBuf.slice(idx + 1);
+    dispatchChildLine(line);
+  }
+});
+
+// Returns true when the line was fully handled, so dispatchChildLine must not
+// write or fall through for it.
+function handleSteerResponse(line, msg) {
+  if (typeof msg.id !== 'number' || !steerIds.has(msg.id) || (msg.result === undefined && msg.error === undefined)) return false;
+  steerIds.delete(msg.id);
+  if (forwardedCompleted) process.stdout.write(line);
+  else held.push(line);
+  return true;
+}
+
+function handleCompletedBoundary(line, msg) {
+  if ((msg.method !== 'turn/completed' && msg.method !== 'turn/failed') || held.length === 0) return false;
+  forwardedCompleted = true;
+  process.stdout.write(line + held.splice(0).join(''));
+  return true;
+}
+
+function holdFollowUpStart(msg) {
+  if (delayTurnStartedMs > 0 && typeof msg.id === 'number' && followUpStartIds.has(msg.id) && msg.result !== undefined) {
+    followUpStartIds.delete(msg.id);
+    stdoutPaused = true;
+    resumeTimer = setTimeout(resumeStdout, delayTurnStartedMs);
+  }
+}
+
+function dispatchChildLine(line) {
+  if (stdoutPaused) {
+    pausedChunks.push(line);
+    return;
+  }
+  let msg;
+  try { msg = JSON.parse(line); } catch { process.stdout.write(line); return; }
+  if (handleSteerResponse(line, msg)) return;
+  if (held.length && isSteerEcho(msg)) {
+    if (echoInTurn) process.stdout.write(line);
+    return;
+  }
+  if (handleCompletedBoundary(line, msg)) return;
+  if (msg.method === 'turn/completed' || msg.method === 'turn/failed') forwardedCompleted = true;
+  if (msg.method === 'turn/started') forwardedCompleted = false;
+  process.stdout.write(line);
+  holdFollowUpStart(msg);
+}
+child.on('exit', (code, signal) => {
+  if (resumeTimer) clearTimeout(resumeTimer);
+  // A killed follow-up whose turn/started is still paused must not flush into a
+  // closing runner; with the hold fix the delay elapses before close.
+  if (!stdoutPaused) {
+    if (outBuf) process.stdout.write(outBuf);
+    if (held.length) process.stdout.write(held.join(''));
+  }
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});
+
+function isSteerEcho(msg) {
+  const item = msg.params?.item;
+  if (!item || typeof item !== 'object') return false;
+  if (item.type === 'userMessage' && typeof item.clientId === 'string' && steeredClientIds.has(item.clientId)) return true;
+  if (item.type === 'agentMessage' && typeof item.text === 'string' && steeredTexts.has(item.text)) return true;
+  return false;
+}

package/scripts/mock-codex-subagents.mjs

@@ -0,0 +1,52 @@
+// `mock:subagent-background` on the Codex app-server wire (hearsay-tools/cezarion#2431). Frame
+// shapes follow src/core/__fixtures__/codex/background-subagent.ndjson, trimmed from a live
+// codex-cli 0.164.0 capture: the parent turn completes while the spawned child thread runs; the
+// child's end is its own turn/completed (rootTurnId = the parent turn) and then a parent-thread
+// `subAgentActivity(kind: completed)` stamped with the already-completed parent turn id. Codex
+// never starts a parent turn by itself, so there is no `subagent-resume`, and it reports no
+// failed or interrupted child, so `subagent-status` is ignored. Prompt tokens:
+// - `parity-release=<path>` (required): the children's end waits until this file exists;
+// - `subagents=<n>`: spawn n children, th_bg_01…, whose ends follow in order;
+// - `subagent-duplicate`: send each completed activity twice;
+// - `mock:monitoring` / `mock:done`: the parking turn's text ends with that marker.
+// The parking turn returns at once, so turns started while the children run are answered.
+export async function replyWithBackgroundSubagents(turnText, { emit, afterParityPark }) {
+  const count = Math.max(1, Number(/\bsubagents=(\d+)/.exec(turnText)?.[1] ?? 1));
+  const parentTurn = 'turn_mock_1';
+  const children = Array.from({ length: count }, (_, index) => {
+    const n = String(index + 1).padStart(2, '0');
+    return { callId: `call_bg_${n}`, threadId: `th_bg_${n}`, turnId: `turn_bg_${n}`, agentPath: `/root/background_${n}` };
+  });
+  const onParent = (item) => ({ threadId: 'th_mock_1', turnId: parentTurn, item });
+  for (const child of children) {
+    const started = { type: 'subAgentActivity', model: 'gpt-mock', reasoningEffort: 'low', id: child.callId, kind: 'started', agentThreadId: child.threadId, agentPath: child.agentPath };
+    emit({ method: 'thread/status/changed', params: { threadId: child.threadId, status: { type: 'idle' } } });
+    emit({ method: 'item/started', params: onParent(started) });
+    emit({ method: 'item/completed', params: onParent(started) });
+    emit({ method: 'thread/status/changed', params: { threadId: child.threadId, status: { type: 'active', activeFlags: [] } } });
+    emit({ method: 'turn/started', params: { threadId: child.threadId, turn: { id: child.turnId, rootTurnId: parentTurn, items: [], status: 'inProgress' } } });
+  }
+  const marker = turnText.includes('mock:monitoring') ? '\nCEZ:MONITORING' : turnText.includes('mock:done') ? '\nCEZ:DONE' : '';
+  const parked = `SPAWNED ${count}${marker}`;
+  emit({ method: 'item/completed', params: onParent({ type: 'agentMessage', id: 'bg-parent', text: parked, phase: 'final_answer' }) });
+  emit({ method: 'thread/status/changed', params: { threadId: 'th_mock_1', status: { type: 'idle' } } });
+  emit({ method: 'turn/completed', params: { threadId: 'th_mock_1', turn: { id: parentTurn, rootTurnId: parentTurn, status: 'completed' } } });
+  void (async () => {
+    await afterParityPark(turnText);
+    for (const child of children) {
+      const command = { type: 'commandExecution', id: `exec_${child.callId}`, command: 'sleep 1', cwd: '/repo' };
+      emit({ method: 'item/started', params: { threadId: child.threadId, turnId: child.turnId, item: { ...command, status: 'inProgress' } } });
+      emit({ method: 'item/completed', params: { threadId: child.threadId, turnId: child.turnId, item: { ...command, status: 'completed', exitCode: 0 } } });
+      emit({ method: 'thread/status/changed', params: { threadId: child.threadId, status: { type: 'idle' } } });
+      emit({ method: 'turn/completed', params: { threadId: child.threadId, turn: { id: child.turnId, rootTurnId: parentTurn, status: 'completed' } } });
+      const ended = { type: 'subAgentActivity', model: null, reasoningEffort: null, id: `subagent-completed-${child.turnId}`, kind: 'completed', agentThreadId: child.threadId, agentPath: child.agentPath };
+      for (let copy = turnText.includes('subagent-duplicate') ? 2 : 1; copy > 0; copy -= 1) {
+        emit({ method: 'item/started', params: onParent(ended) });
+        emit({ method: 'item/completed', params: onParent(ended) });
+      }
+    }
+  })().catch((error) => {
+    process.stderr.write(`mock-codex-subagents: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}

package/scripts/mock-controls.d.mts

@@ -0,0 +1,11 @@
+import type { readFailureControl } from './mock-failure-control.mjs';
+import type { readDeliveryControl } from './mock-delivery-control.mjs';
+
+/** Loads the failure and delivery controls a test configured; appends this pid to `CEZ_MOCK_PID_FILE` when set. */
+export declare function loadControls(options?: {
+  failure?: Parameters<typeof readFailureControl>[0];
+  delivery?: Parameters<typeof readDeliveryControl>[0];
+}): Promise<{
+  failureControl: ReturnType<typeof readFailureControl> | undefined;
+  delivery: ReturnType<typeof readDeliveryControl> | undefined;
+}>;

package/scripts/mock-controls.mjs

@@ -0,0 +1,13 @@
+import { appendFileSync } from 'node:fs';
+
+// Load only when configured: ordinary mock turns retain their event-loop ordering.
+// Every native mock calls this once at startup, so `CEZ_MOCK_PID_FILE` lists every native process a
+// session started, one pid per line (seam contract row S43).
+export async function loadControls({ failure, delivery } = {}) {
+  if (process.env.CEZ_MOCK_PID_FILE) appendFileSync(process.env.CEZ_MOCK_PID_FILE, `${process.pid}\n`);
+  const failureControl = process.env.CEZ_MOCK_FAILURE_CONTROL === undefined ? undefined
+    : (await import('./mock-failure-control.mjs')).readFailureControl(failure);
+  const deliveryControl = process.env.CEZ_MOCK_DELIVERY_CONTROL === undefined ? undefined
+    : (await import('./mock-delivery-control.mjs')).readDeliveryControl(delivery);
+  return { failureControl, delivery: deliveryControl };
+}

package/scripts/mock-cursor-hang-stdin-late.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// #587: the bootstrap write succeeds first, then stdin dies.
+//
+// The parent writes session/new while the pipe's read end is still open, so
+// that write cannot fail. The child then drops the read end and never answers
+// session/new. The runner's next write — the bootstrap stdin probe — is what
+// must surface the death, not the 15s request timeout.
+//
+// The close is three steps, and the order matters. Closing fd 0 while
+// readline's libuv handle still owns it aborts the child on some machines
+// (SIGABRT — the fixture would become a process-death test); on other
+// machines closeSync alone throws EBADF and never closes the read end, so the
+// parent's write silently succeeds and only the 15s request timeout can catch
+// the hang (#588). destroy() disarms the handle, closeSync(0) actually closes
+// the pipe's read end (destroy alone leaves the fd open). The stdin 'error'
+// handler swallows the EBADF from the next read attempt.
+import { createInterface } from 'node:readline';
+import { closeSync } from 'node:fs';
+const emit = value => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...value })}\n`);
+const rl = createInterface({ input: process.stdin });
+process.stdin.on('error', () => { /* the EBADF below is intentional */ });
+rl.on('line', line => {
+  let msg; try { msg = JSON.parse(line); } catch { return; }
+  if (msg.method === 'initialize') {
+    emit({ id: msg.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: true } } });
+  } else if (msg.method === 'session/new') {
+    // The parent's write already succeeded into the kernel buffer; only now
+    // does the read end die, with the child staying up.
+    rl.close();
+    process.stdin.destroy();
+    try { closeSync(0); } catch { /* already closed */ }
+  }
+});
+process.on('SIGTERM', () => { /* ignore — the child must outlive its stdin */ });
+setInterval(() => {}, 1e6);

package/scripts/mock-cursor-hang-stdin.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// #587: answers initialize, then dies on stdin while the child stays up.
+// The parent's next write (session/new) must hit EPIPE and surface as a fast
+// v1 error.
+//
+// Close before replying: a fast parent sends session/new as soon as it reads
+// initialize, and that write must encounter the dead input pipe. The close is
+// three steps, and the order matters. Closing fd 0 while readline's libuv
+// handle still owns it aborts the child on some machines (SIGABRT — the
+// fixture would become a process-death test); on other machines closeSync
+// alone throws EBADF and never closes the read end, so the parent's write
+// silently succeeds and only the 15s request timeout can catch the hang
+// (#588). destroy() disarms the handle, closeSync(0) actually closes the
+// pipe's read end (destroy alone leaves the fd open).
+import { createInterface } from 'node:readline';
+import { closeSync } from 'node:fs';
+const emit = value => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...value })}\n`);
+const rl = createInterface({ input: process.stdin });
+process.stdin.on('error', () => { /* the EBADF below is intentional */ });
+rl.on('line', line => {
+  let msg; try { msg = JSON.parse(line); } catch { return; }
+  if (msg.method === 'initialize') {
+    rl.close();
+    process.stdin.destroy();
+    try { closeSync(0); } catch { /* already closed */ }
+    emit({ id: msg.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: true } } });
+  }
+});
+process.on('SIGTERM', () => { /* ignore — the child must outlive its stdin */ });
+setInterval(() => {}, 1e6);

package/scripts/mock-cursor-print.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import { loadControls } from './mock-controls.mjs';
+import { scenarioFor, play } from './mock-scenario.mjs';
+import { waitForRelease } from './mock-lifecycle.mjs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+// Print acknowledges an input on its first model work and cannot refuse one, so a held
+// acknowledgement and a held response both hold that first model work.
+const { failureControl, delivery } = await loadControls({ delivery: ['hold-ack', 'hold-response'] });
+const { answerNudge, NO_WAIT_NUDGE_PREFIX } = await import('./mock-nudge.mjs');
+
+const args = process.argv.slice(2);
+// No import or await on the ordinary mock path.
+const wireRecorder = process.env.CEZ_MOCK_WIRE_FILE === undefined ? undefined
+  : await import('./mock-wire-recorder.mjs');
+wireRecorder?.installWireRecorder();
+if (args.includes('--version')) { process.stdout.write('2026.10.01-e373342\n'); process.exit(0); }
+if (args.includes('__cezar_probe_invalid__')) {
+  process.stderr.write('Invalid --allowed-tools value(s): __cezar_probe_invalid__. Expected one of: '+
+    'shell_tool_call, delete_tool_call, glob_tool_call, grep_tool_call, read_tool_call, update_todos_tool_call, read_todos_tool_call, edit_tool_call, ls_tool_call, read_lints_tool_call, mcp_tool_call, sem_search_tool_call, create_plan_tool_call, web_search_tool_call, list_mcp_resources_tool_call, read_mcp_resource_tool_call, apply_agent_diff_tool_call, ask_question_tool_call, fetch_tool_call, switch_mode_tool_call, generate_image_tool_call, record_screen_tool_call, computer_use_tool_call, write_shell_stdin_tool_call, reflect_tool_call, setup_vm_environment_tool_call, truncated_tool_call, web_fetch_tool_call, report_bugfix_results_tool_call, ai_attribution_tool_call, pr_management_tool_call, mcp_auth_tool_call, await_tool_call, blame_by_file_path_tool_call, get_mcp_tools_tool_call, report_bug_tool_call, set_active_branch_tool_call, communicate_update_tool_call, send_final_summary_tool_call, update_pr_code_tour_tool_call, replace_env_tool_call, edit_pr_labels_tool_call, record_ci_investigation_findings_tool_call, fetch_cloud_agent_data_tool_call, send_to_user_tool_call, pi_read_tool_call, pi_bash_tool_call, pi_edit_tool_call, pi_write_tool_call, pi_grep_tool_call, pi_find_tool_call, pi_ls_tool_call, connect_scm_tool_call, search_conversations_tool_call, create_goal_tool_call, update_goal_tool_call, get_pr_code_tour_tool_call, write_canvas_tool_call, read_canvas_tool_call, task_tool_call, create_agent_tool_call, adopt_tool_call, send_to_agent_tool_call, send_message_tool_call, get_agent_status_tool_call, stop_agent_tool_call, read_agent_transcript_tool_call, start_grind_execution_tool_call, start_grind_planning_tool_call\n');
+  process.exit(1);
+}
+const flag = name => { const at = args.indexOf(name); return at < 0 ? undefined : args[at + 1]; };
+const resumeId = flag('--resume');
+const mode = process.env.CEZ_MOCK_CURSOR_PRINT_MODE ?? 'normal';
+const turn = resumeId ? 2 : 1;
+// Cursor accepts a print prompt on stdin. Preserve the positional form so a
+// regression back to argv delivery is visible to the runner tests.
+const valueFlags = new Set(['--output-format', '--model', '--resume', '--allowed-tools',
+  '--add-dir', '--plugin-dir', '--image']);
+let positionalPrompt = '';
+for (let i = 0; i < args.length; i++) {
+  if (valueFlags.has(args[i])) { i++; continue; }
+  if (!args[i].startsWith('-')) positionalPrompt = args[i];
+}
+const stdinChunks = [];
+if (!positionalPrompt) for await (const chunk of process.stdin) stdinChunks.push(chunk);
+const stdinPrompt = Buffer.concat(stdinChunks).toString('utf8');
+const promptArg = stdinPrompt || positionalPrompt;
+const promptBoundary = promptArg.lastIndexOf('\n\n---\n\n');
+const rawPrompt = promptBoundary < 0 ? promptArg : promptArg.slice(promptBoundary + '\n\n---\n\n'.length);
+const taggedScenarios = [
+  ['resume-cezar-done', 'a0000001'], ['autonomous-cezar-ask-cap', 'a0000002'],
+  ['autonomous-cap', 'a0000003'], ['silent-tail-late-turn-start', 'a0000004'],
+  ['silent-tail-no-reply', 'a0000005'], ['silent-tail-late-reply', 'a0000006'],
+  ['silent-tail-slow-done', 'a0000007'], ['silent-tail-again', 'a0000008'],
+  ['silent-tail', 'a0000009'], ['tool-tail', 'a000000a'],
+];
+const freshTag = taggedScenarios.find(([name]) => rawPrompt.includes(`mock:${name}`))?.[1];
+const id = resumeId && mode !== 'mismatch-on-resume' ? resumeId
+  : (freshTag ? freshTag + randomUUID().slice(8) : randomUUID());
+const stateFile = join(process.cwd(), '.ai', 'cezar', 'mock-cursor-print', `${id}.json`);
+let origin = taggedScenarios.find(([, tag]) => resumeId?.startsWith(tag))?.[0];
+if (resumeId && existsSync(stateFile)) {
+  try { origin = JSON.parse(readFileSync(stateFile, 'utf8')).origin ?? origin; } catch { /* isolated mock state */ }
+}
+if (freshTag) {
+  origin = taggedScenarios.find(([, tag]) => tag === freshTag)?.[0];
+  mkdirSync(join(process.cwd(), '.ai', 'cezar', 'mock-cursor-print'), { recursive: true });
+  writeFileSync(stateFile, JSON.stringify({ origin }));
+}
+// One process per turn: the session's opening scenario comes from its tag, not a latch.
+const silentOrigin = /^(silent-tail|tool-tail)/.test(origin ?? '');
+const prompt = silentOrigin ? rawPrompt : answerNudge(rawPrompt);
+const frame = value => process.stdout.write(`${JSON.stringify(value)}\n`);
+const assistant = text => frame({ type: 'assistant', session_id: id,
+  message: { role: 'assistant', content: [{ type: 'text', text }] } });
+const result = (text, error = false) => frame({ type: 'result', subtype: error ? 'error_during_execution' : 'success',
+  session_id: id, is_error: error, result: text });
+const readTool = (content = 'A project') => {
+  const call = { readToolCall: { args: { path: 'README.md' } } };
+  frame({ type: 'tool_call', subtype: 'started', call_id: 'read-1', session_id: id, tool_call: call });
+  frame({ type: 'tool_call', subtype: 'completed', call_id: 'read-1', session_id: id,
+    tool_call: { readToolCall: { ...call.readToolCall, result: { success: { content } } } } });
+};
+
+const finish = (text) => { assistant(text); result(text); };
+// hearsay-tools/cezarion#2397: a reply that finishes, asks or waits calls that cezar tool over
+// the --plugin-dir MCP config before its turn ends. Returns '' or a note for the text.
+const tools = () => import('./mock-ci-tool.mjs');
+const lifecycle = async (call) => (await tools()).lifecycleCall('cursor', args, ...call);
+const done = async (text) => text + await lifecycle((await tools()).DONE);
+const log = process.env.CEZ_MOCK_CURSOR_PRINT_LOG;
+if (log) appendFileSync(log, `${JSON.stringify({ pid: process.pid, resumeId, id, args,
+  promptSource: stdinPrompt ? 'stdin' : 'argv', prompt: promptArg })}\n`);
+if (process.env.CEZ_MOCK_ARGS_FILE) {
+  appendFileSync(process.env.CEZ_MOCK_ARGS_FILE, `${JSON.stringify(args)}\n`);
+  const pluginDir = flag('--plugin-dir');
+  if (pluginDir) appendFileSync(process.env.CEZ_MOCK_ARGS_FILE,
+    `${JSON.stringify({ type: 'cursor-print-plugin', ...JSON.parse(readFileSync(`${pluginDir}/mcp.json`, 'utf8')) })}\n`);
+}
+if (process.env.CEZ_MOCK_STDIN_FILE && stdinPrompt) {
+  appendFileSync(process.env.CEZ_MOCK_STDIN_FILE,
+    `${JSON.stringify({ method: 'cursor-print/stdin', prompt: stdinPrompt })}\n`);
+}
+if (mode === 'delay-init') await new Promise(resolve => setTimeout(resolve, 10_000));
+// Reproduce a loaded host's per-process startup cost on every turn: Cursor print
+// spawns one process per turn, so a cap row pays it MAX_AUTO_CONTINUES + 1 times
+// (hearsay-tools/cezarion#1125).
+const spawnDelayMs = Number.parseInt(process.env.CEZ_MOCK_CURSOR_SPAWN_DELAY_MS ?? '0', 10) || 0;
+if (spawnDelayMs > 0) await new Promise(resolve => setTimeout(resolve, spawnDelayMs));
+const attempt = log ? readFileSync(log, 'utf8').trim().split('\n').length : 1;
+const rejectModel = () => process.stderr.write(`Cannot use this model: ${flag('--model')}. Available models: ${'other-model, '.repeat(1000)}\n`);
+if (mode === 'model-rejection-always' || (mode === 'model-rejection-once' && attempt === 1) ||
+  (mode === 'model-rejection-on-resume' && resumeId && attempt === 2)) {
+  rejectModel(); process.exit(1);
+}
+if (mode === 'model-rejection-held') {
+  rejectModel(); await waitForRelease(10_000); process.exit(1);
+}
+if (mode === 'unrelated-startup-error') { process.stderr.write('Account unavailable\n'); process.exit(1); }
+const sharedNames = ['autonomous', 'silent-tail', 'tool-tail', 'crash-stderr', 'cezar-tool', 'ci-wait',
+  'multi-pr-refs', 'turn-messages', 'agent-echo', 'provider-error', 'hold-cezar-done', 'hold-cezar-ask',
+  'cezar-done', 'cezar-ask', 'busy-progress', 'no-progress', 'hold-gated', 'hold', 'deferred-turn-start'];
+// Print has no persistent input, steering, child transcript or cezar-wait reply.
+const unsupported = ['ack-only', 'steer-tool', 'steer-late', 'subagent-after-park', 'cezar-wait'];
+let crashContinues = false;
+const session = {
+  get resumeAfterAsk() { return origin === 'resume-cezar-done'; },
+  set resumeAfterAsk(value) {
+    if (!value) return;
+    mkdirSync(join(process.cwd(), '.ai', 'cezar', 'mock-cursor-print'), { recursive: true });
+    writeFileSync(stateFile, JSON.stringify({ origin: 'resume-cezar-done' }));
+  },
+};
+function selectScenario(name, text = prompt) {
+  return scenarioFor(text, {
+    runner: 'cursor', lifecycle, session, nativeFailureControl: Boolean(failureControl),
+    unsupported: [...unsupported, ...sharedNames.filter(candidate => candidate !== name)],
+    toolPrompt: text => tools().then(module => module.toolPrompt('cursor', args, text)),
+    ciPrompt: text => tools().then(module => module.ciPrompt('cursor', args, text)),
+    async crash(text) { crashContinues = (await import('./mock-runner-crash.mjs')).crashWithStderr(text, '{"type":"assistant",') === true; },
+  });
+}
+// A missing scenario is synchronous. The player alone awaits asynchronous steps.
+function dispatch(replies, index = 0) {
+  for (; index < replies.length; index++) {
+    const route = replies[index];
+    if (route.when && !route.when()) continue;
+    if (route.reply) return route.reply();
+    const selected = selectScenario(route.name, route.prompt?.() ?? prompt);
+    if (!selected) continue;
+    const next = index + 1;
+    const finish = outcome => {
+      if (selected.name === 'no-progress' || selected.name === 'silent-tail' && origin === 'silent-tail-no-reply' && prompt.includes(NO_WAIT_NUDGE_PREFIX)) {
+        setInterval(() => {}, 1000); return new Promise(() => {});
+      }
+      return outcome === 'continue' || selected.name === 'crash-stderr' && crashContinues ? dispatch(replies, next) : undefined;
+    };
+    const outcome = play(selected, encoder(selected));
+    return outcome instanceof Promise ? outcome.then(finish) : finish(outcome);
+  }
+}
+function encoder(selected) {
+  let text = '';
+  return {
+    open() {},
+    text(step) { const block = step.parts.join(''); text = block; assistant(block); },
+    reasoning(step) { frame({ type: 'assistant', session_id: id, message: { role: 'assistant', content: [{ type: 'thinking', thinking: step.text }] } }); },
+    toolStart: ({ call }) => scenarioTool(call, false),
+    toolEnd: ({ call }) => scenarioTool(call, true),
+    child() { throw new Error('Cursor print has no child wire'); },
+    readSteers() {},
+    progress: () => assistant('working\n'),
+    reply: () => prompt === 'inspect the working tree' || prompt.includes('mock:baseline') ? baselineReply() : defaultReply(),
+    end(step) {
+      const empty = selected.name === 'turn-messages' || ['silent-tail', 'tool-tail'].includes(selected.name) && !prompt.includes(NO_WAIT_NUDGE_PREFIX);
+      result(step.error === 'provider' ? 'RetriableError: provider unavailable' : empty ? '' : text, step.error === 'provider');
+    },
+  };
+}
+function scenarioTool(call, completed) {
+  const key = call.name === 'read' ? 'readToolCall' : 'shellToolCall';
+  const args = call.input;
+  const success = call.name === 'read' ? { content: call.output } : { exitCode: call.isError ? 1 : 0, stdout: call.output, stderr: '' };
+  frame({ type: 'tool_call', subtype: completed ? 'completed' : 'started', call_id: call.id, session_id: id,
+    tool_call: { [key]: { args, ...(completed ? { result: { success } } : {}) } } });
+}
+// Delay admission through the shared script, but keep native init and modes in their slots.
+const deferred = selectScenario('deferred-turn-start');
+if (deferred) await play({ steps: [...deferred.steps].filter(step => step.kind === 'effect') }, encoder(deferred));
+frame({ type: 'system', subtype: 'init', session_id: id, model: flag('--model') ?? 'auto', cwd: process.cwd() });
+if (delivery) {
+  await new Promise(resolve => delivery.ack(prompt, resolve));
+  await delivery.holdResponse(prompt);
+}
+if (mode === 'model-rejection-after-init' || mode === 'model-rejection-after-work') {
+  if (mode === 'model-rejection-after-work') assistant('Work already began');
+  rejectModel(); process.exit(1);
+}
+if (mode === 'no-result') process.exit(0);
+if (mode === 'native-question') {
+  const args = { title: 'Choice', questions: [{ prompt: 'Choose', options: [{ label: 'Alpha' }, { label: 'Beta' }], allowMultiple: false }], runAsync: false };
+  const call = { askQuestionToolCall: { args } };
+  frame({ type: 'tool_call', subtype: 'started', call_id: 'question-1', session_id: id, tool_call: call });
+  frame({ type: 'tool_call', subtype: 'completed', call_id: 'question-1', session_id: id,
+    tool_call: { askQuestionToolCall: { args, result: { rejected: { reason: 'Questions skipped by the user, continue with the information you already have' } } } } });
+  finish('I could not ask the question.'); process.exit(0);
+}
+const selectedFailure = failureControl?.failureFor(prompt);
+const nativeFailure = selectedFailure instanceof Promise ? await selectedFailure : selectedFailure;
+if (failureControl ? nativeFailure === 'provider' : mode === 'provider-error') {
+  result('RetriableError: provider unavailable', true);
+  process.exit(0);
+}
+if (silentOrigin) (await import('./mock-silent-tail.mjs')).noteSilentTailPrompt(`mock:${origin}`);
+await dispatch([
+  { name: 'crash-stderr' },
+  { when: () => origin === 'autonomous-cezar-ask-cap' && resumeId && prompt.startsWith('Continue working autonomously until the task is fully complete.'), reply: () => finish('Still working.') },
+  { name: 'autonomous', prompt: () => origin?.startsWith('autonomous') && selectScenario('autonomous') ? `${prompt} mock:${origin}` : prompt },
+  { name: 'silent-tail' }, { name: 'tool-tail' },
+  { when: () => origin === 'resume-cezar-done' && resumeId, reply: async () => finish(await done('Resumed work finished.')) },
+  { name: 'cezar-tool' }, { name: 'ci-wait' },
+  { when: () => process.env.CEZ_MOCK_CI_PR, reply: async () => finish(JSON.stringify((await (await tools()).probeCiTool('cursor', args)).response)) },
+  ...['no-progress', 'busy-progress', 'hold-cezar-done', 'hold-cezar-ask', 'hold-gated', 'multi-pr-refs', 'turn-messages'].map(name => ({ name })),
+  { when: () => prompt.includes('mock:ask-bad'), reply: () => finish('Malformed question skipped.') },
+  { name: 'provider-error' },
+  { when: () => resumeId && /Library:|Tests:|Plan:/.test(prompt), reply: async () => finish(await done('Done.')) },
+  { name: 'cezar-done' },
+  { name: 'cezar-ask', when: () => !resumeId || prompt.includes('mock:cezar-ask-reply-late') },
+  { name: 'hold' },
+  { when: () => prompt === 'inspect the working tree' || prompt.includes('mock:baseline'), reply: baselineReply },
+  { name: 'agent-echo' },
+  { reply: defaultReply },
+]);
+function baselineReply() { readTool(); finish('Cursor inspected the workspace.'); }
+async function defaultReply() {
+  const text = `turn ${turn}: ${prompt}`;
+  if (mode === 'delay-work' && resumeId) await new Promise(resolve => setTimeout(resolve, 200));
+  assistant(text);
+  if (mode === 'crash-after-work') process.exit(1);
+  result(text);
+  if (mode === 'duplicate-result') result(text);
+  if (mode === 'late-frame') assistant('LATE_FRAME');
+  if (mode === 'result-before-exit') await new Promise(resolve => setTimeout(resolve, 250));
+}

package/scripts/mock-deferred-turn-start.mjs

@@ -0,0 +1,16 @@
+/**
+ * hearsay-tools/cezarion#1112: a follow-up whose native turn starts late. A mock that sees
+ * the token in a follow-up holds that turn's native start past the 250 ms held-input
+ * recheck (HELD_HUMAN_INPUT_RECHECK_MS in workflows/run.ts), the window a loaded host
+ * opened between a Cursor print process spawning and its init frame.
+ *
+ * Callers test for the token inline before a dynamic import, so a mock without it keeps
+ * its exact event-loop ordering (an unconditional `await` would yield on every turn), and
+ * a testkit that copies a mock elsewhere and rewrites `import('./` still resolves it.
+ */
+export const DEFERRED_TURN_START_TOKEN = 'mock:deferred-turn-start';
+export const DEFERRED_TURN_START_MS = 800;
+
+export function deferredTurnStart() {
+  return new Promise(resolve => setTimeout(resolve, DEFERRED_TURN_START_MS));
+}

package/scripts/mock-delivery-control.d.mts

@@ -0,0 +1,23 @@
+export type DeliveryControlOptions =
+  | { kind: 'reject'; match: string; persistent?: boolean }
+  | { kind: 'hold-ack'; match: string }
+  | { kind: 'hold-response'; match: string };
+export type DeliveryKind = DeliveryControlOptions['kind'];
+export function createDeliveryControl(root: string, options: DeliveryControlOptions): {
+  path: string;
+  held(): boolean;
+  release(): void;
+  lift(): void;
+};
+/** Throws on a malformed control. A kind outside `supportedKinds` makes the mock exit with
+ *  an error naming the variable when an input matches, before it answers that input. */
+export function readDeliveryControl(supportedKinds: readonly DeliveryKind[]): {
+  kind: DeliveryKind;
+  /** True when this input must be rejected now; a non-persistent rule claims once across processes. */
+  rejects(text: string): boolean;
+  /** Sends the acknowledgement now, or after release for a matching hold-ack, without blocking the caller. */
+  ack(text: string, send: () => void): void;
+  /** Undefined when nothing is held; for a matching hold-response, a promise that resolves on release.
+   *  A synchronous answer lets a mock that cannot await decide at once whether to buffer. */
+  holdResponse(text: string): Promise<void> | undefined;
+};