@wjarka/cezarion 0.14.6 → 0.14.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wjarka/cezarion",
-  "version": "0.14.6",
+  "version": "0.14.7",
   "description": "Local cockpit for running and tracking AI agent tasks in your repo. Uses your logged-in `claude` CLI and `gh` — zero config, zero database.",
   "license": "MIT",
   "type": "module",
@@ -43,6 +43,7 @@
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "@hono/node-server": "^1.13.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "hono": "^4.6.0",
     "smol-toml": "^1.7.0",
     "ws": "^8.21.1",
@@ -50,8 +51,8 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@open-mercato/cezar-api-client": "^0.14.6",
-    "@open-mercato/cezar-contract": "^0.14.6",
+    "@open-mercato/cezar-api-client": "^0.14.7",
+    "@open-mercato/cezar-contract": "^0.14.7",
     "@types/node": "^20.14.0",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.28.1",

package/scripts/mock-ci-tool.mjs

@@ -0,0 +1,53 @@
+// Offline harness fixtures share the real bundled MCP protocol, never a fake receipt.
+import { writeFileSync, existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+export async function probeCiTool(backend, wire, pr = process.env.CEZ_MOCK_CI_PR) {
+  if (!pr) return;
+  let result;
+  if (backend === 'pi') {
+    const extensions = wire.flatMap((arg, index) => arg === '--extension' ? [wire[index + 1]] : []);
+    const path = extensions.find(path => basename(path) === 'pi-ci-wait.mjs');
+    if (!path) throw new Error('CI extension absent');
+    // The real Pi loader compiles TS when running from source; installed script uses JS.
+    if (existsSync(new URL('../src/ci-wait/mcp.ts', import.meta.url))) { const { register } = await import('tsx/esm/api'); register(); }
+    const { default: extension } = await import(pathToFileURL(path));
+    const tools = [];
+    extension({ registerTool(tool) { tools.push(tool); } });
+    result = { names: tools.map(tool => tool.name), response: await tools[0].execute('ci-1', { pr }) };
+  } else {
+    let server; let env;
+    if (backend === 'claude') {
+      server = Object.values(JSON.parse(wire[wire.indexOf('--mcp-config') + 1]).mcpServers)[0];
+      env = Object.fromEntries(Object.entries(server.env ?? {}).map(([key, value]) => [key, value.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? '')]));
+    } else if (backend === 'codex') {
+      server = Object.entries(wire.config ?? {}).find(([key]) => key.startsWith('mcp_servers.cezar_ci_'))?.[1];
+      env = Object.fromEntries((server?.env_vars ?? []).map(name => [name, process.env[name]]));
+    } else if (backend === 'cursor') {
+      server = wire.mcpServers.find(server => server.name.startsWith('cezar_ci_'));
+      env = Object.fromEntries(server?.env.map(({name,value}) => [name,value]) ?? []);
+    } else {
+      const local = Object.entries(wire.mcp ?? {}).find(([key]) => key.startsWith('cezar_ci_'))?.[1];
+      server = local && { command: local.command[0], args: local.command.slice(1) };
+      env = { ...process.env, ...local?.environment };
+    }
+    if (!server) throw new Error('CI server absent');
+    const client = new Client({ name: 'offline-harness', version: '1' });
+    try {
+      await client.connect(new StdioClientTransport({ command: server.command, args: server.args, env, stderr: 'pipe' }));
+      const list = await client.listTools();
+      result = { names: list.tools.map(tool => tool.name), response: await client.callTool({ name: 'cezar_wait_for_ci', arguments: { pr } }) };
+    } finally { await client.close(); }
+  }
+  if (process.env.CEZ_MOCK_CI_RESULT) writeFileSync(process.env.CEZ_MOCK_CI_RESULT, JSON.stringify(result));
+  return result;
+}
+
+export async function ciPrompt(backend, wire, text) {
+  const pr = /mock:ci-wait(?:\s+(https:\/\/[^\s\"\\]+))?/.exec(text)?.[1] ?? 'https://github.com/owner/repo/pull/1';
+  const result = await probeCiTool(backend, wire, pr);
+  return JSON.stringify(result.response);
+}

package/scripts/mock-claude.mjs

@@ -22,6 +22,7 @@ if (process.env.CEZ_MOCK_ARGS_FILE) {
   }
 }
 
+if (process.env.CEZ_MOCK_CI_PR) { const { probeCiTool } = await import('./mock-ci-tool.mjs'); await probeCiTool('claude', process.argv.slice(2)); }
 emit({ type: 'system', subtype: 'init' });
 
 let turn = 0;
@@ -75,6 +76,13 @@ function writeHandoffAndTodo() {
 }
 
 async function respond(userText, imageCount) {
+  if (userText.includes('mock:ci-wait')) {
+    const { ciPrompt } = await import('./mock-ci-tool.mjs');
+    const text = await ciPrompt('claude', process.argv.slice(2), userText);
+    emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text }] } });
+    emit({ type: 'result', subtype: 'success', result: text, usage: { input_tokens: 20, output_tokens: 10 } });
+    return;
+  }
   turn += 1;
   await sleep(250);
   // `mock:done` anywhere in the message → the reply ends with the CEZ:DONE

package/scripts/mock-codex-app-server.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+// Bundled dry-run mock of `codex app-server` — speaks just enough JSON-RPC 2.0
+// JSONL (§3 of agent-event-protocols.md) for the runner wiring test in
+// `codex-ui-mapper.test.ts`: initialize/thread/turn handshake, one scripted
+// turn with an agentMessage + a commandExecution (with live outputDelta),
+// cumulative token usage, then exits on stdin EOF like the real server.
+//
+// `MOCK_CODEX_IGNORE_EOF=1` switches to the #703 teardown shape instead: the
+// server stays deaf to stdin EOF (the CLI hang the EOF watchdog exists for)
+// and handles SIGTERM itself, exiting 143 rather than dying from the signal.
+import { createInterface } from 'node:readline';
+import { appendFileSync } from 'node:fs';
+
+const emit = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
+const rl = createInterface({ input: process.stdin });
+let echoSerial = 0;
+let ciWire;
+
+const ignoreEof = process.env.MOCK_CODEX_IGNORE_EOF === '1';
+if (ignoreEof) {
+  process.on('SIGTERM', () => process.exit(143));
+  // Keep the event loop alive so EOF alone can never end the process.
+  setInterval(() => {}, 60_000);
+}
+
+rl.on('line', async (line) => {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (process.env.CEZ_MOCK_ARGS_FILE) appendFileSync(process.env.CEZ_MOCK_ARGS_FILE, `${JSON.stringify(msg)}\n`);
+  if (msg.id === 'ask-bad-1' && msg.error) {
+    // The runner rejected the malformed payload with -32602, as it must. A real
+    // app-server carries on from there, so the turn still completes — a mock
+    // that went silent here would make harness parity R4 pass by hanging
+    // instead of by ending the turn.
+    emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+  } else if (msg.id === 'ask-1' && msg.result) {
+    const answer = msg.result.answers?.library?.answers;
+    const freeText = msg.result.answers?.first?.answers;
+    emit((Array.isArray(answer) && answer[0] === 'Vitest') || (Array.isArray(freeText) && freeText[0] === 'Use sensible defaults')
+      ? { method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } }
+      : { method: 'turn/failed', params: { turn: { id: 'turn_mock_1', status: 'failed' }, error: { message: 'bad answer' } } });
+  } else if (msg.method === 'initialize') {
+    emit({ id: msg.id, result: { userAgent: 'mock-codex/0.0.0' } });
+  } else if (msg.method === 'thread/start' || msg.method === 'thread/resume') {
+    if (process.env.CEZ_MOCK_CI_PR) { const { probeCiTool } = await import('./mock-ci-tool.mjs'); await probeCiTool('codex', msg.params); }
+    ciWire = msg.params;
+    const expectedSandbox = process.env.CEZ_CODEX_NETWORK === '0' ? 'workspace-write' : 'danger-full-access';
+    if (msg.params?.sandbox !== expectedSandbox || msg.params?.approvalPolicy !== undefined) {
+      emit({ id: msg.id, error: { code: -32602, message: `expected ${expectedSandbox} managed permissions` } });
+      return;
+    }
+    if (process.argv.includes('sandbox_workspace_write.network_access=true')) {
+      emit({ id: msg.id, error: { code: -32602, message: 'workspace-write override is obsolete in full-access mode' } });
+      return;
+    }
+    if (msg.method === 'thread/start') {
+      emit({ method: 'thread/started', params: { thread: { id: 'th_mock_1' } } });
+      emit({ id: msg.id, result: { thread: { id: 'th_mock_1' } } });
+    } else if (process.env.MOCK_CODEX_REJECT_RESUME === '1') {
+      emit({ id: msg.id, error: { code: -32603, message: `no rollout found for thread id ${msg.params?.threadId ?? ''}` } });
+      rl.close();
+    } else {
+      emit({ id: msg.id, result: { thread: { id: msg.params?.threadId } } });
+    }
+  } else if (msg.method === 'turn/start') {
+    emit({ id: msg.id, result: { turn: { id: 'turn_mock_1' } } });
+    emit({ method: 'turn/started', params: { turn: { id: 'turn_mock_1', status: 'inProgress', items: [] } } });
+    const turnText = msg.params?.input?.map?.((part) => part.text ?? '').join('\n') ?? '';
+    if (turnText.includes('mock:ci-wait')) {
+      const { ciPrompt } = await import('./mock-ci-tool.mjs');
+      const text = await ciPrompt('codex', ciWire, turnText);
+      emit({ method: 'item/completed', params: { item: { type: 'agentMessage', id: 'ci-result', text } } });
+      emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
+    if (turnText.includes('mock:agent-echo')) {
+      // Same documented agentMessage/turn completion frames as the baseline below.
+      emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: `item_echo_${++echoSerial}`, text: turnText } } });
+      emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
+    if (turnText.includes('mock:split-text')) {
+      // Deltas that split the marker itself, then the authoritative snapshot on
+      // `item/completed` — codex's real streaming shape. A runner emitting one
+      // v1 `text` per delta tears `CEZ:MONITORING` into `CEZ:` + `MONITORING`,
+      // which is #2 on codex's wire (harness parity S8).
+      const full = 'parity split text\n\nCEZ:MONITORING';
+      emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_sp1', text: '' } } });
+      for (const delta of ['parity split text\n\n', 'CEZ:', 'MONITORING']) {
+        emit({ method: 'item/agentMessage/delta', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_sp1', delta } });
+      }
+      emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_sp1', text: full } } });
+      emit({ method: 'thread/tokenUsage/updated', params: { threadId: 'th_mock_1', tokenUsage: { total: { totalTokens: 30, inputTokens: 20, outputTokens: 10 }, last: { totalTokens: 30, inputTokens: 20, outputTokens: 10 } } } });
+      emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
+    if (turnText.includes('mock:ask-bad')) {
+      // `questions` is not an array of question objects, so `codexAskQuestions`
+      // must reject it: no card renders, and the turn still ends once the
+      // rejection lands above (harness parity R4).
+      emit({ id: 'ask-bad-1', method: 'item/tool/requestUserInput', params: {
+        threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_ask_bad', autoResolutionMs: null,
+        questions: 'not-an-array',
+      } });
+      return;
+    }
+    if (turnText.includes('mock:done')) {
+      // A turn that DECLARES the task complete, so the run reaches cezar's
+      // review gate instead of parking for the user. A markerless turn-end
+      // correctly parks as `waiting`, which is why harness parity R1 needs
+      // this scenario rather than the baseline one.
+      const full = 'parity done: the task is complete\n\nCEZ:DONE';
+      emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_d1', text: '' } } });
+      emit({ method: 'item/agentMessage/delta', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_d1', delta: full } });
+      emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_d1', text: full } } });
+      emit({ method: 'thread/tokenUsage/updated', params: { threadId: 'th_mock_1', tokenUsage: { total: { totalTokens: 30, inputTokens: 20, outputTokens: 10 }, last: { totalTokens: 30, inputTokens: 20, outputTokens: 10 } } } });
+      emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
+    if (turnText.includes('mock:hold')) {
+      // The `turn/start` response and `turn/started` above are the ack. Holding
+      // the content AND `turn/completed` behind it is what makes harness parity
+      // S2 meaningful: a runner deriving turn-end from the ack reports it before
+      // this content ever arrives (the #4 failure mode on codex's wire).
+      setTimeout(() => {
+        const held = 'parity hold: content after the pause';
+        emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_h1', text: '' } } });
+        emit({ method: 'item/agentMessage/delta', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_h1', delta: held } });
+        emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_h1', text: held } } });
+        emit({ method: 'thread/tokenUsage/updated', params: { threadId: 'th_mock_1', tokenUsage: { total: { totalTokens: 30, inputTokens: 20, outputTokens: 10 }, last: { totalTokens: 30, inputTokens: 20, outputTokens: 10 } } } });
+        emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+      }, 250);
+      return;
+    }
+    if (turnText.includes('mock:provider-error') || turnText.includes('mock:empty-success')) {
+      // Derived from the 0.147 rollout and upstream envelope; see the source
+      // core/__fixtures__/codex/provider-error.md and its independent golden NDJSON.
+      const completion = {"method": "turn/completed", "params": {"threadId": "th_mock_1", "turn": {"id": "turn_mock_1", "items": [], "itemsView": "notLoaded", "status": "failed", "error": {"message": "{\"type\":\"error\",\"status\":400,\"error\":{\"type\":\"invalid_request_error\",\"message\":\"The 'gpt-6-astra' model requires a newer version of Codex. Please upgrade to the latest app or CLI and try again.\"}}", "codexErrorInfo": "other", "additionalDetails": null}, "startedAt": 1788632328, "completedAt": 1788632331, "durationMs": 3502}}};
+      if (turnText.includes('mock:empty-success')) {
+        completion.params.turn.status = 'completed';
+        completion.params.turn.error = null;
+      }
+      emit(completion);
+      return;
+    }
+    if (turnText.includes('mock:turn-failed')) {
+      emit({ method: 'turn/failed', params: {
+        turn: { id: 'turn_mock_1', status: 'failed' },
+        error: { message: turnText.includes('mock:legacy-interrupt') ? 'Turn interrupted by user' : 'model unavailable' },
+      } });
+      return;
+    }
+    if (turnText.includes('mock:subagent-activity')) {
+      emit({ method: 'item/started', params: { item: { type: 'subAgentActivity', id: 'activity_1', kind: 'started', agentThreadId: 'th_child', agentPath: '/root/scope_review' } } });
+      emit({ method: 'item/completed', params: { item: { type: 'subAgentActivity', id: 'activity_1', kind: 'started', agentThreadId: 'th_child', agentPath: '/root/scope_review' } } });
+      emit({ method: 'item/started', params: { item: { type: 'collabAgentToolCall', id: 'wait_1', tool: 'wait', status: 'inProgress', receiverThreadIds: [] } } });
+      emit({ method: 'item/completed', params: { item: { type: 'collabAgentToolCall', id: 'wait_1', tool: 'wait', status: 'completed', receiverThreadIds: [] } } });
+      emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
+    if (turnText.includes('mock:child-turn')) {
+      // A spawned sub-agent runs in its OWN child thread that emits a full turn
+      // lifecycle over the shared connection. Its turn/completed must not end the
+      // parent turn (#600): the parent is still working after the child finishes.
+      // Collaboration attribution from collab-agent-tool-call.ndjson; late text reproduces #149.
+      emit({ method: 'item/started', params: { threadId: 'th_mock_1', item: { type: 'collabAgentToolCall', id: 'item_spawn', tool: 'spawnAgent', status: 'inProgress', receiverThreadIds: ['th_child'] } } });
+      emit({ method: 'turn/started', params: { threadId: 'th_child', turn: { id: 'turn_child', status: 'inProgress', items: [] } } });
+      emit({ method: 'item/started', params: { threadId: 'th_child', turnId: 'turn_child', item: { type: 'commandExecution', id: 'item_child', command: ['rg', 'requestUserInput'], cwd: '/repo', status: 'inProgress' } } });
+      emit({ method: 'turn/completed', params: { threadId: 'th_child', turn: { id: 'turn_child', status: 'completed' } } });
+      // Parent keeps streaming after the child's turn ended.
+      emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_p1', text: '' } } });
+      emit({ method: 'item/agentMessage/delta', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_p1', delta: 'Still working after the sub-agent.\nCEZ:MONITORING' } });
+      emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_p1', text: 'Still working after the sub-agent.\nCEZ:MONITORING' } } });
+      emit({ method: 'item/completed', params: { threadId: 'th_child', turnId: 'turn_child', item: { type: 'agentMessage', id: 'item_child_text', text: 'Child review finished.' } } });
+      // No completion for this second child item: parent turn-end must not flush it into v1.
+      emit({ method: 'item/agentMessage/delta', params: { threadId: 'th_child', turnId: 'turn_child', itemId: 'item_child_partial', delta: 'Child review still streaming.' } });
+      emit({ method: 'turn/completed', params: { threadId: 'th_mock_1', turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
+    if (process.env.MOCK_CODEX_ASK === '1' || turnText.includes('mock:native-codex-ask')) {
+      const questions = turnText.includes('multi free text')
+        ? [{ id: 'first', header: 'First', question: 'First choice?', isOther: true, isSecret: false,
+            options: [{ label: 'A', description: 'Option A.' }, { label: 'B', description: 'Option B.' }] },
+          { id: 'second', header: 'Second', question: 'Second choice?', isOther: true, isSecret: false,
+            options: [{ label: 'C', description: 'Option C.' }, { label: 'D', description: 'Option D.' }] }]
+        : [{ id: 'library', header: 'Library', question: 'Which test library?', isOther: true,
+            isSecret: false, options: [{ label: 'Vitest', description: 'Use the existing test runner.' },
+              { label: 'Node test', description: 'Use node:test.' }] }];
+      emit({ id: 'ask-1', method: 'item/tool/requestUserInput', params: {
+        threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_ask_1', autoResolutionMs: null,
+        questions,
+      } });
+      return;
+    }
+    emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_m1', text: '' } } });
+    emit({ method: 'item/agentMessage/delta', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_m1', delta: 'Checking the working tree.' } });
+    emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'item_m1', text: 'Checking the working tree.' } } });
+    emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'commandExecution', id: 'item_c1', command: ['bash', '-lc', 'git status --short'], cwd: '/repo', status: 'inProgress' } } });
+    emit({ method: 'item/commandExecution/outputDelta', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', itemId: 'item_c1', delta: ' M src/example.ts\n' } });
+    emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'commandExecution', id: 'item_c1', command: ['bash', '-lc', 'git status --short'], cwd: '/repo', status: 'completed', exitCode: 0 } } });
+    emit({ method: 'thread/tokenUsage/updated', params: { threadId: 'th_mock_1', tokenUsage: { total: { totalTokens: 1500, inputTokens: 1200, outputTokens: 300 }, last: { totalTokens: 1500, inputTokens: 1200, outputTokens: 300 } } } });
+    emit({ method: 'turn/completed', params: { turn: { id: 'turn_mock_1', status: 'completed' } } });
+  }
+});
+
+rl.on('close', () => {
+  if (!ignoreEof) process.exit(0);
+});

package/scripts/mock-cursor-acp.mjs

@@ -2,7 +2,7 @@
 // Offline Cursor ACP wire. Shapes: cursor.com/docs/cli/acp; ACP v1 schema.
 import { createInterface } from 'node:readline';
 import { appendFileSync } from 'node:fs';
-const record = (file, value) => { if (file) appendFileSync(file, `${JSON.stringify(value)}\n`); };
+const record = (file, value) => { if (file) appendFileSync(file, `${JSON.stringify(value, (key, value) => key === 'env' && Array.isArray(value) ? value.map(item => item.name?.startsWith('CEZ_TOOL_') ? { ...item, value: '[redacted]' } : item) : value)}\n`); };
 record(process.env.CEZ_MOCK_ARGS_FILE, process.argv.slice(2));
 const emit = value => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...value })}\n`);
 const reply = (id, result) => emit({ id, result });
@@ -18,6 +18,7 @@ const configOptions = () => [
 ];
 const configuration = () => process.env.CEZ_MOCK_CURSOR_LEGACY === '1' ? {} : { configOptions: configOptions() };
 let pendingAsk;
+let ciWire;
 let resumeDone = false;
 let prompts = 0;
 const update = (value, id = sessionId) => emit({ method: 'session/update', params: { sessionId: id, update: value } });
@@ -27,6 +28,7 @@ const question = { id: 'tests', prompt: 'Which test runner?', options: [{ id: 'v
 async function prompt(id, content) {
   const input = content.filter(b => b.type === 'text').map(b => b.text).join('\n');
   prompts += 1;
+  if (input.includes('mock:ci-wait')) { const { ciPrompt } = await import('./mock-ci-tool.mjs'); text(await ciPrompt('cursor', ciWire, input)); complete(id); return; }
   if (resumeDone) { resumeDone = false; text('Resumed work finished.\nCEZ:DONE'); complete(id); return; }
   if (input.includes('mock:hold')) await new Promise(r => setTimeout(r, 500));
   if (input.includes('mock:rpc-error')) { emit({ id, error: { code: -32603, message: 'Provider rejected request' } }); return; }
@@ -60,7 +62,7 @@ async function prompt(id, content) {
   text('Cursor inspected the workspace.');
   complete(id);
 }
-createInterface({ input: process.stdin }).on('line', line => {
+createInterface({ input: process.stdin }).on('line', async line => {
   let msg; try { msg = JSON.parse(line); } catch { return; }
   record(process.env.CEZ_MOCK_ARGS_FILE, msg);
   record(process.env.CEZ_MOCK_STDIN_FILE, msg);
@@ -82,6 +84,8 @@ createInterface({ input: process.stdin }).on('line', line => {
     }
     return;
   }
+  if (process.env.CEZ_MOCK_CI_PR && ['session/new', 'session/load'].includes(msg.method)) { const { probeCiTool } = await import('./mock-ci-tool.mjs'); await probeCiTool('cursor', msg.params); }
+  if (['session/new', 'session/load'].includes(msg.method)) ciWire = msg.params;
   switch (msg.method) {
     case 'initialize': reply(msg.id, { protocolVersion: 1, agentCapabilities: { loadSession: true, promptCapabilities: { image: true } } }); break;
     case 'cursor/list_available_models': reply(msg.id, { models: [{ value: model, name: model, configOptions: configOptions().filter(option => option.id !== 'model') }] }); break;