@adecore/agents 0.39.0 → 0.40.1

package/src/testing/fake-claude.ts

@@ -23,29 +23,35 @@ export function fakeClaude(io: FakeIo): FakeProgram {
     const assistantText = (text: string): void => {
         const id = `msg_${nonce}_${++messageCounter}`;
         out({ type: 'stream_event', event: { type: 'message_start', message: { id, model } }, session_id: sessionId });
+
         out({
             type: 'stream_event',
             event: { type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } },
             session_id: sessionId
         });
+
         out({
             type: 'stream_event',
             event: { type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'weighing it' } },
             session_id: sessionId
         });
+
         out({ type: 'stream_event', event: { type: 'content_block_stop', index: 0 }, session_id: sessionId });
         out({ type: 'stream_event', event: { type: 'content_block_start', index: 1, content_block: { type: 'text', text: '' } }, session_id: sessionId });
         const half = Math.ceil(text.length / 2);
+
         out({
             type: 'stream_event',
             event: { type: 'content_block_delta', index: 1, delta: { type: 'text_delta', text: text.slice(0, half) } },
             session_id: sessionId
         });
+
         out({
             type: 'stream_event',
             event: { type: 'content_block_delta', index: 1, delta: { type: 'text_delta', text: text.slice(half) } },
             session_id: sessionId
         });
+
         // Every frame carries the uuid of its line in the transcript, which is what a fork is cut at.
         out({
             type: 'assistant',
@@ -53,12 +59,14 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             message: { id, model, role: 'assistant', content: [{ type: 'thinking', thinking: '' }], usage },
             session_id: sessionId
         });
+
         out({
             type: 'assistant',
             uuid: `${id}-text`,
             message: { id, model, role: 'assistant', content: [{ type: 'text', text }], usage },
             session_id: sessionId
         });
+
         out({ type: 'stream_event', event: { type: 'message_stop' }, session_id: sessionId });
     };
 
@@ -79,6 +87,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
     // A request the API turned away: a synthetic message with the reason, then a result that failed without saying which error.
     const refusal = (text: string, error: string, status: number): void => {
         const id = `msg_${nonce}_${++messageCounter}`;
+
         out({
             type: 'assistant',
             uuid: `${id}-text`,
@@ -87,6 +96,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             error,
             session_id: sessionId
         });
+
         out({
             type: 'result',
             subtype: 'success',
@@ -111,6 +121,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 session_id: sessionId
             });
         };
+
         const childResult = (toolUseId: string, content: string): void => {
             out({
                 type: 'user',
@@ -119,10 +130,12 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 session_id: sessionId
             });
         };
+
         child([{ type: 'tool_use', id: `${agentToolUseId}_read`, name: 'Read', input: { file_path: 'README.md' } }]);
         childResult(`${agentToolUseId}_read`, '# Notes');
         child([{ type: 'tool_use', id: `${agentToolUseId}_bash`, name: 'Bash', input: { command: 'ls', description: 'List files' } }]);
         childResult(`${agentToolUseId}_bash`, 'README.md');
+
         out({
             type: 'system',
             subtype: 'task_progress',
@@ -134,6 +147,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             last_tool_name: 'Bash',
             session_id: sessionId
         });
+
         child([{ type: 'text', text: report }]);
     };
 
@@ -151,11 +165,14 @@ export function fakeClaude(io: FakeIo): FakeProgram {
 
     const settleTwo = (name: 'a-one' | 'a-two', stopped: boolean): void => {
         const toolUseId = name === 'a-one' ? 'toolu_two_a' : 'toolu_two_b';
+
         if (!openTwo.delete(name)) {
             return;
         }
+
         if (stopped) {
             out({ type: 'system', subtype: 'task_updated', task_id: name, patch: { status: 'killed', end_time: 0 }, session_id: sessionId });
+
             out({
                 type: 'system',
                 subtype: 'task_notification',
@@ -167,6 +184,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 session_id: sessionId
             });
         }
+
         out({
             type: 'user',
             message: {
@@ -175,6 +193,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             },
             session_id: sessionId
         });
+
         if (openTwo.size === 0) {
             assistantText('summarized B');
             result();
@@ -184,6 +203,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
     // The rest of a background agent once its request was answered: its call's result, its report, and the turn the CLI opens about it.
     const finishBackgroundAgent = (command: string, allowed: boolean, message: string | undefined): void => {
         const toolUseId = 'toolu_bgask';
+
         out({
             type: 'user',
             message: {
@@ -200,13 +220,16 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             parent_tool_use_id: toolUseId,
             session_id: sessionId
         });
+
         const report = allowed ? `the agent ran ${command}` : 'the agent could not run it';
+
         out({
             type: 'assistant',
             message: { id: `msg_${nonce}_${++messageCounter}`, model, role: 'assistant', content: [{ type: 'text', text: report }], usage },
             parent_tool_use_id: toolUseId,
             session_id: sessionId
         });
+
         out({
             type: 'system',
             subtype: 'task_notification',
@@ -217,6 +240,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             summary: report,
             session_id: sessionId
         });
+
         out({ type: 'system', subtype: 'init', session_id: sessionId, model, cwd: io.cwd, tools: ['Bash'], slash_commands: [], argv: args });
         assistantText(report);
         result();
@@ -225,11 +249,14 @@ export function fakeClaude(io: FakeIo): FakeProgram {
     const handleUser = (text: string): void => {
         if (text === 'crash') {
             io.exit(1);
+
             return;
         }
+
         // Two foreground subagents beside each other; the turn ends once both settled: a-two when the test runs what is put off, a-one by a `stop_task`.
         if (text === 'two subagents') {
             openTwo.add('a-one').add('a-two');
+
             for (const [name, toolUseId] of [
                 ['a-one', 'toolu_two_a'],
                 ['a-two', 'toolu_two_b']
@@ -247,6 +274,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     },
                     session_id: sessionId
                 });
+
                 out({
                     type: 'system',
                     subtype: 'task_started',
@@ -261,21 +289,28 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     session_id: sessionId
                 });
             }
+
             io.later(() => settleTwo('a-two', false));
+
             return;
         }
+
         if (text === 'crash loudly') {
             io.err(`${'warming up\n'.repeat(2000)}Error: the fake lost its key\n    at handleUser (fake-claude.ts)\n`);
             io.exit(1);
+
             return;
         }
+
         // Over stdio only: a process of the CLI's own, as a dev server an agent started would be.
         if (text === 'start a grandchild') {
             const grandchild = spawn('sleep', ['600'], { stdio: 'ignore' });
             assistantText(`grandchild ${grandchild.pid}`);
             result();
+
             return;
         }
+
         /*
          * A background agent that asks to run a command while the turn that launched it ends, framed the way Claude
          * Code 2.1.282 sends it: the request names the agent's own call and its `agent_id`, the result of the turn
@@ -287,6 +322,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             const [first = '', ...rest] = text.split('\n');
             const command = first.slice(20).trim() || 'ls';
             const toolUseId = 'toolu_bgask';
+
             out({
                 type: 'assistant',
                 message: {
@@ -300,6 +336,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             out({
                 type: 'system',
                 subtype: 'task_started',
@@ -311,6 +348,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 task_type: 'local_agent',
                 session_id: sessionId
             });
+
             out({
                 type: 'user',
                 message: {
@@ -319,6 +357,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             const ask = (): void => {
                 out({
                     type: 'assistant',
@@ -332,7 +371,9 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     parent_tool_use_id: toolUseId,
                     session_id: sessionId
                 });
+
                 backgroundAsk = { requestId: 'req-bg', command };
+
                 out({
                     type: 'control_request',
                     request_id: 'req-bg',
@@ -347,45 +388,62 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     }
                 });
             };
+
             if (rest.includes('late')) {
                 assistantText('the agent runs');
                 result();
                 io.later(ask);
+
                 return;
             }
+
             ask();
+
             if (rest.includes('slow')) {
                 slow = true;
+
                 return;
             }
+
             assistantText('the agent runs');
             result();
+
             return;
         }
+
         // A line of its own, so a prompt with a task brief under it or a message above it still waits.
         if (text.split('\n').some((line) => line === 'slow')) {
             slow = true;
             out({ type: 'stream_event', event: { type: 'message_start', message: { id: `msg_${nonce}_${++messageCounter}`, model } }, session_id: sessionId });
+
             return;
         }
+
         // Lines of their own, as the two ways Claude Code 2.1.281 ends a turn it could not get an answer for.
         const limit = text.split('\n').find((line) => line.startsWith('limit:'));
+
         if (limit !== undefined) {
             const resetsAt = Number(limit.slice(6));
+
             out({
                 type: 'rate_limit_event',
                 rate_limit_info: { status: 'rejected', resetsAt, rateLimitType: 'five_hour', utilization: 1 },
                 uuid: `rate-${nonce}`,
                 session_id: sessionId
             });
+
             refusal("You've hit your session limit · resets 3pm", 'rate_limit', 429);
+
             return;
         }
+
         // A line of its own as well: a tool call whose result is that many bytes, the way a long log or a big file reads back.
         const output = text.split('\n').find((line) => line.startsWith('output:'));
+
         if (output !== undefined) {
             const bytes = Number(output.slice(7));
             const toolUseId = `toolu_${nonce}_${++messageCounter}`;
+
             out({
                 type: 'assistant',
                 message: {
@@ -397,7 +455,9 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             const line = 'build step finished without warnings\n';
+
             out({
                 type: 'user',
                 message: {
@@ -408,23 +468,31 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             assistantText(`read ${bytes} bytes of build log`);
             result();
+
             return;
         }
+
         if (text.split('\n').includes('overloaded')) {
             refusal('API Error: Repeated 529 Overloaded errors', 'overloaded', 529);
+
             return;
         }
+
         if (text === 'compact') {
             out({ type: 'system', subtype: 'compact_boundary', compact_metadata: { trigger: 'manual', pre_tokens: 5000 }, session_id: sessionId });
             assistantText('compacted');
             result();
+
             return;
         }
+
         if (text.startsWith('ask:')) {
             const question = text.slice(4).trim();
             pendingQuestion = question;
+
             out({
                 type: 'control_request',
                 request_id: 'req-q',
@@ -447,14 +515,17 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     tool_use_id: 'toolu_q'
                 }
             });
+
             return;
         }
+
         if (text.startsWith('write:')) {
             const [path = '', ...rest] = text.slice(6).trim().split(' ');
             const content = `${rest.join(' ')}\n`;
             // Against the CLI's own folder: in a test the fake shares the test runner's working directory.
             writeFileSync(resolve(io.cwd, path), content);
             const id = `msg_${nonce}_${++messageCounter}`;
+
             out({
                 type: 'assistant',
                 message: {
@@ -466,20 +537,26 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             out({
                 type: 'user',
                 message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_write', content: `wrote ${path}`, is_error: false }] },
                 session_id: sessionId
             });
+
             assistantText('written');
             result();
+
             return;
         }
+
         // `delegate late:` sends the subagent's first work before `task_started`, an order the CLI does not promise to avoid.
         const late = text.startsWith('delegate late:');
+
         if (late || text.startsWith('delegate:')) {
             const description = text.slice(text.indexOf(':') + 1).trim();
             const report = '# Report\n\n- one\n- two';
+
             out({
                 type: 'assistant',
                 message: {
@@ -498,6 +575,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             const taskStarted = (): void => {
                 out({
                     type: 'system',
@@ -513,13 +591,17 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     session_id: sessionId
                 });
             };
+
             if (!late) {
                 taskStarted();
             }
+
             subagentWork('toolu_delegate', report);
+
             if (late) {
                 taskStarted();
             }
+
             out({
                 type: 'user',
                 message: {
@@ -528,10 +610,13 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             assistantText('summarized');
             result();
+
             return;
         }
+
         /*
          * A background agent that opens a foreground one of its own, in the order Claude Code 2.1.282 streams it:
          * the grandchild's call and result come as frames of its parent, its own steps not at all, and its
@@ -539,12 +624,15 @@ export function fakeClaude(io: FakeIo): FakeProgram {
          */
         if (text.startsWith('nested:')) {
             const summary = text.slice(7).trim() || 'done';
+
             const task = (frame: Record<string, unknown>): void => {
                 out({ type: 'system', session_id: sessionId, ...frame });
             };
+
             const underMiddle = (message: Record<string, unknown>, type: 'assistant' | 'user'): void => {
                 out({ type, message, parent_tool_use_id: 'toolu_middle', session_id: sessionId });
             };
+
             out({
                 type: 'assistant',
                 message: {
@@ -563,6 +651,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             task({
                 subtype: 'task_started',
                 task_id: 'a-middle',
@@ -574,6 +663,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 task_type: 'local_agent',
                 prompt: summary
             });
+
             out({
                 type: 'user',
                 message: {
@@ -582,8 +672,10 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             assistantText('sent');
             result();
+
             io.later(() => {
                 underMiddle(
                     {
@@ -595,6 +687,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     },
                     'assistant'
                 );
+
                 task({
                     subtype: 'task_started',
                     task_id: 'a-leaf',
@@ -606,17 +699,22 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     task_type: 'local_agent',
                     prompt: 'echo PONG'
                 });
+
                 task({ subtype: 'task_updated', task_id: 'a-leaf', patch: { status: 'completed', end_time: 0 } });
                 task({ subtype: 'task_notification', task_id: 'a-leaf', tool_use_id: 'toolu_leaf', status: 'completed', output_file: '', summary: 'PONG' });
+
                 underMiddle(
                     { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_leaf', content: `PONG${agentFooter('a-leaf')}`, is_error: false }] },
                     'user'
                 );
+
                 underMiddle(
                     { id: `msg_${nonce}_${++messageCounter}`, model, role: 'assistant', content: [{ type: 'text', text: `the leaf said PONG` }], usage },
                     'assistant'
                 );
+
                 task({ subtype: 'task_updated', task_id: 'a-middle', patch: { status: 'completed', end_time: 0 } });
+
                 task({
                     subtype: 'task_notification',
                     task_id: 'a-middle',
@@ -626,15 +724,19 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     summary,
                     usage: { total_tokens: 1500, tool_uses: 1, duration_ms: 250 }
                 });
+
                 out({ type: 'system', subtype: 'init', session_id: sessionId, model, cwd: io.cwd, tools: ['Bash'], slash_commands: [], argv: args });
                 assistantText(`done: ${summary}`);
                 result();
             });
+
             return;
         }
+
         if (text.startsWith('background:')) {
             const summary = text.slice(11).trim() || 'done';
             const id = `msg_${nonce}_${++messageCounter}`;
+
             out({
                 type: 'assistant',
                 message: {
@@ -648,6 +750,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             out({
                 type: 'system',
                 subtype: 'task_started',
@@ -659,6 +762,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 task_type: 'local_agent',
                 session_id: sessionId
             });
+
             out({
                 type: 'user',
                 message: {
@@ -667,12 +771,15 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             assistantText('I will report back');
             result();
+
             // What the real CLI does after the turn ended: the subagent works on, and only later come a
             // notification, a fresh init, an assistant message of its own and a result, with no user frame.
             io.later(() => {
                 subagentWork('toolu_agent', `the subagent says: ${summary}`);
+
                 io.later(() => {
                     out({
                         type: 'system',
@@ -685,13 +792,16 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                         usage: { total_tokens: 1500, tool_uses: 2, duration_ms: 250 },
                         session_id: sessionId
                     });
+
                     out({ type: 'system', subtype: 'init', session_id: sessionId, model, cwd: io.cwd, tools: ['Bash'], slash_commands: [], argv: args });
                     assistantText(`the subagent says: ${summary}`);
                     result();
                 });
             });
+
             return;
         }
+
         /*
          * A background subagent that sends a command to the background and answers at once, the way Claude
          * Code 2.1.282 runs one: its notification opens a turn with that answer while the command runs on.
@@ -703,6 +813,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             const command = text.split('\n')[0]!.slice(19).trim() || 'sleep 30';
             const agentUse = 'toolu_cmd_agent';
             const bashUse = 'toolu_cmd_bash';
+
             const subagent = (content: unknown[]): void => {
                 out({
                     type: 'assistant',
@@ -711,6 +822,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     session_id: sessionId
                 });
             };
+
             const subagentResult = (toolUseId: string, content: string): void => {
                 out({
                     type: 'user',
@@ -719,6 +831,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     session_id: sessionId
                 });
             };
+
             const agentNotified = (summary: string): void => {
                 out({
                     type: 'system',
@@ -730,8 +843,10 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     usage: { total_tokens: 1500, tool_uses: 1, duration_ms: 250 },
                     session_id: sessionId
                 });
+
                 out({ type: 'system', subtype: 'init', session_id: sessionId, model, cwd: io.cwd, tools: ['Bash'], slash_commands: [], argv: args });
             };
+
             out({
                 type: 'assistant',
                 message: {
@@ -743,6 +858,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             out({
                 type: 'system',
                 subtype: 'task_started',
@@ -754,6 +870,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 task_type: 'local_agent',
                 session_id: sessionId
             });
+
             out({
                 type: 'user',
                 message: {
@@ -762,10 +879,13 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             assistantText('started');
             result();
+
             io.later(() => {
                 subagent([{ type: 'tool_use', id: bashUse, name: 'Bash', input: { command, run_in_background: true } }]);
+
                 out({
                     type: 'system',
                     subtype: 'task_started',
@@ -776,13 +896,16 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     is_backgrounded: true,
                     session_id: sessionId
                 });
+
                 subagentResult(bashUse, 'Command running in background with ID: b-cmd.');
                 subagent([{ type: 'text', text: 'Command started in the background.' }]);
                 agentNotified('Agent "Run it" finished');
                 assistantText('the subagent says: Command started in the background.');
                 result();
+
                 io.later(() => {
                     out({ type: 'system', subtype: 'task_updated', task_id: 'b-cmd', patch: { status: 'completed', end_time: 30000 }, session_id: sessionId });
+
                     out({
                         type: 'system',
                         subtype: 'task_notification',
@@ -793,6 +916,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                         summary: `Background command "${command}" completed (exit code 0)`,
                         session_id: sessionId
                     });
+
                     subagent([{ type: 'tool_use', id: 'toolu_cmd_read', name: 'Read', input: { file_path: 'b-cmd.output' } }]);
                     subagentResult('toolu_cmd_read', 'DONE');
                     subagent([{ type: 'text', text: 'The command printed DONE.' }]);
@@ -801,24 +925,30 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     result();
                 });
             });
+
             return;
         }
+
         /*
          * A two-phase workflow, framed the way Claude Code 2.1.282 streams one: the call answers at launch,
          * and its agents send no frames of their own; only some progress frames carry a report of the whole run.
          */
         if (text.startsWith('workflow:')) {
             const summary = text.slice(9).trim() || 'Write a file, then read it';
+
             const task = (frame: Record<string, unknown>): void => {
                 out({ type: 'system', task_id: 'wf-task', session_id: sessionId, ...frame });
             };
+
             const phases = [
                 { type: 'workflow_phase', index: 1, title: 'Write' },
                 { type: 'workflow_phase', index: 2, title: 'Read' }
             ];
+
             const writer = { type: 'workflow_agent', index: 1, label: 'write-file', phaseIndex: 1, phaseTitle: 'Write', agentId: 'a-writer', startedAt: 1000 };
             const reader = { type: 'workflow_agent', index: 2, label: 'read-file', phaseIndex: 2, phaseTitle: 'Read', agentId: 'a-reader', startedAt: 6000 };
             const writerDone = { ...writer, state: 'done', lastToolName: 'Write', tokens: 16264, toolCalls: 1, durationMs: 5000 };
+
             const progress = (description: string, report?: unknown[]): void => {
                 task({
                     subtype: 'task_progress',
@@ -830,6 +960,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     ...(report === undefined ? {} : { workflow_progress: report })
                 });
             };
+
             out({
                 type: 'assistant',
                 message: {
@@ -841,13 +972,16 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             out({
                 type: 'system',
                 subtype: 'background_tasks_changed',
                 tasks: [{ task_id: 'wf-task', task_type: 'local_workflow', description: summary }],
                 session_id: sessionId
             });
+
             task({ subtype: 'task_started', tool_use_id: 'toolu_wf', description: summary, task_type: 'local_workflow', workflow_name: 'write-and-read' });
+
             out({
                 type: 'user',
                 message: {
@@ -863,15 +997,18 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 },
                 session_id: sessionId
             });
+
             progress('Write: write-file', [...phases, { ...writer, state: 'start' }]);
             assistantText('the workflow runs');
             result();
+
             io.later(() => {
                 progress('Write: write-file');
                 progress('Read: read-file', [...phases, writerDone, { ...reader, state: 'start' }]);
                 progress('Read: read-file', [...phases, writerDone, { ...reader, state: 'done', lastToolName: 'Read', durationMs: 4000 }]);
                 out({ type: 'system', subtype: 'background_tasks_changed', tasks: [], session_id: sessionId });
                 task({ subtype: 'task_updated', patch: { status: 'completed', end_time: 10000 } });
+
                 task({
                     subtype: 'task_notification',
                     tool_use_id: 'toolu_wf',
@@ -880,20 +1017,25 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     summary: `Dynamic workflow "${summary}" completed`,
                     usage: { total_tokens: 32403, tool_uses: 2, duration_ms: 9000 }
                 });
+
                 out({ type: 'system', subtype: 'init', session_id: sessionId, model, cwd: io.cwd, tools: ['Bash'], slash_commands: [], argv: args });
                 assistantText('the workflow is done');
                 result();
             });
+
             return;
         }
+
         if (text.startsWith('run:')) {
             const command = text.slice(4).trim();
             const id = `msg_${nonce}_${++messageCounter}`;
+
             out({
                 type: 'assistant',
                 message: { id, model, role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_run', name: 'Bash', input: { command } }], usage },
                 session_id: sessionId
             });
+
             // The frames the real CLI emits around a long Bash call, in its order and shape.
             out({
                 type: 'system',
@@ -905,6 +1047,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 task_type: 'local_bash',
                 session_id: sessionId
             });
+
             out({
                 type: 'tool_progress',
                 tool_use_id: 'toolu_run',
@@ -914,6 +1057,7 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 task_id: 'task-1',
                 session_id: sessionId
             });
+
             out({
                 type: 'system',
                 subtype: 'task_notification',
@@ -924,24 +1068,31 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 summary: `Run ${command}`,
                 session_id: sessionId
             });
+
             out({
                 type: 'user',
                 message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_run', content: `ran: ${command}`, is_error: false }] },
                 session_id: sessionId
             });
+
             assistantText('done');
             result();
+
             return;
         }
+
         if (text.startsWith('tool:')) {
             const command = text.slice(5).trim();
             const id = `msg_${nonce}_${++messageCounter}`;
+
             out({
                 type: 'assistant',
                 message: { id, model, role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command } }], usage },
                 session_id: sessionId
             });
+
             pendingApproval = { command };
+
             out({
                 type: 'control_request',
                 request_id: 'req-1',
@@ -956,14 +1107,18 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                     ]
                 }
             });
+
             return;
         }
+
         if (text === 'system?') {
             const at = args.indexOf('--append-system-prompt');
             assistantText(at >= 0 ? args[at + 1]! : 'none');
             result();
+
             return;
         }
+
         assistantText(`echo: ${text}`);
         result();
     };
@@ -972,31 +1127,40 @@ export function fakeClaude(io: FakeIo): FakeProgram {
         const inner = response.response as
             | { behavior?: string; message?: string; updatedInput?: { answers?: Record<string, string> }; updatedPermissions?: unknown[] }
             | undefined;
+
         if (backgroundAsk !== null && response.request_id === backgroundAsk.requestId) {
             const { command } = backgroundAsk;
             backgroundAsk = null;
             finishBackgroundAgent(command, inner?.behavior === 'allow', inner?.message);
+
             return;
         }
+
         if (pendingQuestion) {
             const answer = inner?.updatedInput?.answers?.[pendingQuestion] ?? 'no answer';
             pendingQuestion = null;
             assistantText(`you chose ${answer}`);
             result();
+
             return;
         }
+
         const approval = pendingApproval;
         pendingApproval = null;
+
         if (!approval) {
             return;
         }
+
         if (inner?.behavior === 'allow') {
             const always = Array.isArray(inner.updatedPermissions) && inner.updatedPermissions.length > 0;
+
             out({
                 type: 'user',
                 message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: `ran: ${approval.command}`, is_error: false }] },
                 session_id: sessionId
             });
+
             assistantText(always ? 'done, remembered' : 'done');
         } else {
             out({
@@ -1004,8 +1168,10 @@ export function fakeClaude(io: FakeIo): FakeProgram {
                 message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'denied by user', is_error: true }] },
                 session_id: sessionId
             });
+
             assistantText('denied');
         }
+
         result();
     };
 
@@ -1014,10 +1180,12 @@ export function fakeClaude(io: FakeIo): FakeProgram {
     return {
         onLine: (line) => {
             const frame = JSON.parse(line) as Record<string, unknown>;
+
             if (frame.type === 'user') {
                 if (args.includes('--replay-user-messages') && typeof frame.uuid === 'string') {
                     out(frame);
                 }
+
                 const message = frame.message as { content: Array<{ text: string }> };
                 handleUser(message.content[0]?.text ?? '');
             } else if (frame.type === 'control_response') {
@@ -1025,9 +1193,11 @@ export function fakeClaude(io: FakeIo): FakeProgram {
             } else if (frame.type === 'control_request') {
                 const request = frame.request as { subtype: string; task_id?: string };
                 out({ type: 'control_response', response: { subtype: 'success', request_id: frame.request_id, response: {} } });
+
                 if (request.subtype === 'stop_task' && (request.task_id === 'a-one' || request.task_id === 'a-two')) {
                     settleTwo(request.task_id, true);
                 }
+
                 if (request.subtype === 'interrupt' && slow) {
                     slow = false;
                     assistantText('[interrupted]');
@@ -1047,14 +1217,19 @@ export function claudeStoppingOnResume(sessionIds: ReadonlySet<string>, how: 'mi
     return (io) => {
         const resumeAt = io.argv.indexOf('--resume');
         const sessionId = resumeAt >= 0 ? io.argv[resumeAt + 1] : undefined;
+
         if (sessionId === undefined || !sessionIds.has(sessionId)) {
             return fakeClaude(io);
         }
+
         if (how === 'exit') {
             fakeClaude(io);
+
             return { onLine: () => io.exit(1) };
         }
+
         const message = `No conversation found with session ID: ${sessionId}`;
+
         io.out({
             type: 'result',
             subtype: 'error_during_execution',
@@ -1069,8 +1244,10 @@ export function claudeStoppingOnResume(sessionIds: ReadonlySet<string>, how: 'mi
             permission_denials: [],
             errors: [message]
         });
+
         io.err(`${message}\n`);
         io.exit(1);
+
         return { onLine: () => undefined };
     };
 }