rafcode 3.2.1 → 3.8.0

package/RAF/45-signal-lantern/outcomes/3-show-codex-token-summaries-without-fake-cost.md

@@ -0,0 +1,14 @@
+Updated RAF's shared token-summary formatting so token counts still render for all providers, but USD cost only appears when the CLI supplies an exact value. This removes misleading `$0.00` output from Codex summaries while preserving exact Claude cost reporting.
+
+Key changes:
+- Updated `src/utils/terminal-symbols.ts` to make cost rendering availability-aware for both per-task summaries and grand-total summaries, while still treating exact zero as a real cost.
+- Updated `tests/unit/terminal-symbols.test.ts` to cover Codex-style token-only summaries, mixed multi-attempt cost availability, and Claude exact-cost regressions.
+- Updated `tests/unit/command-output.test.ts` to verify the logged output path shows token-only Codex summaries and exact Claude totals.
+- Updated `README.md` to document that Codex currently reports exact token counts post-run, but RAF omits USD cost unless the provider returns an exact price.
+
+Important notes:
+- `src/commands/do.ts` already routed both per-task and grand-total usage output through the shared formatter, so no provider-specific command branching was needed.
+- Verification was attempted but blocked by the worktree environment because `node_modules` is absent:
+  - `npm test -- --runInBand tests/unit/terminal-symbols.test.ts tests/unit/command-output.test.ts` -> failed with `jest: command not found`
+  - `npm run lint` -> failed with `tsc: command not found`
+<promise>COMPLETE</promise>

package/RAF/45-signal-lantern/plans/1-add-effort-and-fast-to-do-model-display.md

@@ -0,0 +1,38 @@
+---
+effort: low
+---
+# Task: Add Effort And Fast To Do Model Display
+
+## Objective
+Augment every existing `raf do` model display to include task effort and a fast-mode marker when present.
+
+## Context
+`raf do` already shows the resolved model in compact task lines and in verbose execution logs. The user wants the same display points to carry more execution metadata so task routing is visible at a glance, without adding extra log lines.
+
+## Requirements
+- Update the same places where the model is currently shown; do not add new display locations.
+- Compact task lines should follow the existing pattern with appended metadata, for example: `● 01-auth-login (sonnet, low, fast) 12s`.
+- Omit the effort label when it is unavailable.
+- Omit `fast` when the resolved model entry has `fast: false`, `null`, or `undefined`.
+- Preserve current model identifier style per output surface.
+- Running, completed, and failed compact lines must stay aligned with the current `formatTaskProgress()` behavior.
+- Verbose `Model:` and retry logs should include the same effort/fast metadata rather than silently diverging from compact mode.
+
+## Implementation Steps
+1. Identify every `raf do` output path that currently renders model information, including the timer status line and verbose execution/retry logs in [`src/commands/do.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/commands/do.ts).
+2. Extend the task progress formatter in [`src/utils/terminal-symbols.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/utils/terminal-symbols.ts) so it can render model plus optional effort/fast metadata without changing unrelated progress output.
+3. Thread resolved frontmatter effort and `fast` from the task model resolution path into all current model-display call sites.
+4. Keep truncation and spacing behavior stable so long task names still render cleanly.
+5. Add or update unit tests for compact progress formatting and any `do` command expectations affected by the new suffix.
+
+## Acceptance Criteria
+- [ ] Running compact lines show model metadata in the same place the model appears today.
+- [ ] Completed compact lines show model metadata in the same place the model appears today.
+- [ ] Failed compact lines show model metadata in the same place the model appears today.
+- [ ] Verbose `Model:` and retry logs include effort and `fast` metadata when available.
+- [ ] Effort is omitted when unavailable.
+- [ ] `fast` is omitted when falsy.
+- [ ] Existing output-format tests pass after expectation updates.
+
+## Notes
+- Reasonable assumption: verbose logs should keep the current resolved model identifier style and append metadata instead of replacing the model string.

package/RAF/45-signal-lantern/plans/2-capture-codex-post-run-token-usage.md

@@ -0,0 +1,37 @@
+---
+effort: medium
+---
+# Task: Capture Codex Post-Run Token Usage
+
+## Objective
+Capture Codex input/output token counts from non-interactive execution and carry them through RAF’s post-run usage pipeline.
+
+## Context
+Research during planning found that RAF’s Codex path already sees `turn.completed` usage data in `codex exec --json`, and prior local outcome notes show real Codex runs reporting `in`/`out` token counts. However, [`src/core/codex-runner.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/core/codex-runner.ts) currently returns `usageData: undefined`, so `raf do` cannot include Codex token totals after execution.
+
+## Requirements
+- Parse Codex `turn.completed` usage from the JSON stream used by `codex exec --json`.
+- Capture at least exact input and output token counts from Codex.
+- Preserve compatibility with existing Claude usage tracking.
+- Do not invent or estimate dollar cost for Codex.
+- Represent missing exact Codex cost as unavailable rather than pretending the value is exact.
+- Keep retry accumulation behavior intact so Codex retries still roll up correctly.
+
+## Implementation Steps
+1. Extend the Codex stream renderer in [`src/parsers/codex-stream-renderer.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/parsers/codex-stream-renderer.ts) to return structured usage data for `turn.completed` events, not just display text.
+2. Update the shared run-result plumbing so [`src/core/codex-runner.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/core/codex-runner.ts) records Codex usage data from streamed events the same way Claude does.
+3. Introduce or refine the usage-data representation so Codex can express exact token counts with no exact dollar-cost value.
+4. Ensure token tracking in [`src/utils/token-tracker.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/utils/token-tracker.ts) can accumulate Codex attempts without collapsing “unknown cost” into a misleading exact zero.
+5. Add unit tests for Codex usage extraction and runner propagation.
+
+## Acceptance Criteria
+- [ ] Codex `turn.completed` input token counts are captured into RAF usage data.
+- [ ] Codex `turn.completed` output token counts are captured into RAF usage data.
+- [ ] `raf do` receives Codex usage data through the runner result path.
+- [ ] Existing Claude usage tests continue to pass unchanged in behavior.
+- [ ] Codex cost remains explicitly unavailable unless an exact field is present.
+- [ ] Codex retry attempts still accumulate token usage correctly.
+- [ ] New Codex renderer/runner tests pass.
+
+## Notes
+- Planning research conclusion as of March 21, 2026: current Codex surfaces clearly expose token usage, but exact per-run dollar cost was not confirmed in the `exec --json` path RAF uses.

package/RAF/45-signal-lantern/plans/3-show-codex-token-summaries-without-fake-cost.md

@@ -0,0 +1,40 @@
+---
+effort: medium
+---
+# Task: Show Codex Token Summaries Without Fake Cost
+
+## Objective
+Update RAF’s post-execution token summaries so Codex runs show exact token counts while omitting dollar cost when no exact price is available.
+
+## Context
+Once Codex token usage is captured, RAF’s current summary format will otherwise show `Cost: $0.00`, which reads like an exact price instead of “unknown”. The user explicitly wants input/output tokens surfaced, but only wants price shown when RAF can source it exactly.
+
+## Dependencies
+2
+
+## Requirements
+- Show Codex input/output token summaries after each task and in the grand total summary.
+- Do not show `$0.00` when Codex cost is unavailable.
+- Continue showing exact dollar cost for Claude runs exactly as RAF does today.
+- Avoid estimated pricing for Codex entirely.
+- Make the “cost unavailable” behavior data-driven so future providers with token-only usage can reuse it.
+- Update README and any config/docs references affected by the new provider-specific summary behavior.
+
+## Implementation Steps
+1. Update token summary formatting in [`src/utils/terminal-symbols.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/utils/terminal-symbols.ts) so cost output is conditional on exact-cost availability instead of always rendering a dollar value.
+2. Adjust any supporting token-tracker or usage-data helpers to preserve the distinction between exact zero and unavailable cost.
+3. Wire the updated summary behavior through [`src/commands/do.ts`](/Users/eremeev/.raf/worktrees/RAF/45-signal-lantern/src/commands/do.ts) for both per-task and grand-total reporting.
+4. Update README and related docs to explain that Codex currently reports token counts post-run, while dollar cost is shown only when the CLI provides an exact value.
+5. Add tests covering Codex token-only summaries and regression tests proving Claude still shows exact cost.
+
+## Acceptance Criteria
+- [ ] Codex task summaries show input/output tokens after execution.
+- [ ] Codex grand totals show input/output tokens after execution.
+- [ ] Codex summaries omit dollar cost when exact price is unavailable.
+- [ ] Claude summaries still show exact dollar cost.
+- [ ] No summary path prints a misleading `$0.00` for unknown Codex cost.
+- [ ] README reflects the current Codex token-only limitation.
+- [ ] Updated formatter and command-output tests pass.
+
+## Notes
+- If Codex later adds an exact per-run dollar-cost field, the display should start showing it through the same availability-aware path instead of introducing provider-specific formatting branches.

package/RAF/46-lantern-arc/decisions.md

@@ -0,0 +1,19 @@
+# Project Decisions
+
+## Should the spark alias be removed entirely or remapped to a different model?
+Remove entirely. Delete 'spark' from CodexModelAlias type, MODEL_ALIAS_TO_FULL_ID, tier ordering, VALID_CODEX_MODEL_ALIASES, and any other references including config-docs.md.
+
+## Should worktree cleanup be limited to the plan command or broader?
+Plan command only. Remove worktree references only from PlanCommandOptions interface and the plan command action handler.
+
+## Should token usage from multiple turn.completed events be summed or kept as last-only?
+Sum all token fields. Accumulate inputTokens, outputTokens, cacheReadInputTokens, cacheCreationInputTokens, and totalCostUsd across all turn.completed events in both claude-runner.ts and codex-runner.ts.
+
+## Where should effort appear in the compact display status line?
+Inside parentheses: (sonnet, medium, fast) - effort between model and fast flag.
+
+## What should happen with fast mode for Codex harness?
+Research whether Codex CLI supports fast mode. If it does, wire it up. If not, remove the fast setting entirely from Codex-related config paths (don't just warn - clean it up).
+
+## Which prompt files should be optimized?
+All three: planning.ts, execution.ts, and amend.ts.

package/RAF/46-lantern-arc/input.md

@@ -0,0 +1,6 @@
+- [ ] config wizard say: Important caveat: RAF only applies fast mode on Claude runners. Since your planning model is stillprovider: "codex", this setting will not change raf plan behavior. If you want actual fast-mode planning, I can switch models.plan to a Claude model and keep fast: true. Invetigate if it's possible to wire fast mode to codex harness. do if possible
+- [ ] optimise prompts for llms. focus if there is confusing statements and repeating statements. clarify or remove redundancy if so. try to be less verbose but still clear for llm
+- [ ] The PlanCommandOptions interface declares worktree?: boolean and the action handler reads options.worktree - clean this up, no --worktree flag needed
+- [ ] When multiple `turn.completed` events are emitted in a single `codex exec --json` run (e.g., tool-driven multi-turn executions), this assignment overwrites prior usage and keeps only the last turn's tokens. That makes per-task and run-level token summaries undercount actual usage for those sessions. The runner should merge successive `rendered.usageData` payloads instead of replacing them.
+- [ ] effort is not displayed in task execution status in 'raf do' compact
+- [ ] spark alias in the RAF codebase already maps to gpt-5.3-codex <- find that alias are remove, this is wrong

package/RAF/46-lantern-arc/outcomes/1-remove-spark-alias.md

@@ -0,0 +1,16 @@
+# Outcome: Remove spark alias
+
+## Summary
+Removed the `spark` model alias from the codebase. It incorrectly mapped to `gpt-5.3-codex` and has been eliminated entirely.
+
+## Changes Made
+- `src/types/config.ts`: Removed `'spark'` from `CodexModelAlias` type and `VALID_CODEX_MODEL_ALIASES` array
+- `src/utils/config.ts`: Removed `spark` from `MODEL_ALIAS_TO_FULL_ID`, `CODEX_MODEL_TIER_ORDER`, alias recognition condition, and updated JSDoc comment
+- `src/prompts/config-docs.md`: Removed `spark` row from the Codex models table; updated `codex` row description
+
+## Verification
+- No remaining `spark` references in `src/`
+- TypeScript compiles without errors
+- `codex` and `gpt54` aliases remain intact
+
+<promise>COMPLETE</promise>

package/RAF/46-lantern-arc/outcomes/2-clean-up-worktree-plan-command.md

@@ -0,0 +1,30 @@
+# Outcome: Clean up worktree flag from plan command
+
+## Summary
+Removed all dead worktree code from `runPlanCommand()` in `src/commands/plan.ts`. The `--worktree` flag was never exposed on the plan command, making `worktreeMode` and related logic unreachable dead code.
+
+## Changes Made
+- `src/commands/plan.ts`:
+  - Removed `worktree?: boolean` from `PlanCommandOptions` interface
+  - Removed `getWorktreeDefault` and `getSyncMainBranch` from config.js imports
+  - Removed `createWorktree`, `removeWorktree`, `pullMainBranch` from worktree.js imports
+  - Removed `getNextProjectNumber`, `formatProjectNumber`, `getDecisionsPath`, `getOutcomesDir` from paths.js imports
+  - Removed `sanitizeProjectName` import (was only used in worktree path construction)
+  - Removed `const worktreeMode = options.worktree ?? getWorktreeDefault()` from action handler
+  - Removed `worktreeMode` parameter from `runPlanCommand()` signature and call site
+  - Removed git validation block for worktree mode
+  - Removed worktree path variables (`worktreePath`, `worktreeBranch`) and all worktree creation logic
+  - Collapsed if/else into standard-mode-only project creation
+  - Simplified shutdown handler (removed worktree cleanup branch)
+  - Removed `worktreeMode` from `getPlanningPrompt()` call
+  - Removed `cwd: worktreePath ?? undefined` from `runInteractive()` call
+  - Simplified success message (removed worktree-specific branch)
+  - Simplified `commitPlanningArtifacts()` call (removed `cwd` option)
+  - Simplified finally block (removed worktree cleanup branch)
+
+## Verification
+- TypeScript compiles without errors
+- No `worktreeMode` or dead worktree references remain in `runPlanCommand()`
+- `runAmendCommand` and `runResumeCommand` retain their worktree support (still functional)
+
+<promise>COMPLETE</promise>

package/RAF/46-lantern-arc/outcomes/3-fix-token-usage-accumulation.md

@@ -0,0 +1,32 @@
+# Outcome: Fix token usage accumulation for multi-turn executions
+
+## Summary
+Implemented cumulative usage merging for streamed execution events so token and cost totals now reflect all `turn.completed`/`result` events in a run rather than only the last event.
+
+## Key Changes Made
+- Added shared merge utility in `src/utils/token-tracker.ts`:
+  - New `mergeUsageData(existing, incoming)` handles first-event initialization and incremental accumulation.
+  - Sums `inputTokens`, `outputTokens`, `cacheReadInputTokens`, `cacheCreationInputTokens`, and `totalCostUsd`.
+  - Merges `modelUsage` per model with the same accumulation behavior.
+  - Handles undefined/missing fields defensively to avoid `NaN`/crashes.
+- Updated runners to accumulate usage instead of overwrite:
+  - `src/core/codex-runner.ts`: replaced both `usageData = rendered.usageData` assignments with `mergeUsageData(...)`.
+  - `src/core/claude-runner.ts`: replaced both `usageData = rendered.usageData` assignments with `mergeUsageData(...)`.
+- Refactored existing usage aggregation internals to reuse shared merge logic:
+  - `accumulateUsage()` now folds through `mergeUsageData`.
+  - `TokenTracker.getTotals()` now merges per-task usage via `mergeUsageData`.
+- Added/updated tests:
+  - `tests/unit/codex-runner.test.ts`: added multi-`turn.completed` accumulation test.
+  - `tests/unit/claude-runner.test.ts`: added multi-`result` accumulation test.
+  - `tests/unit/token-tracker.test.ts`: added `mergeUsageData` behavior tests, including undefined/missing-field handling.
+
+## Verification
+- TypeScript build: `npm run -s build` passed.
+- Focused tests passed:
+  - `NODE_OPTIONS='--experimental-vm-modules' npx jest --watchman=false tests/unit/token-tracker.test.ts tests/unit/codex-runner.test.ts tests/unit/claude-runner.test.ts`
+- Note: default `npm test` invocation in this sandbox attempted Watchman and failed due socket permission restrictions; reran with `--watchman=false`.
+
+## Notes
+- No CLI surface/flags changed; README updates were not required.
+
+<promise>COMPLETE</promise>

package/RAF/46-lantern-arc/outcomes/4-display-effort-in-compact-mode.md

@@ -0,0 +1,22 @@
+# Outcome: Display frontmatter effort in compact task status
+
+## Summary
+Updated compact `raf do` task status lines to show the plan frontmatter effort (`low`/`medium`/`high`) instead of the model runtime `reasoningEffort` parameter.
+
+## Key Changes Made
+- `src/commands/do.ts`
+  - Added `currentEffort` tracking for compact status display metadata.
+  - Set `currentEffort` from `task.frontmatter?.effort` after model resolution.
+  - Updated compact status rendering for running/completed/failed lines to pass `effort: currentEffort`.
+  - Removed use of `currentModelReasoningEffort` in compact display call sites so runtime reasoning settings are no longer conflated with task effort frontmatter.
+
+## Verification
+- TypeScript build passed:
+  - `npm run -s build`
+- Focused tests passed:
+  - `NODE_OPTIONS='--experimental-vm-modules' npx jest --watchman=false tests/unit/terminal-symbols.test.ts tests/unit/do-model-display.test.ts`
+
+## Notes
+- Tasks without `effort` frontmatter continue to render model metadata without a blank effort slot because `formatModelMetadata` only appends effort when defined.
+
+<promise>COMPLETE</promise>

package/RAF/46-lantern-arc/outcomes/5-codex-fast-mode-research.md

@@ -0,0 +1,38 @@
+# Outcome: Codex fast mode research and config handling
+
+## Summary
+Verified Codex CLI capabilities and updated RAF to treat `fast` as Claude-only with explicit user-facing warnings for Codex entries.
+
+## Research Findings
+- Checked `codex --help` and `codex exec --help` directly.
+- No Codex fast mode flag is available in current CLI help output.
+- Conclusion: Codex fast mode is unsupported in RAF and should not be applied in Codex runner args.
+
+## Key Changes Made
+- `src/utils/config.ts`
+  - Added `collectConfigValidationWarnings()` to detect `fast: true` on `harness: "codex"` model entries.
+  - Added warning emission during `resolveConfig()` for those entries.
+  - Updated model-entry merge normalization to strip `fast` from resolved Codex entries so the unsupported setting is ignored consistently.
+- `src/commands/config.ts`
+  - Updated `raf config set` flow to emit the same config validation warnings after validation.
+- `src/prompts/config-docs.md`
+  - Clarified that Codex does not support fast mode and RAF warns/ignores `fast: true` on Codex entries.
+- `README.md`
+  - Added CLI note that fast mode is Claude-only and Codex `fast` settings are warned/ignored.
+- `tests/unit/config.test.ts`
+  - Added warning helper coverage for Codex `fast: true` entries.
+  - Added resolve-config coverage to verify Codex `fast` is warned and stripped.
+  - Removed stale `spark` alias expectations.
+- `tests/unit/config-command.test.ts`
+  - Added coverage that `raf config set` warns when setting Codex `fast: true`.
+- `AGENTS.md`
+  - Added agent note documenting Codex fast-mode warning/ignore behavior.
+
+## Verification
+- Build passed: `npm run -s build`
+- Focused tests passed:
+  - `NODE_OPTIONS='--experimental-vm-modules' npx jest --watchman=false tests/unit/config.test.ts tests/unit/config-command.test.ts`
+
+## Notes
+- `CodexRunner` was not modified because Codex CLI currently exposes no fast-mode capability to wire.
+<promise>COMPLETE</promise>

package/RAF/46-lantern-arc/outcomes/6-optimize-llm-prompts.md

@@ -0,0 +1,39 @@
+# Outcome: Optimize LLM prompts for clarity and conciseness
+
+## Summary
+Optimized all three prompt files (planning.ts, execution.ts, amend.ts) to remove redundancy, clarify structure, and reduce verbosity while preserving all functional requirements.
+
+## Key Changes Made
+
+### `src/prompts/planning.ts`
+- Merged "Step 4: Infer Task Dependencies" into Step 3's plan template section (dependency info was duplicated between the template, Step 4, and Important Rules)
+- Consolidated "Important Rules" (9 items) into a compact "Rules" section (3 items) — rules 1,2,5-7,9 were redundant with earlier sections
+- Merged "Step 2.5: Record Decisions" into Step 2 (Interview)
+- Removed "Your Goals" section (duplicated the role description)
+- Tightened Step 1 task identification guidance
+
+### `src/prompts/execution.ts`
+- Removed "Important Rules" section (8 items) — all were redundant with Steps 1-4 and Git Instructions
+- Removed "Error Handling" section — content merged into Step 2 and Step 4
+- Consolidated two "CRITICAL" callouts in Step 4 into streamlined outcome instructions
+- Simplified Step 2 guidelines (removed redundant "Add appropriate error handling")
+- Merged success/failure commit workflow into Step 4's marker section
+
+### `src/prompts/amend.ts`
+- Removed "Important Rules" (10 items) — rules 1-2 duplicated Amendment Mode, 7-8 duplicated template, 10 duplicated Frontmatter Requirements
+- Consolidated into compact "Rules" section (4 items)
+- Shortened section headings ("Protected Tasks (COMPLETED - cannot be modified)" → "Protected (COMPLETED)")
+- Merged "Step 3.5: Record Decisions" into Step 3
+- Tightened Step 2 follow-up task instructions
+
+### Test Updates
+- `tests/unit/planning-prompt.test.ts`: Updated string assertions to match new prompt wording
+- `tests/unit/execution-prompt.test.ts`: Updated assertions for removed/consolidated sections
+- `tests/unit/plan-command.test.ts`: Updated amend prompt assertions for shortened headings and wording
+
+## Verification
+- TypeScript build passes
+- All prompt-related tests pass (85 + 40 + 7 = 132 tests)
+- All functional requirements preserved — no behavioral changes
+
+<promise>COMPLETE</promise>

package/RAF/46-lantern-arc/plans/1-remove-spark-alias.md

@@ -0,0 +1,38 @@
+---
+effort: low
+---
+# Task: Remove spark alias
+
+## Objective
+Remove the incorrect `spark` model alias that maps to `gpt-5.3-codex` from the entire codebase.
+
+## Context
+The `spark` alias in the RAF codebase incorrectly maps to `gpt-5.3-codex`. This alias should be removed entirely rather than remapped.
+
+## Requirements
+- Remove `spark` from the `CodexModelAlias` type union
+- Remove `spark` from `VALID_CODEX_MODEL_ALIASES` array
+- Remove `spark` from `MODEL_ALIAS_TO_FULL_ID` mapping
+- Remove `spark` from codex model tier ordering
+- Remove `spark` from any recognition/resolution logic
+- Remove `spark` from `config-docs.md` documentation
+- Verify no other files reference the spark alias
+
+## Implementation Steps
+1. In `src/types/config.ts`:
+   - Remove `'spark'` from `CodexModelAlias` type (line ~8)
+   - Remove `'spark'` from `VALID_CODEX_MODEL_ALIASES` array (line ~129)
+2. In `src/utils/config.ts`:
+   - Remove `spark` entry from `MODEL_ALIAS_TO_FULL_ID` (line ~577)
+   - Remove `spark` from codex tier ordering (line ~453)
+   - Remove spark from alias recognition logic (line ~547)
+   - Clean up any comments mentioning spark
+3. In `src/prompts/config-docs.md`:
+   - Remove the `"spark"` documentation entry (line ~212)
+4. Search for any remaining `spark` references and remove them
+
+## Acceptance Criteria
+- [ ] `spark` does not appear in any TypeScript source files as a model alias
+- [ ] `spark` does not appear in config-docs.md
+- [ ] TypeScript compiles without errors
+- [ ] Remaining codex aliases (`codex`, `gpt54`) still work correctly

package/RAF/46-lantern-arc/plans/2-clean-up-worktree-plan-command.md

@@ -0,0 +1,33 @@
+---
+effort: low
+---
+# Task: Clean up worktree flag from plan command
+
+## Objective
+Remove the dead `worktree` option from the plan command's interface and action handler.
+
+## Context
+The `PlanCommandOptions` interface still declares `worktree?: boolean` and the action handler reads `options.worktree`, but there is no `--worktree` CLI flag exposed on the plan command. This is dead code that should be cleaned up.
+
+## Requirements
+- Remove `worktree?: boolean` from `PlanCommandOptions` interface
+- Remove `worktreeMode` variable and its usage from the action handler
+- Remove the `worktreeMode` parameter from `runPlanCommand()`
+- Remove worktree-related logic inside `runPlanCommand()` (lines ~148-151 git validation, lines ~205-243 worktree creation)
+- Remove any now-unused worktree imports
+
+## Implementation Steps
+1. In `src/commands/plan.ts`:
+   - Remove `worktree?: boolean` from `PlanCommandOptions` (line 56)
+   - Remove `const worktreeMode = options.worktree ?? getWorktreeDefault();` (line 74)
+   - Remove `worktreeMode` argument from `runPlanCommand()` call (line 87)
+   - Remove `worktreeMode` parameter from `runPlanCommand()` function signature (line 94)
+   - Remove worktree validation block (lines ~148-151)
+   - Remove worktree creation and path handling logic (lines ~205-243)
+   - Remove unused imports (`getWorktreeDefault`, worktree-related imports from `../core/worktree.js`)
+2. Verify the plan command still works for normal (non-worktree) flow
+
+## Acceptance Criteria
+- [ ] No `worktree` references remain in plan.ts (except possibly in unrelated comments)
+- [ ] TypeScript compiles without errors
+- [ ] No unused imports remain

package/RAF/46-lantern-arc/plans/3-fix-token-usage-accumulation.md

@@ -0,0 +1,33 @@
+---
+effort: medium
+---
+# Task: Fix token usage accumulation for multi-turn executions
+
+## Objective
+Merge successive `usageData` payloads from `turn.completed` events instead of overwriting them, so per-task and run-level token summaries reflect actual usage.
+
+## Context
+When multiple `turn.completed` events are emitted in a single `codex exec --json` or `claude --output-format stream-json` run (e.g., tool-driven multi-turn executions), the current code does `usageData = rendered.usageData` which overwrites prior usage and keeps only the last turn's tokens. This makes token summaries undercount actual usage.
+
+## Requirements
+- In both `codex-runner.ts` and `claude-runner.ts`, accumulate token counts across all `turn.completed` events
+- Sum numeric fields: `inputTokens`, `outputTokens`, `cacheReadInputTokens`, `cacheCreationInputTokens`, `totalCostUsd`
+- For `modelUsage` (if present), merge per-model entries similarly
+- Handle the case where `usageData` is initially undefined (first event) vs subsequent events
+
+## Implementation Steps
+1. Create a `mergeUsageData` utility function (either inline in each runner or in a shared utility like `src/utils/token-tracker.ts`):
+   - If existing is undefined, return the new data
+   - Otherwise, sum all numeric fields from both
+   - Merge `modelUsage` maps if present
+2. In `src/core/codex-runner.ts` (lines ~265-267 and ~287-289):
+   - Replace `usageData = rendered.usageData` with `usageData = mergeUsageData(usageData, rendered.usageData)`
+3. In `src/core/claude-runner.ts` (lines ~387-389 and ~409-411):
+   - Replace `usageData = rendered.usageData` with `usageData = mergeUsageData(usageData, rendered.usageData)`
+4. Check the `UsageData` interface in the types to understand all fields that need merging
+
+## Acceptance Criteria
+- [ ] Multi-turn executions report cumulative token counts, not just the last turn
+- [ ] Single-turn executions still work correctly (no regression)
+- [ ] TypeScript compiles without errors
+- [ ] The merge function handles undefined/missing fields gracefully

package/RAF/46-lantern-arc/plans/4-display-effort-in-compact-mode.md

@@ -0,0 +1,28 @@
+---
+effort: medium
+---
+# Task: Display effort level in compact mode task status
+
+## Objective
+Show the frontmatter effort level (low/medium/high) in the compact task status line during `raf do`.
+
+## Context
+The compact display during `raf do` shows model and fast flag in parentheses but not the effort level from the plan frontmatter. The `formatModelMetadata` function in `terminal-symbols.ts` already supports an `effort` option, and `do.ts` already passes `effort: currentModelReasoningEffort` — but `currentModelReasoningEffort` comes from `modelResolution.entry.reasoningEffort` (the model's reasoning effort parameter), NOT the frontmatter's effort field (low/medium/high). These are different concepts: frontmatter effort selects the model tier, while reasoningEffort is a runtime model parameter.
+
+## Requirements
+- Pass the frontmatter effort (low/medium/high) to the compact display
+- Show it inside parentheses: `(sonnet, medium, fast)`
+- Don't confuse it with `reasoningEffort` (model parameter)
+
+## Implementation Steps
+1. In `src/commands/do.ts`, add a variable to track the frontmatter effort level:
+   - Add `let currentEffort: string | undefined;` alongside the existing `currentModelReasoningEffort` tracking
+   - After `resolveTaskModel`, set `currentEffort = task.frontmatter?.effort;`
+2. Update the three display call sites (running ~line 827, completed ~line 1034, failed ~line 1069) to pass `effort: currentEffort` instead of `effort: currentModelReasoningEffort`
+3. Decide what to do with `currentModelReasoningEffort` — if it's not displayed anywhere else, it can be removed. If it serves another purpose, keep both.
+
+## Acceptance Criteria
+- [ ] Running task status shows effort: `● 01-task-name (sonnet, medium) 12s`
+- [ ] Effort displays correctly for low, medium, and high values
+- [ ] Tasks without effort frontmatter don't show a blank entry
+- [ ] TypeScript compiles without errors

package/RAF/46-lantern-arc/plans/5-codex-fast-mode-research.md

@@ -0,0 +1,34 @@
+---
+effort: medium
+---
+# Task: Research and wire fast mode for Codex harness
+
+## Objective
+Determine if the Codex CLI supports fast mode, and either wire it up or remove fast mode from Codex config paths entirely.
+
+## Context
+The config wizard says "RAF only applies fast mode on Claude runners" and config-docs.md states "Codex does not support fast mode." The user wants to know if this is actually true, and if Codex does support fast mode, wire it. If not, clean up by removing the fast setting from Codex-related paths rather than just warning.
+
+## Requirements
+- Research whether `codex exec` supports any fast mode flag (check `codex --help`, `codex exec --help`, or similar)
+- If supported: wire `fast: true` in `CodexRunner` similar to how `ClaudeRunner` does it
+- If NOT supported:
+  - Update `config-docs.md` to clarify fast mode is Claude-only (already says this - verify)
+  - Consider if validation should warn/strip `fast: true` from codex harness entries
+  - Update the config wizard prompt/docs to reflect this clearly
+
+## Implementation Steps
+1. Run `codex --help` and `codex exec --help` (or equivalent) to check for fast mode flags
+2. Search the codex-runner.ts for any existing fast mode references
+3. Based on findings:
+   - **If supported**: Add fast mode flag to `CodexRunner.run()` and `CodexRunner.runInteractive()` similar to `ClaudeRunner`
+   - **If NOT supported**:
+     - Verify config-docs.md accurately reflects this
+     - Add validation in `src/utils/config.ts` that warns if `fast: true` is set with codex harness
+     - Update any config wizard messaging
+
+## Acceptance Criteria
+- [ ] Fast mode either works with Codex or is explicitly unsupported with clear messaging
+- [ ] Config validation warns if user sets fast: true on a codex harness entry
+- [ ] config-docs.md is accurate
+- [ ] TypeScript compiles without errors

package/RAF/46-lantern-arc/plans/6-optimize-llm-prompts.md

@@ -0,0 +1,48 @@
+---
+effort: high
+---
+# Task: Optimize LLM prompts for clarity and conciseness
+
+## Objective
+Review and optimize the three main prompt files (planning.ts, execution.ts, amend.ts) to remove redundancy, clarify confusing statements, and reduce verbosity while preserving clarity for LLMs.
+
+## Dependencies
+1, 2
+
+## Context
+The prompts in this project are sent to LLMs and should be optimized for how LLMs process instructions. Common issues include: repeated instructions across sections, contradictory or confusing statements, unnecessary verbosity that wastes tokens without adding clarity, and instructions that could be consolidated.
+
+## Requirements
+- Review all three prompt files: `src/prompts/planning.ts`, `src/prompts/execution.ts`, `src/prompts/amend.ts`
+- Identify and remove redundant/repeated instructions
+- Clarify confusing or ambiguous statements
+- Reduce verbosity where possible without losing meaning
+- Preserve all functional requirements — don't remove instructions that change behavior
+- Keep the prompts well-structured and scannable
+
+## Implementation Steps
+1. Read `src/prompts/planning.ts` carefully and note:
+   - Repeated instructions (same thing said in multiple places)
+   - Confusing/contradictory statements
+   - Overly verbose sections that could be tightened
+2. Do the same for `src/prompts/execution.ts`
+3. Do the same for `src/prompts/amend.ts`
+4. Apply edits to each file:
+   - Consolidate repeated instructions into a single clear statement
+   - Rewrite confusing passages
+   - Trim verbose sections while preserving intent
+   - Ensure cross-references between prompts still make sense
+5. After editing, re-read each prompt end-to-end to verify coherence
+6. Note: Tasks 1 and 2 may have changed content in these files (spark alias removal, worktree cleanup from planning prompt). Work with the current state of the files.
+
+## Acceptance Criteria
+- [ ] No redundant/repeated instructions across sections within each prompt
+- [ ] No confusing or contradictory statements
+- [ ] Prompts are noticeably more concise
+- [ ] All functional requirements are preserved
+- [ ] TypeScript compiles without errors
+
+## Notes
+- This task depends on tasks 1 and 2 because those tasks modify content within the prompt files. This task should work with the already-cleaned-up versions.
+- Focus on LLM readability, not human readability. LLMs process instructions differently — clear structure and non-redundancy matter more than prose style.
+- Be conservative with the execution prompt — it's the most critical for correct task completion.

package/RAF/47-signal-trim/decisions.md

@@ -0,0 +1,13 @@
+# Project Decisions
+
+## For removing cache from status: should the cache fields be removed from UsageData/ModelTokenUsage interfaces entirely, or just hidden from display?
+Remove everything — delete cache fields from interfaces, tracking, display code, and the showCacheTokens config key.
+
+## What should the final status output look like?
+Compact single line: tokens in / out + cost (e.g., `12,345 in / 6,789 out — $0.42`).
+
+## For adding preset docs to the config wizard: what specific info should be included?
+Docs + wizard actions — add docs AND teach the wizard to run preset save/load/list/delete during the session.
+
+## What should the preset docs cover?
+Just the basics — storage path, CLI commands, name validation rules. Keep it minimal.

package/RAF/47-signal-trim/input.md

@@ -0,0 +1,2 @@
+- [ ] remove cache from 'plan do' status entirely. leave only tokens in / out and price $
+- [ ] add to config wizard docs info on how presets work so it can use it. presets path and cli api