rafcode 2.4.1-0 → 2.5.0

package/CLAUDE.md

@@ -210,11 +210,11 @@ Support multiple identifier formats in commands:
 Use `resolveProjectIdentifierWithDetails()` from `src/utils/paths.ts`
 
 ### Token Usage Tracking
-- After each task, RAF displays a per-task token summary (input/output tokens, cache tokens, estimated cost)
+- After each task, RAF displays a per-task token summary (input/output tokens, cache tokens, cost)
 - After all tasks complete, RAF displays a grand total summary block
-- Token data comes from Claude's `--output-format stream-json --verbose` result events
-- Cost calculation uses configurable per-model pricing (`pricing.*` config keys)
-- `TokenTracker` class (`src/utils/token-tracker.ts`) accumulates usage across tasks
+- Token data and costs come from Claude's `--output-format stream-json --verbose` result events
+- Claude CLI provides exact costs via `total_cost_usd` and per-model `costUSD` fields
+- `TokenTracker` class (`src/utils/token-tracker.ts`) accumulates usage and costs across tasks
 - Formatting utilities in `src/utils/terminal-symbols.ts`: `formatTaskTokenSummary()`, `formatTokenTotalSummary()`, `formatNumber()`, `formatCost()`
 - Failed tasks with partial usage data are still tracked in totals
 - Tasks with no usage data (timeout, crash) are silently skipped

package/RAF/ahwqwq-model-whisperer/decisions.md

@@ -0,0 +1,22 @@
+# Project Decisions
+
+## How should the model be displayed on the task line?
+On the task line, before the timer, in parentheses like `(sonnet)` or `(opus)`. Show in all modes, not just verbose.
+
+## Should the displayed model be the requested model or actual model(s) from result?
+Show the requested model (from effort resolution), not actual models from the result's modelUsage field.
+
+## Should we replace RAF's local cost calculation with Claude's native cost or keep local as fallback?
+Replace entirely. Use Claude CLI's `total_cost_usd` and per-model `costUSD` from the result event.
+
+## Should we keep the pricing config after switching to Claude's native cost?
+Remove pricing config (`pricing.*` keys) and all local cost calculation code entirely.
+
+## What should happen with the rate limit estimation feature?
+Remove it entirely. Remove `showRateLimitEstimate` from display config, remove `rateLimitWindow` config, remove `sonnetTokenCap`, and remove all rate limit percentage calculation and display code.
+
+## How should planning session resume work?
+Add a `--resume` flag to `raf plan` that launches `claude -r` (interactive session picker) from the correct worktree CWD. Minimal approach: just pass `--resume` to Claude CLI without re-injecting system prompts.
+
+## Why don't planning sessions appear in `claude -r`?
+Sessions ARE persisted (`.jsonl` files exist), but they're stored under the worktree path key (e.g., `~/.claude/projects/-Users-...-worktrees-RAF-project/`). Running `claude -r` from the main repo looks under a different project directory. Fix: ensure `--resume` launches from the worktree path.

package/RAF/ahwqwq-model-whisperer/input.md

@@ -0,0 +1,5 @@
+- [ ] show actual execution model per task (on the task line in perentesis, like (sonnet) or
+  (opus). not only in verbose mode
+- [ ] use claude $ estimation instead of own calculations for token usage report
+- [ ] i don't see session limit estimates in token report (**showRateLimitEstimate**). investigate
+  and create task if needed (remove functionlity entirely)

package/RAF/ahwqwq-model-whisperer/outcomes/01-show-model-on-task-line.md

@@ -0,0 +1,49 @@
+# Task 01 - Show execution model on task line
+
+## Summary
+
+Successfully implemented displaying the execution model name in parentheses on all task progress lines. The model appears as a short alias (sonnet, opus, haiku) between the task name and the timer/counter.
+
+## Key Changes Made
+
+### 1. Updated `formatTaskProgress` function (`src/utils/terminal-symbols.ts:54-73`)
+- Added optional `model?: string` parameter (7th parameter)
+- Added `modelSuffix` that adds ` (${model})` when model is provided
+- Model appears after task name, before timer/counter in both time and non-time formats
+- Fully backwards compatible - existing calls without model parameter work unchanged
+
+### 2. Updated `do.ts` to pass model to progress formatter (`src/commands/do.ts`)
+- Added `currentModel` variable (line ~1027) to track the resolved model across retry attempts
+- Updated timer callback (line ~1037) to pass model short name using `getModelShortName(currentModel)`
+- Updated model inside retry loop (line ~1062) after model resolution
+- Updated completed task line (line ~1235) to show model
+- Updated failed task line (line ~1268) to show model
+- Blocked tasks (line ~970) intentionally omit model since it's not resolved yet
+
+### 3. Added comprehensive tests (`tests/unit/terminal-symbols.test.ts`)
+- Added 13 new test cases covering:
+  - Model display with/without time for all task states
+  - Model display with task ID prefix
+  - Model display combined with other parameters
+  - Backwards compatibility (no model = no display)
+
+## Implementation Details
+
+- Uses `getModelShortName()` from `src/utils/config.ts` to convert full model IDs to short aliases
+- Model is tracked in `currentModel` variable and updated on each retry attempt
+- Timer callback captures `currentModel` in its closure, ensuring real-time updates
+- Format examples:
+  - `● 01-auth-login (sonnet) 1m 23s` (running with time)
+  - `✓ 02-setup-db (opus) 2/5` (completed without time)
+  - `✗ 03-deploy (haiku) 45s` (failed with time)
+  - `⊘ 04-depends-on-failed 4/5` (blocked, no model shown)
+
+## Test Results
+
+All tests pass:
+- 87 tests total in terminal-symbols.test.ts
+- All existing tests continue to pass (backwards compatible)
+- 13 new tests added for model display feature
+- TypeScript build succeeds with no errors
+
+<promise>COMPLETE</promise>

package/RAF/ahwqwq-model-whisperer/outcomes/02-use-claude-cost-estimation.md

@@ -0,0 +1,107 @@
+# Task 02 - Use Claude's native cost estimation instead of local calculations
+
+## Summary
+
+Successfully replaced RAF's local token pricing and cost calculation infrastructure with Claude CLI's native `total_cost_usd` and per-model `costUSD` values from stream-json result events. This eliminates the need to maintain pricing tables and ensures accuracy as Anthropic adjusts pricing.
+
+## Key Changes Made
+
+### 1. Updated Type Definitions (`src/types/config.ts`)
+- Added `totalCostUsd: number` field to `UsageData` interface
+- Added `costUsd: number` field to `ModelTokenUsage` interface
+- Removed `PricingCategory`, `ModelPricing`, `PricingConfig` types
+- Removed `RateLimitWindowConfig` interface
+- Removed `pricing` and `rateLimitWindow` from `RafConfig` interface
+- Removed `showRateLimitEstimate` from `DisplayConfig` interface
+- Updated `DEFAULT_CONFIG` to remove pricing and rate limit sections
+
+### 2. Updated Stream Event Parser (`src/parsers/stream-renderer.ts`)
+- Added `total_cost_usd?: number` field to `StreamEvent` interface
+- Added `costUSD?: number` field to modelUsage entries in `StreamEvent`
+- Updated `extractUsageData()` to extract `total_cost_usd` from result events
+- Updated `extractUsageData()` to extract `costUSD` from each modelUsage entry
+- Map extracted values to `UsageData.totalCostUsd` and `ModelTokenUsage.costUsd`
+
+### 3. Simplified TokenTracker (`src/utils/token-tracker.ts`)
+- Removed `PricingConfig` constructor parameter
+- Removed `calculateCost()` method entirely
+- Removed `calculateRateLimitPercentage()` and `getCumulativeRateLimitPercentage()` methods
+- Simplified `CostBreakdown` interface to just `{ totalCost: number }`
+- Updated `addTask()` to sum `totalCostUsd` from attempts
+- Updated `getTotals()` to accumulate costs directly from entries
+- Updated `accumulateUsage()` to merge `costUsd` and sum `totalCostUsd`
+- Updated `sumCostBreakdowns()` to simply sum `totalCost` values
+
+### 4. Removed Config Infrastructure (`src/utils/config.ts`)
+- Removed `PricingCategory`, `ModelPricing`, `PricingConfig`, `RateLimitWindowConfig` imports
+- Removed `pricing` and `rateLimitWindow` from `VALID_TOP_LEVEL_KEYS`
+- Removed pricing and rate limit validation sections from `validateConfig()`
+- Removed `showRateLimitEstimate` from `VALID_DISPLAY_KEYS`
+- Removed pricing and rate limit deep-merge logic from `deepMerge()`
+- Removed accessor functions: `resolveModelPricingCategory()`, `getPricing()`, `getPricingConfig()`, `getRateLimitWindowConfig()`, `getShowRateLimitEstimate()`, `getSonnetTokenCap()`
+
+### 5. Updated Display Formatting (`src/utils/terminal-symbols.ts`)
+- Removed `showRateLimitEstimate` and `rateLimitPercentage` from `TokenSummaryOptions`
+- Removed `formatRateLimitPercentage()` function
+- Removed rate limit display from `formatTokenLine()`
+- Updated `formatTaskTokenSummary()` signature to remove `calculateAttemptCost` parameter
+- Updated `formatTaskTokenSummary()` to read `totalCostUsd` directly from attempts
+- Changed "Est. cost" label to "Cost" in `formatTokenLine()`
+- Changed "Estimated cost" to "Total cost" in `formatTokenTotalSummary()`
+- Removed rate limit display from `formatTokenTotalSummary()`
+
+### 6. Updated do.ts (`src/commands/do.ts`)
+- Removed `getShowRateLimitEstimate` import
+- Removed `TokenTracker` pricing constructor argument
+- Removed `getCumulativeRateLimitPercentage()` calls
+- Removed `calculateCost` callback from `formatTaskTokenSummary()` calls
+- Simplified token summary display to only pass `showCacheTokens` option
+
+### 7. Updated Documentation (`src/prompts/config-docs.md`)
+- Removed entire `pricing` section
+- Removed entire `rateLimitWindow` section
+- Removed `showRateLimitEstimate` from display options documentation
+- Updated validation rules to remove pricing and rate limit references
+- Updated full config example to remove pricing and rate limit fields
+
+### 8. Updated CLAUDE.md
+- Updated Token Usage Tracking section to reflect Claude-provided costs
+- Changed "cost calculation uses configurable per-model pricing" to "Claude CLI provides exact costs via `total_cost_usd` and per-model `costUSD` fields"
+- Changed "estimated cost" references to "cost"
+
+### 9. Updated All Tests
+- **config.test.ts**: Removed pricing and rate limit validation tests, removed `resolveModelPricingCategory` tests, updated display config tests
+- **terminal-symbols.test.ts**: Removed `formatRateLimitPercentage` tests, updated cost display expectations to "Cost:" instead of "Est. cost:", updated multi-attempt tests to use `totalCostUsd`
+- **token-tracker.test.ts**: Complete rewrite to test simplified TokenTracker using Claude-provided costs
+- **stream-renderer.test.ts**: Added tests for `total_cost_usd` and `costUSD` extraction
+- **config-command.test.ts**: Updated nested key tests to use `showCacheTokens` instead of pricing/rate limit fields
+- **claude-runner.test.ts**: Added `costUsd: 0` to modelUsage expectations
+
+## Test Results
+
+All tests pass: **1251 tests passed** (50 test suites)
+
+## Verification
+
+All acceptance criteria met:
+- ✅ `total_cost_usd` extracted from stream-json result events
+- ✅ Per-model `costUSD` extracted from modelUsage
+- ✅ `TokenTracker` accumulates costs from Claude data (no local calculation)
+- ✅ `pricing.*` config keys removed from types, defaults, validation, and docs
+- ✅ `rateLimitWindow` config removed entirely
+- ✅ `showRateLimitEstimate` display option removed
+- ✅ Rate limit percentage display removed from all summaries
+- ✅ `resolveModelPricingCategory()` and related functions removed
+- ✅ Token counts (in/out/cache) still tracked and displayed
+- ✅ Cost display shows "Cost:" instead of "Est. cost:"
+- ✅ Config validation rejects `pricing` and `rateLimitWindow` as unknown keys
+- ✅ All tests updated and passing
+
+## Notes
+
+- The change from "Est. cost" to "Cost" reflects that we now display exact costs from Claude rather than estimates
+- Config validation now properly rejects `pricing` and `rateLimitWindow` keys as unknown, preventing users from trying to configure these removed features
+- Token tracking infrastructure remains intact - only cost calculation changed
+- Defensive handling: if Claude doesn't provide cost data, `totalCostUsd` and `costUsd` default to 0
+
+<promise>COMPLETE</promise>

package/RAF/ahwqwq-model-whisperer/outcomes/03-add-plan-resume-flag.md

@@ -0,0 +1,87 @@
+# Task 03 - Add --resume flag to raf plan for continuing planning sessions
+
+## Summary
+
+Successfully implemented `raf plan --resume <project>` flag that launches Claude's interactive session picker from the correct CWD (worktree or main repo), enabling users to resume interrupted planning sessions.
+
+## Key Changes Made
+
+### 1. Added `runResume()` method to ClaudeRunner (`src/core/claude-runner.ts:367-425`)
+- New method similar to `runInteractive()` but simplified for session resumption
+- Launches `claude --resume --model <model>` with TTY passthrough
+- No system prompt or user message injection (minimal approach)
+- Accepts `cwd` option to control where Claude looks for sessions
+- Same PTY setup and cleanup logic as `runInteractive()`
+
+### 2. Updated plan command interface (`src/commands/plan.ts:54-60`)
+- Added `resume?: string` field to `PlanCommandOptions` interface
+- Added `--resume <identifier>` option to the command definition (line 73)
+- Option accepts project identifier (base26 ID, project name, or full folder name)
+
+### 3. Implemented `runResumeCommand()` function (`src/commands/plan.ts:698-779`)
+- Validates environment before proceeding
+- Resolves project identifier using `resolveProjectIdentifierWithDetails()`
+- Determines correct CWD for session resume:
+  - Checks for worktree existence in `~/.raf/worktrees/<repo-basename>/<project-folder>/`
+  - Validates worktree if found, uses it as CWD
+  - Falls back to main repo project path if no worktree or invalid worktree
+- Launches `claudeRunner.runResume()` with resolved CWD
+- Post-session: lists plan files to show project state
+- Handles errors: ambiguous project names, project not found, invalid worktrees
+
+### 4. Updated command routing logic (`src/commands/plan.ts:74-101`)
+- Added check for `options.resume` before amend and normal plan flows
+- Resume flow has early return, skipping all normal plan setup
+- Routing order: resume → amend → normal plan
+
+## Implementation Details
+
+- **CWD resolution**: Ensures Claude session picker finds the right sessions
+  - For worktree projects: uses `~/.raf/worktrees/<repo-basename>/<project-folder>/`
+  - For non-worktree projects: uses `<repo-root>/RAF/<project-folder>/`
+- **Model parameter**: Resume sessions use the configured planning model via `--model` flag
+- **Session picker**: Claude CLI's `--resume` flag without session ID opens interactive picker
+- **No validation workaround**: When worktree is invalid, falls back gracefully to main repo
+- **Post-session feedback**: Shows plan count and lists plan files after session ends
+
+## Test Results
+
+All tests pass: **1251 tests passed** (50 test suites)
+
+TypeScript build succeeds with no errors.
+
+## Verification
+
+All acceptance criteria met:
+- ✅ `raf plan --resume <project>` launches Claude's interactive session picker
+- ✅ Correct CWD used for worktree projects (sessions discoverable)
+- ✅ Correct CWD used for non-worktree projects
+- ✅ Normal plan flow (project creation, input) skipped when `--resume` is used
+- ✅ Plan file checking still runs after session ends
+- ✅ Error message shown when project not found
+- ✅ ClaudeRunner has `runResume()` method for minimal session resume
+
+## Usage Examples
+
+```bash
+# Resume by base26 ID
+raf plan --resume ahwqwq
+
+# Resume by project name
+raf plan --resume model-whisperer
+
+# Resume by full folder name
+raf plan --resume ahwqwq-model-whisperer
+
+# Short flag
+raf plan -r ahwqwq
+```
+
+## Notes
+
+- The `--resume` flag is mutually exclusive with normal plan creation and `--amend`
+- When multiple projects have the same name, user is prompted to specify the ID or full folder name
+- Worktree detection is automatic - user doesn't need to specify `--worktree` with `--resume`
+- Claude's session picker will show sessions created in that CWD (worktree or main repo)
+
+<promise>COMPLETE</promise>

package/RAF/ahwqwq-model-whisperer/plans/01-show-model-on-task-line.md

@@ -0,0 +1,45 @@
+---
+effort: low
+---
+# Task: Show execution model on task line
+
+## Objective
+Display the resolved model name in parentheses on the task progress line (e.g., `● 01-auth-login (sonnet) 1:23`), always visible, not just in verbose mode.
+
+## Context
+Currently the execution model per task is only displayed in `--verbose` mode (`Model: claude-opus-4-6`). Users want to see which model is running each task at a glance during normal execution. The model should appear as a short alias (sonnet, opus, haiku) in parentheses, placed before the timer/counter.
+
+## Requirements
+- Show the **requested model** (from effort resolution), not actual models from the result
+- Use short alias form: `(sonnet)`, `(opus)`, `(haiku)` — use `getModelShortName()` from `src/utils/config.ts`
+- Display on ALL task states: running, completed, failed, blocked, pending
+- Display in both verbose and non-verbose modes
+- Format: `● 01-task-name (sonnet) 1:23` or `✓ 01-task-name (opus) 2m 45s`
+
+## Implementation Steps
+
+1. **Update `formatTaskProgress` signature** in `src/utils/terminal-symbols.ts` to accept an optional `model?: string` parameter
+2. **Insert model in output** — when `model` is provided, add ` (${model})` after the display name and before the timer/counter:
+   - With time: `` `${symbol} ${idPrefix}${displayName} (${model}) ${timeStr}` ``
+   - Without time: `` `${symbol} ${idPrefix}${displayName} (${model}) ${current}/${total}` ``
+3. **Pass model to `formatTaskProgress`** in `src/commands/do.ts`:
+   - The resolved model is available from `modelResolution.model` (inside the while loop)
+   - Use `getModelShortName(modelResolution.model)` to get the alias
+   - Pass to the timer callback (line ~1034), completed line, failed line, blocked line
+   - For blocked tasks (where model isn't resolved yet), pass `undefined`
+4. **Update tests** in `tests/unit/terminal-symbols.test.ts`:
+   - Add tests for `formatTaskProgress` with model parameter
+   - Verify model appears between task name and timer
+
+## Acceptance Criteria
+- [ ] `formatTaskProgress` accepts optional `model` parameter
+- [ ] Model shown in parentheses on running task status line (timer updates)
+- [ ] Model shown on completed and failed task lines
+- [ ] Short alias used (sonnet, not claude-sonnet-4-5-20250929)
+- [ ] Blocked tasks show without model (since model isn't resolved)
+- [ ] All existing `formatTaskProgress` tests pass (backwards compatible)
+- [ ] New tests added for model display
+
+## Notes
+- `getModelShortName()` already exists in `src/utils/config.ts:421` and handles both aliases and full model IDs
+- The model resolution happens inside the retry loop at `do.ts:1050`, so the model variable needs to be accessible in the timer callback — it should be stored outside the while loop and updated on each iteration

package/RAF/ahwqwq-model-whisperer/plans/02-use-claude-cost-estimation.md

@@ -0,0 +1,115 @@
+---
+effort: medium
+---
+# Task: Use Claude's native cost estimation instead of local calculations
+
+## Objective
+Replace RAF's local token pricing and cost calculation with Claude CLI's native `total_cost_usd` and per-model `costUSD` values from the stream-json result event.
+
+## Context
+RAF currently maintains its own pricing tables (`pricing.*` config) and calculates costs locally using per-model token counts. Claude CLI already provides accurate cost data in the result event: `total_cost_usd` (session total) and `modelUsage.<model>.costUSD` (per-model). Using Claude's native cost eliminates the need to maintain pricing tables and ensures accuracy as Anthropic adjusts pricing.
+
+## Requirements
+- Extract `total_cost_usd` from the stream-json result event
+- Extract per-model `costUSD` from `modelUsage.<model>` entries
+- Replace all local cost calculation with Claude-provided values
+- Remove `pricing.*` config keys, `PricingConfig`/`ModelPricing` types, and all related code
+- Remove `PricingCategory` type and `resolveModelPricingCategory()` function
+- Keep token tracking (input/output/cache counts) — only cost calculation changes
+- If Claude doesn't provide cost data (unlikely but defensive), show `$?.??` or similar
+
+## Implementation Steps
+
+1. **Update `UsageData` type** in `src/types/config.ts`:
+   - Add `totalCostUsd: number` field
+   - Add `costUsd` to `ModelTokenUsage` interface
+   - Remove `PricingConfig`, `ModelPricing`, `PricingCategory` types
+
+2. **Update `extractUsageData` in `src/parsers/stream-renderer.ts`**:
+   - Extract `total_cost_usd` from the result event (top-level field)
+   - Extract `costUSD` from each `modelUsage` entry
+   - Map to `UsageData.totalCostUsd` and `ModelTokenUsage.costUsd`
+   - Update `StreamEvent` interface to include `total_cost_usd?: number` and `costUSD` in modelUsage
+
+3. **Simplify `TokenTracker` in `src/utils/token-tracker.ts`**:
+   - Remove `PricingConfig` constructor parameter
+   - Remove `calculateCost()` method entirely
+   - Remove `calculateRateLimitPercentage()` and `getCumulativeRateLimitPercentage()` methods
+   - Simplify `CostBreakdown` to just `{ totalCost: number }` (since we only get a single cost number from Claude)
+   - In `addTask()`: sum `totalCostUsd` from attempts instead of calculating
+   - In `getTotals()`: sum costs directly from entries
+
+4. **Remove config infrastructure**:
+   - Remove `pricing` from `RafConfig` interface and `DEFAULT_CONFIG` in `src/types/config.ts`
+   - Remove `rateLimitWindow` from `RafConfig` and `DEFAULT_CONFIG`
+   - Remove `showRateLimitEstimate` from `DisplayConfig`
+   - Remove `RateLimitWindowConfig` interface
+   - Remove from `VALID_TOP_LEVEL_KEYS` in `src/utils/config.ts`
+   - Remove pricing validation in `validateConfig()`
+   - Remove `rateLimitWindow` validation in `validateConfig()`
+   - Remove `showRateLimitEstimate` from `VALID_DISPLAY_KEYS`
+   - Remove accessor functions: `getPricing()`, `getPricingConfig()`, `getRateLimitWindowConfig()`, `getShowRateLimitEstimate()`, `getSonnetTokenCap()`, `resolveModelPricingCategory()`
+   - Remove deep-merge logic for `pricing` and `rateLimitWindow` in `mergeConfigs()`
+
+5. **Update display formatting** in `src/utils/terminal-symbols.ts`:
+   - Remove `formatRateLimitPercentage()` function
+   - Remove `showRateLimitEstimate` and `rateLimitPercentage` from `TokenSummaryOptions`
+   - Remove rate limit display from `formatTokenLine()` and `formatTokenTotalSummary()`
+   - Update `formatTaskTokenSummary()` — the `calculateAttemptCost` callback is no longer needed; instead read `totalCostUsd` directly from each attempt's `UsageData`
+   - Change "Est. cost" label to "Cost" (since it's now exact)
+
+6. **Update `do.ts` call sites** in `src/commands/do.ts`:
+   - Remove `TokenTracker` pricing constructor arg
+   - Remove `getCumulativeRateLimitPercentage()` calls
+   - Remove `getShowRateLimitEstimate()` calls
+   - Remove `calculateCost` callback from `formatTaskTokenSummary()` calls
+   - Simplify token summary display calls
+
+7. **Update config-docs.md** in `src/prompts/config-docs.md`:
+   - Remove `pricing` section
+   - Remove `rateLimitWindow` section
+   - Remove `display.showRateLimitEstimate` documentation
+   - Update the full config example
+
+8. **Update tests**:
+   - Rewrite `tests/unit/token-tracker.test.ts`: remove all pricing/cost calculation tests, add tests for cost accumulation from `UsageData.totalCostUsd`
+   - Update `tests/unit/terminal-symbols.test.ts`: remove rate limit tests, update cost display tests
+   - Update `tests/unit/stream-renderer.test.ts`: add tests for `total_cost_usd` and `costUSD` extraction
+   - Update `tests/unit/config.test.ts`: remove pricing/rateLimitWindow validation tests
+
+9. **Update CLAUDE.md**: Remove pricing-related architectural notes, update token tracking documentation
+
+## Acceptance Criteria
+- [ ] `total_cost_usd` extracted from stream-json result events
+- [ ] Per-model `costUSD` extracted from modelUsage
+- [ ] `TokenTracker` accumulates costs from Claude data (no local calculation)
+- [ ] `pricing.*` config keys removed from types, defaults, validation, and docs
+- [ ] `rateLimitWindow` config removed entirely
+- [ ] `showRateLimitEstimate` display option removed
+- [ ] Rate limit percentage display removed from all summaries
+- [ ] `resolveModelPricingCategory()` and related functions removed
+- [ ] Token counts (in/out/cache) still tracked and displayed
+- [ ] Cost display shows "Cost:" instead of "Est. cost:"
+- [ ] Config validation rejects `pricing` and `rateLimitWindow` as unknown keys
+- [ ] All tests updated and passing
+
+## Notes
+- Claude CLI result event structure (verified):
+  ```json
+  {
+    "type": "result",
+    "total_cost_usd": 0.009946,
+    "modelUsage": {
+      "claude-haiku-4-5-20251001": {
+        "inputTokens": 348,
+        "outputTokens": 52,
+        "cacheReadInputTokens": 18005,
+        "cacheCreationInputTokens": 6030,
+        "costUSD": 0.009946
+      }
+    }
+  }
+  ```
+- The `total_cost_usd` and per-model `costUSD` appear in both `--output-format json` and `--output-format stream-json --verbose` result events
+- `sumCostBreakdowns()` and `accumulateUsage()` helpers should be simplified or removed as needed
+- For multi-attempt tasks, sum `totalCostUsd` across attempts

package/RAF/ahwqwq-model-whisperer/plans/03-add-plan-resume-flag.md

@@ -0,0 +1,70 @@
+---
+effort: medium
+---
+# Task: Add --resume flag to raf plan for continuing planning sessions
+
+## Objective
+Add a `--resume <project>` flag to `raf plan` that launches Claude's interactive session picker (`claude -r`) from the correct worktree CWD, enabling users to resume interrupted planning sessions.
+
+## Context
+Planning sessions are persisted by Claude CLI as `.jsonl` files under `~/.claude/projects/<path-key>/`. However, worktree planning sessions are stored under the worktree path key, not the main repo path. Running `claude -r` from the main repo doesn't find these sessions. RAF needs a `--resume` flag that resolves the correct worktree path for a project and launches Claude's session picker from there.
+
+## Requirements
+- New flag: `raf plan --resume <project-identifier>` (accepts base26 ID, project name, or full folder name)
+- Resolve the project's worktree path using existing project resolution utilities
+- Launch `claude -r` (interactive resume picker) from the worktree CWD
+- Minimal approach: just pass `--resume` to Claude CLI, no system prompt injection
+- If the project is not a worktree project, launch from the project's directory in the main repo
+- If no worktree path exists and the project used worktree mode, show helpful error
+
+## Dependencies
+01
+
+## Implementation Steps
+
+1. **Add `--resume` option to plan command** in `src/commands/plan.ts`:
+   - Add `.option('--resume <identifier>', 'Resume a planning session for an existing project')` to the commander setup
+   - When `--resume` is provided, skip all normal plan setup (project creation, input gathering, etc.)
+
+2. **Resolve project path**:
+   - Use `resolveProjectIdentifierWithDetails()` from `src/utils/paths.ts` to find the project
+   - Check for worktree path: look up `~/.raf/worktrees/<repo-basename>/<project-folder>/`
+   - If worktree exists, use that as CWD
+   - If no worktree, use the project path in the main repo as CWD
+   - If neither exists, error with helpful message
+
+3. **Launch Claude with `--resume`**:
+   - Add a new method to `ClaudeRunner` or use `pty.spawn` directly: launch `claude -r` (or `claude --resume`) from the resolved CWD
+   - Pass `--model` flag to match the planning model
+   - Do NOT pass `--append-system-prompt` or user message (minimal resume)
+   - Use the same TTY passthrough setup as `runInteractive()`
+
+4. **Add `runResume` method to `ClaudeRunner`** in `src/core/claude-runner.ts`:
+   - Similar to `runInteractive` but with simpler args: just `['--resume', '--model', this.model]`
+   - Same pty.spawn, stdin/stdout passthrough, cleanup logic
+   - Accept `cwd` option for worktree path
+
+5. **Update plan command flow** in `src/commands/plan.ts`:
+   - Early return path when `--resume` is detected
+   - Resolve project, find CWD, launch `runResume()`
+   - After session ends, run the same plan file checking logic as normal plan
+
+6. **Update tests** (if plan-command tests exist):
+   - Test that `--resume` skips project creation
+   - Test that correct CWD is resolved for worktree projects
+
+## Acceptance Criteria
+- [ ] `raf plan --resume <project>` launches Claude's interactive session picker
+- [ ] Correct CWD used for worktree projects (sessions discoverable)
+- [ ] Correct CWD used for non-worktree projects
+- [ ] Normal plan flow (project creation, input) skipped when `--resume` is used
+- [ ] Plan file checking still runs after session ends
+- [ ] Error message shown when project not found
+- [ ] ClaudeRunner has `runResume()` method for minimal session resume
+
+## Notes
+- `resolveProjectIdentifierWithDetails()` in `src/utils/paths.ts` handles all identifier formats
+- Worktree paths follow the pattern: `~/.raf/worktrees/<repo-basename>/<project-folder>/`
+- `listWorktreeProjects()` in `src/core/worktree.ts` can help discover worktree projects
+- Claude CLI's `-r` flag without a session ID opens an interactive picker showing sessions for the CWD
+- The `--model` flag should still be passed to ensure the resume session uses the configured planning model

package/RAF/ahwvrz-legacy-sunset/decisions.md

@@ -0,0 +1,10 @@
+# Project Decisions
+
+## Should CLAUDE.md also be checked for any references to the migrate command that need cleanup, or is it just code + README?
+Also check CLAUDE.md — scan for any mentions of the migrate command and remove them.
+
+## For auto-detection: should `--resume` automatically detect if a project lives in a worktree (and use worktree mode) even without `--worktree` flag?
+Yes, auto-detect. Search both main repo and worktrees. If found in a worktree, auto-enable worktree mode. `--worktree` flag is optional.
+
+## If the project exists in both the main repo AND a worktree, which should take priority when --worktree is not specified?
+Worktree first. Prefer the worktree copy since it likely has the latest state (worktree is the active working copy).

package/RAF/ahwvrz-legacy-sunset/input.md

@@ -0,0 +1,10 @@
+- [ ] remove `raf migrate-project-ids-base26` (all code and update readme)
+
+---
+
+investigate why this doesn't work
+➜  RAF git:(main) raf plan --resume ahwvrz-legacy-sunset --worktree
+✗ Project not found: ahwvrz-legacy-sunset
+
+is the promlem with worktree resolution? fix and make sure --worktree is optional and check either
+way

package/RAF/ahwvrz-legacy-sunset/outcomes/01-remove-migrate-command.md

@@ -0,0 +1,30 @@
+# Outcome: Remove `raf migrate-project-ids-base26` command
+
+## Summary
+
+Successfully removed the legacy `raf migrate-project-ids-base26` command and all associated code, tests, types, and documentation.
+
+## Changes Made
+
+### Files Deleted
+- `src/commands/migrate.ts` - Command implementation
+- `tests/unit/migrate-command.test.ts` - Test file
+
+### Files Modified
+- `src/index.ts` - Removed import and registration of migrate command
+- `src/types/config.ts` - Removed `MigrateCommandOptions` interface
+- `README.md` - Removed two sections documenting the migrate command:
+  - Usage section (lines 120-128)
+  - Command options table (lines 223-228)
+
+### Verification
+- ✅ Build compiles successfully (`npm run build`)
+- ✅ All tests pass (1236 tests passed, 49 test suites)
+- ✅ No references to migrate command in CLAUDE.md
+
+## Notes
+
+- All shared utilities (`encodeBase26`, `getRafDir`, etc.) were preserved as they are used by other parts of the codebase
+- The historical project `ahnbcu-letterjam` containing the original migration implementation remains untouched as archival content
+
+<promise>COMPLETE</promise>

package/RAF/ahwvrz-legacy-sunset/outcomes/02-fix-resume-worktree-resolution.md

@@ -0,0 +1,62 @@
+# Outcome: Fix `--resume` worktree project resolution
+
+## Summary
+
+Successfully fixed `raf plan --resume` to find projects in worktrees and auto-detect worktree mode without requiring the `--worktree` flag. The command now searches worktrees first, falls back to the main repo if not found, and automatically sets the correct working directory.
+
+## Changes Made
+
+### Files Modified
+
+**src/commands/plan.ts**:
+1. Added `resolveWorktreeProjectByIdentifier` to imports from `../core/worktree.js` (line 51)
+2. Refactored `runResumeCommand()` (lines 694-746) to implement the new resolution logic:
+   - Declare `projectPath`, `resumeCwd`, and `folderName` as `string | undefined` for proper TypeScript handling
+   - Try worktree resolution first using `resolveWorktreeProjectByIdentifier()` if in a git repo
+   - When found in worktree, validate with `validateWorktree()` and use worktree root as CWD
+   - Fall back to main repo resolution via `resolveProjectIdentifierWithDetails()` if not found in worktree or if worktree is invalid
+   - Removed the old worktree detection block (previously lines 714-741) which only checked after main repo resolution
+
+### Files Created
+
+**tests/unit/plan-resume-worktree-resolution.test.ts**:
+- Added comprehensive unit tests for the resume worktree resolution logic
+- Tests cover:
+  - Resolution flow: worktree priority, main repo fallback, invalid worktree handling
+  - `resumeCwd` determination: worktree root vs main repo path
+  - Variable initialization: proper handling of `undefined` states
+- All tests use simplified logic testing rather than full integration to avoid mocking complexity
+
+## Key Features
+
+1. **Worktree-first resolution**: Projects in worktrees take priority over main repo
+2. **Auto-detection**: No `--worktree` flag required - mode is auto-detected based on where the project is found
+3. **Graceful fallback**: If worktree resolution fails (not found or invalid), falls back to main repo seamlessly
+4. **Proper working directory**: Sets `resumeCwd` to worktree root when using worktree, or project path when using main repo
+5. **TypeScript safety**: Variables properly typed as `string | undefined` to handle all code paths
+
+## Verification
+
+- ✅ `npm run build` succeeds (TypeScript compiles without errors)
+- ✅ `npm test` passes (1243 tests passed, 0 failed)
+- ✅ New tests added for resume worktree resolution logic
+- ✅ Follows the same pattern as `runAmendCommand()` for consistency
+
+## Acceptance Criteria Met
+
+- ✅ `raf plan --resume ahwvrz-legacy-sunset` (without `--worktree`) finds the project in the worktree
+- ✅ `raf plan --resume ahwvrz-legacy-sunset --worktree` also works (--worktree is now optional but still supported)
+- ✅ When project exists in both main repo and worktree, worktree is preferred
+- ✅ When project only exists in main repo, main repo resolution still works
+- ✅ Ambiguous/not-found errors are reported clearly (existing error handling preserved)
+- ✅ Build succeeds
+- ✅ Tests pass
+
+## Notes
+
+- The implementation mirrors the pattern used in `runAmendCommand()` for consistency
+- The worktree resolution uses the existing `resolveWorktreeProjectByIdentifier()` utility from `src/core/worktree.ts`
+- Invalid worktrees are detected and a warning is logged before falling back to main repo
+- The refactor maintains backward compatibility - projects in main repo continue to work as before
+
+<promise>COMPLETE</promise>