rafcode 2.1.1 → 2.3.0

package/src/utils/terminal-symbols.ts

@@ -4,6 +4,8 @@
  */
 
 import { formatElapsedTime } from './timer.js';
+import type { UsageData } from '../types/config.js';
+import type { CostBreakdown, TaskUsageEntry } from './token-tracker.js';
 
 /**
  * Visual symbols for terminal output using dots/symbols style.
@@ -125,3 +127,104 @@ export function formatProgressBar(tasks: TaskStatus[]): string {
 
   return tasks.map((status) => SYMBOLS[status]).join('');
 }
+
+/**
+ * Formats a number with thousands separators (e.g., 12345 -> "12,345").
+ */
+export function formatNumber(n: number): string {
+  return n.toLocaleString('en-US');
+}
+
+/**
+ * Formats a cost in USD with 2-4 decimal places.
+ * Uses 2 decimals for values >= $0.01, 4 decimals for smaller values.
+ */
+export function formatCost(cost: number): string {
+  if (cost === 0) return '$0.00';
+  if (cost < 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(2)}`;
+}
+
+/**
+ * Formats a single line of token usage (for a single attempt or total).
+ * Used internally by formatTaskTokenSummary.
+ */
+function formatTokenLine(
+  usage: UsageData,
+  costValue: number,
+  prefix: string = '',
+  indent: string = '  '
+): string {
+  const parts: string[] = [];
+  const tokenPart = `${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`;
+  parts.push(prefix ? `${prefix}: ${tokenPart}` : `Tokens: ${tokenPart}`);
+
+  const cacheTotal = usage.cacheReadInputTokens + usage.cacheCreationInputTokens;
+  if (cacheTotal > 0) {
+    if (usage.cacheReadInputTokens > 0 && usage.cacheCreationInputTokens > 0) {
+      parts.push(`Cache: ${formatNumber(usage.cacheReadInputTokens)} read / ${formatNumber(usage.cacheCreationInputTokens)} created`);
+    } else if (usage.cacheReadInputTokens > 0) {
+      parts.push(`Cache: ${formatNumber(usage.cacheReadInputTokens)} read`);
+    } else {
+      parts.push(`Cache: ${formatNumber(usage.cacheCreationInputTokens)} created`);
+    }
+  }
+
+  parts.push(`Est. cost: ${formatCost(costValue)}`);
+  return `${indent}${parts.join(' | ')}`;
+}
+
+/**
+ * Formats a per-task token usage summary.
+ * For single-attempt tasks: "  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42"
+ * For multi-attempt tasks: shows per-attempt breakdown plus total.
+ *
+ * @param entry - The TaskUsageEntry containing accumulated usage, cost, and attempts array
+ * @param calculateAttemptCost - Optional function to calculate cost for a single attempt's UsageData
+ */
+export function formatTaskTokenSummary(
+  entry: TaskUsageEntry,
+  calculateAttemptCost?: (usage: UsageData) => CostBreakdown
+): string {
+  // Single-attempt: render exactly as before (no per-attempt breakdown)
+  if (entry.attempts.length <= 1) {
+    return formatTokenLine(entry.usage, entry.cost.totalCost);
+  }
+
+  // Multi-attempt: show per-attempt lines plus total
+  const lines: string[] = [];
+  entry.attempts.forEach((attemptUsage, i) => {
+    const attemptCost = calculateAttemptCost
+      ? calculateAttemptCost(attemptUsage).totalCost
+      : 0;
+    lines.push(formatTokenLine(attemptUsage, attemptCost, `Attempt ${i + 1}`, '    '));
+  });
+  lines.push(formatTokenLine(entry.usage, entry.cost.totalCost, 'Total', '    '));
+  return lines.join('\n');
+}
+
+/**
+ * Formats the grand total token usage summary block.
+ * Displayed after all tasks complete.
+ */
+export function formatTokenTotalSummary(usage: UsageData, cost: CostBreakdown): string {
+  const lines: string[] = [];
+  const divider = '── Token Usage Summary ──────────────────';
+  lines.push(divider);
+  lines.push(`Total tokens: ${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`);
+
+  if (usage.cacheReadInputTokens > 0 || usage.cacheCreationInputTokens > 0) {
+    const cacheParts: string[] = [];
+    if (usage.cacheReadInputTokens > 0) {
+      cacheParts.push(`${formatNumber(usage.cacheReadInputTokens)} read`);
+    }
+    if (usage.cacheCreationInputTokens > 0) {
+      cacheParts.push(`${formatNumber(usage.cacheCreationInputTokens)} created`);
+    }
+    lines.push(`Cache: ${cacheParts.join(' / ')}`);
+  }
+
+  lines.push(`Estimated cost: ${formatCost(cost.totalCost)}`);
+  lines.push('─────────────────────────────────────────');
+  return lines.join('\n');
+}

package/src/utils/token-tracker.ts

@@ -0,0 +1,177 @@
+import { UsageData, PricingConfig } from '../types/config.js';
+import { resolveModelPricingCategory, getPricingConfig } from './config.js';
+
+/** Cost breakdown for a single task or accumulated total. */
+export interface CostBreakdown {
+  inputCost: number;
+  outputCost: number;
+  cacheReadCost: number;
+  cacheCreateCost: number;
+  totalCost: number;
+}
+
+/** Per-task usage snapshot stored by the tracker. */
+export interface TaskUsageEntry {
+  taskId: string;
+  /** Accumulated usage across all attempts. */
+  usage: UsageData;
+  /** Cost breakdown for accumulated usage. */
+  cost: CostBreakdown;
+  /** Raw per-attempt usage data (for display breakdowns). */
+  attempts: UsageData[];
+}
+
+/**
+ * Merge multiple UsageData objects into a single accumulated UsageData.
+ * Sums all token fields and merges modelUsage maps.
+ */
+export function accumulateUsage(attempts: UsageData[]): UsageData {
+  const result: UsageData = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    modelUsage: {},
+  };
+
+  for (const attempt of attempts) {
+    result.inputTokens += attempt.inputTokens;
+    result.outputTokens += attempt.outputTokens;
+    result.cacheReadInputTokens += attempt.cacheReadInputTokens;
+    result.cacheCreationInputTokens += attempt.cacheCreationInputTokens;
+
+    // Merge per-model usage
+    for (const [modelId, modelUsage] of Object.entries(attempt.modelUsage)) {
+      const existing = result.modelUsage[modelId];
+      if (existing) {
+        existing.inputTokens += modelUsage.inputTokens;
+        existing.outputTokens += modelUsage.outputTokens;
+        existing.cacheReadInputTokens += modelUsage.cacheReadInputTokens;
+        existing.cacheCreationInputTokens += modelUsage.cacheCreationInputTokens;
+      } else {
+        result.modelUsage[modelId] = { ...modelUsage };
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Accumulates token usage across multiple task executions and calculates costs
+ * using configurable per-model pricing.
+ */
+export class TokenTracker {
+  private entries: TaskUsageEntry[] = [];
+  private pricingConfig: PricingConfig;
+
+  constructor(pricingConfig?: PricingConfig) {
+    this.pricingConfig = pricingConfig ?? getPricingConfig();
+  }
+
+  /**
+   * Record usage data from a completed task.
+   * Accepts an array of UsageData (one per attempt) and accumulates them.
+   */
+  addTask(taskId: string, attempts: UsageData[]): TaskUsageEntry {
+    const usage = accumulateUsage(attempts);
+    const cost = this.calculateCost(usage);
+    const entry: TaskUsageEntry = { taskId, usage, cost, attempts };
+    this.entries.push(entry);
+    return entry;
+  }
+
+  /**
+   * Get all recorded task entries.
+   */
+  getEntries(): readonly TaskUsageEntry[] {
+    return this.entries;
+  }
+
+  /**
+   * Get accumulated totals across all tasks.
+   */
+  getTotals(): { usage: UsageData; cost: CostBreakdown } {
+    const totalUsage: UsageData = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+    };
+    const totalCost: CostBreakdown = {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: 0,
+    };
+
+    for (const entry of this.entries) {
+      totalUsage.inputTokens += entry.usage.inputTokens;
+      totalUsage.outputTokens += entry.usage.outputTokens;
+      totalUsage.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
+      totalUsage.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
+
+      // Merge per-model usage
+      for (const [modelId, modelUsage] of Object.entries(entry.usage.modelUsage)) {
+        const existing = totalUsage.modelUsage[modelId];
+        if (existing) {
+          existing.inputTokens += modelUsage.inputTokens;
+          existing.outputTokens += modelUsage.outputTokens;
+          existing.cacheReadInputTokens += modelUsage.cacheReadInputTokens;
+          existing.cacheCreationInputTokens += modelUsage.cacheCreationInputTokens;
+        } else {
+          totalUsage.modelUsage[modelId] = { ...modelUsage };
+        }
+      }
+
+      totalCost.inputCost += entry.cost.inputCost;
+      totalCost.outputCost += entry.cost.outputCost;
+      totalCost.cacheReadCost += entry.cost.cacheReadCost;
+      totalCost.cacheCreateCost += entry.cost.cacheCreateCost;
+      totalCost.totalCost += entry.cost.totalCost;
+    }
+
+    return { usage: totalUsage, cost: totalCost };
+  }
+
+  /**
+   * Calculate cost for a given UsageData using per-model pricing.
+   * Uses per-model breakdown when available, falls back to aggregate with sonnet pricing.
+   */
+  calculateCost(usage: UsageData): CostBreakdown {
+    const result: CostBreakdown = {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: 0,
+    };
+
+    const modelEntries = Object.entries(usage.modelUsage);
+
+    if (modelEntries.length > 0) {
+      // Use per-model breakdown for accurate pricing
+      for (const [modelId, modelUsage] of modelEntries) {
+        const category = resolveModelPricingCategory(modelId);
+        const pricing = this.pricingConfig[category ?? 'sonnet'];
+
+        result.inputCost += (modelUsage.inputTokens / 1_000_000) * pricing.inputPerMTok;
+        result.outputCost += (modelUsage.outputTokens / 1_000_000) * pricing.outputPerMTok;
+        result.cacheReadCost += (modelUsage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
+        result.cacheCreateCost += (modelUsage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
+      }
+    } else {
+      // Fallback: use aggregate totals with sonnet pricing
+      const pricing = this.pricingConfig.sonnet;
+      result.inputCost = (usage.inputTokens / 1_000_000) * pricing.inputPerMTok;
+      result.outputCost = (usage.outputTokens / 1_000_000) * pricing.outputPerMTok;
+      result.cacheReadCost = (usage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
+      result.cacheCreateCost = (usage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
+    }
+
+    result.totalCost = result.inputCost + result.outputCost + result.cacheReadCost + result.cacheCreateCost;
+    return result;
+  }
+}

package/src/utils/validation.ts

@@ -2,6 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
 import { logger } from './logger.js';
+import type { ClaudeModelName, ModelScenario } from '../types/config.js';
+import { VALID_MODEL_ALIASES, FULL_MODEL_ID_PATTERN } from '../types/config.js';
+import { getModel } from './config.js';
 
 export interface ValidationResult {
   valid: boolean;
@@ -88,19 +91,21 @@ export function reportValidation(result: ValidationResult): void {
   }
 }
 
-const VALID_MODELS = ['sonnet', 'haiku', 'opus'] as const;
+/** @deprecated Use ClaudeModelName from types/config.js instead */
+export type ValidModelName = ClaudeModelName;
 
-export type ValidModelName = (typeof VALID_MODELS)[number];
-
-export function validateModelName(model: string): ValidModelName | null {
+export function validateModelName(model: string): ClaudeModelName | null {
   const normalized = model.toLowerCase();
-  if (VALID_MODELS.includes(normalized as ValidModelName)) {
-    return normalized as ValidModelName;
+  if ((VALID_MODEL_ALIASES as readonly string[]).includes(normalized)) {
+    return normalized as ClaudeModelName;
+  }
+  if (FULL_MODEL_ID_PATTERN.test(normalized)) {
+    return normalized as ClaudeModelName;
   }
   return null;
 }
 
-export function resolveModelOption(model?: string, sonnet?: boolean): ValidModelName {
+export function resolveModelOption(model?: string, sonnet?: boolean, scenario: ModelScenario = 'execute'): ClaudeModelName {
   // Check for conflicting flags
   if (model && sonnet) {
     throw new Error('Cannot specify both --model and --sonnet flags');
@@ -115,11 +120,11 @@ export function resolveModelOption(model?: string, sonnet?: boolean): ValidModel
   if (model) {
     const validated = validateModelName(model);
     if (!validated) {
-      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODELS.join(', ')}`);
+      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODEL_ALIASES.join(', ')} or a full model ID (e.g., claude-sonnet-4-5-20250929)`);
     }
     return validated;
   }
 
-  // Default to opus
-  return 'opus';
+  // Default from config
+  return getModel(scenario);
 }

package/src/utils/verbose-toggle.ts

@@ -0,0 +1,103 @@
+/**
+ * Runtime verbose toggle for task execution.
+ *
+ * Listens for Tab keypress on process.stdin to toggle verbose display on/off.
+ * When verbose is on, tool-use activity lines from stream-json are displayed.
+ * When verbose is off, they are suppressed (but data is still captured).
+ *
+ * Requires a TTY stdin. Silently skips setup when stdin is not a TTY (e.g., piped input).
+ */
+
+import { logger } from './logger.js';
+
+export class VerboseToggle {
+  private _verbose: boolean;
+  private _active = false;
+  private _dataHandler: ((data: Buffer) => void) | null = null;
+
+  constructor(initialVerbose: boolean) {
+    this._verbose = initialVerbose;
+  }
+
+  /** Current verbose display state. */
+  get isVerbose(): boolean {
+    return this._verbose;
+  }
+
+  /** Whether the toggle listener is currently active. */
+  get isActive(): boolean {
+    return this._active;
+  }
+
+  /**
+   * Start listening for Tab keypress on stdin.
+   * Sets stdin to raw mode to capture individual keypresses.
+   * Shows a hint message about the toggle.
+   *
+   * No-op if stdin is not a TTY or if already active.
+   */
+  start(): void {
+    if (this._active) return;
+    if (!process.stdin.isTTY) return;
+
+    try {
+      process.stdin.setRawMode(true);
+    } catch {
+      // Cannot set raw mode — skip
+      return;
+    }
+
+    process.stdin.resume();
+
+    this._dataHandler = (data: Buffer) => {
+      for (let i = 0; i < data.length; i++) {
+        const byte = data[i];
+
+        if (byte === 0x09) {
+          // Tab key
+          this._verbose = !this._verbose;
+          const state = this._verbose ? 'on' : 'off';
+          logger.dim(`  [verbose: ${state}]`);
+        } else if (byte === 0x03) {
+          // Ctrl+C — re-emit SIGINT so the shutdown handler catches it
+          process.emit('SIGINT');
+        }
+      }
+    };
+
+    process.stdin.on('data', this._dataHandler);
+    this._active = true;
+
+    // Show toggle hint
+    logger.dim('  Press Tab to toggle verbose mode');
+  }
+
+  /**
+   * Stop listening and restore stdin to normal mode.
+   * Safe to call multiple times.
+   */
+  stop(): void {
+    if (!this._active) return;
+
+    if (this._dataHandler) {
+      process.stdin.off('data', this._dataHandler);
+      this._dataHandler = null;
+    }
+
+    try {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    } catch {
+      // Ignore — stdin may already be closed
+    }
+
+    try {
+      process.stdin.pause();
+    } catch {
+      // Ignore
+    }
+
+    this._active = false;
+  }
+}

package/tests/unit/claude-runner.test.ts

@@ -305,8 +305,8 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit context overflow message
-      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded'));
+      // Emit context overflow message (with newline so NDJSON line buffer processes it)
+      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded\n'));
 
       const result = await runPromise;
       expect(result.contextOverflow).toBe(true);
@@ -333,7 +333,8 @@ describe('ClaudeRunner', () => {
         const runner = new ClaudeRunner();
         const runPromise = runner.run('test prompt', { timeout: 60 });
 
-        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}`));
+        // Trailing newline needed for NDJSON line buffer processing
+        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}\n`));
 
         const result = await runPromise;
         expect(result.contextOverflow).toBe(true);
@@ -696,7 +697,7 @@ describe('ClaudeRunner', () => {
       expect(spawnArgs).toContain('--verbose');
     });
 
-    it('should NOT include --output-format or --verbose flags in run()', async () => {
+    it('should include --output-format stream-json and --verbose flags in run() (unified stream-json)', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -707,9 +708,9 @@ describe('ClaudeRunner', () => {
       await runPromise;
 
       const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).not.toContain('--output-format');
-      expect(spawnArgs).not.toContain('stream-json');
-      expect(spawnArgs).not.toContain('--verbose');
+      expect(spawnArgs).toContain('--output-format');
+      expect(spawnArgs).toContain('stream-json');
+      expect(spawnArgs).toContain('--verbose');
     });
 
     it('should extract text from NDJSON assistant events', async () => {
@@ -756,6 +757,169 @@ describe('ClaudeRunner', () => {
     });
   });
 
+  describe('usage data extraction', () => {
+    function createMockProcess() {
+      const stdout = new EventEmitter();
+      const stderr = new EventEmitter();
+      const proc = new EventEmitter() as any;
+      proc.stdout = stdout;
+      proc.stderr = stderr;
+      proc.kill = jest.fn();
+      return proc;
+    }
+
+    it('should return usageData from run() when result event has usage', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Done' }] },
+      });
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 1000, output_tokens: 500, cache_read_input_tokens: 200, cache_creation_input_tokens: 100 },
+        modelUsage: { 'claude-opus-4-6': { inputTokens: 1000, outputTokens: 500, cacheReadInputTokens: 200, cacheCreationInputTokens: 100 } },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(assistantEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(1000);
+      expect(result.usageData!.outputTokens).toBe(500);
+      expect(result.usageData!.modelUsage['claude-opus-4-6']).toEqual({
+        inputTokens: 1000,
+        outputTokens: 500,
+        cacheReadInputTokens: 200,
+        cacheCreationInputTokens: 100,
+      });
+    });
+
+    it('should return usageData from runVerbose() when result event has usage', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 2000, output_tokens: 800 },
+        modelUsage: { 'claude-sonnet-4-5-20250929': { inputTokens: 2000, outputTokens: 800 } },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(2000);
+      expect(result.usageData!.outputTokens).toBe(800);
+    });
+
+    it('should return undefined usageData when no result event', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Output' }] },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(assistantEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeUndefined();
+    });
+
+    it('should suppress display in run() but still capture usage data', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Spy on stdout.write to verify no display output in non-verbose mode
+      const writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const toolEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [
+          { type: 'text', text: 'Working...' },
+          { type: 'tool_use', name: 'Read', input: { file_path: '/test.ts' } },
+        ] },
+      });
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 100, output_tokens: 50 },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(toolEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+
+      // No display output (run() is non-verbose)
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // But usage data is still captured
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(100);
+
+      // And text content is captured
+      expect(result.output).toContain('Working...');
+
+      writeSpy.mockRestore();
+    });
+
+    it('should use verboseCheck callback to dynamically control display', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+      let dynamicVerbose = false;
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        verboseCheck: () => dynamicVerbose,
+      });
+
+      // First event with verbose OFF — should not display
+      const event1 = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/a.ts' } }] },
+      });
+      mockProc.stdout.emit('data', Buffer.from(event1 + '\n'));
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // Toggle verbose ON
+      dynamicVerbose = true;
+
+      // Second event with verbose ON — should display
+      const event2 = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/b.ts' } }] },
+      });
+      mockProc.stdout.emit('data', Buffer.from(event2 + '\n'));
+      expect(writeSpy).toHaveBeenCalled();
+
+      mockProc.emit('close', 0);
+      await runPromise;
+
+      writeSpy.mockRestore();
+    });
+  });
+
   describe('retry isolation (timeout per attempt)', () => {
     function createMockProcess() {
       const stdout = new EventEmitter();