rafcode 2.4.1-0 → 2.5.0-0

package/src/prompts/config-docs.md

@@ -135,49 +135,12 @@ Controls the format of git commit messages. Templates use `{placeholder}` syntax
 
 Unknown placeholders are left as-is in the output.
 
-### `pricing` — Token Cost Pricing
-
-Controls per-model token pricing used for cost estimation. Prices are in dollars per million tokens. Each model category (`opus`, `sonnet`, `haiku`) has four pricing fields:
-
-| Field | Description |
-|-------|-------------|
-| `inputPerMTok` | Cost per million input tokens |
-| `outputPerMTok` | Cost per million output tokens |
-| `cacheReadPerMTok` | Cost per million cache read tokens (discounted) |
-| `cacheCreatePerMTok` | Cost per million cache creation tokens |
-
-**Default values:**
-
-| Category | Input | Output | Cache Read | Cache Create |
-|----------|-------|--------|------------|--------------|
-| `opus` | $15 | $75 | $1.50 | $18.75 |
-| `sonnet` | $3 | $15 | $0.30 | $3.75 |
-| `haiku` | $1 | $5 | $0.10 | $1.25 |
-
-Full model IDs from CLI output (e.g., `claude-opus-4-6`) are automatically mapped to the corresponding pricing category based on the model family name.
-
-Example override:
-
-```json
-{
-  "pricing": {
-    "opus": {
-      "inputPerMTok": 10,
-      "outputPerMTok": 50
-    }
-  }
-}
-```
-
-Only specify the fields you want to change — unset fields keep their defaults.
-
 ### `display` — Token Summary Display Options
 
 Controls what information is shown in token usage summaries after tasks and in the grand total.
 
 | Key | Default | Description |
 |-----|---------|-------------|
-| `display.showRateLimitEstimate` | `true` | Show estimated 5h rate limit window percentage (e.g., `~42% of 5h window`) |
 | `display.showCacheTokens` | `true` | Show cache read/create token counts in summaries |
 
 Example:
@@ -185,34 +148,11 @@ Example:
 ```json
 {
   "display": {
-    "showRateLimitEstimate": false,
     "showCacheTokens": true
   }
 }
 ```
 
-### `rateLimitWindow` — Rate Limit Configuration
-
-Controls the rate limit estimation calculation.
-
-| Key | Default | Description |
-|-----|---------|-------------|
-| `rateLimitWindow.sonnetTokenCap` | `88000` | The Sonnet-equivalent token cap for the 5-hour window. All token usage is normalized to Sonnet-equivalent tokens using pricing ratios. |
-
-The 5h window percentage is calculated as: `(estimatedCost / sonnetCostPerToken) / sonnetTokenCap * 100`
-
-Where `sonnetCostPerToken` is derived from the configured Sonnet pricing. Heavier models (Opus) consume the window faster than lighter ones (Haiku) in proportion to their API pricing ratios.
-
-Example:
-
-```json
-{
-  "rateLimitWindow": {
-    "sonnetTokenCap": 100000
-  }
-}
-```
-
 ## Validation Rules
 
 The config is validated when loaded. Invalid configs cause an error with a descriptive message. The following rules are enforced:
@@ -224,9 +164,7 @@ The config is validated when loaded. Invalid configs cause an error with a descr
 - **`maxRetries`** must be a non-negative integer.
 - **`autoCommit`**, **`worktree`**, and **`syncMainBranch`** must be booleans.
 - **`commitFormat` values** must be strings.
-- **`pricing`** categories must be `"opus"`, `"sonnet"`, or `"haiku"`. Each field must be a non-negative number.
-- **`display` values** (`showRateLimitEstimate`, `showCacheTokens`) must be booleans.
-- **`rateLimitWindow.sonnetTokenCap`** must be a positive number.
+- **`display` values** (`showCacheTokens`) must be booleans.
 - The config file must be valid JSON containing an object (not an array or primitive).
 
 ## CLI Precedence
@@ -294,17 +232,8 @@ Uses Sonnet for planning and caps task execution at Sonnet (tasks with `effort:
     "amend": "{prefix}[{projectId}] Amend: {projectName}",
     "prefix": "RAF"
   },
-  "pricing": {
-    "opus": { "inputPerMTok": 15, "outputPerMTok": 75, "cacheReadPerMTok": 1.5, "cacheCreatePerMTok": 18.75 },
-    "sonnet": { "inputPerMTok": 3, "outputPerMTok": 15, "cacheReadPerMTok": 0.3, "cacheCreatePerMTok": 3.75 },
-    "haiku": { "inputPerMTok": 1, "outputPerMTok": 5, "cacheReadPerMTok": 0.1, "cacheCreatePerMTok": 1.25 }
-  },
   "display": {
-    "showRateLimitEstimate": true,
     "showCacheTokens": true
-  },
-  "rateLimitWindow": {
-    "sonnetTokenCap": 88000
   }
 }
 ```

package/src/types/config.ts

@@ -39,38 +39,12 @@ export interface CommitFormatConfig {
   prefix: string;
 }
 
-/** Pricing category derived from model family name. */
-export type PricingCategory = 'opus' | 'sonnet' | 'haiku';
-
-/** Per-direction pricing for a single model category, in dollars per million tokens. */
-export interface ModelPricing {
-  inputPerMTok: number;
-  outputPerMTok: number;
-  cacheReadPerMTok: number;
-  cacheCreatePerMTok: number;
-}
-
-/** Pricing config: per-category pricing in dollars per million tokens. */
-export interface PricingConfig {
-  opus: ModelPricing;
-  sonnet: ModelPricing;
-  haiku: ModelPricing;
-}
-
 /** Display options for token usage summaries. */
 export interface DisplayConfig {
-  /** Show estimated 5h rate limit window percentage. Default: true */
-  showRateLimitEstimate: boolean;
   /** Show cache token counts in summaries. Default: true */
   showCacheTokens: boolean;
 }
 
-/** Rate limit window configuration. */
-export interface RateLimitWindowConfig {
-  /** Sonnet-equivalent token cap for the 5h window. Default: 88000 */
-  sonnetTokenCap: number;
-}
-
 export interface RafConfig {
   models: ModelsConfig;
   /** Maps task complexity labels (low/medium/high) to models. Used for per-task effort frontmatter. */
@@ -82,9 +56,7 @@ export interface RafConfig {
   /** Sync main branch with remote before worktree/PR operations. Default: true */
   syncMainBranch: boolean;
   commitFormat: CommitFormatConfig;
-  pricing: PricingConfig;
   display: DisplayConfig;
-  rateLimitWindow: RateLimitWindowConfig;
 }
 
 export const DEFAULT_CONFIG: RafConfig = {
@@ -112,33 +84,9 @@ export const DEFAULT_CONFIG: RafConfig = {
     amend: '{prefix}[{projectId}] Amend: {projectName}',
     prefix: 'RAF',
   },
-  pricing: {
-    opus: {
-      inputPerMTok: 15,
-      outputPerMTok: 75,
-      cacheReadPerMTok: 1.5,
-      cacheCreatePerMTok: 18.75,
-    },
-    sonnet: {
-      inputPerMTok: 3,
-      outputPerMTok: 15,
-      cacheReadPerMTok: 0.3,
-      cacheCreatePerMTok: 3.75,
-    },
-    haiku: {
-      inputPerMTok: 1,
-      outputPerMTok: 5,
-      cacheReadPerMTok: 0.1,
-      cacheCreatePerMTok: 1.25,
-    },
-  },
   display: {
-    showRateLimitEstimate: true,
     showCacheTokens: true,
   },
-  rateLimitWindow: {
-    sonnetTokenCap: 88000,
-  },
 };
 
 /** Deep partial type for user config files — all fields optional at every level */
@@ -201,6 +149,8 @@ export interface ModelTokenUsage {
   outputTokens: number;
   cacheReadInputTokens: number;
   cacheCreationInputTokens: number;
+  /** Cost in USD for this model's usage (provided by Claude CLI). */
+  costUsd: number;
 }
 
 /** Token usage data extracted from Claude CLI stream-json result event. */
@@ -212,4 +162,6 @@ export interface UsageData {
   cacheCreationInputTokens: number;
   /** Per-model breakdown (e.g., { "claude-opus-4-6": { ... } }). */
   modelUsage: Record<string, ModelTokenUsage>;
+  /** Total cost in USD for this usage (provided by Claude CLI). */
+  totalCostUsd: number;
 }

package/src/utils/config.ts

@@ -12,11 +12,7 @@ import {
   TaskEffortLevel,
   ModelScenario,
   CommitFormatType,
-  PricingCategory,
-  ModelPricing,
-  PricingConfig,
   DisplayConfig,
-  RateLimitWindowConfig,
   EffortMappingConfig,
 } from '../types/config.js';
 
@@ -38,12 +34,9 @@ export function getClaudeSettingsPath(): string {
 
 const VALID_TOP_LEVEL_KEYS = new Set<string>([
   'models', 'effortMapping', 'timeout', 'maxRetries', 'autoCommit',
-  'worktree', 'syncMainBranch', 'commitFormat', 'pricing', 'display', 'rateLimitWindow',
+  'worktree', 'syncMainBranch', 'commitFormat', 'display',
 ]);
 
-const VALID_PRICING_CATEGORIES = new Set<string>(['opus', 'sonnet', 'haiku']);
-const VALID_PRICING_FIELDS = new Set<string>(['inputPerMTok', 'outputPerMTok', 'cacheReadPerMTok', 'cacheCreatePerMTok']);
-
 const VALID_MODEL_KEYS = new Set<string>([
   'plan', 'execute', 'nameGeneration', 'failureAnalysis', 'prGeneration', 'config',
 ]);
@@ -52,9 +45,7 @@ const VALID_EFFORT_MAPPING_KEYS = new Set<string>(['low', 'medium', 'high']);
 
 const VALID_COMMIT_FORMAT_KEYS = new Set<string>(['task', 'plan', 'amend', 'prefix']);
 
-const VALID_DISPLAY_KEYS = new Set<string>(['showRateLimitEstimate', 'showCacheTokens']);
-
-const VALID_RATE_LIMIT_WINDOW_KEYS = new Set<string>(['sonnetTokenCap']);
+const VALID_DISPLAY_KEYS = new Set<string>(['showCacheTokens']);
 
 export class ConfigValidationError extends Error {
   constructor(message: string) {
@@ -167,27 +158,6 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
-  // pricing
-  if (obj.pricing !== undefined) {
-    if (typeof obj.pricing !== 'object' || obj.pricing === null || Array.isArray(obj.pricing)) {
-      throw new ConfigValidationError('pricing must be an object');
-    }
-    const pricing = obj.pricing as Record<string, unknown>;
-    checkUnknownKeys(pricing, VALID_PRICING_CATEGORIES, 'pricing');
-    for (const [category, catVal] of Object.entries(pricing)) {
-      if (typeof catVal !== 'object' || catVal === null || Array.isArray(catVal)) {
-        throw new ConfigValidationError(`pricing.${category} must be an object`);
-      }
-      const fields = catVal as Record<string, unknown>;
-      checkUnknownKeys(fields, VALID_PRICING_FIELDS, `pricing.${category}`);
-      for (const [field, val] of Object.entries(fields)) {
-        if (typeof val !== 'number' || val < 0 || !Number.isFinite(val)) {
-          throw new ConfigValidationError(`pricing.${category}.${field} must be a non-negative number`);
-        }
-      }
-    }
-  }
-
   // display
   if (obj.display !== undefined) {
     if (typeof obj.display !== 'object' || obj.display === null || Array.isArray(obj.display)) {
@@ -202,20 +172,6 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
-  // rateLimitWindow
-  if (obj.rateLimitWindow !== undefined) {
-    if (typeof obj.rateLimitWindow !== 'object' || obj.rateLimitWindow === null || Array.isArray(obj.rateLimitWindow)) {
-      throw new ConfigValidationError('rateLimitWindow must be an object');
-    }
-    const rlw = obj.rateLimitWindow as Record<string, unknown>;
-    checkUnknownKeys(rlw, VALID_RATE_LIMIT_WINDOW_KEYS, 'rateLimitWindow');
-    if (rlw.sonnetTokenCap !== undefined) {
-      if (typeof rlw.sonnetTokenCap !== 'number' || rlw.sonnetTokenCap <= 0 || !Number.isFinite(rlw.sonnetTokenCap)) {
-        throw new ConfigValidationError('rateLimitWindow.sonnetTokenCap must be a positive number');
-      }
-    }
-  }
-
   return config as UserConfig;
 }
 
@@ -233,19 +189,9 @@ function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
   if (overrides.commitFormat) {
     result.commitFormat = { ...defaults.commitFormat, ...overrides.commitFormat };
   }
-  if (overrides.pricing) {
-    result.pricing = {
-      opus: { ...defaults.pricing.opus, ...overrides.pricing.opus },
-      sonnet: { ...defaults.pricing.sonnet, ...overrides.pricing.sonnet },
-      haiku: { ...defaults.pricing.haiku, ...overrides.pricing.haiku },
-    };
-  }
   if (overrides.display) {
     result.display = { ...defaults.display, ...overrides.display };
   }
-  if (overrides.rateLimitWindow) {
-    result.rateLimitWindow = { ...defaults.rateLimitWindow, ...overrides.rateLimitWindow };
-  }
   if (overrides.timeout !== undefined) result.timeout = overrides.timeout;
   if (overrides.maxRetries !== undefined) result.maxRetries = overrides.maxRetries;
   if (overrides.autoCommit !== undefined) result.autoCommit = overrides.autoCommit;
@@ -271,7 +217,6 @@ export function resolveConfig(configPath?: string): RafConfig {
       effortMapping: { ...DEFAULT_CONFIG.effortMapping },
       commitFormat: { ...DEFAULT_CONFIG.commitFormat },
       display: { ...DEFAULT_CONFIG.display },
-      rateLimitWindow: { ...DEFAULT_CONFIG.rateLimitWindow },
     };
   }
 
@@ -459,40 +404,6 @@ export function resolveFullModelId(modelName: string): string {
   return modelName;
 }
 
-/**
- * Map a full model ID (e.g., `claude-opus-4-6`) or short alias to a pricing category.
- * Returns null if the model cannot be mapped.
- */
-export function resolveModelPricingCategory(modelId: string): PricingCategory | null {
-  // Short aliases map directly
-  if (modelId === 'opus' || modelId === 'sonnet' || modelId === 'haiku') {
-    return modelId;
-  }
-  // Full model IDs: extract family from `claude-{family}-{version}`
-  const match = modelId.match(/^claude-([a-z]+)-/);
-  if (match) {
-    const family = match[1];
-    if (family === 'opus' || family === 'sonnet' || family === 'haiku') {
-      return family;
-    }
-  }
-  return null;
-}
-
-/**
- * Get pricing config for a specific model category.
- */
-export function getPricing(category: PricingCategory): ModelPricing {
-  return getResolvedConfig().pricing[category];
-}
-
-/**
- * Get the full pricing config.
- */
-export function getPricingConfig(): PricingConfig {
-  return getResolvedConfig().pricing;
-}
-
 /**
  * Get the full display config.
  */
@@ -500,20 +411,6 @@ export function getDisplayConfig(): DisplayConfig {
   return getResolvedConfig().display;
 }
 
-/**
- * Get the full rate limit window config.
- */
-export function getRateLimitWindowConfig(): RateLimitWindowConfig {
-  return getResolvedConfig().rateLimitWindow;
-}
-
-/**
- * Get whether to show rate limit estimate in token summaries.
- */
-export function getShowRateLimitEstimate(): boolean {
-  return getResolvedConfig().display.showRateLimitEstimate;
-}
-
 /**
  * Get whether to show cache tokens in summaries.
  */
@@ -521,13 +418,6 @@ export function getShowCacheTokens(): boolean {
   return getResolvedConfig().display.showCacheTokens;
 }
 
-/**
- * Get the Sonnet-equivalent token cap for the 5h rate limit window.
- */
-export function getSonnetTokenCap(): number {
-  return getResolvedConfig().rateLimitWindow.sonnetTokenCap;
-}
-
 /**
  * Render a commit message template by replacing {placeholder} tokens with values.
  * Unknown placeholders are left as-is.

package/src/utils/terminal-symbols.ts

@@ -11,10 +11,6 @@ import type { CostBreakdown, TaskUsageEntry } from './token-tracker.js';
 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;
 }
 
 /**
@@ -49,7 +45,8 @@ function truncate(str: string, maxLength: number): string {
  * @param name - Task name
  * @param elapsedMs - Optional elapsed time in milliseconds
  * @param taskId - Optional task ID prefix display
- * @returns Formatted string like "● 001-auth-login 1:23" or "✓ 001-auth-login 1/5"
+ * @param model - Optional model short name to display (e.g., "sonnet", "opus", "haiku")
+ * @returns Formatted string like "● 001-auth-login (sonnet) 1:23" or "✓ 001-auth-login (opus) 1/5"
  */
 export function formatTaskProgress(
   current: number,
@@ -57,19 +54,21 @@ export function formatTaskProgress(
   status: TaskStatus,
   name: string,
   elapsedMs?: number,
-  taskId?: string
+  taskId?: string,
+  model?: string
 ): string {
   const symbol = SYMBOLS[status];
   const displayName = truncate(name || 'task', 40);
   const idPrefix = taskId ? `${taskId}-` : '';
+  const modelSuffix = model ? ` (${model})` : '';
 
   // Show elapsed time for running tasks, completed tasks, and failed tasks
   if (elapsedMs !== undefined) {
     const timeStr = formatElapsedTime(elapsedMs);
-    return `${symbol} ${idPrefix}${displayName} ${timeStr}`;
+    return `${symbol} ${idPrefix}${displayName}${modelSuffix} ${timeStr}`;
   }
 
-  return `${symbol} ${idPrefix}${displayName} ${current}/${total}`;
+  return `${symbol} ${idPrefix}${displayName}${modelSuffix} ${current}/${total}`;
 }
 
 /**
@@ -155,17 +154,6 @@ 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.
@@ -177,7 +165,7 @@ function formatTokenLine(
   indent: string = '  ',
   options: TokenSummaryOptions = {}
 ): string {
-  const { showCacheTokens = true, showRateLimitEstimate = true, rateLimitPercentage } = options;
+  const { showCacheTokens = true } = options;
   const parts: string[] = [];
   const tokenPart = `${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`;
   parts.push(prefix ? `${prefix}: ${tokenPart}` : `Tokens: ${tokenPart}`);
@@ -195,27 +183,21 @@ function formatTokenLine(
     }
   }
 
-  parts.push(`Est. cost: ${formatCost(costValue)}`);
-
-  if (showRateLimitEstimate && rateLimitPercentage !== undefined) {
-    parts.push(formatRateLimitPercentage(rateLimitPercentage));
-  }
+  parts.push(`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 | ~2% of 5h window"
+ * For single-attempt tasks: "  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | 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
- * @param options - Display options for showing cache tokens and rate limit percentage
+ * @param options - Display options for showing cache tokens
  */
 export function formatTaskTokenSummary(
   entry: TaskUsageEntry,
-  calculateAttemptCost?: (usage: UsageData) => CostBreakdown,
   options: TokenSummaryOptions = {}
 ): string {
   // Single-attempt: render exactly as before (no per-attempt breakdown)
@@ -224,19 +206,10 @@ export function formatTaskTokenSummary(
   }
 
   // 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));
+    const attemptCost = attemptUsage.totalCostUsd;
+    lines.push(formatTokenLine(attemptUsage, attemptCost, `Attempt ${i + 1}`, '    ', options));
   });
   lines.push(formatTokenLine(entry.usage, entry.cost.totalCost, 'Total', '    ', options));
   return lines.join('\n');
@@ -248,14 +221,14 @@ export function formatTaskTokenSummary(
  *
  * @param usage - Total usage data
  * @param cost - Total cost breakdown
- * @param options - Display options for cache tokens and rate limit
+ * @param options - Display options for cache tokens
  */
 export function formatTokenTotalSummary(
   usage: UsageData,
   cost: CostBreakdown,
   options: TokenSummaryOptions = {}
 ): string {
-  const { showCacheTokens = true, showRateLimitEstimate = true, rateLimitPercentage } = options;
+  const { showCacheTokens = true } = options;
   const lines: string[] = [];
   const divider = '── Token Usage Summary ──────────────────';
   lines.push(divider);
@@ -272,11 +245,8 @@ export function formatTokenTotalSummary(
     lines.push(`Cache: ${cacheParts.join(' / ')}`);
   }
 
-  lines.push(`Estimated cost: ${formatCost(cost.totalCost)}`);
+  lines.push(`Total cost: ${formatCost(cost.totalCost)}`);
 
-  if (showRateLimitEstimate && rateLimitPercentage !== undefined) {
-    lines.push(formatRateLimitPercentage(rateLimitPercentage));
-  }
   lines.push('─────────────────────────────────────────');
   return lines.join('\n');
 }