@wjarka/cezarion 0.15.1 → 0.16.0

package/scripts/mock-opencode-serve.mjs

@@ -14,6 +14,13 @@ function watchdogStall(prompt) {
   if (prompt.includes('held-pipe')) {
     watchdogSpawn(process.execPath, ['-e', 'setTimeout(() => {}, 5000)'], { stdio: ['ignore', process.stdout, process.stderr] });
   }
+  if (prompt.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)`;
+    watchdogSpawn(process.execPath, ['-e', leftover('leftover-group.pid')], { stdio: 'ignore' });
+    watchdogSpawn(process.execPath, ['-e', leftover('leftover-session.pid')], { stdio: 'ignore', detached: true }).unref();
+  }
   return true;
 }
 
@@ -24,8 +31,30 @@ function watchdogStall(prompt) {
 // response resolves immediately — every part and the closing `session.idle`
 // arrive over SSE afterwards, so a correct stream (v1 and v2 alike) must
 // take its turn-end from `session.idle`, never from the HTTP response.
-import { appendFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+// Aliased: owned-input-delivery.testkit.ts prepends its own `existsSync`/`writeFileSync` import,
+// and a second import of the same name is a SyntaxError.
+import { appendFileSync, existsSync as sessionStoreExists, mkdirSync, readFileSync, writeFileSync as sessionStoreWrite } from 'node:fs';
 import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+// #872: the first N starts die before listening, the way opencode 1.18.33 did
+// when started within ~2 s of SIGTERM to the previous server on the same DB.
+// Starts are counted across processes in a file, so start N+1 listens normally.
+const failStarts = Number(process.env.CEZ_MOCK_OPENCODE_SERVE_FAIL_STARTS ?? 0);
+if (failStarts > 0) {
+  const counter = process.env.CEZ_MOCK_OPENCODE_SERVE_FAIL_FILE
+    || (process.env.CEZ_MOCK_ARGS_FILE ? `${process.env.CEZ_MOCK_ARGS_FILE}.opencode-serve-starts`
+      : join(tmpdir(), `cez-mock-opencode-serve-starts-${createHash('sha256').update(process.cwd()).digest('hex')}`));
+  const start = (sessionStoreExists(counter) ? Number(readFileSync(counter, 'utf8')) || 0 : 0) + 1;
+  sessionStoreWrite(counter, String(start));
+  if (start <= failStarts) {
+    // Pipe writes to stderr are synchronous on POSIX, so exiting right away loses nothing.
+    process.stderr.write(`Error: Unexpected error (start ${start})\nServeError\n`);
+    process.exit(1);
+  }
+}
 
 if (process.env.CEZ_MOCK_ARGS_FILE && process.env.OPENCODE_CONFIG_CONTENT) appendFileSync(process.env.CEZ_MOCK_ARGS_FILE, JSON.stringify({ type: 'runtime-config', config: JSON.parse(process.env.OPENCODE_CONFIG_CONTENT) }) + '\n');
 if (process.env.CEZ_MOCK_CI_PR) { const { probeCiTool } = await import('./mock-ci-tool.mjs'); await probeCiTool('opencode', JSON.parse(process.env.OPENCODE_CONFIG_CONTENT ?? '{}')); }
@@ -37,6 +66,15 @@ async function afterParityPark(prompt) {
   if (!gate) throw new Error('post-park scenario requires a release path');
   while (!parityGateFs.existsSync(gate)) await new Promise(resolve => setTimeout(resolve, 10));
 }
+async function waitForMockRelease(fallbackMs) {
+  const file = process.env.CEZ_MOCK_RELEASE_FILE;
+  if (!file) { if (fallbackMs) await new Promise(r => setTimeout(r, fallbackMs)); return; }
+  const deadline = Date.now() + 15_000;
+  while (!parityGateFs.existsSync(file)) {
+    if (Date.now() > deadline) throw new Error('CEZ_MOCK_RELEASE_FILE was not created');
+    await new Promise(r => setTimeout(r, 10));
+  }
+}
 
 const args = process.argv.slice(2);
 const arg = (flag, fallback) => {
@@ -45,9 +83,81 @@ const arg = (flag, fallback) => {
 };
 const hostname = arg('--hostname', '127.0.0.1');
 
-const SESSION_ID = 'ses_mock_1';
+const DEFAULT_SESSION_ID = 'ses_mock_1';
+let SESSION_ID = DEFAULT_SESSION_ID;
 const MESSAGE_ID = 'msg_mock_1';
 
+function sessionStorePath() {
+  if (process.env.CEZ_MOCK_OPENCODE_SESSIONS_FILE) return process.env.CEZ_MOCK_OPENCODE_SESSIONS_FILE;
+  // Keyed on the args file, not its directory: spec-support probes and D1 share a
+  // cwd and would otherwise increment ses_mock_N across unrelated launches.
+  if (process.env.CEZ_MOCK_ARGS_FILE) return `${process.env.CEZ_MOCK_ARGS_FILE}.opencode-sessions.json`;
+  // Dry-run Continue (no args file) must resume in the same worktree: persist by cwd.
+  const key = createHash('sha256').update(process.cwd()).digest('hex');
+  return join(tmpdir(), `cez-mock-opencode-sessions-${key}.json`);
+}
+function emptySessionStore() {
+  return { seq: 0, sessions: {} };
+}
+function readPersistedSessionStore() {
+  const path = sessionStorePath();
+  if (!path || !sessionStoreExists(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed && typeof parsed === 'object' && parsed.sessions && typeof parsed.sessions === 'object') return parsed;
+  } catch {
+    // A corrupt store is treated as missing so a later POST can mint a session.
+  }
+  return null;
+}
+let memorySessionStore = readPersistedSessionStore() ?? emptySessionStore();
+function loadSessionStore() {
+  return readPersistedSessionStore() ?? memorySessionStore;
+}
+function saveSessionStore(store) {
+  memorySessionStore = store;
+  const path = sessionStorePath();
+  if (!path) return;
+  mkdirSync(dirname(path), { recursive: true });
+  sessionStoreWrite(path, JSON.stringify(store));
+}
+function getSession(id) {
+  return loadSessionStore().sessions[id] ?? null;
+}
+function createSession(body = {}) {
+  const store = loadSessionStore();
+  store.seq += 1;
+  const id = store.seq === 1 ? DEFAULT_SESSION_ID : `ses_mock_${store.seq}`;
+  store.sessions[id] = {
+    id,
+    title: typeof body.title === 'string' ? body.title : 'cezar task',
+    prompts: [],
+    ...(Array.isArray(body.permission) ? { permission: [...body.permission] } : {}),
+  };
+  saveSessionStore(store);
+  return id;
+}
+function addPrompt(id, text) {
+  const store = loadSessionStore();
+  if (!store.sessions[id]) return;
+  store.sessions[id].prompts = [...(store.sessions[id].prompts ?? []), text];
+  saveSessionStore(store);
+}
+function patchSession(id, body) {
+  const store = loadSessionStore();
+  if (!store.sessions[id]) return null;
+  // OpenCode 1.18.33: PATCH permission APPENDS (no replace, no dedupe); a
+  // title-only PATCH leaves permission alone.
+  const next = { ...store.sessions[id], ...body, id };
+  if (Array.isArray(body.permission)) {
+    const existing = Array.isArray(store.sessions[id].permission) ? store.sessions[id].permission : [];
+    next.permission = [...existing, ...body.permission];
+  }
+  store.sessions[id] = next;
+  saveSessionStore(store);
+  return store.sessions[id];
+}
+
 let sse = null;
 const write = (event) => {
   if (sse) sse.write(`data: ${JSON.stringify(event)}\n\n`);
@@ -117,6 +227,9 @@ const info = (extra) => ({
   ...extra,
 });
 
+let autonomousTurn = 0;
+let autonomousCap = false;
+let autonomousReadinessIdle = false;
 const server = createServer((req, res) => {
   const url = req.url ?? '';
   if (req.method === 'GET' && url === '/question') {
@@ -151,15 +264,63 @@ const server = createServer((req, res) => {
       else acknowledge();
       return;
     }
+    const sessionGet = req.method === 'GET' && /^\/session\/([^/]+)$/.exec(url);
+    if (sessionGet) {
+      const session = getSession(sessionGet[1]);
+      if (!session) {
+        res.writeHead(404, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: 'NotFoundError' }));
+        return;
+      }
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({
+        id: session.id,
+        title: session.title,
+        ...(Array.isArray(session.permission) ? { permission: session.permission } : {}),
+      }));
+      return;
+    }
+    const sessionPatch = req.method === 'PATCH' && /^\/session\/([^/]+)$/.exec(url);
+    if (sessionPatch) {
+      const session = patchSession(sessionPatch[1], body ? JSON.parse(body) : {});
+      if (!session) {
+        res.writeHead(404, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: 'NotFoundError' }));
+        return;
+      }
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({
+        id: session.id,
+        title: session.title,
+        ...(Array.isArray(session.permission) ? { permission: session.permission } : {}),
+      }));
+      return;
+    }
     if (req.method === 'POST' && url === '/session') {
+      const parsed = body ? JSON.parse(body) : {};
+      SESSION_ID = createSession(parsed);
       res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify({ id: SESSION_ID, title: 'cezar task' }));
+      res.end(JSON.stringify({
+        id: SESSION_ID,
+        title: parsed.title ?? 'cezar task',
+        ...(Array.isArray(parsed.permission) ? { permission: parsed.permission } : {}),
+      }));
       return;
     }
-    if (
-      req.method === 'POST' &&
-      (url === `/session/${SESSION_ID}/prompt_async` || url === `/session/${SESSION_ID}/message`)
-    ) {
+    const sessionPrompt = req.method === 'POST' && /^\/session\/([^/]+)\/(prompt_async|message)$/.exec(url);
+    if (sessionPrompt && getSession(sessionPrompt[1])) {
+      SESSION_ID = sessionPrompt[1];
+      try {
+        const text = body ? JSON.parse(body).parts?.map(part => part.text ?? '').join('\n') ?? '' : '';
+        if (text) addPrompt(SESSION_ID, text);
+      } catch {
+        // Keep the scripted turn even when the body is not JSON.
+      }
+      if (body.includes('mock:crash-stderr-pre-ack')) {
+        const { crashWithStderr } = await import('./mock-runner-crash.mjs');
+        crashWithStderr(body);
+        return;
+      }
       if (body.includes('mock:reject-agent-post')) {
         res.writeHead(503, { 'content-type': 'application/json' });
         res.end(JSON.stringify({ error: 'agent prompt rejected' }));
@@ -180,13 +341,42 @@ const server = createServer((req, res) => {
       turnActive = true;
       // `prompt_async` semantics: acknowledge now, stream the turn over SSE.
       res.writeHead(200, { 'content-type': 'application/json' });
+      // #426: a nudged turn can finish on SSE before its HTTP acceptance arrives.
+      // Force that ordering in the cap scenario; the first opening stays ordinary.
+      if (autonomousReadinessIdle && body.includes('Continue working autonomously until the task is fully complete.')) {
+        // Keep the portable answer HTTP request unacknowledged while its SSE turn finishes.
+      } else if (autonomousCap && body.includes('Continue working autonomously until the task is fully complete.')) {
+        setTimeout(() => res.end(JSON.stringify({ info: info({}), parts: [] })), 100);
+      } else if (body.includes('f7-delay-ack')) {
+        // F7: SSE turn-end before HTTP ACK so parkAfterAck applies the silent-tail nudge.
+        setTimeout(() => res.end(JSON.stringify({ info: info({}), parts: [] })), 250);
+      } else {
       res.end(JSON.stringify({ info: info({}), parts: [] }));
+      }
+      if (body.includes('mock:autonomous-readiness-idle')) autonomousReadinessIdle = true;
+      if (body.includes('mock:autonomous-cap') || body.includes('mock:autonomous-ask-cap')) autonomousCap = true;
+      if (body.includes('mock:silent-tail') || body.includes('Your last turn ended without a message to the user.')) {
+        const silent = await import('./mock-silent-tail.mjs');
+        const prompt = (() => { try { return JSON.parse(body).parts.map(part => part.text ?? '').join('\n'); } catch { return body; } })();
+        silent.noteSilentTailPrompt(prompt);
+        if (silent.isAckOnlyNudge(prompt)) {
+          const beats = setInterval(() => { if (sse) sse.write(': heartbeat\n\n'); }, 50);
+          beats.unref?.();
+          return;
+        }
+        if (silent.isLateNudge(prompt)) await silent.sleep(silent.LATE_REPLY_MS);
+      }
       if (url.endsWith('/prompt_async')) {
         currentUserId = `msg_user_${++steerSerial}`;
         const text = JSON.parse(body).parts.map(part => part.text ?? '').join('\n');
         send({ type: 'message.updated', properties: { info: { id: currentUserId, sessionID: SESSION_ID, role: 'user', time: { created: Date.now() } } } });
         send({ type: 'message.part.updated', properties: { part: { id: `prt_${currentUserId}`, messageID: currentUserId, sessionID: SESSION_ID, type: 'text', text } } });
       }
+      if (body.includes('mock:crash-stderr')) {
+        const { crashWithStderr } = await import('./mock-runner-crash.mjs');
+        if (body.includes('mock:crash-stderr-clean')) crashWithStderr(body);
+        else { setTimeout(() => crashWithStderr(body), 30); return; }
+      }
       if (body.includes('mock:steer-tool')) {
         send({ type: 'message.updated', properties: { info: info({}) } });
         send({ type: 'message.part.updated', properties: { part: { id: 'prt_steer_tool', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'tool', callID: 'call_steer', tool: 'bash', state: { status: 'running', input: { command: 'wait' } } } } });
@@ -212,6 +402,15 @@ const server = createServer((req, res) => {
         send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
         return;
       }
+      if (body.includes('mock:turn-messages:')) {
+        const { turnMessages } = await import('./mock-turn-messages.mjs');
+        send({ type: 'message.updated', properties: { info: info({}) } });
+        for (const text of turnMessages(JSON.parse(body).parts.map(part => part.text ?? '').join('\n'))) {
+          send({ type: 'message.part.updated', properties: { part: { id: `prt_multi_${++echoSerial}`, messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text, time: { start: 1, end: 2 } } } });
+        }
+        send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
+        return;
+      }
       if (body.includes('mock:agent-echo')) {
         send({ type: 'message.updated', properties: { info: info({}) } });
         send({ type: 'message.part.updated', properties: { part: {
@@ -288,6 +487,22 @@ const server = createServer((req, res) => {
         }, 60);
         return;
       }
+      // #723: native GET /skill diagnostic captured on 1.18.33; upstream
+      // packages/opencode/src/skill/index.ts:96-111 skips the unreadable skill.
+      if (body.includes('mock:skill-warning')) {
+        for (const root of ['.claude', '.agents']) send({ type: 'session.error', properties: {
+          error: { name: 'UnknownError', data: { message: `Failed to parse skill /home/agent/${root}/skills/pen-design/SKILL.md` } },
+        } });
+      }
+      if (body.includes('mock:unscoped-provider-failure') || body.includes('mock:scoped-skill-failure')) {
+        send({ type: 'session.error', properties: {
+          ...(body.includes('mock:scoped-skill-failure') ? { sessionID: SESSION_ID } : {}),
+          error: { name: 'UnknownError', data: { message: body.includes('mock:scoped-skill-failure')
+            ? 'Failed to parse skill /skills/required/SKILL.md' : 'provider unavailable — retry after restoring service' } },
+        } });
+        setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
+        return;
+      }
       if (body.includes('mock:provider-error-early')) {
         // #505 review: the provider rejects before any assistant message exists.
         send({ type: 'session.error', properties: { sessionID: SESSION_ID, error: { name: 'ProviderAuthError', data: { message: 'API key expired' } } } });
@@ -331,10 +546,53 @@ const server = createServer((req, res) => {
         setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
         return;
       }
+      if (body.includes('mock:autonomous') || body.includes('Continue working autonomously until the task is fully complete.')) {
+        const { autonomousReply } = await import('./mock-autonomous.mjs');
+        send({ type: 'message.updated', properties: { info: info({}) } });
+        send({ type: 'message.part.updated', properties: { part: { id: `autonomous-${++autonomousTurn}`, messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: autonomousReply(JSON.parse(body).parts.map(part => part.text ?? '').join('\n')), time: { start: 1, end: 2 } } } });
+        send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
+        return;
+      }
+      if (body.includes('mock:silent-tail') || body.includes('mock:tool-tail') || body.includes('Your last turn ended without a message to the user.')) {
+        const silent = await import('./mock-silent-tail.mjs');
+        const prompt = (() => { try { return JSON.parse(body).parts.map(part => part.text ?? '').join('\n'); } catch { return body; } })();
+        silent.noteSilentTailPrompt(prompt);
+        if (silent.isFinalMessageNudge(prompt)) {
+          const kind = silent.finalMessageNudgeKind();
+          send({ type: 'message.updated', properties: { info: info({}) } });
+          if (kind === 'silent') {
+            send({ type: 'message.part.updated', properties: { part: { id: 'silent-nudge-rsn', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'reasoning', text: silent.SILENT_TAIL_REASONING, time: { start: 1, end: 2 } } } });
+          } else {
+            if (kind === 'slow-done') {
+              send({ type: 'message.part.updated', properties: { part: { id: 'silent-nudge-prefix', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: silent.SLOW_DONE_PREFIX, time: { start: 1, end: 2 } } } });
+              await silent.sleep(silent.SLOW_DONE_TAIL_MS);
+            }
+            const text = kind === 'standing' ? silent.FINAL_MESSAGE_STANDING : silent.SILENT_TAIL_DONE;
+            send({ type: 'message.part.updated', properties: { part: { id: 'silent-nudge-done', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text, time: { start: 1, end: 2 } } } });
+          }
+          send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
+          return;
+        }
+        if (silent.isSilentTailScenario(prompt)) {
+          send({ type: 'message.updated', properties: { info: info({}) } });
+          send({ type: 'message.part.updated', properties: { part: { id: 'silent-open', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: silent.SILENT_TAIL_OPENING, time: { start: 1, end: 2 } } } });
+          send({ type: 'message.part.updated', properties: { part: { id: 'silent-gh', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'tool', callID: 'call_silent_gh', tool: 'bash', state: { status: 'completed', input: { command: 'gh issue create' }, output: 'created', time: { start: 1, end: 2 } } } } });
+          send({ type: 'message.part.updated', properties: { part: { id: 'silent-rsn', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'reasoning', text: silent.SILENT_TAIL_REASONING, time: { start: 1, end: 2 } } } });
+          send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
+          return;
+        }
+        if (silent.isToolTailScenario(prompt)) {
+          send({ type: 'message.updated', properties: { info: info({}) } });
+          send({ type: 'message.part.updated', properties: { part: { id: 'tool-tail-open', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: silent.TOOL_TAIL_OPENING, time: { start: 1, end: 2 } } } });
+          send({ type: 'message.part.updated', properties: { part: { id: 'tool-tail-git', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'tool', callID: 'call_tool_tail', tool: 'bash', state: { status: 'completed', input: { command: 'git status --short' }, output: ' M src/example.ts', time: { start: 1, end: 2 } } } } });
+          send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
+          return;
+        }
+      }
       // #401: one completed text snapshot, without an earlier streaming part.
       if (body.includes('mock:ask-snapshot')) {
         send({ type: 'message.updated', properties: { info: info({}) } });
-        send({ type: 'message.part.updated', properties: { part: { id: 'ask-snapshot', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: 'Using the CEZ:ASK structured question format instead:\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}', time: { start: 1, end: 2 } } } });
+        send({ type: 'message.part.updated', properties: { part: { id: 'ask-snapshot', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: body.includes('mock:ask-snapshot-bad') ? 'CEZ:ASK {not valid json' : 'Using the CEZ:ASK structured question format instead:\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}', time: { start: 1, end: 2 } } } });
         send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
         return;
       }
@@ -371,6 +629,22 @@ const server = createServer((req, res) => {
         }] });
         return;
       }
+      if (body.includes('mock:hold-done')) {
+        // Pause, then CEZ:DONE, so a mid-turn sendMessage can queue behind the
+        // running turn and race the close (#486).
+        await waitForMockRelease(400);
+        send({ type: 'message.updated', properties: { info: info({}) } });
+        send({ type: 'message.part.updated', properties: { part: {
+          id: 'prt_mock_hold_done', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text',
+          text: 'parity hold-done: content after the pause\n\nCEZ:DONE',
+          time: { start: 1760000000500, end: 1760000000600 },
+        } } });
+        send({ type: 'message.updated', properties: { info: info({
+          cost: 0.0001, tokens: { input: 20, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
+        }) } });
+        setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
+        return;
+      }
       if (body.includes('mock:done')) {
         // Declares the task complete so the run reaches cezar's review gate; a
         // markerless turn-end correctly parks as `waiting` instead (harness
@@ -390,19 +664,18 @@ const server = createServer((req, res) => {
       if (body.includes('mock:hold-ask')) {
         // Portable CEZ:ASK after a pause, so a mid-turn sendMessage can queue
         // and then race the park (run.ts must discard that waiter).
-        setTimeout(() => {
-          const ask = 'Pick one.\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which date library should I standardize on?","options":[{"label":"date-fns","description":"Tree-shakeable, functional"},{"label":"Luxon","description":"Immutable, tz-aware"}]}]}';
-          send({ type: 'message.updated', properties: { info: info({}) } });
-          send({ type: 'message.part.updated', properties: { part: {
-            id: 'prt_mock_hold_ask', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text',
-            text: ask,
-            time: { start: 1760000000500, end: 1760000000600 },
-          } } });
-          send({ type: 'message.updated', properties: { info: info({
-            cost: 0.0001, tokens: { input: 20, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
-          }) } });
-          setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
-        }, 250);
+        await waitForMockRelease(250);
+        const ask = 'Pick one.\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which date library should I standardize on?","options":[{"label":"date-fns","description":"Tree-shakeable, functional"},{"label":"Luxon","description":"Immutable, tz-aware"}]}]}';
+        send({ type: 'message.updated', properties: { info: info({}) } });
+        send({ type: 'message.part.updated', properties: { part: {
+          id: 'prt_mock_hold_ask', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text',
+          text: ask,
+          time: { start: 1760000000500, end: 1760000000600 },
+        } } });
+        send({ type: 'message.updated', properties: { info: info({
+          cost: 0.0001, tokens: { input: 20, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
+        }) } });
+        setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
         return;
       }
       if (watchdogStall(body)) return;
@@ -414,6 +687,19 @@ const server = createServer((req, res) => {
         }, 100);
         return;
       }
+      if (body.includes('mock:hold-gated')) {
+        await waitForMockRelease(250);
+        const gated = 'parity hold-gated: content after the pause';
+        send({ type: 'message.updated', properties: { info: info({}) } });
+        send({ type: 'message.part.updated', properties: { part: {
+          id: 'prt_mock_hold_gated', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: gated,
+        } } });
+        send({ type: 'message.updated', properties: { info: info({
+          cost: 0.0001, tokens: { input: 20, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
+        }) } });
+        setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
+        return;
+      }
       if (body.includes('mock:hold')) {
         // The response above is the ack (this is the #4 wire: `prompt_async`
         // resolves immediately, the turn arrives over SSE afterwards). Holding
@@ -522,4 +808,8 @@ server.listen(0, hostname, () => {
   // The runner reads the bound URL back from stdout, like the real server.
   console.log(`opencode server listening on http://${hostname}:${server.address().port}`);
 });
-process.on('SIGTERM', () => process.exit(0));
+process.on('SIGTERM', () => {
+  // Expose the end-request/process-exit interval to the root idle regression.
+  if (autonomousReadinessIdle) setTimeout(() => process.exit(0), 250);
+  else process.exit(0);
+});

package/scripts/mock-pi-rpc.mjs

@@ -14,11 +14,28 @@ function watchdogStall(prompt) {
   if (prompt.includes('held-pipe')) {
     watchdogSpawn(process.execPath, ['-e', 'setTimeout(() => {}, 5000)'], { stdio: ['ignore', process.stdout, process.stderr] });
   }
+  if (prompt.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)`;
+    watchdogSpawn(process.execPath, ['-e', leftover('leftover-group.pid')], { stdio: 'ignore' });
+    watchdogSpawn(process.execPath, ['-e', leftover('leftover-session.pid')], { stdio: 'ignore', detached: true }).unref();
+  }
   return true;
 }
 
 import readline from 'node:readline';
-import { appendFileSync } from 'node:fs';
+import { appendFileSync, existsSync as mockReleaseExists } from 'node:fs';
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+async function waitForMockRelease(fallbackMs) {
+  const file = process.env.CEZ_MOCK_RELEASE_FILE;
+  if (!file) { if (fallbackMs) await sleep(fallbackMs); return; }
+  const deadline = Date.now() + 15_000;
+  while (!mockReleaseExists(file)) {
+    if (Date.now() > deadline) throw new Error('CEZ_MOCK_RELEASE_FILE was not created');
+    await sleep(10);
+  }
+}
 if (process.env.CEZ_MOCK_ARGS_FILE) appendFileSync(process.env.CEZ_MOCK_ARGS_FILE, `${JSON.stringify(process.argv.slice(2))}\n`);
 
 // Pi handles SIGTERM and reports 128 + signal, rather than a null exit code.
@@ -66,7 +83,6 @@ const send = (value) => {
   }
   write(value);
 };
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 /** One valid CEZ:ASK payload (spec #473), used by the `mock:ask` scenario. */
 const ASK_MARKER_BODY = "{\"questions\":[{\"header\":\"Library\",\"question\":\"Which test library?\",\"multiSelect\":false,\"options\":[{\"label\":\"Vitest\",\"description\":\"Use the existing test runner\"},{\"label\":\"Node test\",\"description\":\"Use node:test\"}]}]}";
@@ -81,6 +97,13 @@ function sendText(deltas) {
   send({ type: 'message_update', message: {}, assistantMessageEvent: { type: 'text_end', contentIndex: 0, content, partial: {} } });
 }
 
+/** Native thinking block — contentIndex 1 when a text block already occupied 0. */
+function sendThinking(text, contentIndex = 0) {
+  send({ type: 'message_update', message: {}, assistantMessageEvent: { type: 'thinking_start', contentIndex, partial: {} } });
+  send({ type: 'message_update', message: {}, assistantMessageEvent: { type: 'thinking_delta', contentIndex, delta: text, partial: {} } });
+  send({ type: 'message_update', message: {}, assistantMessageEvent: { type: 'thinking_end', contentIndex, content: text, partial: {} } });
+}
+
 /** The terminal quartet: usage-bearing message_end, then turn/agent settle. */
 function sendTurnEnd(usage = { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: { total: 0.001 } }) {
   send({ type: 'message_end', message: { role: 'assistant', usage } });
@@ -104,6 +127,60 @@ rl.on('line', (line) => {
 rl.on('close', () => { queue.then(() => process.exit(0)); });
 
 async function handle(command) {
+  if (command.type === 'prompt' && (command.message.includes('mock:autonomous') || command.message.startsWith('Continue working autonomously until the task is fully complete.'))) {
+    const { autonomousReply } = await import('./mock-autonomous.mjs');
+    send({ id: command.id, type: 'response', command: 'prompt', success: true });
+    send({ type: 'agent_start' });
+    send({ type: 'turn_start' });
+    sendText([autonomousReply(command.message)]);
+    sendTurnEnd();
+    return;
+  }
+  if (command.type === 'prompt' && (command.message.includes('mock:silent-tail') || command.message.includes('mock:tool-tail') || command.message.includes('Your last turn ended without a message to the user.'))) {
+    const silent = await import('./mock-silent-tail.mjs');
+    silent.noteSilentTailPrompt(command.message);
+    if (silent.isFinalMessageNudge(command.message)) {
+      send({ id: command.id, type: 'response', command: 'prompt', success: true });
+      const kind = silent.finalMessageNudgeKind();
+      if (kind === 'ack-only') return;
+      if (kind === 'late') await silent.sleep(silent.LATE_REPLY_MS);
+      send({ type: 'agent_start' });
+      send({ type: 'turn_start' });
+      if (kind === 'silent') sendThinking(silent.SILENT_TAIL_REASONING);
+      else if (kind === 'slow-done') {
+        sendText([silent.SLOW_DONE_PREFIX]);
+        await silent.sleep(silent.SLOW_DONE_TAIL_MS);
+        sendText([silent.SILENT_TAIL_DONE]);
+      } else sendText([kind === 'standing' ? silent.FINAL_MESSAGE_STANDING : silent.SILENT_TAIL_DONE]);
+      sendTurnEnd();
+      return;
+    }
+    if (silent.isSilentTailScenario(command.message)) {
+      send({ id: command.id, type: 'response', command: 'prompt', success: true });
+      send({ type: 'agent_start' });
+      send({ type: 'turn_start' });
+      sendText([silent.SILENT_TAIL_OPENING]);
+      send({ type: 'tool_execution_start', toolCallId: 'tool-silent-gh', toolName: 'bash', args: { command: 'gh issue create' } });
+      send({ type: 'tool_execution_end', toolCallId: 'tool-silent-gh', toolName: 'bash', result: { content: [{ type: 'text', text: 'created' }] }, isError: false });
+      sendThinking(silent.SILENT_TAIL_REASONING, 1);
+      sendTurnEnd();
+      return;
+    }
+    if (silent.isToolTailScenario(command.message)) {
+      send({ id: command.id, type: 'response', command: 'prompt', success: true });
+      send({ type: 'agent_start' });
+      send({ type: 'turn_start' });
+      sendText([silent.TOOL_TAIL_OPENING]);
+      send({ type: 'tool_execution_start', toolCallId: 'tool-tail-git', toolName: 'bash', args: { command: 'git status --short' } });
+      send({ type: 'tool_execution_end', toolCallId: 'tool-tail-git', toolName: 'bash', result: { content: [{ type: 'text', text: ' M src/example.ts' }] }, isError: false });
+      sendTurnEnd();
+      return;
+    }
+  }
+  if (command.type === 'prompt' && command.message.includes('mock:crash-stderr')) {
+    const { crashWithStderr } = await import('./mock-runner-crash.mjs');
+    if (crashWithStderr(command.message, '{"type":"tool_execution_update","toolCallId":"truncated')) return;
+  }
   // Testability hook, mirroring mock-claude: CEZ_MOCK_STDIN_FILE=<path> appends
   // each inbound prompt's text and image count, so tests can assert what the
   // runner actually wrote onto the RPC (harness parity's AgentRunSpec probes).
@@ -153,6 +230,12 @@ async function handle(command) {
     activeTurn.late = true;
     await sleep(300);
     sendTurnEnd();
+  } else if (command.type === 'prompt' && command.message.includes('mock:turn-messages:')) {
+    const { turnMessages } = await import('./mock-turn-messages.mjs');
+    send({ id: command.id, type: 'response', command: 'prompt', success: true });
+    send({ type: 'agent_start' }); send({ type: 'turn_start' });
+    for (const text of turnMessages(command.message)) sendText([text]);
+    sendTurnEnd();
   } else if (command.type === 'prompt' && command.message.includes('mock:agent-echo')) {
     // rpc-lifecycle.ndjson's normal prompt/assistant/settled sequence.
     send({ id: command.id, type: 'response', command: 'prompt', success: true });
@@ -191,6 +274,20 @@ async function handle(command) {
       errorMessage: 'Not Found',
     } });
     send({ type: 'agent_settled' });
+  } else if (command.type === 'prompt' && command.message.includes('mock:hold-done')) {
+    send({ id: command.id, type: 'response', command: 'prompt', success: true });
+    send({ type: 'agent_start' });
+    send({ type: 'turn_start' });
+    await waitForMockRelease(400);
+    sendText(['parity hold-done: content after the pause\n\nCEZ:DONE']);
+    sendTurnEnd();
+  } else if (command.type === 'prompt' && command.message.includes('mock:hold-ask')) {
+    send({ id: command.id, type: 'response', command: 'prompt', success: true });
+    send({ type: 'agent_start' });
+    send({ type: 'turn_start' });
+    await waitForMockRelease(400);
+    sendText(['Pick one.\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}']);
+    sendTurnEnd();
   } else if (command.type === 'prompt' && (command.message.includes('mock:done') || (resumeAfterAsk && command.message.trim() === 'Library: Vitest'))) {
     resumeAfterAsk = false;
     // Declares the task complete so the run reaches cezar's review gate; a
@@ -206,7 +303,7 @@ async function handle(command) {
     send({ id: command.id, type: 'response', command: 'prompt', success: true });
     send({ type: 'agent_start' });
     send({ type: 'turn_start' });
-    send({ type: 'message_update', message: {}, assistantMessageEvent: { type: 'text_end', contentIndex: 0, content: 'Using the CEZ:ASK structured question format instead:\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}', partial: {} } });
+    send({ type: 'message_update', message: {}, assistantMessageEvent: { type: 'text_end', contentIndex: 0, content: command.message.includes('mock:ask-snapshot-bad') ? 'CEZ:ASK {not valid json' : 'Using the CEZ:ASK structured question format instead:\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}', partial: {} } });
     sendTurnEnd();
   } else if (command.type === 'prompt' && command.message.includes('mock:ask-prose')) {
     send({ id: command.id, type: 'response', command: 'prompt', success: true });
@@ -241,6 +338,14 @@ async function handle(command) {
       for (let i = 0; i < 24; i++) { send({ type: 'tool_execution_update', toolCallId: 'busy', toolName: 'bash', partialResult: { content: [{ type: 'text', text: 'working' }] } }); await sleep(100); }
       sendTurnEnd();
     }
+  } else if (command.type === 'prompt' && command.message.includes('mock:hold-gated')) {
+    send({ id: command.id, type: 'response', command: 'prompt', success: true });
+    send({ type: 'agent_start' });
+    send({ type: 'turn_start' });
+    await waitForMockRelease(250);
+    sendText(['parity hold-gated: content after the pause']);
+    await sleep(250);
+    sendTurnEnd();
   } else if (command.type === 'prompt' && command.message.includes('mock:hold')) {
     // The `response` below is the ack. Holding the content AND the terminal
     // quartet behind it is what makes harness parity S2 meaningful: a runner
@@ -292,6 +397,7 @@ async function handle(command) {
       result: { content: [{ type: 'text', text: 'mock file' }] },
       isError: false,
     });
+    if (!monitoringMarker) sendText(['Done with the first pass.']);
     send({
       type: 'message_end',
       message: {