rafcode 3.2.1 → 3.8.0

package/src/utils/terminal-symbols.ts

@@ -13,6 +13,10 @@ export interface TokenSummaryOptions {
   showCacheTokens?: boolean;
 }
 
+function hasExactCost(cost: number | null): cost is number {
+  return cost !== null;
+}
+
 /**
  * Visual symbols for terminal output using dots/symbols style.
  */
@@ -27,6 +31,11 @@ export const SYMBOLS = {
 
 export type TaskStatus = 'running' | 'completed' | 'failed' | 'pending' | 'blocked';
 
+export interface ModelDisplayOptions {
+  effort?: string;
+  fast?: boolean;
+}
+
 /**
  * Truncates a string to the specified length, adding ellipsis if needed.
  */
@@ -55,12 +64,13 @@ export function formatTaskProgress(
   name: string,
   elapsedMs?: number,
   taskId?: string,
-  model?: string
+  model?: string,
+  modelOptions: ModelDisplayOptions = {}
 ): string {
   const symbol = SYMBOLS[status];
   const displayName = truncate(name || 'task', 40);
   const idPrefix = taskId ? `${taskId}-` : '';
-  const modelSuffix = model ? ` (${model})` : '';
+  const modelSuffix = formatModelDisplay(model, modelOptions);
 
   // Show elapsed time for running tasks, completed tasks, and failed tasks
   if (elapsedMs !== undefined) {
@@ -71,6 +81,31 @@ export function formatTaskProgress(
   return `${symbol} ${idPrefix}${displayName}${modelSuffix} ${current}/${total}`;
 }
 
+/**
+ * Formats a model label with optional effort/fast metadata.
+ * Examples: "sonnet", "sonnet, low", "sonnet, low, fast"
+ */
+export function formatModelMetadata(model: string, options: ModelDisplayOptions = {}): string {
+  const parts = [model];
+  if (options.effort) {
+    parts.push(options.effort);
+  }
+  if (options.fast) {
+    parts.push('fast');
+  }
+  return parts.join(', ');
+}
+
+/**
+ * Formats model metadata for display surfaces that wrap the label in parentheses.
+ */
+export function formatModelDisplay(model?: string, options: ModelDisplayOptions = {}): string {
+  if (!model) {
+    return '';
+  }
+  return ` (${formatModelMetadata(model, options)})`;
+}
+
 /**
  * Formats a project header line.
  * @param name - Project name
@@ -148,7 +183,8 @@ export function formatNumber(n: number): string {
  * 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 {
+export function formatCost(cost: number | null): string {
+  if (cost === null) return 'unavailable';
   if (cost === 0) return '$0.00';
   if (cost < 0.01) return `$${cost.toFixed(4)}`;
   return `$${cost.toFixed(2)}`;
@@ -160,7 +196,7 @@ export function formatCost(cost: number): string {
  */
 function formatTokenLine(
   usage: UsageData,
-  costValue: number,
+  costValue: number | null,
   prefix: string = '',
   indent: string = '  ',
   options: TokenSummaryOptions = {}
@@ -183,7 +219,9 @@ function formatTokenLine(
     }
   }
 
-  parts.push(`Cost: ${formatCost(costValue)}`);
+  if (hasExactCost(costValue)) {
+    parts.push(`Cost: ${formatCost(costValue)}`);
+  }
 
   return `${indent}${parts.join(' | ')}`;
 }
@@ -245,7 +283,9 @@ export function formatTokenTotalSummary(
     lines.push(`Cache: ${cacheParts.join(' / ')}`);
   }
 
-  lines.push(`Total cost: ${formatCost(cost.totalCost)}`);
+  if (hasExactCost(cost.totalCost)) {
+    lines.push(`Total cost: ${formatCost(cost.totalCost)}`);
+  }
 
   lines.push('─────────────────────────────────────────');
   return lines.join('\n');

package/src/utils/token-tracker.ts

@@ -2,7 +2,7 @@ import { UsageData } from '../types/config.js';
 
 /** Cost breakdown for a single task or accumulated total. */
 export interface CostBreakdown {
-  totalCost: number;
+  totalCost: number | null;
 }
 
 /** Per-task usage snapshot stored by the tracker. */
@@ -16,12 +16,82 @@ export interface TaskUsageEntry {
   attempts: UsageData[];
 }
 
+function mergeCostUsd(existing: number | null | undefined, incoming: number | null | undefined): number | null {
+  if (existing === null || incoming === null || existing === undefined || incoming === undefined) {
+    return null;
+  }
+  return existing + incoming;
+}
+
+/**
+ * Merge usage data into an accumulated snapshot.
+ * Handles undefined input for first-event initialization.
+ */
+export function mergeUsageData(existing: UsageData | undefined, incoming: UsageData | undefined): UsageData | undefined {
+  if (!incoming) {
+    return existing;
+  }
+
+  if (!existing) {
+    return {
+      inputTokens: incoming.inputTokens ?? 0,
+      outputTokens: incoming.outputTokens ?? 0,
+      cacheReadInputTokens: incoming.cacheReadInputTokens ?? 0,
+      cacheCreationInputTokens: incoming.cacheCreationInputTokens ?? 0,
+      modelUsage: Object.fromEntries(
+        Object.entries(incoming.modelUsage ?? {}).map(([modelId, usage]) => [
+          modelId,
+          {
+            inputTokens: usage.inputTokens ?? 0,
+            outputTokens: usage.outputTokens ?? 0,
+            cacheReadInputTokens: usage.cacheReadInputTokens ?? 0,
+            cacheCreationInputTokens: usage.cacheCreationInputTokens ?? 0,
+            costUsd: usage.costUsd ?? null,
+          },
+        ]),
+      ),
+      totalCostUsd: incoming.totalCostUsd ?? null,
+    };
+  }
+
+  const merged: UsageData = {
+    inputTokens: (existing.inputTokens ?? 0) + (incoming.inputTokens ?? 0),
+    outputTokens: (existing.outputTokens ?? 0) + (incoming.outputTokens ?? 0),
+    cacheReadInputTokens: (existing.cacheReadInputTokens ?? 0) + (incoming.cacheReadInputTokens ?? 0),
+    cacheCreationInputTokens: (existing.cacheCreationInputTokens ?? 0) + (incoming.cacheCreationInputTokens ?? 0),
+    modelUsage: {},
+    totalCostUsd: mergeCostUsd(existing.totalCostUsd, incoming.totalCostUsd),
+  };
+
+  const allModelIds = new Set([
+    ...Object.keys(existing.modelUsage ?? {}),
+    ...Object.keys(incoming.modelUsage ?? {}),
+  ]);
+
+  for (const modelId of allModelIds) {
+    const existingModel = existing.modelUsage?.[modelId];
+    const incomingModel = incoming.modelUsage?.[modelId];
+    merged.modelUsage[modelId] = {
+      inputTokens: (existingModel?.inputTokens ?? 0) + (incomingModel?.inputTokens ?? 0),
+      outputTokens: (existingModel?.outputTokens ?? 0) + (incomingModel?.outputTokens ?? 0),
+      cacheReadInputTokens: (existingModel?.cacheReadInputTokens ?? 0) + (incomingModel?.cacheReadInputTokens ?? 0),
+      cacheCreationInputTokens: (existingModel?.cacheCreationInputTokens ?? 0) + (incomingModel?.cacheCreationInputTokens ?? 0),
+      costUsd: mergeCostUsd(existingModel?.costUsd, incomingModel?.costUsd),
+    };
+  }
+
+  return merged;
+}
+
 /**
  * Sum multiple CostBreakdown objects into a single total.
  */
 export function sumCostBreakdowns(costs: CostBreakdown[]): CostBreakdown {
   let totalCost = 0;
   for (const cost of costs) {
+    if (cost.totalCost === null) {
+      return { totalCost: null };
+    }
     totalCost += cost.totalCost;
   }
   return { totalCost };
@@ -32,7 +102,12 @@ export function sumCostBreakdowns(costs: CostBreakdown[]): CostBreakdown {
  * Sums all token fields and merges modelUsage maps.
  */
 export function accumulateUsage(attempts: UsageData[]): UsageData {
-  const result: UsageData = {
+  let result: UsageData | undefined;
+  for (const attempt of attempts) {
+    result = mergeUsageData(result, attempt);
+  }
+
+  return result ?? {
     inputTokens: 0,
     outputTokens: 0,
     cacheReadInputTokens: 0,
@@ -40,32 +115,6 @@ export function accumulateUsage(attempts: UsageData[]): UsageData {
     modelUsage: {},
     totalCostUsd: 0,
   };
-
-  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;
-        existing.costUsd += modelUsage.costUsd;
-      } else {
-        result.modelUsage[modelId] = { ...modelUsage };
-      }
-    }
-
-    // Sum totalCostUsd across attempts
-    result.totalCostUsd += attempt.totalCostUsd;
-  }
-
-  return result;
 }
 
 /**
@@ -85,8 +134,7 @@ export class TokenTracker {
    */
   addTask(taskId: string, attempts: UsageData[]): TaskUsageEntry {
     const usage = accumulateUsage(attempts);
-    // Sum costs from CLI-provided totalCostUsd
-    const totalCost = attempts.reduce((sum, attempt) => sum + attempt.totalCostUsd, 0);
+    const totalCost = usage.totalCostUsd;
     const cost: CostBreakdown = { totalCost };
     const entry: TaskUsageEntry = { taskId, usage, cost, attempts };
     this.entries.push(entry);
@@ -104,43 +152,34 @@ export class TokenTracker {
    * Get accumulated totals across all tasks.
    */
   getTotals(): { usage: UsageData; cost: CostBreakdown } {
-    const totalUsage: UsageData = {
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadInputTokens: 0,
-      cacheCreationInputTokens: 0,
-      modelUsage: {},
-      totalCostUsd: 0,
-    };
+    let totalUsage: UsageData | undefined;
     const totalCost: CostBreakdown = {
       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;
-      totalUsage.totalCostUsd += entry.usage.totalCostUsd;
-
-      // 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;
-          existing.costUsd += modelUsage.costUsd;
+      totalUsage = mergeUsageData(totalUsage, entry.usage);
+
+      if (totalCost.totalCost !== null) {
+        if (entry.cost.totalCost === null) {
+          totalCost.totalCost = null;
         } else {
-          totalUsage.modelUsage[modelId] = { ...modelUsage };
+          totalCost.totalCost += entry.cost.totalCost;
         }
       }
-
-      totalCost.totalCost += entry.cost.totalCost;
     }
 
-    return { usage: totalUsage, cost: totalCost };
+    return {
+      usage: totalUsage ?? {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        modelUsage: {},
+        totalCostUsd: 0,
+      },
+      cost: totalCost,
+    };
   }
 
 }

package/src/utils/validation.ts

@@ -2,9 +2,8 @@ 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 } from '../types/config.js';
-import { getModel, isValidModelName } from './config.js';
+import type { ClaudeModelName } from '../types/config.js';
+import { isValidModelName } from './config.js';
 
 export interface ValidationResult {
   valid: boolean;
@@ -19,12 +18,12 @@ export function validateEnvironment(): ValidationResult {
     errors: [],
   };
 
-  // Check CLI provider is installed
+  // Check that at least one supported CLI harness is installed
   try {
-    execSync('which claude', { encoding: 'utf-8', stdio: 'pipe' });
+    execSync('which claude || which codex', { encoding: 'utf-8', stdio: 'pipe' });
   } catch {
     result.valid = false;
-    result.errors.push('CLI provider not found. Please install Claude CLI or Codex CLI first.');
+    result.errors.push('CLI harness not found. Please install Claude CLI or Codex CLI first.');
   }
 
   // Check for git repo (warning only)
@@ -101,27 +100,3 @@ export function validateModelName(model: string): ClaudeModelName | null {
   }
   return null;
 }
-
-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');
-  }
-
-  // --sonnet shorthand
-  if (sonnet) {
-    return 'sonnet';
-  }
-
-  // --model flag
-  if (model) {
-    const validated = validateModelName(model);
-    if (!validated) {
-      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), or harness-prefixed (e.g., codex/gpt-5.4)`);
-    }
-    return validated;
-  }
-
-  // Default from config
-  return getModel(scenario);
-}

package/tests/unit/amend-prompt.test.ts

@@ -65,7 +65,7 @@ describe('Amend Prompt', () => {
       expect(systemPrompt).not.toContain('--worktree');
     });
 
-    it('should show raf do with --worktree when worktreeMode is true', () => {
+    it('should show raf do without --worktree when worktreeMode is true', () => {
       const params: AmendPromptParams = {
         ...baseParams,
         worktreeMode: true,
@@ -73,7 +73,8 @@ describe('Amend Prompt', () => {
 
       const { systemPrompt } = getAmendPrompt(params);
 
-      expect(systemPrompt).toContain('raf do <project> --worktree');
+      expect(systemPrompt).toContain('raf do <project>');
+      expect(systemPrompt).not.toContain('--worktree');
     });
 
     it('should include new task description in user message', () => {

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

@@ -1,5 +1,16 @@
 import { jest } from '@jest/globals';
 import { EventEmitter } from 'events';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const suiteHomeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-claude-home-'));
+let mockHomeDir = suiteHomeDir;
+
+jest.unstable_mockModule('node:os', () => ({
+  homedir: () => mockHomeDir,
+  tmpdir: () => os.tmpdir(),
+}));
 
 // Create mock pty spawn before importing ClaudeRunner
 const mockPtySpawn = jest.fn();
@@ -16,6 +27,7 @@ jest.unstable_mockModule('node:child_process', () => ({
 
 // Import after mocking
 const { ClaudeRunner } = await import('../../src/core/claude-runner.js');
+const { getModel, resetConfigCache } = await import('../../src/utils/config.js');
 
 describe('ClaudeRunner - runInteractive', () => {
   // Save original stdin/stdout for restoration
@@ -24,15 +36,22 @@ describe('ClaudeRunner - runInteractive', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    fs.rmSync(path.join(mockHomeDir, '.raf'), { recursive: true, force: true });
+    resetConfigCache();
     mockExecSync.mockReturnValue('/usr/local/bin/claude\n');
   });
 
   afterEach(() => {
+    resetConfigCache();
     // Restore stdin/stdout
     Object.defineProperty(process, 'stdin', { value: originalStdin });
     Object.defineProperty(process, 'stdout', { value: originalStdout });
   });
 
+  afterAll(() => {
+    fs.rmSync(suiteHomeDir, { recursive: true, force: true });
+  });
+
   /**
    * Creates a mock PTY process for testing.
    */
@@ -129,7 +148,7 @@ describe('ClaudeRunner - runInteractive', () => {
       await runPromise;
     });
 
-    it('should use opus as default model', async () => {
+    it('should use the configured execute model by default', async () => {
       const mockProc = createMockPtyProcess();
       const mockStdin = createMockStdin();
       const mockStdout = createMockStdout();
@@ -144,9 +163,8 @@ describe('ClaudeRunner - runInteractive', () => {
 
       const spawnArgs = mockPtySpawn.mock.calls[0][1] as string[];
       expect(spawnArgs).toContain('--model');
-      // Default model comes from config, could be short alias or full model ID
       const modelArgIndex = spawnArgs.indexOf('--model');
-      expect(spawnArgs[modelArgIndex + 1]).toMatch(/^(opus|sonnet|haiku|claude-(opus|sonnet|haiku)-.+)$/);
+      expect(spawnArgs[modelArgIndex + 1]).toBe(getModel('execute').model);
 
       mockProc._exitCallback({ exitCode: 0 });
       await runPromise;

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

@@ -762,6 +762,45 @@ describe('ClaudeRunner', () => {
       expect(result.usageData!.outputTokens).toBe(800);
     });
 
+    it('should accumulate usageData across multiple result events', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const firstResultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 1000, output_tokens: 500, cache_read_input_tokens: 100, cache_creation_input_tokens: 50 },
+        modelUsage: { 'claude-opus-4-6': { inputTokens: 1000, outputTokens: 500, cacheReadInputTokens: 100, cacheCreationInputTokens: 50 } },
+        total_cost_usd: 2.5,
+      });
+      const secondResultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 600, output_tokens: 300, cache_read_input_tokens: 40, cache_creation_input_tokens: 20 },
+        modelUsage: { 'claude-opus-4-6': { inputTokens: 600, outputTokens: 300, cacheReadInputTokens: 40, cacheCreationInputTokens: 20 } },
+        total_cost_usd: 1.5,
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(firstResultEvent + '\n' + secondResultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(1600);
+      expect(result.usageData!.outputTokens).toBe(800);
+      expect(result.usageData!.cacheReadInputTokens).toBe(140);
+      expect(result.usageData!.cacheCreationInputTokens).toBe(70);
+      expect(result.usageData!.totalCostUsd).toBe(4);
+      expect(result.usageData!.modelUsage['claude-opus-4-6']).toEqual({
+        inputTokens: 1600,
+        outputTokens: 800,
+        cacheReadInputTokens: 140,
+        cacheCreationInputTokens: 70,
+        costUsd: 0,
+      });
+    });
+
     it('should return undefined usageData when no result event', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);

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

@@ -0,0 +1,163 @@
+import { jest } from '@jest/globals';
+import { EventEmitter } from 'events';
+
+const mockSpawn = jest.fn();
+const mockExecSync = jest.fn();
+
+const mockExistsSync = jest.fn();
+const mockStatSync = jest.fn();
+const mockReadFileSync = jest.fn();
+
+const mockGetHeadCommitHash = jest.fn();
+const mockGetHeadCommitMessage = jest.fn();
+const mockIsFileCommittedInHead = jest.fn();
+
+jest.unstable_mockModule('node:child_process', () => ({
+  spawn: mockSpawn,
+  execSync: mockExecSync,
+}));
+
+jest.unstable_mockModule('node-pty', () => ({
+  spawn: jest.fn(),
+}));
+
+jest.unstable_mockModule('node:fs', () => ({
+  default: {
+    existsSync: mockExistsSync,
+    statSync: mockStatSync,
+    readFileSync: mockReadFileSync,
+  },
+  existsSync: mockExistsSync,
+  statSync: mockStatSync,
+  readFileSync: mockReadFileSync,
+}));
+
+jest.unstable_mockModule('../../src/core/git.js', () => ({
+  getHeadCommitHash: mockGetHeadCommitHash,
+  getHeadCommitMessage: mockGetHeadCommitMessage,
+  isFileCommittedInHead: mockIsFileCommittedInHead,
+}));
+
+const { CodexRunner } = await import('../../src/core/codex-runner.js');
+
+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().mockImplementation(() => {
+    setImmediate(() => proc.emit('close', 1));
+  });
+  return proc;
+}
+
+describe('CodexRunner', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockExecSync.mockReturnValue('/usr/local/bin/codex\n');
+    mockExistsSync.mockReturnValue(false);
+  });
+
+  it('returns usageData from run() when turn.completed includes usage', async () => {
+    const mockProc = createMockProcess();
+    mockSpawn.mockReturnValue(mockProc);
+
+    const runner = new CodexRunner({ model: 'gpt-5.4' });
+    const runPromise = runner.run('test prompt');
+
+    mockProc.stdout.emit('data', Buffer.from(`${JSON.stringify({
+      type: 'turn.completed',
+      model: 'gpt-5.4',
+      usage: {
+        input_tokens: 1000,
+        output_tokens: 250,
+      },
+    })}\n`));
+    mockProc.emit('close', 0);
+
+    const result = await runPromise;
+    expect(result.usageData).toEqual({
+      inputTokens: 1000,
+      outputTokens: 250,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {
+        'gpt-5.4': {
+          inputTokens: 1000,
+          outputTokens: 250,
+          cacheReadInputTokens: 0,
+          cacheCreationInputTokens: 0,
+          costUsd: null,
+        },
+      },
+      totalCostUsd: null,
+    });
+  });
+
+  it('accumulates usageData across multiple turn.completed events', async () => {
+    const mockProc = createMockProcess();
+    mockSpawn.mockReturnValue(mockProc);
+
+    const runner = new CodexRunner({ model: 'gpt-5.4' });
+    const runPromise = runner.run('test prompt');
+
+    const firstTurn = JSON.stringify({
+      type: 'turn.completed',
+      model: 'gpt-5.4',
+      usage: {
+        input_tokens: 1000,
+        output_tokens: 250,
+      },
+    });
+    const secondTurn = JSON.stringify({
+      type: 'turn.completed',
+      model: 'gpt-5.4',
+      usage: {
+        input_tokens: 500,
+        output_tokens: 150,
+      },
+    });
+
+    mockProc.stdout.emit('data', Buffer.from(firstTurn + '\n' + secondTurn + '\n'));
+    mockProc.emit('close', 0);
+
+    const result = await runPromise;
+    expect(result.usageData).toEqual({
+      inputTokens: 1500,
+      outputTokens: 400,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {
+        'gpt-5.4': {
+          inputTokens: 1500,
+          outputTokens: 400,
+          cacheReadInputTokens: 0,
+          cacheCreationInputTokens: 0,
+          costUsd: null,
+        },
+      },
+      totalCostUsd: null,
+    });
+  });
+
+  it('returns undefined usageData when no turn.completed usage event is present', async () => {
+    const mockProc = createMockProcess();
+    mockSpawn.mockReturnValue(mockProc);
+
+    const runner = new CodexRunner({ model: 'gpt-5.4' });
+    const runPromise = runner.run('test prompt');
+
+    mockProc.stdout.emit('data', Buffer.from(`${JSON.stringify({
+      type: 'item.completed',
+      item: {
+        type: 'agent_message',
+        text: 'Done.',
+      },
+    })}\n`));
+    mockProc.emit('close', 0);
+
+    const result = await runPromise;
+    expect(result.usageData).toBeUndefined();
+  });
+});