rafcode 2.3.0 → 2.4.1-0

package/src/utils/terminal-symbols.ts

@@ -7,6 +7,16 @@ import { formatElapsedTime } from './timer.js';
 import type { UsageData } from '../types/config.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.
  */
@@ -145,6 +155,17 @@ export function formatCost(cost: number): string {
   return `$${cost.toFixed(2)}`;
 }
 
+/**
+ * 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.
@@ -153,67 +174,94 @@ function formatTokenLine(
   usage: UsageData,
   costValue: number,
   prefix: string = '',
-  indent: string = '  '
+  indent: string = '  ',
+  options: TokenSummaryOptions = {}
 ): string {
+  const { showCacheTokens = true, showRateLimitEstimate = true, rateLimitPercentage } = options;
   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`);
+  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(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"
+ * 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
+  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);
+    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}`, '    '));
+    lines.push(formatTokenLine(attemptUsage, attemptCost, `Attempt ${i + 1}`, '    ', perAttemptOptions));
   });
-  lines.push(formatTokenLine(entry.usage, entry.cost.totalCost, 'Total', '    '));
+  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 = true, 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`);
@@ -225,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 {
@@ -21,6 +21,29 @@ export interface TaskUsageEntry {
   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.
@@ -72,10 +95,15 @@ 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, attempts: UsageData[]): TaskUsageEntry {
     const usage = accumulateUsage(attempts);
-    const cost = this.calculateCost(usage);
+    // 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;
@@ -174,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', () => {

package/tests/unit/commit-planning-artifacts-worktree.test.ts

@@ -162,13 +162,9 @@ describe('commitPlanningArtifacts - worktree integration', () => {
       '# Task: New Task'
     );
 
-    // Call commitPlanningArtifacts with additional files
-    const additionalFiles = [
-      path.join(wtProjectPath, 'plans', '02-new-task.md'),
-    ];
+    // Call commitPlanningArtifacts (plan files not included in amend commit)
     await commitPlanningArtifacts(wtProjectPath, {
       cwd: worktreePath,
-      additionalFiles,
       isAmend: true,
     });
 
@@ -176,11 +172,11 @@ describe('commitPlanningArtifacts - worktree integration', () => {
     const lastMsg = getLastCommitMessage(worktreePath);
     expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
 
-    // Verify all three files are in the commit
+    // Verify only input.md and decisions.md are in the commit (not plan files)
     const committedFiles = getLastCommitFiles(worktreePath);
     expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
     expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
-    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+    expect(committedFiles).not.toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
   });
 
   it('should commit after worktree recreation from branch', async () => {
@@ -234,13 +230,9 @@ describe('commitPlanningArtifacts - worktree integration', () => {
       '# Task: New Task'
     );
 
-    // Call commitPlanningArtifacts with worktree cwd
-    const additionalFiles = [
-      path.join(recreatedProjectPath, 'plans', '02-new-task.md'),
-    ];
+    // Call commitPlanningArtifacts (plan files not included in amend commit)
     await commitPlanningArtifacts(recreatedProjectPath, {
       cwd: recreatedWtPath,
-      additionalFiles,
       isAmend: true,
     });
 
@@ -248,11 +240,11 @@ describe('commitPlanningArtifacts - worktree integration', () => {
     const lastMsg = getLastCommitMessage(recreatedWtPath);
     expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
 
-    // Verify all files are in the commit
+    // Verify only input.md and decisions.md are in the commit (not plan files)
     const committedFiles = getLastCommitFiles(recreatedWtPath);
     expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
     expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
-    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+    expect(committedFiles).not.toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
   });
 
   it('should work when only some files have changed', async () => {

package/tests/unit/commit-planning-artifacts.test.ts

@@ -252,7 +252,7 @@ describe('commitPlanningArtifacts', () => {
     );
   });
 
-  it('should stage additional files when provided', async () => {
+  it('should not stage plan files in amend mode', async () => {
     mockExecSync.mockImplementation((cmd: unknown) => {
       const cmdStr = cmd as string;
       if (cmdStr.includes('rev-parse')) {
@@ -262,32 +262,24 @@ describe('commitPlanningArtifacts', () => {
         return '';
       }
       if (cmdStr.includes('git diff --cached')) {
-        return 'RAF/aaaaar-decision-vault/input.md\nRAF/aaaaar-decision-vault/plans/04-new-task.md\n';
+        return 'RAF/aaaaar-decision-vault/input.md\n';
       }
       return '';
     });
 
-    const additionalFiles = [
-      '/Users/test/RAF/aaaaar-decision-vault/plans/04-new-task.md',
-      '/Users/test/RAF/aaaaar-decision-vault/plans/05-another-task.md',
-    ];
-
     await commitPlanningArtifacts('/Users/test/RAF/aaaaar-decision-vault', {
-      additionalFiles,
       isAmend: true,
     });
 
-    // Verify git add called for all 4 files (input, decisions, 2 plans)
+    // Verify git add called for only 2 files (input, decisions)
     const addCalls = mockExecSync.mock.calls.filter(
       (call) => (call[0] as string).includes('git add')
     );
-    expect(addCalls.length).toBe(4);
+    expect(addCalls.length).toBe(2);
 
     const addCmds = addCalls.map((c) => c[0] as string);
     expect(addCmds.some((cmd) => cmd.includes('input.md'))).toBe(true);
     expect(addCmds.some((cmd) => cmd.includes('decisions.md'))).toBe(true);
-    expect(addCmds.some((cmd) => cmd.includes('04-new-task.md'))).toBe(true);
-    expect(addCmds.some((cmd) => cmd.includes('05-another-task.md'))).toBe(true);
   });
 
   it('should pass cwd to isGitRepo for worktree support', async () => {