rafcode 2.2.0 → 2.4.0

package/src/utils/session-parser.ts

@@ -0,0 +1,161 @@
+/**
+ * Utilities for parsing Claude CLI session files to extract token usage data.
+ * Claude CLI saves session data to ~/.claude/projects/<escaped-path>/<session-id>.jsonl
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { UsageData } from '../types/config.js';
+
+/** Raw usage structure from Claude session JSONL assistant message entries. */
+interface SessionMessageUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+}
+
+/** Structure of an assistant message entry in the session JSONL. */
+interface SessionMessageEntry {
+  type: 'assistant';
+  message?: {
+    usage?: SessionMessageUsage;
+    model?: string;
+  };
+  costUSD?: number;
+}
+
+/** Result of parsing a session file. */
+export interface SessionParseResult {
+  /** Accumulated usage data from all assistant messages. */
+  usage: UsageData;
+  /** Whether parsing was successful. */
+  success: boolean;
+  /** Error message if parsing failed. */
+  error?: string;
+}
+
+/**
+ * Escape a path for use in Claude's project directory naming scheme.
+ * Claude escapes `/` to `-` in project paths.
+ */
+export function escapeProjectPath(projectPath: string): string {
+  // Remove leading slash and replace remaining slashes with dashes
+  return projectPath.replace(/^\//, '').replace(/\//g, '-');
+}
+
+/**
+ * Compute the expected session file path for a given session ID and working directory.
+ *
+ * @param sessionId - The UUID session ID passed to --session-id
+ * @param cwd - The working directory where Claude was run (project path)
+ * @returns The expected path to the session JSONL file
+ */
+export function getSessionFilePath(sessionId: string, cwd: string): string {
+  const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+  const escapedPath = escapeProjectPath(cwd);
+  return path.join(claudeDir, escapedPath, `${sessionId}.jsonl`);
+}
+
+/**
+ * Parse a Claude session JSONL file and extract accumulated token usage data.
+ *
+ * @param sessionFilePath - Path to the session JSONL file
+ * @returns Parsed usage data or error information
+ */
+export function parseSessionFile(sessionFilePath: string): SessionParseResult {
+  const emptyUsage: UsageData = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    modelUsage: {},
+  };
+
+  if (!fs.existsSync(sessionFilePath)) {
+    return {
+      usage: emptyUsage,
+      success: false,
+      error: `Session file not found: ${sessionFilePath}`,
+    };
+  }
+
+  try {
+    const content = fs.readFileSync(sessionFilePath, 'utf-8');
+    const lines = content.trim().split('\n').filter(line => line.trim());
+
+    const accumulated: UsageData = { ...emptyUsage, modelUsage: {} };
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line) as Record<string, unknown>;
+
+        // Only process assistant message entries
+        if (entry.type !== 'assistant') continue;
+
+        const assistantEntry = entry as unknown as SessionMessageEntry;
+        const usage = assistantEntry.message?.usage;
+        const model = assistantEntry.message?.model;
+
+        if (!usage) continue;
+
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+        const cacheCreateTokens = usage.cache_creation_input_tokens ?? 0;
+
+        // Accumulate aggregate totals
+        accumulated.inputTokens += inputTokens;
+        accumulated.outputTokens += outputTokens;
+        accumulated.cacheReadInputTokens += cacheReadTokens;
+        accumulated.cacheCreationInputTokens += cacheCreateTokens;
+
+        // Accumulate per-model usage
+        if (model) {
+          const existing = accumulated.modelUsage[model];
+          if (existing) {
+            existing.inputTokens += inputTokens;
+            existing.outputTokens += outputTokens;
+            existing.cacheReadInputTokens += cacheReadTokens;
+            existing.cacheCreationInputTokens += cacheCreateTokens;
+          } else {
+            accumulated.modelUsage[model] = {
+              inputTokens,
+              outputTokens,
+              cacheReadInputTokens: cacheReadTokens,
+              cacheCreationInputTokens: cacheCreateTokens,
+            };
+          }
+        }
+      } catch {
+        // Skip malformed lines
+        continue;
+      }
+    }
+
+    return {
+      usage: accumulated,
+      success: true,
+    };
+  } catch (error) {
+    return {
+      usage: emptyUsage,
+      success: false,
+      error: `Failed to parse session file: ${error}`,
+    };
+  }
+}
+
+/**
+ * Parse a Claude session by session ID and working directory.
+ * Convenience wrapper around getSessionFilePath + parseSessionFile.
+ *
+ * @param sessionId - The UUID session ID passed to --session-id
+ * @param cwd - The working directory where Claude was run
+ * @returns Parsed usage data or error information
+ */
+export function parseSessionById(sessionId: string, cwd: string): SessionParseResult {
+  const filePath = getSessionFilePath(sessionId, cwd);
+  return parseSessionFile(filePath);
+}

package/src/utils/terminal-symbols.ts

@@ -5,7 +5,17 @@
 
 import { formatElapsedTime } from './timer.js';
 import type { UsageData } from '../types/config.js';
-import type { CostBreakdown } from './token-tracker.js';
+import type { CostBreakdown, TaskUsageEntry } from './token-tracker.js';
+
+/** Options for token summary formatting. */
+export interface TokenSummaryOptions {
+  /** Whether to show cache token counts. Default: true */
+  showCacheTokens?: boolean;
+  /** Whether to show rate limit percentage. Default: true */
+  showRateLimitEstimate?: boolean;
+  /** Rate limit percentage to display (requires showRateLimitEstimate: true) */
+  rateLimitPercentage?: number;
+}
 
 /**
  * Visual symbols for terminal output using dots/symbols style.
@@ -146,39 +156,112 @@ export function formatCost(cost: number): string {
 }
 
 /**
- * Formats a per-task token usage summary line.
- * Example: "  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42"
+ * Formats a rate limit percentage for display.
+ * Uses tilde (~) prefix to indicate estimate.
+ */
+export function formatRateLimitPercentage(percentage: number): string {
+  if (percentage === 0) return '~0% of 5h window';
+  if (percentage < 0.1) return `~${percentage.toFixed(2)}% of 5h window`;
+  if (percentage < 1) return `~${percentage.toFixed(1)}% of 5h window`;
+  return `~${Math.round(percentage)}% of 5h window`;
+}
+
+/**
+ * Formats a single line of token usage (for a single attempt or total).
+ * Used internally by formatTaskTokenSummary.
  */
-export function formatTaskTokenSummary(usage: UsageData, cost: CostBreakdown): string {
+function formatTokenLine(
+  usage: UsageData,
+  costValue: number,
+  prefix: string = '',
+  indent: string = '  ',
+  options: TokenSummaryOptions = {}
+): string {
+  const { showCacheTokens = true, showRateLimitEstimate = false, rateLimitPercentage } = options;
   const parts: string[] = [];
-  parts.push(`Tokens: ${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`);
-
-  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`);
+  const tokenPart = `${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`;
+  parts.push(prefix ? `${prefix}: ${tokenPart}` : `Tokens: ${tokenPart}`);
+
+  if (showCacheTokens) {
+    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(cost.totalCost)}`);
-  return `  ${parts.join(' | ')}`;
+  parts.push(`Est. cost: ${formatCost(costValue)}`);
+
+  if (showRateLimitEstimate && rateLimitPercentage !== undefined) {
+    parts.push(formatRateLimitPercentage(rateLimitPercentage));
+  }
+
+  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 | ~2% of 5h window"
+ * 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
+ * @param options - Display options for showing cache tokens and rate limit percentage
+ */
+export function formatTaskTokenSummary(
+  entry: TaskUsageEntry,
+  calculateAttemptCost?: (usage: UsageData) => CostBreakdown,
+  options: TokenSummaryOptions = {}
+): string {
+  // Single-attempt: render exactly as before (no per-attempt breakdown)
+  if (entry.attempts.length <= 1) {
+    return formatTokenLine(entry.usage, entry.cost.totalCost, '', '  ', options);
+  }
+
+  // Multi-attempt: show per-attempt lines plus total
+  // Per-attempt lines don't show rate limit (only show on total)
+  const perAttemptOptions: TokenSummaryOptions = {
+    ...options,
+    showRateLimitEstimate: false,
+    rateLimitPercentage: undefined,
+  };
+
+  const lines: string[] = [];
+  entry.attempts.forEach((attemptUsage, i) => {
+    const attemptCost = calculateAttemptCost
+      ? calculateAttemptCost(attemptUsage).totalCost
+      : 0;
+    lines.push(formatTokenLine(attemptUsage, attemptCost, `Attempt ${i + 1}`, '    ', perAttemptOptions));
+  });
+  lines.push(formatTokenLine(entry.usage, entry.cost.totalCost, 'Total', '    ', options));
+  return lines.join('\n');
 }
 
 /**
  * Formats the grand total token usage summary block.
  * Displayed after all tasks complete.
+ *
+ * @param usage - Total usage data
+ * @param cost - Total cost breakdown
+ * @param options - Display options for cache tokens and rate limit
  */
-export function formatTokenTotalSummary(usage: UsageData, cost: CostBreakdown): string {
+export function formatTokenTotalSummary(
+  usage: UsageData,
+  cost: CostBreakdown,
+  options: TokenSummaryOptions = {}
+): string {
+  const { showCacheTokens = true, showRateLimitEstimate = false, rateLimitPercentage } = options;
   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) {
+  if (showCacheTokens && (usage.cacheReadInputTokens > 0 || usage.cacheCreationInputTokens > 0)) {
     const cacheParts: string[] = [];
     if (usage.cacheReadInputTokens > 0) {
       cacheParts.push(`${formatNumber(usage.cacheReadInputTokens)} read`);
@@ -190,6 +273,10 @@ export function formatTokenTotalSummary(usage: UsageData, cost: CostBreakdown):
   }
 
   lines.push(`Estimated cost: ${formatCost(cost.totalCost)}`);
+
+  if (showRateLimitEstimate && rateLimitPercentage !== undefined) {
+    lines.push(formatRateLimitPercentage(rateLimitPercentage));
+  }
   lines.push('─────────────────────────────────────────');
   return lines.join('\n');
 }

package/src/utils/token-tracker.ts

@@ -1,5 +1,5 @@
 import { UsageData, PricingConfig } from '../types/config.js';
-import { resolveModelPricingCategory, getPricingConfig } from './config.js';
+import { resolveModelPricingCategory, getPricingConfig, getRateLimitWindowConfig } from './config.js';
 
 /** Cost breakdown for a single task or accumulated total. */
 export interface CostBreakdown {
@@ -13,8 +13,71 @@ export interface CostBreakdown {
 /** 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[];
+}
+
+/**
+ * Sum multiple CostBreakdown objects into a single total.
+ */
+export function sumCostBreakdowns(costs: CostBreakdown[]): CostBreakdown {
+  const result: CostBreakdown = {
+    inputCost: 0,
+    outputCost: 0,
+    cacheReadCost: 0,
+    cacheCreateCost: 0,
+    totalCost: 0,
+  };
+
+  for (const cost of costs) {
+    result.inputCost += cost.inputCost;
+    result.outputCost += cost.outputCost;
+    result.cacheReadCost += cost.cacheReadCost;
+    result.cacheCreateCost += cost.cacheCreateCost;
+    result.totalCost += cost.totalCost;
+  }
+
+  return result;
+}
+
+/**
+ * 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;
 }
 
 /**
@@ -31,10 +94,17 @@ export class TokenTracker {
 
   /**
    * Record usage data from a completed task.
+   * Accepts an array of UsageData (one per attempt) and accumulates them.
+   * Cost is calculated per-attempt to avoid underreporting when some attempts
+   * have modelUsage and others only have aggregate fields.
    */
-  addTask(taskId: string, usage: UsageData): TaskUsageEntry {
-    const cost = this.calculateCost(usage);
-    const entry: TaskUsageEntry = { taskId, usage, cost };
+  addTask(taskId: string, attempts: UsageData[]): TaskUsageEntry {
+    const usage = accumulateUsage(attempts);
+    // Calculate cost per-attempt, then sum. This ensures attempts with only
+    // aggregate fields use sonnet fallback pricing independently.
+    const perAttemptCosts = attempts.map((attempt) => this.calculateCost(attempt));
+    const cost = sumCostBreakdowns(perAttemptCosts);
+    const entry: TaskUsageEntry = { taskId, usage, cost, attempts };
     this.entries.push(entry);
     return entry;
   }
@@ -132,4 +202,39 @@ export class TokenTracker {
     result.totalCost = result.inputCost + result.outputCost + result.cacheReadCost + result.cacheCreateCost;
     return result;
   }
+
+  /**
+   * Calculate the 5h rate limit window percentage for a given cost.
+   * Converts cost to Sonnet-equivalent tokens using the configured Sonnet pricing,
+   * then divides by the configured cap.
+   *
+   * @param totalCost - The total cost in dollars
+   * @param sonnetTokenCap - Optional override for the Sonnet-equivalent token cap (defaults to config value)
+   * @returns The percentage of the 5h window consumed (0-100+)
+   */
+  calculateRateLimitPercentage(totalCost: number, sonnetTokenCap?: number): number {
+    if (totalCost === 0) return 0;
+
+    // Get the configured cap or use the provided override
+    const cap = sonnetTokenCap ?? getRateLimitWindowConfig().sonnetTokenCap;
+
+    // Calculate the average Sonnet cost per token
+    // Using the average of input and output pricing (simplified approach)
+    const sonnetPricing = this.pricingConfig.sonnet;
+    const avgSonnetCostPerToken = (sonnetPricing.inputPerMTok + sonnetPricing.outputPerMTok) / 2 / 1_000_000;
+
+    // Convert cost to Sonnet-equivalent tokens
+    const sonnetEquivalentTokens = totalCost / avgSonnetCostPerToken;
+
+    // Calculate percentage
+    return (sonnetEquivalentTokens / cap) * 100;
+  }
+
+  /**
+   * Get the cumulative 5h window percentage across all recorded tasks.
+   */
+  getCumulativeRateLimitPercentage(sonnetTokenCap?: number): number {
+    const totals = this.getTotals();
+    return this.calculateRateLimitPercentage(totals.cost.totalCost, sonnetTokenCap);
+  }
 }

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

@@ -144,7 +144,9 @@ describe('ClaudeRunner - runInteractive', () => {
 
       const spawnArgs = mockPtySpawn.mock.calls[0][1] as string[];
       expect(spawnArgs).toContain('--model');
-      expect(spawnArgs).toContain('opus');
+      // 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)-.+)$/);
 
       mockProc._exitCallback({ exitCode: 0 });
       await runPromise;
@@ -244,8 +246,8 @@ describe('ClaudeRunner - runInteractive', () => {
     });
   });
 
-  describe('effort level (not applied in interactive mode)', () => {
-    it('should NOT set CLAUDE_CODE_EFFORT_LEVEL in runInteractive env', async () => {
+  describe('environment passing', () => {
+    it('should pass process.env to pty spawn in runInteractive', async () => {
       const mockProc = createMockPtyProcess();
       const mockStdin = createMockStdin();
       const mockStdout = createMockStdout();
@@ -256,12 +258,12 @@ describe('ClaudeRunner - runInteractive', () => {
       mockPtySpawn.mockReturnValue(mockProc);
 
       const runner = new ClaudeRunner();
-      // Even if effortLevel were somehow passed, interactive mode should use process.env as-is
       const runPromise = runner.runInteractive('system', 'user');
 
       const spawnOptions = mockPtySpawn.mock.calls[0][2];
-      // Interactive mode passes process.env directly, no effort level override
-      expect(spawnOptions.env).not.toHaveProperty('CLAUDE_CODE_EFFORT_LEVEL');
+      // Interactive mode passes process.env directly
+      // Note: effortLevel option was removed from ClaudeRunner in favor of per-task model resolution
+      expect(spawnOptions.env).toBeDefined();
 
       mockProc._exitCallback({ exitCode: 0 });
       await runPromise;

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

@@ -473,7 +473,9 @@ describe('ClaudeRunner', () => {
     });
   });
 
-  describe('effort level', () => {
+  // Note: effortLevel option was removed from ClaudeRunner in favor of per-task model resolution
+  // via plan frontmatter. See effortMapping config and frontmatter.ts for the new approach.
+  describe('environment handling', () => {
     function createMockProcess() {
       const stdout = new EventEmitter();
       const stderr = new EventEmitter();
@@ -484,35 +486,7 @@ describe('ClaudeRunner', () => {
       return proc;
     }
 
-    it('should set CLAUDE_CODE_EFFORT_LEVEL env var in run() when effortLevel is provided', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.run('test prompt', { timeout: 60, effortLevel: 'medium' });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnOptions = mockSpawn.mock.calls[0][2];
-      expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe('medium');
-    });
-
-    it('should set CLAUDE_CODE_EFFORT_LEVEL env var in runVerbose() when effortLevel is provided', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.runVerbose('test prompt', { timeout: 60, effortLevel: 'medium' });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnOptions = mockSpawn.mock.calls[0][2];
-      expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe('medium');
-    });
-
-    it('should NOT set CLAUDE_CODE_EFFORT_LEVEL when effortLevel is not provided in run()', async () => {
+    it('should pass process.env to child process in run()', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -523,11 +497,10 @@ describe('ClaudeRunner', () => {
       await runPromise;
 
       const spawnOptions = mockSpawn.mock.calls[0][2];
-      // env should be process.env directly (no CLAUDE_CODE_EFFORT_LEVEL override)
       expect(spawnOptions.env).toBe(process.env);
     });
 
-    it('should NOT set CLAUDE_CODE_EFFORT_LEVEL when effortLevel is not provided in runVerbose()', async () => {
+    it('should pass process.env to child process in runVerbose()', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -538,42 +511,8 @@ describe('ClaudeRunner', () => {
       await runPromise;
 
       const spawnOptions = mockSpawn.mock.calls[0][2];
-      // env should be process.env directly (no CLAUDE_CODE_EFFORT_LEVEL override)
       expect(spawnOptions.env).toBe(process.env);
     });
-
-    it('should support different effort levels', async () => {
-      for (const level of ['low', 'medium', 'high'] as const) {
-        const mockProc = createMockProcess();
-        mockSpawn.mockReturnValue(mockProc);
-
-        const runner = new ClaudeRunner();
-        const runPromise = runner.run('test prompt', { timeout: 60, effortLevel: level });
-
-        mockProc.emit('close', 0);
-        await runPromise;
-
-        const spawnOptions = mockSpawn.mock.calls[mockSpawn.mock.calls.length - 1][2];
-        expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe(level);
-      }
-    });
-
-    it('should preserve other env vars when effortLevel is set', async () => {
-      const mockProc = createMockProcess();
-      mockSpawn.mockReturnValue(mockProc);
-
-      const runner = new ClaudeRunner();
-      const runPromise = runner.run('test prompt', { timeout: 60, effortLevel: 'medium' });
-
-      mockProc.emit('close', 0);
-      await runPromise;
-
-      const spawnOptions = mockSpawn.mock.calls[0][2];
-      // Should have PATH from process.env
-      expect(spawnOptions.env.PATH).toBe(process.env.PATH);
-      // And the injected effort level
-      expect(spawnOptions.env.CLAUDE_CODE_EFFORT_LEVEL).toBe('medium');
-    });
   });
 
   describe('system prompt append flag', () => {