@wjarka/cezarion 0.14.9-dev.944 → 0.14.9-dev.958

package/dist/server/server.d.ts

@@ -4318,19 +4318,6 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
 } & {
     "/repo/commit/:sha": {
         $get: {
-            output: string;
-            outputFormat: "text";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
-            input: {
-                query: {
-                    structured?: string | undefined;
-                };
-            } & {
-                param: {
-                    sha: string;
-                };
-            };
-        } | {
             output: {
                 error: string;
                 code?: "invalid_input" | undefined;
@@ -4394,6 +4381,19 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
                     sha: string;
                 };
             };
+        } | {
+            output: string;
+            outputFormat: "text";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+            input: {
+                query: {
+                    structured?: string | undefined;
+                };
+            } & {
+                param: {
+                    sha: string;
+                };
+            };
         };
     };
 } & {
@@ -12306,20 +12306,20 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
 } & {
     "/runs/:id/handoff": {
         $get: {
-            output: string;
-            outputFormat: "text";
-            status: 200;
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
             input: {
                 param: {
                     id: string;
                 };
             };
         } | {
-            output: {
-                error: string;
-            };
-            outputFormat: "json";
-            status: 404;
+            output: string;
+            outputFormat: "text";
+            status: 200;
             input: {
                 param: {
                     id: string;
@@ -12357,20 +12357,20 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
 } & {
     "/runs/:id/diff": {
         $get: {
-            output: string;
-            outputFormat: "text";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
             input: {
                 param: {
                     id: string;
                 };
             };
         } | {
-            output: {
-                error: string;
-            };
-            outputFormat: "json";
-            status: 404;
+            output: string;
+            outputFormat: "text";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
             input: {
                 param: {
                     id: string;
@@ -15239,19 +15239,6 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
 } & {
     "/repo/commit/:sha": {
         $get: {
-            output: string;
-            outputFormat: "text";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
-            input: {
-                query: {
-                    structured?: string | undefined;
-                };
-            } & {
-                param: {
-                    sha: string;
-                };
-            };
-        } | {
             output: {
                 error: string;
                 code?: "invalid_input" | undefined;
@@ -15315,6 +15302,19 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
                     sha: string;
                 };
             };
+        } | {
+            output: string;
+            outputFormat: "text";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+            input: {
+                query: {
+                    structured?: string | undefined;
+                };
+            } & {
+                param: {
+                    sha: string;
+                };
+            };
         };
     };
 } & {
@@ -23227,20 +23227,20 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
 } & {
     "/runs/:id/handoff": {
         $get: {
-            output: string;
-            outputFormat: "text";
-            status: 200;
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
             input: {
                 param: {
                     id: string;
                 };
             };
         } | {
-            output: {
-                error: string;
-            };
-            outputFormat: "json";
-            status: 404;
+            output: string;
+            outputFormat: "text";
+            status: 200;
             input: {
                 param: {
                     id: string;
@@ -23278,20 +23278,20 @@ export declare function createApp(deps: ServerDeps): import("hono/hono-base").Ho
 } & {
     "/runs/:id/diff": {
         $get: {
-            output: string;
-            outputFormat: "text";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
             input: {
                 param: {
                     id: string;
                 };
             };
         } | {
-            output: {
-                error: string;
-            };
-            outputFormat: "json";
-            status: 404;
+            output: string;
+            outputFormat: "text";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
             input: {
                 param: {
                     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wjarka/cezarion",
-  "version": "0.14.9-dev.944",
+  "version": "0.14.9-dev.958",
   "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",
@@ -35,8 +35,8 @@
     "server-uninstall": "tsx src/index.ts server-uninstall",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:unit": "node --import tsx --test test/unit/*.test.ts",
-    "test:package": "node --import tsx --test test/e2e/*.test.ts",
+    "test:unit": "node --import ../../scripts/test-git-env.mjs --import tsx --test test/unit/*.test.ts",
+    "test:package": "node --import ../../scripts/test-git-env.mjs --import tsx --test test/e2e/*.test.ts",
     "typecheck": "tsc --noEmit -p tsconfig.test.json",
     "postbuild": "node scripts/inline-contract.mjs"
   },
@@ -51,8 +51,8 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@open-mercato/cezar-api-client": "0.14.9-dev.944",
-    "@open-mercato/cezar-contract": "0.14.9-dev.944",
+    "@open-mercato/cezar-api-client": "0.14.9-dev.958",
+    "@open-mercato/cezar-contract": "0.14.9-dev.958",
     "@types/node": "^20.14.0",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.28.1",

package/scripts/mock-claude.mjs

@@ -8,6 +8,15 @@
 import { createInterface } from 'node:readline';
 import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
 
+import * as parityGateFs from 'node:fs';
+
+// #401: let the test observe the actual monitoring park before releasing late wire frames.
+async function afterParityPark(prompt) {
+  const gate = /parity-release=([^\s"\\]+)/.exec(prompt)?.[1];
+  if (!gate) throw new Error('post-park scenario requires a release path');
+  while (!parityGateFs.existsSync(gate)) await new Promise(resolve => setTimeout(resolve, 10));
+}
+
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const emit = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
 
@@ -105,6 +114,23 @@ async function respond(userText, imageCount, uuid) {
     emit({ type: 'result', subtype: 'success', result: text, user_message_uuids: [uuid, ...steered.map(s => s.uuid)].filter(Boolean), usage: { input_tokens: 20, output_tokens: 10 } });
     return;
   }
+  // Native child attribution from __fixtures__/claude/subagent-task.ndjson.
+  if (!userText.includes('[cez-namer]') && userText.includes('mock:subagent-after-park')) {
+    const task = `toolu_park_${turn}`;
+    emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id: task, name: 'Task', input: { description: 'Review' } }] } });
+    emit({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'Watching the child.\nCEZ:MONITORING' }] } });
+    emit({ type: 'result', subtype: 'success', result: 'Watching the child.\nCEZ:MONITORING', usage: { input_tokens: 10, output_tokens: 5 } });
+    await afterParityPark(userText);
+    emit({ type: 'assistant', parent_tool_use_id: task, message: { role: 'assistant', content: [{ type: 'tool_use', id: 'late-read', name: 'Read', input: { file_path: 'README.md' } }] } });
+    emit({ type: 'user', parent_tool_use_id: task, message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'late-read', content: 'Read the file.' }] } });
+    emit({ type: 'assistant', parent_tool_use_id: task, message: { role: 'assistant', content: [{ type: 'text', text: 'Post-park child update processed.' }] } });
+    return;
+  }
+  // #401: result-only full text; mapResult and v1 use the same fallback.
+  if (!userText.includes('[cez-namer]') && userText.includes('mock:ask-snapshot')) {
+    emit({ type: 'result', subtype: 'success', result: 'Choose a test library.\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}', usage: { input_tokens: 10, output_tokens: 5 } });
+    return;
+  }
   if (userText.includes('mock:ci-wait')) {
     const { ciPrompt } = await import('./mock-ci-tool.mjs');
     const text = await ciPrompt('claude', process.argv.slice(2), userText);

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

@@ -11,6 +11,15 @@
 import { createInterface } from 'node:readline';
 import { appendFileSync } from 'node:fs';
 
+import * as parityGateFs from 'node:fs';
+
+// #401: let the test observe the actual monitoring park before releasing late wire frames.
+async function afterParityPark(prompt) {
+  const gate = /parity-release=([^\s"\\]+)/.exec(prompt)?.[1];
+  if (!gate) throw new Error('post-park scenario requires a release path');
+  while (!parityGateFs.existsSync(gate)) await new Promise(resolve => setTimeout(resolve, 10));
+}
+
 const write = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
 // #505: like the real app-server, any active main-thread turn accepts `turn/steer`.
 // Steers accepted by an ordinary scripted turn are read just before it completes:
@@ -141,6 +150,23 @@ rl.on('line', async (line) => {
       emit({ method: 'item/started', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: opening } });
       emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: opening } });
     }
+    // Native thread attribution from collab-agent-tool-call.ndjson (#121/#401).
+    if (turnText.includes('mock:subagent-after-park')) {
+      emit({ method: 'item/started', params: { threadId: 'th_mock_1', item: { type: 'collabAgentToolCall', id: 'park-spawn', tool: 'spawnAgent', status: 'inProgress', receiverThreadIds: ['th_park_child'] } } });
+      emit({ method: 'item/completed', params: { threadId: 'th_mock_1', item: { type: 'agentMessage', id: 'park-parent', text: 'Watching the child.\nCEZ:MONITORING' } } });
+      emit({ method: 'turn/completed', params: { threadId: 'th_mock_1', turn: { id: 'turn_mock_1', status: 'completed' } } });
+      await afterParityPark(turnText);
+      emit({ method: 'item/started', params: { threadId: 'th_park_child', item: { type: 'commandExecution', id: 'late-read', command: 'cat README.md', status: 'inProgress' } } });
+      emit({ method: 'item/completed', params: { threadId: 'th_park_child', item: { type: 'commandExecution', id: 'late-read', command: 'cat README.md', status: 'completed', exitCode: 0 } } });
+      emit({ method: 'item/completed', params: { threadId: 'th_park_child', item: { type: 'agentMessage', id: 'late-child', text: 'Post-park child update processed.' } } });
+      return;
+    }
+    // #401: agentMessage completion without deltas (same item envelope as baseline).
+    if (turnText.includes('mock:ask-snapshot')) {
+      emit({ method: 'item/completed', params: { threadId: 'th_mock_1', turnId: 'turn_mock_1', item: { type: 'agentMessage', id: 'ask-snapshot', text: 'Choose a test library.\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}' } } });
+      emit({ method: 'turn/completed', params: { threadId: 'th_mock_1', turn: { id: 'turn_mock_1', status: 'completed' } } });
+      return;
+    }
     if (turnText.includes('mock:ci-wait')) {
       const { ciPrompt } = await import('./mock-ci-tool.mjs');
       const text = await ciPrompt('codex', ciWire, turnText);

package/scripts/mock-cursor-acp.mjs

@@ -2,6 +2,15 @@
 // Offline Cursor ACP wire. Shapes: cursor.com/docs/cli/acp; ACP v1 schema.
 import { createInterface } from 'node:readline';
 import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
+import * as parityGateFs from 'node:fs';
+
+// #401: let the test observe the actual monitoring park before releasing late wire frames.
+async function afterParityPark(prompt) {
+  const gate = /parity-release=([^\s"\\]+)/.exec(prompt)?.[1];
+  if (!gate) throw new Error('post-park scenario requires a release path');
+  while (!parityGateFs.existsSync(gate)) await new Promise(resolve => setTimeout(resolve, 10));
+}
+
 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));
 /** #529: remaining-count file. Each session/new or session/load decrements; at >0 the process writes stderr and exits 1 before the reply. */
@@ -62,11 +71,31 @@ async function prompt(id, content) {
   if (input.includes('mock:provider-error-instant-far')) { text(`\n\nError: usage limit reached, try again at ${new Date(Date.now() + 6 * 3600000).toISOString()}.`); complete(id); return; }
   if (input.includes('mock:provider-error-verbose')) { text(`\n\nError: usage limit reached. The request ${'x'.repeat(600)} could not be completed, try again at ${new Date(Date.now() + 6 * 3600000).toISOString()}.`); complete(id); return; }
   if (input.includes('mock:provider-error') && !input.includes('mock:provider-error-')) { text('\n\nError: [unauthenticated] Backend rejected authentication.'); complete(id); return; }
+  // #401: ACP has chunks only, so completion must flush the same text to v1/v2.
+  if (input.includes('mock:ask-snapshot')) {
+    text('Choose a test library.\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}'); complete(id); return;
+  }
   if (input.includes('mock:ask-bad')) { pendingAsk = { id }; emit({ id: 'bad-question', method: 'cursor/ask_question', params: { questions: [] } }); return; }
   if (input.includes('mock:plan')) { pendingAsk = { id, input }; emit({ id: 'plan-1', method: 'cursor/create_plan', params: { name: 'Test plan', overview: 'Approve the changes?', plan: 'Implement the change and run tests.' } }); return; }
   if (input.includes('mock:multi-ask')) { pendingAsk = { id }; emit({ id: 'multi-question', method: 'cursor/ask_question', params: { title: 'Choices', questions: [question, { ...question, id: 'build', prompt: 'Which build tool?', options: [{ id: 'vite', label: 'Vite' }, { id: 'webpack', label: 'Webpack' }] }] } }); return; }
   if (input.includes('mock:ask')) { pendingAsk = { id, input }; emit({ id: 'question-1', method: 'cursor/ask_question', params: { toolCallId: 'ask-tool', title: 'Tests', questions: [question] } }); return; }
   if (input.includes('mock:permission')) { pendingAsk = { id }; emit({ id: 'permission-1', method: 'session/request_permission', params: { sessionId, toolCall: { toolCallId: 'shell-1', title: 'echo hello', kind: 'execute' }, options: [{ optionId: 'allow-once', name: 'Allow once', kind: 'allow_once' }, { optionId: 'reject-once', name: 'Reject', kind: 'reject_once' }] } }); return; }
+  // ACP subagent attribution from __fixtures__/cursor/acp-subagents.ndjson.
+  if (input.includes('mock:subagent-after-park')) {
+    update({ sessionUpdate: 'subagent_spawned', subagentSessionId: 'park-child', name: 'Reviewer', task: 'Review', capabilities: {}, _meta: { cursor: { toolCallId: 'park-task', agentId: 'park-agent' } } });
+    update({ sessionUpdate: 'tool_call', toolCallId: 'late-read', kind: 'other', title: 'Inspect README', status: 'in_progress' }, 'park-child');
+    update({ sessionUpdate: 'tool_call_update', toolCallId: 'late-read', status: 'completed' }, 'park-child');
+    text('Watching the child.\nCEZ:MONITORING');
+    complete(id);
+    await afterParityPark(input);
+    update({ sessionUpdate: 'tool_call_update', toolCallId: 'late-read', status: 'completed', rawOutput: 'Read the file.' }, 'park-child');
+    update({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Late child text.' } }, 'park-child');
+    // Cursor task metadata can follow the regular completion (acp-subagents.ndjson).
+    // Sessionless extensions are attributed by their known child toolCallId even
+    // after prompt completion; this is the ordered barrier and a nested item update.
+    emit({ method: 'cursor/task', params: { toolCallId: 'late-read', description: 'Post-park child update processed.' } });
+    return;
+  }
   if (input.includes('mock:subagent')) {
     update({ sessionUpdate: 'tool_call', toolCallId: 'task-1', title: 'Review', kind: 'other', rawInput: { description: 'Review' }, status: 'in_progress' });
     update({ sessionUpdate: 'subagent_spawned', subagentSessionId: 'child', name: 'Reviewer', task: 'Review', capabilities: {}, _meta: { cursor: { toolCallId: 'task-1', agentId: 'child-agent' } } });

package/scripts/mock-opencode-serve.mjs

@@ -11,6 +11,15 @@ import { createServer } from 'node:http';
 
 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 ?? '{}')); }
+import * as parityGateFs from 'node:fs';
+
+// #401: let the test observe the actual monitoring park before releasing late wire frames.
+async function afterParityPark(prompt) {
+  const gate = /parity-release=([^\s"\\]+)/.exec(prompt)?.[1];
+  if (!gate) throw new Error('post-park scenario requires a release path');
+  while (!parityGateFs.existsSync(gate)) await new Promise(resolve => setTimeout(resolve, 10));
+}
+
 const args = process.argv.slice(2);
 const arg = (flag, fallback) => {
   const i = args.indexOf(flag);
@@ -194,6 +203,23 @@ const server = createServer((req, res) => {
         send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
         return;
       }
+      // SSE child attribution from __fixtures__/opencode/subtask-nested.ndjson.
+      if (body.includes('mock:subagent-after-park')) {
+        send({ type: 'message.updated', properties: { info: info({}) } });
+        send({ type: 'message.part.updated', properties: { part: { id: 'park-task', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'subtask', prompt: 'Review', description: 'Review', agent: 'general' } } });
+        send({ type: 'message.updated', properties: { info: { ...info({}), id: 'park-child-msg', sessionID: 'park-child', parentID: SESSION_ID, mode: 'subagent' } } });
+        send({ type: 'message.part.updated', properties: { part: { id: 'early-child', messageID: 'park-child-msg', sessionID: 'park-child', type: 'text', text: 'Child review started.', time: { start: 1, end: 2 } } } });
+        send({ type: 'message.part.updated', properties: { part: { id: 'park-parent', messageID: MESSAGE_ID, sessionID: SESSION_ID, type: 'text', text: 'Watching the child.\nCEZ:MONITORING', time: { start: 1, end: 2 } } } });
+        send({ type: 'session.idle', properties: { sessionID: SESSION_ID } });
+        await afterParityPark(body);
+        send({ type: 'message.part.updated', properties: { part: { id: 'late-read', messageID: 'park-child-msg', sessionID: 'park-child', type: 'tool', tool: 'read', state: { status: 'running', input: { path: 'README.md' } } } } });
+        send({ type: 'message.part.updated', properties: { part: { id: 'late-read', messageID: 'park-child-msg', sessionID: 'park-child', type: 'tool', tool: 'read', state: { status: 'completed', input: { path: 'README.md' }, output: 'Read the file.' } } } });
+        send({ type: 'message.part.updated', properties: { part: { id: 'late-child-text', messageID: 'park-child-msg', sessionID: 'park-child', type: 'text', text: 'Late child text.', time: { start: 3, end: 4 } } } });
+        // Closed child scopes are ignored. This passive usage snapshot proves the
+        // preceding SSE frames have reached the runner before the test observes it.
+        send({ type: 'message.updated', properties: { info: info({ tokens: { input: 424240, output: 2, reasoning: 0, cache: { read: 0, write: 0 } } }) } });
+        return;
+      }
       if (body.includes('mock:subagent')) {
         // Wire shape from `__fixtures__/opencode/subtask-nested.ndjson`: a
         // `subtask` part on the parent message, then a child message whose info
@@ -287,6 +313,13 @@ const server = createServer((req, res) => {
         setTimeout(() => send({ type: 'session.idle', properties: { sessionID: SESSION_ID } }), 30);
         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: 'Choose a test library.\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;
+      }
       if (body.includes('mock:ask-bad')) {
         // Malformed: `questions` is not an array, so the runner must REJECT the
         // native question and finish the turn rather than wait for an answer to

package/scripts/mock-pi-rpc.mjs

@@ -181,6 +181,13 @@ async function handle(command) {
     send({ type: 'turn_start' });
     sendText(['parity done: the task is complete\n\nCEZ:DONE']);
     sendTurnEnd();
+  } else if (command.type === 'prompt' && command.message.includes('mock:ask-snapshot')) {
+    // #401: authoritative text_end without deltas, using rpc-lifecycle frames.
+    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: 'Choose a test library.\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-bad')) {
     // A marker whose JSON body is invalid. `parseAskMarker` must render no card
     // and the turn must still end (harness parity R4) — pi has no native ask