rafcode 3.0.0 → 3.8.0

package/.claude/settings.local.json

@@ -34,7 +34,9 @@
       "Bash(git add:*)",
       "WebFetch(domain:support.claude.com)",
       "WebFetch(domain:www.anthropic.com)",
-      "Bash(ls:*)"
+      "Bash(ls:*)",
+      "Bash(git rebase:*)",
+      "Bash(npx tsc:*)"
     ]
   }
 }

package/CLAUDE.md

@@ -8,4 +8,3 @@ Node.js CLI tool that orchestrates task planning and execution via Claude Code C
 
 - Keep README.md updated when adding/changing CLI commands, flags, or features
 - This app has no users. Make whatever changes you want. This project is super greenfield. It's ok if you change the schema entirely.
-- The role of this file is to describe common mistakes and confusion points that agents might encounter as they work in this project. If you ever encounter something in the project that surprises you, please alert the developer working with you and indicate that this is the case in the AgentMD file to help prevent future agents from having the same issue.

package/RAF/38-dual-wielder/decisions.md

@@ -33,3 +33,12 @@ The existing project check is skipped in auto mode (`-y` flag). The condition `i
 
 ## Should `raf plan --amend` and auto-detect accept numeric project IDs?
 Yes. Both the explicit `--amend <id>` flow and the auto-detect prompt (`raf plan <identifier>`) should resolve numeric IDs (e.g., `raf plan --amend 38` or `raf plan 38`). Resolution should check both main-repo and worktree projects, consistent with name resolution.
+
+## What kind of Codex testing should be done?
+E2E only — actually run `raf plan` and `raf do` with `--provider codex` against a real dummy Node.js project. No unit tests for now.
+
+## What scenarios should Codex E2E testing cover?
+All scenarios: `raf plan --provider codex`, `raf do --provider codex`, config/model resolution, error handling, and edge cases. Sequential execution is fine (no need for parallel agents).
+
+## How should issues found during Codex testing be handled?
+Document only. List all issues in the outcome file. User decides what to fix after reviewing.

package/RAF/38-dual-wielder/input.md

@@ -5,4 +5,9 @@ agnostic
 ---
 
 - [ ] raf do should scan worktreee and non worktree projects
-- [ ] if command is like "raf plan project-name" - make sure to check if project with exact name exist (in main or worktree) and prompt to user whether he wants to amend (probably forgot to put --amend flag)
+- [ ] if command is like "raf plan project-name" - make sure to check if project with exact name exist (in main or worktree) and prompt to user whether he wants to amend (probably forgot to put --amend flag)
+
+---
+
+test codex by actually running raf on some dummy project folder. test as much scenarious as you
+can. use team and coordinate it. if something wrong - create task to fix

package/RAF/38-dual-wielder/outcomes/8-e2e-test-codex-provider.md

@@ -0,0 +1,139 @@
+# Task 8: E2E Test Codex Provider
+
+## Summary
+Tested the Codex provider integration end-to-end by running `raf-dev` commands with `--provider codex`, exercising the runner factory, config/model resolution, JSONL stream rendering, and error handling. Found **2 critical** and **1 major** issues.
+
+## Test Environment
+- codex-cli 0.116.0
+- Node.js v22.11.0
+- macOS Darwin 25.3.0
+- Codex account: ChatGPT-based (not API key)
+
+## Test Results
+
+### Phase 1: Dummy Project Setup — PASS
+- Created `/tmp/raf-codex-test-project/` with package.json, tsconfig.json, src/index.ts
+- Initialized git repo with initial commit
+- Project has intentional TODOs (input validation, negative numbers, email parsing)
+
+### Phase 2: Config/Model Resolution — PASS (all functions work correctly)
+
+| Test | Expected | Actual | Status |
+|------|----------|--------|--------|
+| `getModel('execute', 'codex')` | `gpt-5.4` | `gpt-5.4` | PASS |
+| `getModel('plan', 'codex')` | `gpt-5.3-codex` | `gpt-5.3-codex` | PASS |
+| `getModel('nameGeneration', 'codex')` | `gpt-5.3-codex-spark` | `gpt-5.3-codex-spark` | PASS |
+| `resolveEffortToModel('low', 'codex')` | `gpt-5.3-codex-spark` | `gpt-5.3-codex-spark` | PASS |
+| `resolveEffortToModel('medium', 'codex')` | `gpt-5.3-codex` | `gpt-5.3-codex` | PASS |
+| `resolveEffortToModel('high', 'codex')` | `gpt-5.4` | `gpt-5.4` | PASS |
+| `parseModelSpec('codex/gpt-5.4')` | `{provider:'codex',model:'gpt-5.4'}` | Correct | PASS |
+| `parseModelSpec('spark')` | `{provider:'codex',model:'spark'}` | Correct | PASS |
+| `isValidModelName('gpt-5.4')` | `true` | `true` | PASS |
+| `isValidModelName('codex/gpt-5.4')` | `true` | `true` | PASS |
+| `resolveFullModelId('spark')` | `gpt-5.3-codex-spark` | `gpt-5.3-codex-spark` | PASS |
+| `getModelShortName('gpt-5.3-codex')` | `codex` | `codex` | PASS |
+| `getModelTier('spark')` | `1` | `1` | PASS |
+| `getModelTier('gpt-5.4')` | `3` | `3` | PASS |
+
+### Phase 3: Runner Factory — PASS
+
+| Test | Expected | Actual | Status |
+|------|----------|--------|--------|
+| `createRunner({provider:'codex'})` | `CodexRunner` | `CodexRunner` | PASS |
+| `createRunner({provider:'claude'})` | `ClaudeRunner` | `ClaudeRunner` | PASS |
+| `createRunner()` (default) | `ClaudeRunner` | `ClaudeRunner` | PASS |
+| All ICliRunner methods exist on CodexRunner | 6 methods | 6 methods | PASS |
+| `runResume()` throws | Error: "not supported" | Correct | PASS |
+| `isRunning()` when idle | `false` | `false` | PASS |
+
+### Phase 4: JSONL Stream Renderer — FAIL (Critical)
+
+| Test | Expected | Actual | Status |
+|------|----------|--------|--------|
+| Parse real `item.completed` (agent_message) event | display + textContent | Both empty | **FAIL** |
+| Parse real `item.completed` (command_execution) event | display output | Empty | **FAIL** |
+| Parse real `turn.completed` (usage) event | Capture usage | Ignored | **FAIL** |
+| Parse real `error` event | Display error | Ignored | **FAIL** |
+| Parse real `turn.failed` event | Display failure | Ignored | **FAIL** |
+
+**Details**: The `codex-stream-renderer.ts` expects event types like `AgentMessage`, `CommandExecution`, `FileChange`, but the actual Codex CLI emits a completely different format:
+- Real: `{"type":"item.completed","item":{"type":"agent_message","text":"..."}}`
+- Expected: `{"type":"AgentMessage","content":"..."}`
+- Real: `{"type":"item.completed","item":{"type":"command_execution","command":"...","exit_code":0}}`
+- Expected: `{"type":"CommandExecution","command":"...","exit_code":0}`
+
+All real events hit the `default` case and produce empty output.
+
+### Phase 5: CodexRunner Non-Interactive Execution — FAIL (consequence of renderer bug)
+
+| Test | Expected | Actual | Status |
+|------|----------|--------|--------|
+| `run()` with gpt-5.4 (working model) | Output captured | Empty string | **FAIL** |
+| `runVerbose()` with gpt-5.4 | Verbose display + output | No display, empty output | **FAIL** |
+| Exit code with working model | 0 | 0 | PASS |
+| Exit code with unavailable model | Non-zero | 1 | PASS |
+| Timeout/contextOverflow flags | false when not triggered | false | PASS |
+| usageData | undefined | undefined | PASS (by design) |
+
+### Phase 6: `--provider` CLI Flag — FAIL (Major)
+
+| Test | Expected | Actual | Status |
+|------|----------|--------|--------|
+| `--provider codex` forwarded to `createRunner()` | provider passed | Never read from options | **FAIL** |
+| `--provider codex` forwarded to `resolveEffortToModel()` | provider passed | Not passed | **FAIL** |
+| `--provider codex` forwarded to `resolveModelOption()` | provider passed | Not passed | **FAIL** |
+
+**Details**: In both `do.ts` and `plan.ts`, the `--provider` option is declared via Commander but `options.provider` is never read. All calls to `createRunner()` omit the `provider` field. All calls to `resolveEffortToModel()` and `resolveModelOption()` omit the provider. The flag is completely inert.
+
+### Phase 7: Error Handling — PASS (partial)
+
+| Test | Expected | Actual | Status |
+|------|----------|--------|--------|
+| Missing codex binary (getCodexPath) | Error thrown | Error thrown (tested via code review) | PASS |
+| `runResume()` | Throws "not supported" | Correct | PASS |
+| Invalid model (codex returns error JSON) | Error surfaced | Error swallowed silently (renderer bug) | **FAIL** |
+| Kill / isRunning | Work correctly | Code review confirms correct pattern | PASS |
+
+### Phase 8: Model Availability — INFO (environment-specific)
+
+The configured default Codex models (`gpt-5.3-codex-spark`, `gpt-5.3-codex`) are not available on ChatGPT-based Codex accounts. Only `gpt-5.4` and the default model work. This is an environment issue, not a code bug, but the error is invisible due to the renderer bug.
+
+## Issues Found
+
+### Issue 1: CRITICAL — JSONL Stream Renderer Parses Wrong Event Format
+- **File**: `src/parsers/codex-stream-renderer.ts`
+- **Severity**: Critical
+- **Impact**: All non-interactive Codex runs produce empty output; verbose mode shows nothing; completion detection cannot work (relies on output text)
+- **Root cause**: Renderer expects event types `AgentMessage`, `CommandExecution`, etc. but real Codex CLI emits `item.completed`, `item.started`, `turn.completed`, `error`, `turn.failed` with nested `item` objects
+- **Suggested fix**: Rewrite switch to handle real event types: `item.completed` → check `item.type` for `agent_message` (text in `item.text`), `command_execution` (command in `item.command`), `file_change`, etc. Also handle `error` and `turn.failed` events. Consider extracting usage data from `turn.completed` events.
+
+### Issue 2: CRITICAL — `--provider` Flag is a No-Op
+- **File**: `src/commands/do.ts` (line 1036), `src/commands/plan.ts` (lines 289, 619, 802)
+- **Severity**: Critical
+- **Impact**: Users cannot actually use the Codex provider via CLI — the flag is accepted but ignored
+- **Root cause**: `options.provider` is never read from the Commander options object and never passed to `createRunner()`, `resolveEffortToModel()`, or `resolveModelOption()`
+- **Suggested fix**: Read `options.provider`, pass it through to all runner creation and model resolution calls. The `RunnerConfig` type already supports `provider`.
+
+### Issue 3: MAJOR — Codex Error Events Silently Swallowed
+- **File**: `src/parsers/codex-stream-renderer.ts`
+- **Severity**: Major (partially overlaps with Issue 1)
+- **Impact**: When Codex reports errors (invalid model, API failures), the runner returns exit code 0-1 with empty output and no error information
+- **Root cause**: `error` and `turn.failed` event types are not handled by the renderer
+- **Suggested fix**: Add handlers for `error` and `turn.failed` events that capture error messages in both `display` and `textContent`
+
+## What Works Correctly
+- Config schema and types for Codex models/effort mapping
+- Model resolution functions (`getModel`, `resolveEffortToModel`, `parseModelSpec`, etc.) when called with explicit provider parameter
+- Runner factory creates correct runner type for each provider
+- `RunnerConfig.provider` type exists and is used by factory
+- CodexRunner constructor, `kill()`, `isRunning()`, `runResume()` error
+- Command construction (`codex exec --full-auto --json --ephemeral -m <model>`) uses correct flags
+- Process spawning, timeout handling, PTY setup code structure
+- `usageData: undefined` doesn't break downstream consumers (guarded by `if (result.usageData)`)
+
+## Notes
+- Interactive mode (`runInteractive`) was not tested E2E because it requires PTY interaction which cannot be automated in this context. Code review shows the PTY setup follows the same pattern as ClaudeRunner.
+- The `raf-dev plan --provider codex` and `raf-dev do --provider codex` commands were not tested interactively because Issue 2 makes the flag inert and Issue 1 would prevent any output capture.
+- Timeout behavior was not stress-tested due to API costs, but the code structure is identical to ClaudeRunner's proven implementation.
+
+<promise>COMPLETE</promise>

package/RAF/38-dual-wielder/plans/8-e2e-test-codex-provider.md

@@ -0,0 +1,95 @@
+---
+effort: high
+---
+# Task: E2E Test Codex Provider
+
+## Objective
+Verify the Codex provider integration works end-to-end by running `raf-dev plan` and `raf-dev do` with `--provider codex` against a dummy Node.js project, documenting all issues found.
+
+## Context
+This is a follow-up to task 3 (implement-codex-runner). See outcome: /Users/eremeev/projects/RAF/RAF/38-dual-wielder/outcomes/3-implement-codex-runner.md
+
+Tasks 1-4 added Codex support (config schema, abstract runner, CodexRunner implementation, LLM-agnostic prompts) but none of this has been tested E2E against a real project. This task validates the full integration.
+
+## Dependencies
+3
+
+## Requirements
+- Create a simple dummy Node.js project to use as a test target
+- Run `raf-dev plan` and `raf-dev do` with `--provider codex` and verify real behavior
+- Use `raf-dev` (not `raf`) for all testing — this is the development binary
+- Test all major scenarios: planning, execution, config/model resolution, error handling
+- Document all issues found in the outcome — do NOT auto-create fix tasks
+- Sequential testing is fine (no need for parallel agents)
+
+## Implementation Steps
+
+### Phase 1: Set up dummy project
+
+1. Create a temporary dummy Node.js project folder (e.g., `/tmp/raf-codex-test-project/`) with:
+   - `package.json` with a name and basic scripts
+   - `src/index.ts` — a small file with a few intentional TODOs or bugs (e.g., a function that doesn't handle edge cases)
+   - `tsconfig.json` — basic TypeScript config
+   - Initialize a git repo in it (`git init && git add . && git commit`)
+2. The project should be simple enough that an LLM can meaningfully plan and execute tasks against it
+
+### Phase 2: Test `raf-dev plan --provider codex`
+
+3. Run `raf-dev plan --provider codex` targeting the dummy project
+   - Provide a simple input like "add input validation to the exported functions"
+   - Verify: Does the PTY spawn correctly? Does Codex receive the prompt?
+   - Verify: Are plan files generated with correct frontmatter?
+   - Verify: Does the interactive planning session complete without crashes?
+4. Check the generated plan files — are they well-formed? Do they have the expected structure?
+
+### Phase 3: Test `raf-dev do --provider codex`
+
+5. Run `raf-dev do --provider codex` on the planned project
+   - Verify: Does task execution start correctly?
+   - Verify: Is the `codex exec --full-auto --json --ephemeral` command constructed properly?
+   - Verify: Does JSONL stream output display correctly in verbose mode?
+   - Verify: Does completion detection work (outcome file, commit verification)?
+   - Verify: Does the task complete and produce an outcome file?
+6. Check the outcome files and any commits made — are they correct?
+
+### Phase 4: Test config/model resolution
+
+7. Test that `--provider codex` correctly overrides the default provider in config
+8. Test effort-based model resolution for codex:
+   - A plan with `effort: low` should use `gpt-5.3-codex-spark`
+   - A plan with `effort: medium` should use `gpt-5.3-codex`
+   - A plan with `effort: high` should use `gpt-5.4`
+9. Test explicit model override in plan frontmatter (e.g., `model: codex/gpt-5.4`)
+
+### Phase 5: Test error handling and edge cases
+
+10. Test what happens when `codex` binary is not in PATH (temporarily rename or use a bad path)
+11. Test timeout behavior — does a long-running task get terminated correctly?
+12. Test that `runResume` correctly throws "not supported" for Codex
+13. Test behavior with malformed/unexpected Codex output
+14. Verify that usage data being `undefined` for Codex doesn't break any display or logging code
+
+### Phase 6: Document results
+
+15. Create a comprehensive outcome document listing:
+    - Each scenario tested and its result (PASS/FAIL)
+    - Detailed description of any failures or unexpected behavior
+    - Severity assessment for each issue (critical/major/minor)
+    - Suggested fixes for each issue found
+
+## Acceptance Criteria
+- [ ] Dummy Node.js project created and initialized with git
+- [ ] `raf-dev plan --provider codex` tested and results documented
+- [ ] `raf-dev do --provider codex` tested and results documented
+- [ ] Config/model resolution tested for codex provider
+- [ ] Error handling and edge cases tested
+- [ ] Comprehensive outcome document listing all issues found with severity
+
+## Notes
+- This task requires the `codex` CLI to be installed and available in PATH
+- If Codex CLI is not available, document that as the first finding and test what you can without it (e.g., error handling for missing binary, config resolution logic)
+- Focus on documenting issues clearly — the user will decide what to fix based on the outcome
+- When testing interactively (raf-dev plan), you may need to provide input via the PTY — document any difficulties with this
+- Check `src/core/codex-runner.ts` for the actual command construction to verify correctness
+- Check `src/core/runner-factory.ts` to verify provider routing
+- Check `src/utils/config.ts` for model resolution logic

package/RAF/39-pathless-rover/decisions.md

@@ -0,0 +1,16 @@
+# Project Decisions
+
+## Should the JSONL stream renderer support both old and new event formats, or replace entirely?
+The "old" format is not old — it's the Claude event format. The renderer should add Codex-specific event handling (item.completed, turn.completed, etc.) alongside the existing Claude event handling. Claude should continue to work as before.
+
+## For removing --worktree: when creating a NEW project with raf plan, should it always create a worktree or use config default?
+Config default. --worktree and --no-worktree flags should STILL be supported for `raf plan` (new project creation). They determine where the new project will be created. But for --amend and auto-amend flows, the flag should be removed — auto-detect where the project lives.
+
+## For raf plan --amend: if project exists in main but not worktree, auto-create worktree or amend in-place?
+Amend in-place. Follow where the project lives — if in main repo, amend there; if in worktree, amend there.
+
+## For raf do: just remove --worktree/--no-worktree flags, or deeper refactor?
+Just remove flags. The existing auto-detection logic already scans both worktree and main. Just remove the CLI flags and let auto-detection be the only path.
+
+## Should auto-amend detection (name collision in raf plan) scan worktrees too?
+Yes, scan both main repo and worktrees for name collisions during auto-amend detection.

package/RAF/39-pathless-rover/input.md

@@ -0,0 +1,2 @@
+fix all issues in RAF/38-dual-wielder/outcomes/8-e2e-test-codex-provider.md
+- [ ] raf do should be agnostic of --migration flag, scan worktree and main. remove --worktree entirely. same for --amend flow in raf plan. basically

package/RAF/39-pathless-rover/outcomes/1-fix-codex-stream-renderer.md

@@ -0,0 +1,21 @@
+# Task 1: Fix Codex JSONL Stream Renderer
+
+## Summary
+Updated `codex-stream-renderer.ts` to handle the real Codex CLI event format (nested `item.completed` events) while preserving existing Claude flat-format handlers.
+
+## Changes Made
+
+### File: `src/parsers/codex-stream-renderer.ts`
+- Extended `CodexEvent` interface with `item` (nested object), `message`, and `usage` fields
+- Added `item.completed` handler that dispatches on `item.type`: `agent_message`, `command_execution`, `file_change`
+- Added `item.started` handler (no-op, renders on completion)
+- Added `turn.completed` handler that extracts and displays usage data
+- Added `error` handler — outputs error message in both `display` and `textContent`
+- Added `turn.failed` handler — outputs failure message in both `display` and `textContent`
+- All existing Claude-format handlers (`AgentMessage`, `CommandExecution`, `FileChange`, `McpToolCall`, `TodoList`) remain untouched
+
+## Verification
+- TypeScript compiles without errors (`npm run build`)
+- All acceptance criteria met
+
+<promise>COMPLETE</promise>

package/RAF/39-pathless-rover/outcomes/2-wire-provider-flag.md

@@ -0,0 +1,28 @@
+# Task 2: Wire --provider CLI Flag Through to Runner and Model Resolution
+
+## Summary
+Wired the inert `--provider` CLI flag through to `createRunner()` and `resolveEffortToModel()` in both `do.ts` and `plan.ts`, so that `--provider codex` actually creates a `CodexRunner` and uses the codex effort mapping.
+
+## Changes Made
+
+### File: `src/commands/do.ts`
+- Added `provider` field to `SingleProjectOptions` interface
+- Pass `options.provider` through `executeSingleProject` to the task execution loop
+- Updated `resolveTaskModel()` to accept an optional `provider` parameter and pass it to `resolveEffortToModel()`
+- Pass `provider` to `createRunner({ model, provider })` in the task retry loop
+
+### File: `src/commands/plan.ts`
+- Read `options.provider` in the action handler
+- Pass `provider` through to `runPlanCommand()`, `runAmendCommand()`, and `runResumeCommand()`
+- Pass `provider` to all three `createRunner({ model, provider })` call sites
+- Pass `provider` through the duplicate-project amend redirect flow
+
+## Verification
+- TypeScript compiles without errors (`npm run build`)
+- All acceptance criteria met:
+  - `raf do --provider codex` will create a `CodexRunner` (provider flows to `createRunner`)
+  - `raf plan --provider codex` will create a `CodexRunner` for planning sessions
+  - `resolveEffortToModel` receives the provider param for codex effort mapping
+  - TypeScript compiles cleanly
+
+<promise>COMPLETE</promise>

package/RAF/39-pathless-rover/outcomes/3-remove-worktree-flag-do.md

@@ -0,0 +1,41 @@
+# Task 3: Remove --worktree Flag from raf do — Auto-detect Project Location
+
+## Summary
+Removed `--worktree` and `--no-worktree` CLI flags from `raf do`. Project location (worktree vs main repo) is now always auto-detected. The combined picker and worktree-first resolution are the only code paths.
+
+## Changes Made
+
+### File: `src/commands/do.ts`
+- Removed `-w, --worktree` and `--no-worktree` option lines from `createDoCommand()`
+- Removed `worktreeMode` variable and all assignments to it
+- Removed the early `if (worktreeMode)` block that did worktree-specific setup — the combined picker flow now handles both worktree and main projects
+- Replaced `if (worktreeMode)` in resolution with `if (worktreeRoot)` — when the picker sets worktreeRoot, resolve within that worktree; otherwise auto-detect (worktree first, then main)
+- Moved main branch sync (`pullMainBranch`) to after project resolution, triggered by `worktreeRoot` being set
+- Replaced `worktreeMode && worktreeRoot` guards with just `worktreeRoot`
+- Removed unused `discoverAndPickWorktreeProject` function
+- Cleaned up unused imports: `getWorktreeDefault`, `discoverProjects`, `formatProjectChoice`, `computeWorktreePath`, `computeWorktreeBaseDir`, `validateWorktree`, `listWorktreeProjects`
+
+### File: `src/types/config.ts`
+- Removed `worktree?: boolean` from `DoCommandOptions` interface
+
+### File: `src/commands/plan.ts`
+- Removed `--worktree` from `raf do` suggestions in user-facing log messages (2 locations)
+
+### File: `src/prompts/planning.ts`
+- Removed `worktreeFlag` variable and `worktreeMode` destructuring — `raf do` instruction no longer includes `--worktree`
+
+### File: `src/prompts/amend.ts`
+- Removed `worktreeFlag` variable and `worktreeMode` destructuring — `raf do` instruction no longer includes `--worktree`
+
+### File: `src/prompts/config-docs.md`
+- Updated `worktree` config description to note that `raf do` auto-detects regardless of this setting
+
+## Verification
+- TypeScript compiles without errors (`npm run build`)
+- All acceptance criteria met:
+  - `raf do` CLI no longer accepts `--worktree` or `--no-worktree`
+  - `raf do` (no args) shows combined picker of worktree + main projects
+  - `raf do <project>` auto-detects if project is in worktree or main
+  - Post-execution worktree actions (merge/PR/leave) still work correctly (triggered by `worktreeRoot`)
+
+<promise>COMPLETE</promise>

package/RAF/39-pathless-rover/outcomes/4-remove-worktree-flag-plan-amend.md

@@ -0,0 +1,30 @@
+# Task 4: Remove --worktree Flag from raf plan --amend — Auto-detect Project Location
+
+## Summary
+Modified `runAmendCommand` to auto-detect whether a project lives in a worktree or main repo, removing the `worktreeMode` parameter. The `--worktree`/`--no-worktree` flags remain on the `plan` command for new project creation only.
+
+## Changes Made
+
+### File: `src/commands/plan.ts`
+- Removed `worktreeMode` parameter from `runAmendCommand` signature
+- Replaced the complex worktree-mode branch (manual worktree scanning, branch recreation, fresh worktree creation with file copying) with simple auto-detection: try `resolveWorktreeProjectByIdentifier()` first, fall back to `resolveProjectIdentifierWithDetails()` in main repo
+- Updated both call sites (explicit `--amend` at line ~104 and auto-amend at line ~158) to no longer pass `worktreeMode`
+- Removed `existingWorktreeMode` variable from auto-amend detection flow
+- Removed redundant if/else for `raf do` suggestion (both branches were identical)
+- Simplified `worktreeMode && worktreePath` guard to just `worktreePath`
+- Removed `worktreeMode` from `getAmendPrompt()` call
+- Cleaned up unused imports: `createWorktreeFromBranch`, `branchExists`, `computeWorktreeBaseDir`
+
+### File: `src/prompts/amend.ts`
+- Removed `worktreeMode?: boolean` from `AmendPromptParams` interface
+
+## Verification
+- TypeScript compiles without errors (`npm run build`)
+- All acceptance criteria met:
+  - `raf plan myproject --amend` finds project in worktree without needing `--worktree` flag
+  - `raf plan myproject --amend` finds project in main repo without needing `--no-worktree` flag
+  - `raf plan myproject` (name collision) detects projects in both worktree and main
+  - `--worktree`/`--no-worktree` flags still work for new project creation
+  - TypeScript compiles without errors
+
+<promise>COMPLETE</promise>

package/RAF/39-pathless-rover/outcomes/5-update-prompts-and-docs.md

@@ -0,0 +1,26 @@
+# Task 5: Update Prompts, Docs, and Config Docs for Removed --worktree Flag
+
+## Summary
+Updated README.md to remove stale `--worktree` references for `raf do`. The `raf plan` command still supports `--worktree` for new project creation, so those references were preserved.
+
+## Changes Made
+
+### File: `README.md`
+- Removed `raf do --worktree` and `raf do my-feature -w` examples from the `raf do` usage block
+- Updated "Basic workflow" in Worktree Mode section: `raf do my-feature --worktree` → `raf do my-feature` with note "(auto-detected, no flag needed)"
+- Added bullet in "How it works" section: `raf do` auto-detects whether a project lives in a worktree — no `--worktree` flag needed
+- Clarified `--no-worktree` bullet to specify it applies to `raf plan` (not `raf do`)
+- Removed `-w, --worktree` and `--no-worktree` rows from `raf do` command reference table
+
+## No Changes Needed
+- `src/prompts/planning.ts` — already cleaned up in Task 3
+- `src/prompts/amend.ts` — already cleaned up in Task 3
+- `src/prompts/config-docs.md` — already accurate (references are specific to `raf plan --worktree`, which still has the flag)
+- `src/commands/do.ts` — already cleaned up in Task 3
+
+## Verification
+- TypeScript compiles without errors (`npm run build`)
+- All remaining `--worktree` references are scoped to `raf plan` (still valid)
+- No stale `--worktree` references for `raf do` or `raf plan --amend`
+
+<promise>COMPLETE</promise>

package/RAF/39-pathless-rover/plans/1-fix-codex-stream-renderer.md

@@ -0,0 +1,43 @@
+---
+effort: medium
+---
+# Task: Fix Codex JSONL Stream Renderer for Real Event Format
+
+## Objective
+Update the Codex stream renderer to handle the actual event format emitted by Codex CLI, while preserving existing Claude event handling.
+
+## Context
+The Codex CLI emits events in a nested format (`item.completed` with `item.type` sub-fields) but the renderer expects flat event types (`AgentMessage`, `CommandExecution`). This causes all Codex output to be silently dropped. The existing flat event types are used by Claude's renderer and must be preserved — this is NOT an "old" format, it's the Claude format.
+
+## Requirements
+- Handle real Codex CLI event types: `item.completed`, `item.started`, `turn.completed`, `error`, `turn.failed`
+- For `item.completed`, dispatch on `item.type`: `agent_message` (text in `item.text`), `command_execution` (command in `item.command`), `file_change`
+- Handle `error` and `turn.failed` events — capture error messages in both `display` and `textContent`
+- Extract usage data from `turn.completed` events if available
+- Keep existing `AgentMessage`, `CommandExecution`, `FileChange`, `McpToolCall`, `TodoList` handlers intact — these are for Claude
+- Update the `CodexEvent` interface to model the real nested event structure
+
+## Implementation Steps
+1. Read `src/parsers/codex-stream-renderer.ts` to understand current structure
+2. Update the `CodexEvent` interface to include nested item structure:
+   - Add `item?: { type: string; text?: string; command?: string; exit_code?: number; path?: string; ... }`
+   - Add fields for `error`, `turn.failed`, `turn.completed` events
+3. Add new cases to the switch statement for real Codex event types:
+   - `item.completed` → check `event.item.type` and dispatch to appropriate renderer
+   - `item.started` → optionally render (or skip)
+   - `turn.completed` → extract usage data if present
+   - `error` → render error message in both display and textContent
+   - `turn.failed` → render failure message in both display and textContent
+4. Keep all existing cases (`AgentMessage`, `CommandExecution`, etc.) untouched
+5. Build and verify no type errors
+
+## Acceptance Criteria
+- [ ] Real Codex `item.completed` events with `agent_message` type produce text output
+- [ ] Real Codex `item.completed` events with `command_execution` type show command status
+- [ ] `error` and `turn.failed` events produce visible error output in both display and textContent
+- [ ] Existing Claude event handlers (`AgentMessage`, `CommandExecution`, etc.) continue to work unchanged
+- [ ] TypeScript compiles without errors
+
+## Notes
+- Reference the outcomes file at `RAF/38-dual-wielder/outcomes/8-e2e-test-codex-provider.md` for exact real event JSON samples
+- The `RenderResult` interface from `stream-renderer.ts` is the return type — keep using it

package/RAF/39-pathless-rover/plans/2-wire-provider-flag.md

@@ -0,0 +1,48 @@
+---
+effort: medium
+---
+# Task: Wire --provider CLI Flag Through to Runner and Model Resolution
+
+## Objective
+Make the `--provider` CLI flag actually work by reading `options.provider` and passing it to `createRunner()`, `resolveEffortToModel()`, and `resolveModelOption()`.
+
+## Context
+Both `do.ts` and `plan.ts` declare a `--provider` option via Commander, but `options.provider` is never read. All calls to `createRunner()` omit the `provider` field, and all calls to `resolveEffortToModel()` omit the provider parameter. The flag is completely inert.
+
+## Dependencies
+1
+
+## Requirements
+- Read `options.provider` from Commander options in both `do.ts` and `plan.ts`
+- Pass provider to `createRunner({ model, provider })` in all call sites
+- Pass provider to `resolveEffortToModel(effort, provider)` in `do.ts` (line ~125 where effort mapping happens)
+- Pass provider to `resolveModelOption()` — this function may need a new parameter added to accept provider
+- Ensure `resolveModelOption` in `src/utils/validation.ts` can handle provider-aware model resolution (it currently returns `ClaudeModelName` — may need to return a more general type or use the existing `parseModelSpec` logic)
+
+## Implementation Steps
+1. Read `src/commands/do.ts` — find all `createRunner()` and `resolveEffortToModel()` calls
+2. Read `src/commands/plan.ts` — find all `createRunner()` calls
+3. Read `src/utils/validation.ts` — understand `resolveModelOption()` signature
+4. Read `src/core/runner-factory.ts` — confirm `RunnerConfig` already has `provider` field
+5. In `do.ts`:
+   - Read `options.provider` at the top of `runDoCommand`
+   - Pass `provider` to `resolveModelOption()` (update its signature if needed)
+   - Pass `provider` to all `createRunner()` calls: `createRunner({ model, provider })`
+   - Pass `provider` to all `resolveEffortToModel()` calls
+6. In `plan.ts`:
+   - Read `options.provider` in the action handler
+   - Pass through to `runPlanCommand`, `runAmendCommand`, `runResumeCommand`
+   - Pass `provider` to all `createRunner()` calls
+   - Pass `provider` to `resolveModelOption()` if applicable
+7. Update `resolveModelOption()` signature if needed to accept optional provider
+8. Build and verify no type errors
+
+## Acceptance Criteria
+- [ ] `raf do --provider codex` creates a `CodexRunner` instead of `ClaudeRunner`
+- [ ] `raf plan --provider codex` creates a `CodexRunner` for planning sessions
+- [ ] `resolveEffortToModel` uses codex effort mapping when `--provider codex` is passed
+- [ ] TypeScript compiles without errors
+
+## Notes
+- The `RunnerConfig` type in runner-factory.ts already supports `provider` — just need to pass it through
+- `resolveEffortToModel` in config.ts already accepts an optional `provider` parameter — just not being called with one from the commands

package/RAF/39-pathless-rover/plans/3-remove-worktree-flag-do.md

@@ -0,0 +1,41 @@
+---
+effort: medium
+---
+# Task: Remove --worktree Flag from raf do — Auto-detect Project Location
+
+## Objective
+Remove the `--worktree` and `--no-worktree` CLI flags from `raf do` and make project discovery always scan both worktree and main repo locations automatically.
+
+## Context
+`raf do` already has auto-detection logic that checks worktrees first and auto-switches to worktree mode when a project is found there. The `--worktree` flag is largely redundant. Removing it simplifies the CLI and prevents user confusion. The existing scanning/auto-detection behavior becomes the only path.
+
+## Requirements
+- Remove `-w, --worktree` and `--no-worktree` options from the Commander definition in `do.ts`
+- Remove `worktreeMode` variable that reads from `options.worktree ?? getWorktreeDefault()`
+- Ensure the unified project discovery flow (scanning both worktree and main, with worktree taking precedence) is always active
+- The post-execution actions (merge, PR, leave) should still work when a project is in a worktree
+- Error messages should not reference `--worktree` flag
+- Remove `DoCommandOptions.worktree` from the options interface if it exists
+
+## Implementation Steps
+1. Read `src/commands/do.ts` fully to understand all worktree flag references
+2. Remove the `-w, --worktree` and `--no-worktree` option lines from `createDoCommand()`
+3. Remove `worktreeMode = options.worktree ?? getWorktreeDefault()` — instead, derive worktree mode from where the project is actually found
+4. Simplify the branching logic:
+   - The "if worktreeMode" block (lines ~233-268) that does early worktree-specific setup should be folded into the general flow
+   - The unified project picker (lines ~270-314) should always run when no identifier is provided
+   - When an identifier IS provided, the existing resolution logic (try worktree first, then main) should be the only path
+5. Keep all worktree execution logic intact (worktreeRoot, originalBranch, post-actions) — these are determined by where the project is found, not by a flag
+6. Update any error messages that reference `--worktree`
+7. Build and verify no type errors
+
+## Acceptance Criteria
+- [ ] `raf do` CLI no longer accepts `--worktree` or `--no-worktree`
+- [ ] `raf do` (no args) shows combined picker of worktree + main projects
+- [ ] `raf do <project>` auto-detects if project is in worktree or main
+- [ ] Post-execution worktree actions (merge/PR/leave) still work correctly
+- [ ] TypeScript compiles without errors
+
+## Notes
+- Be careful with the `originalBranch` recording — it's currently done early in the worktree block but still needs to happen when a worktree project is selected
+- The `pullMainBranch` sync logic should still run when executing in a worktree — just triggered by project location rather than flag

package/RAF/39-pathless-rover/plans/4-remove-worktree-flag-plan-amend.md

@@ -0,0 +1,43 @@
+---
+effort: medium
+---
+# Task: Remove --worktree Flag from raf plan --amend — Auto-detect Project Location
+
+## Objective
+Make `raf plan --amend` auto-detect whether a project lives in a worktree or main repo, removing the need for `--worktree`/`--no-worktree` flags in the amend flow. Keep the flags for NEW project creation only.
+
+## Context
+When amending an existing project, the project already exists somewhere — either in main repo or a worktree. The tool should find it and amend in-place rather than requiring the user to specify `--worktree`. The `--worktree`/`--no-worktree` flags remain valid for `raf plan` (new project creation) since they control WHERE the project gets created.
+
+## Dependencies
+3
+
+## Requirements
+- `raf plan <project> --amend` should auto-detect project location (main repo or worktree) and amend there
+- `raf plan <project>` (auto-amend via name collision) should scan BOTH main repo and worktrees for matches
+- The `--worktree`/`--no-worktree` flags should still exist on the `plan` command for new project creation
+- When amend flow is triggered, ignore the `--worktree` flag value — always use auto-detected location
+- `runAmendCommand` should no longer accept a `worktreeMode` boolean — it should determine this internally
+
+## Implementation Steps
+1. Read `src/commands/plan.ts` fully — understand `runAmendCommand` and the auto-amend detection in `runPlanCommand`
+2. Modify `runAmendCommand` signature to remove `worktreeMode` parameter
+3. Inside `runAmendCommand`, auto-detect project location:
+   - First check main repo with `resolveProjectIdentifierWithDetails()`
+   - Then check worktrees with `resolveWorktreeProjectByIdentifier()`
+   - Use whichever location has the project (worktree takes precedence if both exist, matching existing picker behavior)
+4. Update the auto-amend detection in `runPlanCommand` (lines ~122-163):
+   - It already scans both main and worktrees — ensure the detected `existingWorktreeMode` is passed correctly to `runAmendCommand` (or let `runAmendCommand` detect it internally)
+5. Update the call site at line ~102 where `runAmendCommand` is called with `worktreeMode`
+6. Update the call site at line ~156 where auto-amend calls `runAmendCommand`
+7. Build and verify no type errors
+
+## Acceptance Criteria
+- [ ] `raf plan myproject --amend` finds project in worktree without needing `--worktree` flag
+- [ ] `raf plan myproject --amend` finds project in main repo without needing `--no-worktree` flag
+- [ ] `raf plan myproject` (name collision) detects projects in both worktree and main
+- [ ] `--worktree`/`--no-worktree` flags still work for new project creation
+- [ ] TypeScript compiles without errors
+
+## Notes
+- The existing amend logic in lines ~400-700 has complex worktree resolution (recreating worktrees from branches, copying files). When auto-detecting, this should simplify: just find where the project is and amend there. No need to create worktrees for amend.