@wjarka/cezarion 0.16.0 → 0.17.0

package/scripts/mock-omp-rpc.mjs

@@ -1,11 +1,22 @@
 #!/usr/bin/env node
+// Load only when configured: ordinary mock turns retain their event-loop ordering.
+const failureControl = process.env.CEZ_MOCK_FAILURE_CONTROL === undefined ? undefined
+  : (await import('./mock-failure-control.mjs')).readFailureControl();
+const delivery = process.env.CEZ_MOCK_DELIVERY_CONTROL === undefined ? undefined
+  : (await import('./mock-delivery-control.mjs')).readDeliveryControl(['reject', 'hold-ack', 'hold-response']);
 // Offline OMP (Oh My Pi) `--mode rpc` mock in OMP's own wire shape (v18.4.11, #595): the `ready`
 // frame, id-echoed responses, `prompt_result`, `session_settled`. Startup argv and model errors
 // are copied from the real binary (2026-10-05). Keep it standalone: optional scenario helpers
 // are imported lazily.
 import readline from 'node:readline';
 import { spawn } from 'node:child_process';
-import { appendFileSync, existsSync, writeFileSync } from 'node:fs';
+import { appendFileSync, closeSync, existsSync, renameSync, writeFileSync } from 'node:fs';
+import { rawMessage, stripCommandMessage } from './mock-session-context.mjs';
+// Dynamic, like every sibling import here, so a test's copy of this mock can repoint it.
+const { answerNudge, silentNudge } = await import('./mock-nudge.mjs');
+// Publish a pid atomically (temporary sibling, then rename): a test reading it sees no
+// file or a whole pid, never the empty file whose Number() is 0 (hearsay-tools/cezarion#953).
+function watchdogWritePid(file, pid) { const tmp = `${file}.${process.pid}.tmp`; writeFileSync(tmp, pid); renameSync(tmp, file); }
 
 const argv = process.argv.slice(2);
 if (process.env.CEZ_MOCK_ARGS_FILE) appendFileSync(process.env.CEZ_MOCK_ARGS_FILE, `${JSON.stringify(argv)}\n`);
@@ -46,7 +57,7 @@ if (unknownFlags.length > 0) {
 let tools = flags.has('--no-tools') ? [] : DEFAULT_TOOLS;
 if (typeof flags.get('--tools') === 'string') {
   tools = flags.get('--tools').split(',');
-  // The CI extension registers cezar's tools (the preview tool only under CEZ_PREVIEW=1); an MCP name needs a configured server, which the mock
+  // The CI extension registers cezar's tools (the preview tools only under CEZ_PREVIEW=1, the schedule tools only under CEZ_AUTOMATIONS=1); an MCP name needs a configured server, which the mock
   // takes from CEZ_MOCK_OMP_MCP_TOOLS (none by default, like a home without .omp/mcp.json).
   const mcpTools = (process.env.CEZ_MOCK_OMP_MCP_TOOLS ?? '').split(',').filter(Boolean);
   // Tools a user setting disabled (`todo.enabled: false`, `lsp.enabled: false`, ...) are built-ins
@@ -54,7 +65,8 @@ if (typeof flags.get('--tools') === 'string') {
   const disabled = (process.env.CEZ_MOCK_OMP_DISABLED_TOOLS ?? '').split(',').filter(Boolean);
   const registered = (name) => (BUILTIN_TOOLS.includes(name) && !GATED_TOOLS.has(name) && !disabled.includes(name))
     || mcpTools.includes(name)
-    || (extensions.length > 0 && (name === 'cezar_wait_for_ci' || ((name === 'cezar_preview_serve' || name === 'cezar_preview_stop') && process.env.CEZ_PREVIEW === '1')));
+    || (extensions.length > 0 && (['cezar_wait', 'cezar_ask', 'cezar_cancel_wait', 'cezar_done'].includes(name) || ((name === 'cezar_preview_serve' || name === 'cezar_preview_stop') && process.env.CEZ_PREVIEW === '1')
+      || ((name === 'cezar_schedule_task' || name === 'cezar_scheduled_tasks') && process.env.CEZ_AUTOMATIONS === '1')));
   // Mirrors v18.4.11 `emt()`: every missing name in ONE error, unknown names first, then the
   // built-ins this session lacks, each line singular for one name.
   const missing = tools.filter((name) => !registered(name));
@@ -104,6 +116,14 @@ const fail = (command, error) => write({ ...(command.id ? { id: command.id } : {
 const localResult = (command, status, error) => write({ type: 'prompt_result', ...(command.id ? { id: command.id } : {}), agentInvoked: false, status, ...(error ? { error } : {}), sessionSettled: false });
 const respond = (command, data) => write({ ...(command.id ? { id: command.id } : {}), type: 'response', command: command.type, success: true, ...(data === undefined ? {} : { data }) });
 
+// A real broken input pipe before ready exercises the queued startup writes.
+if (process.env.CEZ_MOCK_OMP_CLOSED_INPUT === '1') {
+  closeSync(0);
+  write({ type: 'ready' });
+  setTimeout(() => process.exit(0), 300);
+  await new Promise(() => {});
+}
+
 // Real startup order: `ready`, then three unsolicited frames before any command is answered.
 write({ type: 'ready', protocolVersion: 1, supportedProtocolVersions: [1, 2], maxFrameBytes: 1048576, maxReassembledFrameBytes: 16777216 });
 write({ type: 'extension_ui_request', id: 'mock-widget-1', method: 'setWidget', widgetKey: 'mock', widgetLines: [] });
@@ -120,7 +140,11 @@ let resumeAfterAsk = false;
 
 /** Same as mock-pi-rpc.mjs `watchdogStall`: a turn that never progresses (no-progress rows). */
 function watchdogStall(message) {
-  writeFileSync('watchdog.pid', String(process.pid));
+  if (message.includes('input-closed')) {
+    closeSync(0);
+    watchdogWritePid('input-closed.pid', String(process.pid));
+    setTimeout(() => process.exit(0), message.includes('mock:gate-prompt-ack') ? 15_000 : 300);
+  }
   if (message.includes('ignore-term')) {
     process.removeAllListeners('SIGTERM');
     process.on('SIGTERM', () => {});
@@ -133,10 +157,12 @@ function watchdogStall(message) {
   if (message.includes('leftover')) {
     // hearsay-tools/cezarion#890: one child stays in the session's process group and ignores
     // SIGTERM; one leaves the group with setsid. Both exit on their own as a cleanup backstop.
-    const leftover = (file) => `process.on('SIGTERM',()=>{}); require('fs').writeFileSync(${JSON.stringify(file)}, String(process.pid)); setTimeout(()=>{},20000)`;
+    const leftover = (file) => `process.on('SIGTERM',()=>{}); const fs = require('fs'); fs.writeFileSync(${JSON.stringify(`${file}.tmp`)}, String(process.pid)); fs.renameSync(${JSON.stringify(`${file}.tmp`)}, ${JSON.stringify(file)}); setTimeout(()=>{},20000)`;
     spawn(process.execPath, ['-e', leftover('leftover-group.pid')], { stdio: 'ignore' });
     spawn(process.execPath, ['-e', leftover('leftover-session.pid')], { stdio: 'ignore', detached: true }).unref();
   }
+  // Publish readiness after mode setup: another process may signal us as soon as it sees it.
+  watchdogWritePid('watchdog.pid', String(process.pid));
 }
 
 /** #401: hold late wire frames until the test has observed the park (as the codex mock). */
@@ -240,9 +266,26 @@ let queue = Promise.resolve();
 rl.on('line', (line) => {
   // Every raw command, in arrival order, for tests that pin what the runner wrote.
   if (process.env.CEZ_MOCK_OMP_COMMANDS_FILE) appendFileSync(process.env.CEZ_MOCK_OMP_COMMANDS_FILE, `${line}\n`);
-  const command = JSON.parse(line);
-  if (command.type === 'prompt' && command.streamingBehavior === 'steer' && activeTurn) {
-    record({ userText: command.message, imageCount: (command.images ?? []).length, streamingBehavior: 'steer' });
+  const command = stripCommandMessage(JSON.parse(line));
+  // hearsay-tools/cezarion#1112: a late-ack steer is admitted after the turn's last model call.
+  // OMP acknowledges it now and, never settling with a queued message, reads it in a further
+  // run before `session_settled` (the endTurn `late` path).
+  if (command.type === 'prompt' && command.streamingBehavior === 'steer' && command.message.includes('mock:deferred-turn-start:late-ack')) {
+    const admit = () => {
+      if (!activeTurn) { setTimeout(admit, 5); return; }
+      record({ userText: rawMessage(command), imageCount: (command.images ?? []).length, streamingBehavior: 'steer' });
+      activeTurn.steers.push({ id: command.id, message: command.message });
+      activeTurn.late = true;
+      respond(command);
+    };
+    admit();
+    return;
+  }
+  // hearsay-tools/cezarion#1112: a deferred-start steer is not admitted into the running turn;
+  // OMP acknowledges it as its next prompt once that turn settles, with no turn open.
+  if (command.type === 'prompt' && command.streamingBehavior === 'steer' && activeTurn &&
+    !command.message.includes('mock:deferred-turn-start')) {
+    record({ userText: rawMessage(command), imageCount: (command.images ?? []).length, streamingBehavior: 'steer' });
     // Steers OMP never hands to the running agent: none of them may end its turn.
     if (command.message.includes('mock:steer-rejected')) {
       // Rejected before admission: the error response only, the ticket is discarded.
@@ -307,38 +350,363 @@ async function handle(command) {
       respond(command);
       return;
     case 'prompt':
-      record({ userText: command.message, imageCount: (command.images ?? []).length });
-      return prompt(command);
+      record({ userText: rawMessage(command), imageCount: (command.images ?? []).length });
+      // The delivery control reads both the prompt Cezar sent and a nudge's scripted answer.
+      { const answered = answerNudge(command.message);
+        return prompt({ ...command, message: answered }, answered === command.message ? answered : `${command.message}\n${answered}`); }
     default:
       write({ ...(command.id ? { id: command.id } : {}), type: 'response', command: command.type, success: false, error: `Unknown command: ${command.type}` });
   }
 }
 
-async function prompt(command) {
-  const message = command.message;
-  if (message.includes('mock:local-command')) {
-    // A prompt OMP finished itself (a slash command): the response says so, no prompt_result.
-    respond(command, { agentInvoked: false });
+function respondLocalCommand(command, message, ack) {
+  // A prompt OMP finished itself (a slash command): the response says so, no prompt_result.
+  ack({ agentInvoked: false });
+  return;
+}
+
+function respondLocalResult(command, message, ack) {
+  ack();
+  write({ type: 'prompt_result', ...(command.id ? { id: command.id } : {}), agentInvoked: false, status: 'completed', sessionSettled: true });
+  return;
+}
+
+function respondPromptError(command, message, ack) {
+  // The prompt failed after admission, before the agent ran: the ack, an error response,
+  // then its prompt_result (rpc-mode.ts `onError` + `RpcPromptResults.fail`).
+  ack();
+  fail(command, 'Model not found: anthropic/claude-missing');
+  write({ type: 'prompt_result', ...(command.id ? { id: command.id } : {}), agentInvoked: false, status: 'error', error: { message: 'Model not found: anthropic/claude-missing', provider: 'anthropic', model: 'claude-missing', retryable: false }, sessionSettled: true });
+  return;
+}
+
+function respondPromptRejected(command, message, ack) {
+  // Rejected before admission (an input hook threw): the error response only, no prompt_result.
+  fail(command, 'input hook rejected the prompt');
+}
+
+async function respondMultiPrRefs(command, message, gated) {
+  const { multiPrText, unrelatedPr } = await import('./mock-multi-pr.mjs');
+  assistantThinking(unrelatedPr);
+  subagentText('multi-child', unrelatedPr);
+  write({ type: 'tool_execution_start', toolCallId: 'multi-read', toolName: 'read', args: { path: 'other.txt' } });
+  write({ type: 'tool_execution_end', toolCallId: 'multi-read', toolName: 'read', result: { content: [{ type: 'text', text: unrelatedPr }] }, isError: false });
+  const text = multiPrText(message);
+  assistantText([text.slice(0, 5), text.slice(5)]);
+  endTurn(); return;
+}
+
+async function respondTurnMessages(command, message, gated) {
+  const { turnMessages } = await import('./mock-turn-messages.mjs');
+  // Separate assistant messages within one native OMP turn; settle only after all of them.
+  for (const text of turnMessages(message)) assistantText([text]);
+  endTurn();
+  return;
+}
+
+function respondAgentEcho(command, message, gated) {
+  assistantText([message]);
+  endTurn();
+  return;
+}
+
+async function respondAutonomous(command, message, gated) {
+  const { autonomousReply } = await import('./mock-autonomous.mjs');
+  assistantText([autonomousReply(message)]);
+  endTurn();
+  return;
+}
+
+async function respondFinalNudge(silent) {
+  const kind = silent.finalMessageNudgeKind();
+  if (kind === 'silent') assistantThinking(silent.SILENT_TAIL_REASONING);
+  else if (kind === 'slow-done') {
+    assistantText([silent.SLOW_DONE_PREFIX]);
+    await silent.sleep(silent.SLOW_DONE_TAIL_MS);
+    assistantText([silent.SILENT_TAIL_DONE]);
+  } else assistantText([kind === 'standing' ? silent.FINAL_MESSAGE_STANDING : silent.SILENT_TAIL_DONE]);
+  endTurn();
+  return;
+}
+
+async function respondSilentTail(command, message, gated) {
+  const silent = await import('./mock-silent-tail.mjs');
+  silent.noteSilentTailPrompt(message);
+  if (silent.isFinalMessageNudge(message)) {
+    return respondFinalNudge(silent);
+  }
+  if (silent.isSilentTailScenario(message)) {
+    assistantText([silent.SILENT_TAIL_OPENING]);
+    write({ type: 'tool_execution_start', toolCallId: 'tool-silent-gh', toolName: 'bash', args: { command: 'gh issue create' } });
+    write({ type: 'tool_execution_end', toolCallId: 'tool-silent-gh', toolName: 'bash', result: { content: [{ type: 'text', text: 'created' }] }, isError: false });
+    assistantThinking(silent.SILENT_TAIL_REASONING);
+    endTurn();
     return;
   }
-  if (message.includes('mock:local-result')) {
-    respond(command);
-    write({ type: 'prompt_result', ...(command.id ? { id: command.id } : {}), agentInvoked: false, status: 'completed', sessionSettled: true });
+  if (silent.isToolTailScenario(message)) {
+    assistantText([silent.TOOL_TAIL_OPENING]);
+    write({ type: 'tool_execution_start', toolCallId: 'tool-tail-git', toolName: 'bash', args: { command: 'git status --short' } });
+    write({ type: 'tool_execution_end', toolCallId: 'tool-tail-git', toolName: 'bash', result: { content: [{ type: 'text', text: ' M src/example.ts' }] }, isError: false });
+    endTurn();
     return;
   }
-  if (message.includes('mock:prompt-error')) {
-    // The prompt failed after admission, before the agent ran: the ack, an error response,
-    // then its prompt_result (rpc-mode.ts `onError` + `RpcPromptResults.fail`).
-    respond(command);
-    fail(command, 'Model not found: anthropic/claude-missing');
-    write({ type: 'prompt_result', ...(command.id ? { id: command.id } : {}), agentInvoked: false, status: 'error', error: { message: 'Model not found: anthropic/claude-missing', provider: 'anthropic', model: 'claude-missing', retryable: false }, sessionSettled: true });
+  return false;
+}
+
+async function respondProgress(command, message, gated) {
+  if (message.includes('mock:no-progress')) {
+    // The turn never progresses and never settles.
+    if (!gated) watchdogStall(message);
     return;
   }
-  if (message.includes('mock:prompt-rejected')) {
-    // Rejected before admission (an input hook threw): the error response only, no prompt_result.
-    fail(command, 'input hook rejected the prompt');
-    return;
+  for (let i = 0; i < 24; i++) {
+    write({ type: 'tool_execution_update', toolCallId: 'busy', toolName: 'bash', args: { command: 'build' }, partialResult: { content: [{ type: 'text', text: 'working' }] } });
+    await sleep(100);
+  }
+  assistantText(['busy progress finished', '\n\nCEZ:DONE']);
+  endTurn();
+  return;
+}
+
+function respondSplitText(command, message, gated) {
+  // One text_delta per token, so the marker is split across deltas (harness parity S8).
+  assistantText(['parity split text', '\n\n', 'CEZ:', 'MONITORING']);
+  endTurn();
+  return;
+}
+
+function respondAskSnapshot(command, message, gated) {
+  // #401: an authoritative text_end with no deltas.
+  const messageId = `msg-${++messageSeq}`;
+  const text = message.includes('mock:ask-snapshot-bad') ? 'CEZ:ASK {not valid json' : SNAPSHOT_ASK;
+  write({ type: 'message_start', messageId, message: { role: 'assistant', content: [] } });
+  messageUpdate(messageId, { type: 'text_end', contentIndex: 0, content: text });
+  write({ type: 'message_end', messageId, message: { role: 'assistant', content: [{ type: 'text', text }], provider: 'anthropic', model: 'claude-mock', usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, totalTokens: 15, cost: { total: 0.001 } }, stopReason: 'stop' } });
+  endTurn();
+  return;
+}
+
+function respondAskProse(command, message, gated) {
+  assistantText(['Use `CEZ:ASK {"questions":[]}` in your reply.\n> CEZ:ASK {not valid json']);
+  endTurn();
+  return;
+}
+
+function respondBadAsk(command, message, gated) {
+  // OMP's `ask` tool needs an interactive UI, so the CEZ:ASK marker is the ask path (as Pi's).
+  assistantText(['Pick one.\n\nCEZ:ASK {not valid json']);
+  endTurn();
+  return;
+}
+
+function respondAsk(command, message, gated) {
+  resumeAfterAsk = message.includes('mock:resume-done');
+  // The marker and its JSON body land in separate deltas (the #2 boundary).
+  assistantText(['Pick one.\n\n', 'CEZ:ASK', ' ', ASK_MARKER_BODY]);
+  endTurn();
+  return;
+}
+
+async function respondSubagentAfterPark(command, message, gated) {
+  // A `task` call whose sub-agent is still reporting after the parent parked on its marker.
+  write({ type: 'tool_execution_start', toolCallId: 'toolu_park_task', toolName: 'task', args: { agent: 'explore', task: 'Review the change' } });
+  write({ type: 'subagent_lifecycle', payload: { id: 'ParkReviewer', agent: 'explore', status: 'started', parentToolCallId: 'toolu_park_task', index: 0 } });
+  subagentText('ParkReviewer', 'Child review started.');
+  write({ type: 'tool_execution_end', toolCallId: 'toolu_park_task', toolName: 'task', result: { content: [{ type: 'text', text: 'ParkReviewer: running' }] }, isError: false });
+  assistantText(['Watching the child.\nCEZ:MONITORING']);
+  endTurn();
+  await afterParityPark(message);
+  write({ type: 'subagent_event', payload: { id: 'ParkReviewer', event: { type: 'tool_execution_start', toolCallId: 'toolu_park_read', toolName: 'read', args: { path: 'README.md' } } } });
+  write({ type: 'subagent_event', payload: { id: 'ParkReviewer', event: { type: 'tool_execution_end', toolCallId: 'toolu_park_read', toolName: 'read', result: { content: [{ type: 'text', text: 'mock file' }] } } } });
+  subagentText('ParkReviewer', 'Post-park child update processed.');
+  write({ type: 'subagent_event', payload: { id: 'ParkReviewer', event: { type: 'agent_end', messages: [], isTerminal: true, yielded: true } } });
+  write({ type: 'subagent_lifecycle', payload: { id: 'ParkReviewer', agent: 'explore', status: 'completed', parentToolCallId: 'toolu_park_task', index: 0 } });
+  return;
+}
+
+function respondSubagent(command, message, gated) {
+  // #5/#600: the sub-agent's own terminal agent_end, nested under the parent's `task` call
+  // (rpc-subagents.ndjson), must not end the parent turn; #149: its text stays nested.
+  write({ type: 'tool_execution_start', toolCallId: 'toolu_task_1', toolName: 'task', args: { agent: 'explore', task: 'Review the change' } });
+  write({ type: 'subagent_lifecycle', payload: { id: 'Reviewer', agent: 'explore', status: 'started', parentToolCallId: 'toolu_task_1', index: 0 } });
+  write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'agent_start' } } });
+  write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'tool_execution_start', toolCallId: 'toolu_child_grep', toolName: 'grep', args: { pattern: 'ask' } } } });
+  write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'tool_execution_end', toolCallId: 'toolu_child_grep', toolName: 'grep', result: { content: [{ type: 'text', text: '3 matches' }] } } } });
+  write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'agent_end', messages: [], isTerminal: true, yielded: true } } });
+  write({ type: 'subagent_lifecycle', payload: { id: 'Reviewer', agent: 'explore', status: 'completed', parentToolCallId: 'toolu_task_1', index: 0 } });
+  write({ type: 'tool_execution_end', toolCallId: 'toolu_task_1', toolName: 'task', result: { content: [{ type: 'text', text: 'Reviewer: done' }] }, isError: false });
+  // The parent keeps streaming after the child's terminal frame.
+  assistantText(['Still working after the sub-agent.\nCEZ:MONITORING']);
+  // Late child text after the parent marker; the second block never completes.
+  subagentText('Reviewer', 'Child review finished.', { input: 20, output: 10, cacheRead: 100, cacheWrite: 4, totalTokens: 134, cost: { total: 0.002 } });
+  write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'message_update', message: { role: 'assistant' }, assistantMessageEvent: { type: 'text_start', contentIndex: 0 } } } });
+  write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'message_update', message: { role: 'assistant' }, assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: 'Child review still streaming.' } } } });
+  endTurn();
+  return;
+}
+
+function respondApprovalDenied(command, message, gated) {
+  // A user's stricter `tools.approvalMode`: OMP fails the call closed when no UI can approve it.
+  write({ type: 'tool_execution_start', toolCallId: 'tool-denied', toolName: 'bash', args: { command: 'rm -rf build' } });
+  write({ type: 'tool_execution_end', toolCallId: 'tool-denied', toolName: 'bash', result: { content: [{ type: 'text', text: NO_UI_APPROVAL_ERROR }] }, isError: true });
+  assistantText(['The command needs approval I cannot get here.']);
+  endTurn();
+  return;
+}
+
+async function respondSteerLate(command, message, gated) {
+  // The final text first; a steer admitted now arrives after the last model call (#505).
+  assistantText(['late window: final message already sent']);
+  activeTurn.late = true;
+  await sleep(300);
+  endTurn();
+  return;
+}
+
+async function respondHoldDone(command, message, gated) {
+  await waitForMockRelease(400);
+  assistantText(['parity hold-done: content after the pause\n\nCEZ:DONE']);
+  endTurn();
+  return;
+}
+
+async function respondHoldAsk(command, message, gated) {
+  await waitForMockRelease(400);
+  assistantText(['Pick one.\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}']);
+  endTurn();
+  return;
+}
+
+function respondDone(command, message, gated) {
+  resumeAfterAsk = false;
+  assistantText(['parity done: the task is complete\n\nCEZ:DONE']);
+  endTurn();
+  return;
+}
+
+async function respondCezarTool(command, message, gated) {
+  const { toolPrompt } = await import('./mock-ci-tool.mjs');
+  assistantText([await toolPrompt('omp', argv, message)]);
+  endTurn();
+  return;
+}
+
+async function respondCiWait(command, message, gated) {
+  const { ciPrompt } = await import('./mock-ci-tool.mjs');
+  assistantText([await ciPrompt('omp', argv, message)]);
+  endTurn();
+  return;
+}
+
+async function respondSteerTool(command, message, gated) {
+  write({ type: 'tool_execution_start', toolCallId: 'tool-steer', toolName: 'bash', args: { command: 'wait' } });
+  await sleep(Number(process.env.CEZ_MOCK_STEER_MS ?? 600));
+  write({ type: 'tool_execution_end', toolCallId: 'tool-steer', toolName: 'bash', result: { content: [{ type: 'text', text: 'waited' }] }, isError: false });
+  assistantText(['steer tool done']);
+  endTurn();
+  return;
+}
+
+function respondNoSettle(command, message) {
+  // The stream ends mid-turn after a failed attempt: no agent_end, no settle.
+  assistantText([], { stopReason: 'error', usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { total: 0 } }, extra: { errorMessage: 'Overloaded' } });
+  process.exit(0);
+}
+
+async function respondHoldGated(command, message) {
+  await waitForMockRelease(250);
+  assistantText(['parity hold-gated: content after the pause']);
+  await sleep(250);
+  endTurn();
+  return;
+}
+
+async function respondHold(command, message) {
+  // Content and the settle both trail the prompt ack, so a turn-end derived from the ack
+  // (or a short deadline) is caught before any content arrives.
+  await sleep(250);
+  assistantText(['parity hold: content after the pause']);
+  await sleep(250);
+  endTurn();
+  return;
+}
+
+async function respondDefault(command, message) {
+  assistantText([`Investigating: `, message, ...(message.includes('mock:monitoring') ? ['\n\nCEZ:MONITORING'] : [])]);
+  write({ type: 'tool_execution_start', toolCallId: 'tool-1', toolName: 'read', args: { path: 'README.md' } });
+  write({ type: 'tool_execution_end', toolCallId: 'tool-1', toolName: 'read', result: { content: [{ type: 'text', text: 'mock file' }] }, isError: false });
+  if (!message.includes('mock:monitoring')) {
+    assistantText(['Done with the first pass.'], { usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { total: 0 } } });
+  }
+  endTurn();
+  if (message.includes('mock:wake-after-settle')) {
+    // OMP resumes on its own after settling (async work finished): a new agent run, no prompt.
+    await sleep(250);
+    beginTurn();
+    assistantText(['woke after settle']);
+    write({ type: 'turn_end' });
+    write({ type: 'agent_end', messages: [], isTerminal: true, yielded: true });
+    activeTurn = null;
+    write({ type: 'session_settled' });
   }
+}
+
+// These prompts finish before a native agent turn opens. Keep their admission order.
+const localPromptScenarios = [
+  { matches: message => message.includes('mock:local-command'), respond: respondLocalCommand },
+  { matches: message => message.includes('mock:local-result'), respond: respondLocalResult },
+  { matches: message => message.includes('mock:prompt-error'), respond: respondPromptError },
+  { matches: message => message.includes('mock:prompt-rejected'), respond: respondPromptRejected },
+];
+
+// The first handled scenario wins; silent-tail can fall through after its import.
+const promptScenarios = [
+  { matches: message => message.includes('mock:multi-pr-refs'), respond: respondMultiPrRefs },
+  { matches: message => message.includes('mock:turn-messages:'), respond: respondTurnMessages },
+  { matches: message => message.includes('mock:agent-echo'), respond: respondAgentEcho },
+  { matches: message => message.includes('mock:autonomous') || message.startsWith('Continue working autonomously until the task is fully complete.'), respond: respondAutonomous },
+  { matches: message => message.includes('mock:silent-tail') || message.includes('mock:tool-tail') || silentNudge(message), respond: respondSilentTail },
+  { matches: message => /mock:(no-progress|busy-progress)/.test(message), respond: respondProgress },
+  { matches: message => message.includes('mock:split-text'), respond: respondSplitText },
+  { matches: message => message.includes('mock:ask-snapshot'), respond: respondAskSnapshot },
+  { matches: message => message.includes('mock:ask-prose'), respond: respondAskProse },
+  { matches: message => message.includes('mock:ask-bad'), respond: respondBadAsk },
+  { matches: message => message.includes('mock:ask'), respond: respondAsk },
+  { matches: message => message.includes('mock:subagent-after-park'), respond: respondSubagentAfterPark },
+  { matches: message => message.includes('mock:subagent'), respond: respondSubagent },
+  { matches: message => message.includes('mock:approval-denied'), respond: respondApprovalDenied },
+  { matches: message => message.includes('mock:steer-late'), respond: respondSteerLate },
+  { matches: message => message.includes('mock:hold-done'), respond: respondHoldDone },
+  { matches: message => message.includes('mock:hold-ask'), respond: respondHoldAsk },
+  { matches: message => message.includes('mock:done') || (resumeAfterAsk && message.trim() === 'Library: Vitest'), respond: respondDone },
+  { matches: message => message.includes('mock:cezar-tool'), respond: respondCezarTool },
+  { matches: message => message.includes('mock:ci-wait'), respond: respondCiWait },
+  { matches: message => message.includes('mock:steer-tool'), respond: respondSteerTool },
+];
+
+// Failure controls run before these trailing scenarios, even for an ordinary prompt.
+const tailPromptScenarios = [
+  { matches: message => message.includes('mock:no-settle'), respond: respondNoSettle },
+  { matches: message => message.includes('mock:hold-gated'), respond: respondHoldGated },
+  { matches: message => message.includes('mock:hold'), respond: respondHold },
+];
+
+async function prompt(command, sent = command.message) {
+  const message = command.message;
+  // Rejected before admission: OMP's error response only, no prompt_result (rpc-mode.ts).
+  if (delivery?.rejects(sent)) { fail(command, 'owned turn rejected'); return; }
+  // Every successful admission acknowledges through here, so a configured hold-ack holds it
+  // whichever scenario branch answers the prompt.
+  const ack = (extra) => { if (delivery) delivery.ack(sent, () => respond(command, extra)); else respond(command, extra); };
+  // `mock:ack-only` → the prompt is accepted and no agent run starts (hearsay-tools/cezarion#1301).
+  if (message.includes('mock:ack-only')) { ack(); return; }
+  const gated = message.includes('mock:gate-prompt-ack');
+  if (gated) {
+    watchdogStall(message);
+    while (!existsSync('input-ack.release')) await sleep(10);
+  }
+  const local = localPromptScenarios.find(scenario => scenario.matches(message));
+  if (local) { local.respond(command, message, ack); return; }
 
   if (message.includes('mock:linger')) {
     linger = true;
@@ -361,245 +729,51 @@ async function prompt(command) {
     if (crashWithStderr(message, '{"type":"tool_execution_update","toolCallId":"truncated')) return;
   }
 
-  if (message.includes('mock:silent-tail') || message.includes('Your last turn ended without a message to the user.')) {
+  return startPromptTurn(command, message, ack, gated);
+}
+
+async function startPromptTurn(command, message, ack, gated) {
+  if (message.includes('mock:silent-tail') || silentNudge(message)) {
     const silentEarly = await import('./mock-silent-tail.mjs');
     silentEarly.noteSilentTailPrompt(message);
-    if (silentEarly.isAckOnlyNudge(message)) { respond(command); return; }
+    if (silentEarly.isAckOnlyNudge(message)) { ack(); return; }
     if (silentEarly.isLateNudge(message)) {
-      respond(command);
-      await silentEarly.sleep(silentEarly.LATE_REPLY_MS);
+      ack();
+      await waitForMockRelease(silentEarly.LATE_REPLY_MS);
       beginTurn(command);
     } else {
-      respond(command);
+      ack();
       beginTurn(command);
     }
+  } else if (message.includes('mock:deferred-turn-start')) {
+    // hearsay-tools/cezarion#1112: the acknowledged prompt opens its native run late.
+    ack();
+    await (await import('./mock-deferred-turn-start.mjs')).deferredTurnStart();
+    beginTurn(command);
   } else {
-  respond(command);
-  beginTurn(command);
-  }
-  if (message.includes('mock:turn-messages:')) {
-    const { turnMessages } = await import('./mock-turn-messages.mjs');
-    // Separate assistant messages within one native OMP turn; settle only after all of them.
-    for (const text of turnMessages(message)) assistantText([text]);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:agent-echo')) {
-    assistantText([message]);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:autonomous') || message.startsWith('Continue working autonomously until the task is fully complete.')) {
-    const { autonomousReply } = await import('./mock-autonomous.mjs');
-    assistantText([autonomousReply(message)]);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:silent-tail') || message.includes('mock:tool-tail') || message.includes('Your last turn ended without a message to the user.')) {
-    const silent = await import('./mock-silent-tail.mjs');
-    silent.noteSilentTailPrompt(message);
-    if (silent.isFinalMessageNudge(message)) {
-      const kind = silent.finalMessageNudgeKind();
-      if (kind === 'silent') assistantThinking(silent.SILENT_TAIL_REASONING);
-      else if (kind === 'slow-done') {
-        assistantText([silent.SLOW_DONE_PREFIX]);
-        await silent.sleep(silent.SLOW_DONE_TAIL_MS);
-        assistantText([silent.SILENT_TAIL_DONE]);
-      } else assistantText([kind === 'standing' ? silent.FINAL_MESSAGE_STANDING : silent.SILENT_TAIL_DONE]);
-      endTurn();
-      return;
-    }
-    if (silent.isSilentTailScenario(message)) {
-      assistantText([silent.SILENT_TAIL_OPENING]);
-      write({ type: 'tool_execution_start', toolCallId: 'tool-silent-gh', toolName: 'bash', args: { command: 'gh issue create' } });
-      write({ type: 'tool_execution_end', toolCallId: 'tool-silent-gh', toolName: 'bash', result: { content: [{ type: 'text', text: 'created' }] }, isError: false });
-      assistantThinking(silent.SILENT_TAIL_REASONING);
-      endTurn();
-      return;
-    }
-    if (silent.isToolTailScenario(message)) {
-      assistantText([silent.TOOL_TAIL_OPENING]);
-      write({ type: 'tool_execution_start', toolCallId: 'tool-tail-git', toolName: 'bash', args: { command: 'git status --short' } });
-      write({ type: 'tool_execution_end', toolCallId: 'tool-tail-git', toolName: 'bash', result: { content: [{ type: 'text', text: ' M src/example.ts' }] }, isError: false });
-      endTurn();
-      return;
-    }
-  }
-  if (/mock:(no-progress|busy-progress)/.test(message)) {
-    if (message.includes('mock:no-progress')) {
-      // The turn never progresses and never settles.
-      watchdogStall(message);
-      return;
-    }
-    for (let i = 0; i < 24; i++) {
-      write({ type: 'tool_execution_update', toolCallId: 'busy', toolName: 'bash', args: { command: 'build' }, partialResult: { content: [{ type: 'text', text: 'working' }] } });
-      await sleep(100);
-    }
-    assistantText(['busy progress finished']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:split-text')) {
-    // One text_delta per token, so the marker is split across deltas (harness parity S8).
-    assistantText(['parity split text', '\n\n', 'CEZ:', 'MONITORING']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:ask-snapshot')) {
-    // #401: an authoritative text_end with no deltas.
-    const messageId = `msg-${++messageSeq}`;
-    const text = message.includes('mock:ask-snapshot-bad') ? 'CEZ:ASK {not valid json' : SNAPSHOT_ASK;
-    write({ type: 'message_start', messageId, message: { role: 'assistant', content: [] } });
-    messageUpdate(messageId, { type: 'text_end', contentIndex: 0, content: text });
-    write({ type: 'message_end', messageId, message: { role: 'assistant', content: [{ type: 'text', text }], provider: 'anthropic', model: 'claude-mock', usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, totalTokens: 15, cost: { total: 0.001 } }, stopReason: 'stop' } });
-    endTurn();
-    return;
+    ack();
+    beginTurn(command);
   }
-  if (message.includes('mock:ask-prose')) {
-    assistantText(['Use `CEZ:ASK {"questions":[]}` in your reply.\n> CEZ:ASK {not valid json']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:ask-bad')) {
-    // OMP's `ask` tool needs an interactive UI, so the CEZ:ASK marker is the ask path (as Pi's).
-    assistantText(['Pick one.\n\nCEZ:ASK {not valid json']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:ask')) {
-    resumeAfterAsk = message.includes('mock:resume-done');
-    // The marker and its JSON body land in separate deltas (the #2 boundary).
-    assistantText(['Pick one.\n\n', 'CEZ:ASK', ' ', ASK_MARKER_BODY]);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:subagent-after-park')) {
-    // A `task` call whose sub-agent is still reporting after the parent parked on its marker.
-    write({ type: 'tool_execution_start', toolCallId: 'toolu_park_task', toolName: 'task', args: { agent: 'explore', task: 'Review the change' } });
-    write({ type: 'subagent_lifecycle', payload: { id: 'ParkReviewer', agent: 'explore', status: 'started', parentToolCallId: 'toolu_park_task', index: 0 } });
-    subagentText('ParkReviewer', 'Child review started.');
-    write({ type: 'tool_execution_end', toolCallId: 'toolu_park_task', toolName: 'task', result: { content: [{ type: 'text', text: 'ParkReviewer: running' }] }, isError: false });
-    assistantText(['Watching the child.\nCEZ:MONITORING']);
-    endTurn();
-    await afterParityPark(message);
-    write({ type: 'subagent_event', payload: { id: 'ParkReviewer', event: { type: 'tool_execution_start', toolCallId: 'toolu_park_read', toolName: 'read', args: { path: 'README.md' } } } });
-    write({ type: 'subagent_event', payload: { id: 'ParkReviewer', event: { type: 'tool_execution_end', toolCallId: 'toolu_park_read', toolName: 'read', result: { content: [{ type: 'text', text: 'mock file' }] } } } });
-    subagentText('ParkReviewer', 'Post-park child update processed.');
-    write({ type: 'subagent_event', payload: { id: 'ParkReviewer', event: { type: 'agent_end', messages: [], isTerminal: true, yielded: true } } });
-    write({ type: 'subagent_lifecycle', payload: { id: 'ParkReviewer', agent: 'explore', status: 'completed', parentToolCallId: 'toolu_park_task', index: 0 } });
-    return;
-  }
-  if (message.includes('mock:subagent')) {
-    // #5/#600: the sub-agent's own terminal agent_end, nested under the parent's `task` call
-    // (rpc-subagents.ndjson), must not end the parent turn; #149: its text stays nested.
-    write({ type: 'tool_execution_start', toolCallId: 'toolu_task_1', toolName: 'task', args: { agent: 'explore', task: 'Review the change' } });
-    write({ type: 'subagent_lifecycle', payload: { id: 'Reviewer', agent: 'explore', status: 'started', parentToolCallId: 'toolu_task_1', index: 0 } });
-    write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'agent_start' } } });
-    write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'tool_execution_start', toolCallId: 'toolu_child_grep', toolName: 'grep', args: { pattern: 'ask' } } } });
-    write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'tool_execution_end', toolCallId: 'toolu_child_grep', toolName: 'grep', result: { content: [{ type: 'text', text: '3 matches' }] } } } });
-    write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'agent_end', messages: [], isTerminal: true, yielded: true } } });
-    write({ type: 'subagent_lifecycle', payload: { id: 'Reviewer', agent: 'explore', status: 'completed', parentToolCallId: 'toolu_task_1', index: 0 } });
-    write({ type: 'tool_execution_end', toolCallId: 'toolu_task_1', toolName: 'task', result: { content: [{ type: 'text', text: 'Reviewer: done' }] }, isError: false });
-    // The parent keeps streaming after the child's terminal frame.
-    assistantText(['Still working after the sub-agent.\nCEZ:MONITORING']);
-    // Late child text after the parent marker; the second block never completes.
-    subagentText('Reviewer', 'Child review finished.', { input: 20, output: 10, cacheRead: 100, cacheWrite: 4, totalTokens: 134, cost: { total: 0.002 } });
-    write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'message_update', message: { role: 'assistant' }, assistantMessageEvent: { type: 'text_start', contentIndex: 0 } } } });
-    write({ type: 'subagent_event', payload: { id: 'Reviewer', event: { type: 'message_update', message: { role: 'assistant' }, assistantMessageEvent: { type: 'text_delta', contentIndex: 0, delta: 'Child review still streaming.' } } } });
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:approval-denied')) {
-    // A user's stricter `tools.approvalMode`: OMP fails the call closed when no UI can approve it.
-    write({ type: 'tool_execution_start', toolCallId: 'tool-denied', toolName: 'bash', args: { command: 'rm -rf build' } });
-    write({ type: 'tool_execution_end', toolCallId: 'tool-denied', toolName: 'bash', result: { content: [{ type: 'text', text: NO_UI_APPROVAL_ERROR }] }, isError: true });
-    assistantText(['The command needs approval I cannot get here.']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:steer-late')) {
-    // The final text first; a steer admitted now arrives after the last model call (#505).
-    assistantText(['late window: final message already sent']);
-    activeTurn.late = true;
-    await sleep(300);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:hold-done')) {
-    await waitForMockRelease(400);
-    assistantText(['parity hold-done: content after the pause\n\nCEZ:DONE']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:hold-ask')) {
-    await waitForMockRelease(400);
-    assistantText(['Pick one.\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:done') || (resumeAfterAsk && message.trim() === 'Library: Vitest')) {
-    resumeAfterAsk = false;
-    assistantText(['parity done: the task is complete\n\nCEZ:DONE']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:ci-wait')) {
-    const { ciPrompt } = await import('./mock-ci-tool.mjs');
-    assistantText([await ciPrompt('omp', argv, message)]);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:steer-tool')) {
-    write({ type: 'tool_execution_start', toolCallId: 'tool-steer', toolName: 'bash', args: { command: 'wait' } });
-    await sleep(Number(process.env.CEZ_MOCK_STEER_MS ?? 600));
-    write({ type: 'tool_execution_end', toolCallId: 'tool-steer', toolName: 'bash', result: { content: [{ type: 'text', text: 'waited' }] }, isError: false });
-    assistantText(['steer tool done']);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:provider-error')) {
+  if (delivery) await delivery.holdResponse(message);
+  return respondPromptTurn(command, message, gated);
+}
+
+async function respondPromptTurn(command, message, gated) {
+  for (const scenario of promptScenarios) {
+    if (!scenario.matches(message)) continue;
+    const result = scenario.respond(command, message, gated);
+    const handled = result instanceof Promise ? await result : result;
+    if (handled !== false) return;
+  }
+  const selectedFailure = failureControl?.failureFor(message);
+  const nativeFailure = selectedFailure instanceof Promise ? await selectedFailure : selectedFailure;
+  if (failureControl ? nativeFailure === 'provider' : message.includes('mock:provider-error')) {
     const error = { message: 'Not Found', provider: 'anthropic', model: 'claude-mock', retryable: false };
     assistantText([], { stopReason: 'error', usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { total: 0 } }, extra: { errorMessage: 'Not Found' } });
     endTurn({ status: 'error', error });
     return;
   }
-  if (message.includes('mock:no-settle')) {
-    // The stream ends mid-turn after a failed attempt: no agent_end, no settle.
-    assistantText([], { stopReason: 'error', usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { total: 0 } }, extra: { errorMessage: 'Overloaded' } });
-    process.exit(0);
-  }
-  if (message.includes('mock:hold-gated')) {
-    await waitForMockRelease(250);
-    assistantText(['parity hold-gated: content after the pause']);
-    await sleep(250);
-    endTurn();
-    return;
-  }
-  if (message.includes('mock:hold')) {
-    // Content and the settle both trail the prompt ack, so a turn-end derived from the ack
-    // (or a short deadline) is caught before any content arrives.
-    await sleep(250);
-    assistantText(['parity hold: content after the pause']);
-    await sleep(250);
-    endTurn();
-    return;
-  }
-
-  assistantText([`Investigating: `, message, ...(message.includes('mock:monitoring') ? ['\n\nCEZ:MONITORING'] : [])]);
-  write({ type: 'tool_execution_start', toolCallId: 'tool-1', toolName: 'read', args: { path: 'README.md' } });
-  write({ type: 'tool_execution_end', toolCallId: 'tool-1', toolName: 'read', result: { content: [{ type: 'text', text: 'mock file' }] }, isError: false });
-  if (!message.includes('mock:monitoring')) {
-    assistantText(['Done with the first pass.'], { usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { total: 0 } } });
-  }
-  endTurn();
-  if (message.includes('mock:wake-after-settle')) {
-    // OMP resumes on its own after settling (async work finished): a new agent run, no prompt.
-    await sleep(250);
-    beginTurn();
-    assistantText(['woke after settle']);
-    write({ type: 'turn_end' });
-    write({ type: 'agent_end', messages: [], isTerminal: true, yielded: true });
-    activeTurn = null;
-    write({ type: 'session_settled' });
-  }
+  const tail = tailPromptScenarios.find(scenario => scenario.matches(message));
+  if (tail) return tail.respond(command, message);
+  return respondDefault(command, message);
 }