rafcode 3.0.0 → 3.2.1

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

@@ -0,0 +1,31 @@
+---
+effort: low
+---
+# Task: Update Prompts, Docs, and Config Docs for Removed --worktree Flag
+
+## Objective
+Update all user-facing text (prompts, help text, docs, config documentation) to reflect that `--worktree` is no longer needed for `raf do` and `raf plan --amend`.
+
+## Dependencies
+3, 4
+
+## Requirements
+- Update planning prompt output that suggests `raf do <project> --worktree` → just `raf do <project>`
+- Update amend prompt output if it references `--worktree`
+- Update config-docs.md if it documents the `--worktree` flag behavior for `do` or `amend`
+- Update README.md CLI usage sections
+- Remove any references to `--worktree` in error messages that were in `do.ts`
+
+## Implementation Steps
+1. Read `src/prompts/planning.ts` — update the exit message that suggests `--worktree`
+2. Read `src/prompts/amend.ts` — update if it references `--worktree`
+3. Read `src/prompts/config-docs.md` — update worktree config documentation
+4. Read `README.md` — update CLI usage for `raf do` and `raf plan`
+5. Grep for any remaining `--worktree` references across the codebase and update as needed
+
+## Acceptance Criteria
+- [ ] No prompts suggest `--worktree` for `raf do`
+- [ ] No prompts suggest `--worktree` for `raf plan --amend`
+- [ ] README accurately reflects current CLI flags
+- [ ] Config docs accurately describe worktree behavior
+- [ ] No stale `--worktree` references in codebase (except for `raf plan` new project creation where it's still valid)

package/RAF/40-numeric-order-fix/decisions.md

@@ -0,0 +1,7 @@
+# Project Decisions
+
+## Should the fix be a shared helper function or inline fixes at each call site?
+Shared helper function — create one numeric sort utility and use it everywhere for DRY and consistency.
+
+## Which Codex-related keywords should be added to package.json?
+codex, openai-codex, claude-code, agentic-coding, coding-agent — broader set including agentic coding terms.

package/RAF/40-numeric-order-fix/input.md

@@ -0,0 +1,19 @@
+- [ ] raf do executes task in lexigraphical order (1 then 10). should execute in order of numbers **➜**  **BindNotes** **git:(****main****)** raf do 
+
+✔ **Select a project to execute:** 14 mosaic-drift (0/19 tasks) [worktree]
+
+✔ **After tasks complete, what should happen with branch "14-mosaic-drift"?** Merge into current branch
+
+Rebased onto main
+
+RAF v3.0.0 | Ceiling: claude-opus-4-6
+
+▶ mosaic-drift (19 tasks)
+
+  Press Tab to toggle verbose mode
+
+✓ 1-archived-notebook-name-validation (opus) 5m 6s 
+
+  Tokens: 25 in / 7,798 out | Cost: $1.06
+
+● 10-localize-dutch (sonnet) 43s

package/RAF/40-numeric-order-fix/outcomes/1-fix-numeric-sort-order.md

@@ -0,0 +1,18 @@
+# Outcome: Fix numeric sort order for plan/outcome files
+
+## Summary
+Added a `numericFileSort` comparator helper and replaced all lexicographical `.sort()` calls on plan/outcome file lists with numeric sorting.
+
+## Changes Made
+
+- **`src/utils/paths.ts`**: Added `numericFileSort(a, b)` export that uses `parseInt` to compare leading numeric prefixes.
+- **`src/core/state-derivation.ts`**: Updated plan files sort (line ~201) and outcome files sort (line ~208) to use `numericFileSort`.
+- **`src/commands/plan.ts`**: Updated three `.sort()` calls (lines ~342, ~565, ~726) to use `numericFileSort`.
+- **`src/core/project-manager.ts`**: Updated outcome files sort (line ~146) to use `numericFileSort`.
+- **`src/core/pull-request.ts`**: Updated outcome files sort (line ~211) to use `numericFileSort`.
+
+## Verification
+- Build passes with `npm run build` (no TypeScript errors).
+- Files named `1-x.md` through `19-x.md` now sort as 1, 2, 3, ..., 10, ..., 19.
+
+<promise>COMPLETE</promise>

package/RAF/40-numeric-order-fix/outcomes/2-add-npm-keywords.md

@@ -0,0 +1,10 @@
+# Outcome: Add Codex and agentic coding keywords to package.json
+
+## Summary
+Added five new discoverability keywords to `package.json` to make the package findable via Codex and agentic coding search terms on npm.
+
+## Changes Made
+
+- **`package.json`**: Added `codex`, `openai-codex`, `claude-code`, `agentic-coding`, `coding-agent` to the `keywords` array. All existing keywords remain intact.
+
+<promise>COMPLETE</promise>

package/RAF/40-numeric-order-fix/plans/1-fix-numeric-sort-order.md

@@ -0,0 +1,48 @@
+---
+effort: low
+---
+# Task: Fix numeric sort order for plan/outcome files
+
+## Objective
+Replace all lexicographical `.sort()` calls on numbered file lists with numeric sorting so tasks execute in correct order (1, 2, 10 instead of 1, 10, 2).
+
+## Context
+`raf do` reads plan files named like `1-task.md`, `10-task.md` and sorts them with `.sort()`, which uses string comparison. This causes task 10 to execute before task 2. The codebase already has correct numeric sorting for projects (`a.number - b.number`), but plan/outcome file sorting was missed.
+
+## Requirements
+- Create a shared numeric sort helper function in `src/utils/paths.ts` (where `TASK_ID_PATTERN` already lives)
+- The helper should extract the leading number from filenames like `1-task-name.md` and sort numerically
+- Replace all lexicographical `.sort()` calls on plan/outcome files across the codebase
+
+## Implementation Steps
+
+1. Add a `numericFileSort` comparator function to `src/utils/paths.ts`:
+   ```typescript
+   export function numericFileSort(a: string, b: string): number {
+     const numA = parseInt(a, 10);
+     const numB = parseInt(b, 10);
+     return numA - numB;
+   }
+   ```
+   `parseInt` on `"10-task-name.md"` returns `10` — it stops at the first non-numeric character.
+
+2. Update the following `.sort()` calls to use `numericFileSort`:
+   - `src/core/state-derivation.ts` ~line 201: plan files `.sort()` → `.sort(numericFileSort)`
+   - `src/core/state-derivation.ts` ~line 208: outcome files `.sort()` → `.sort(numericFileSort)`
+   - `src/commands/plan.ts` ~lines 342, 565, 726: plan file sorting after creation
+   - `src/project-manager.ts` ~line 146: outcome files sorting
+   - `src/pull-request.ts` ~line 211: outcome files sorting for PR generation
+
+3. Add the import `import { numericFileSort } from '../utils/paths'` (adjust relative path) to each file that needs it.
+
+4. **Do NOT touch** `src/core/worktree.ts` line 353 — worktree directory sorting may not follow the same numeric prefix pattern; verify before changing.
+
+## Acceptance Criteria
+- [ ] `numericFileSort` helper exists in `src/utils/paths.ts`
+- [ ] All plan/outcome file `.sort()` calls use numeric comparison
+- [ ] Files named `1-x.md` through `19-x.md` sort as 1,2,3,...,10,...,19 (not 1,10,11,...,19,2,3,...)
+- [ ] Project builds without errors (`npm run build` or equivalent)
+
+## Notes
+- `parseInt("10-task-name.md", 10)` correctly returns `10` — no regex needed.
+- The existing `TASK_ID_PATTERN` in `paths.ts` confirms the numeric prefix convention.

package/RAF/40-numeric-order-fix/plans/2-add-npm-keywords.md

@@ -0,0 +1,23 @@
+---
+effort: low
+---
+# Task: Add Codex and agentic coding keywords to package.json
+
+## Objective
+Add discoverability keywords to package.json so the package is findable via Codex and agentic coding search terms on npm.
+
+## Context
+The package currently has keywords like "claude", "anthropic", "ai", but is missing Codex-related and agentic coding terms that users might search for.
+
+## Requirements
+- Add the following keywords to the `keywords` array in `package.json`: `codex`, `openai-codex`, `claude-code`, `agentic-coding`, `coding-agent`
+- Keep existing keywords intact
+
+## Implementation Steps
+1. Open `package.json`
+2. Add the five new keywords to the existing `keywords` array: `codex`, `openai-codex`, `claude-code`, `agentic-coding`, `coding-agent`
+
+## Acceptance Criteria
+- [ ] All five new keywords are present in `package.json` `keywords` array
+- [ ] Existing keywords are unchanged
+- [ ] `package.json` is valid JSON

package/README.md

@@ -85,11 +85,9 @@ raf plan --worktree   # Plan in an isolated git worktree
 Execute project tasks. Without arguments, shows a picker to select a pending project.
 
 ```bash
-raf do                # Interactive picker
+raf do                # Interactive picker (includes worktree projects)
 raf do abcdef         # Execute by project ID
 raf do my-project     # Execute by name
-raf do --worktree     # Pick and execute a worktree project
-raf do my-feature -w  # Execute in worktree (picker will ask what to do after)
 ```
 
 Note: In non-verbose mode, the completion summary reflects the tasks executed in that run (the remaining tasks at start), so the elapsed time maps to those tasks.
@@ -208,8 +206,8 @@ Worktree mode runs planning and execution in an isolated git worktree, keeping y
 # Plan in a worktree (creates branch and worktree directory)
 raf plan my-feature --worktree
 
-# Execute tasks in the worktree
-raf do my-feature --worktree
+# Execute tasks in the worktree (auto-detected, no flag needed)
+raf do my-feature
 ```
 
 ### Post-execution picker
@@ -238,10 +236,11 @@ If `gh` is missing or unauthenticated, the option falls back to "Leave branch" w
 
 - `--worktree` creates a git worktree at `~/.raf/worktrees/<repo>/<project>/` with a new branch named after the project folder (e.g., `abcdef-my-feature`)
 - All planning artifacts, code changes, and commits happen in the worktree branch
+- `raf do` auto-detects whether a project lives in a worktree — no `--worktree` flag needed
 - After successful post-actions (merge, PR, or leave), the worktree directory is cleaned up automatically — the git branch is preserved
 - On merge conflicts, the merge is aborted and you get instructions for manual resolution
 - If tasks fail, the worktree is kept for inspection
-- Use `--no-worktree` to disable worktree mode for a single invocation (useful when `worktree: true` is set in config)
+- Use `--no-worktree` on `raf plan` to disable worktree mode for a single invocation (useful when `worktree: true` is set in config)
 
 ## Command Reference
 
@@ -266,8 +265,6 @@ If `gh` is missing or unauthenticated, the option falls back to "Leave branch" w
 | `-p, --provider <name>` | LLM provider to use (`claude`, `codex`) |
 | `-m, --model <name>` | Model to use (e.g. `sonnet`, `codex/gpt54`) |
 | `--sonnet` | Shorthand for `--model sonnet` |
-| `-w, --worktree` | Execute tasks in a git worktree |
-| `--no-worktree` | Disable worktree mode (overrides config) |
 
 Alias: `raf act`
 

package/dist/commands/do.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"do.d.ts","sourceRoot":"","sources":["../../src/commands/do.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2DpC;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC;AAsE3D;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1D,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,GACf,MAAM,CAkBR;AA0BD,wBAAgB,eAAe,IAAI,OAAO,CAmBzC;AA+TD;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuBhG"}
+{"version":3,"file":"do.d.ts","sourceRoot":"","sources":["../../src/commands/do.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsDpC;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC;AAuE3D;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1D,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,GACf,MAAM,CAkBR;AA0BD,wBAAgB,eAAe,IAAI,OAAO,CAiBzC;AAkOD;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuBhG"}

package/dist/commands/do.js

@@ -10,18 +10,18 @@ import { getExecutionPrompt } from '../prompts/execution.js';
 import { parseOutput, isRetryableFailure } from '../parsers/output-parser.js';
 import { validatePlansExist, resolveModelOption } from '../utils/validation.js';
 import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFromPlanFile, resolveProjectIdentifierWithDetails, getOutcomeFilePath } from '../utils/paths.js';
-import { pickPendingProject, getPendingProjects, getPendingWorktreeProjects, formatProjectChoice } from '../ui/project-picker.js';
+import { pickPendingProject, getPendingProjects, getPendingWorktreeProjects } from '../ui/project-picker.js';
 import { logger } from '../utils/logger.js';
-import { getConfig, getWorktreeDefault, getModel, getModelShortName, resolveFullModelId, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens } from '../utils/config.js';
+import { getConfig, getModel, getModelShortName, resolveFullModelId, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens } from '../utils/config.js';
 import { getVersion } from '../utils/version.js';
 import { createTaskTimer, formatElapsedTime } from '../utils/timer.js';
 import { createStatusLine } from '../utils/status-line.js';
 import { formatProjectHeader, formatSummary, formatTaskProgress, formatTaskTokenSummary, formatTokenTotalSummary, } from '../utils/terminal-symbols.js';
 import { TokenTracker } from '../utils/token-tracker.js';
 import { VerboseToggle } from '../utils/verbose-toggle.js';
-import { deriveProjectState, discoverProjects, getNextExecutableTask, getDerivedStats, getDerivedStatsForTasks, isProjectComplete, hasProjectFailed, parseOutcomeStatus, } from '../core/state-derivation.js';
+import { deriveProjectState, getNextExecutableTask, getDerivedStats, getDerivedStatsForTasks, isProjectComplete, hasProjectFailed, parseOutcomeStatus, } from '../core/state-derivation.js';
 import { analyzeFailure } from '../core/failure-analyzer.js';
-import { getRepoRoot, getRepoBasename, getCurrentBranch, computeWorktreePath, computeWorktreeBaseDir, validateWorktree, listWorktreeProjects, mergeWorktreeBranch, removeWorktree, resolveWorktreeProjectByIdentifier, pushMainBranch, pullMainBranch, detectMainBranch, rebaseOntoMain, } from '../core/worktree.js';
+import { getRepoRoot, getRepoBasename, getCurrentBranch, mergeWorktreeBranch, removeWorktree, resolveWorktreeProjectByIdentifier, pushMainBranch, pullMainBranch, detectMainBranch, rebaseOntoMain, } from '../core/worktree.js';
 import { createPullRequest, prPreflight } from '../core/pull-request.js';
 /**
  * Resolve the execution model for a task from its frontmatter metadata.
@@ -36,7 +36,7 @@ import { createPullRequest, prPreflight } from '../core/pull-request.js';
  * @param ceilingModel - The ceiling model (usually models.execute from config)
  * @param isRetry - Whether this is a retry attempt (escalates to ceiling)
  */
-function resolveTaskModel(frontmatter, frontmatterWarnings, ceilingModel, isRetry) {
+function resolveTaskModel(frontmatter, frontmatterWarnings, ceilingModel, isRetry, provider) {
     const warnings = frontmatterWarnings ? [...frontmatterWarnings] : [];
     // Retry escalation: always use the ceiling model on retry
     if (isRetry) {
@@ -57,7 +57,7 @@ function resolveTaskModel(frontmatter, frontmatterWarnings, ceilingModel, isRetr
     }
     // Effort-based resolution - apply ceiling
     if (frontmatter.effort) {
-        const mappedModel = resolveEffortToModel(frontmatter.effort);
+        const mappedModel = resolveEffortToModel(frontmatter.effort, provider);
         const model = applyModelCeiling(mappedModel, ceilingModel);
         return { model, missingFrontmatter: false, warnings };
     }
@@ -99,8 +99,6 @@ export function createDoCommand() {
         .option('-f, --force', 'Re-run all tasks regardless of status')
         .option('-m, --model <name>', 'Model to use (sonnet, haiku, opus)')
         .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
-        .option('-w, --worktree', 'Execute tasks in a git worktree')
-        .option('--no-worktree', 'Disable worktree mode (overrides config)')
         .option('-p, --provider <provider>', 'CLI provider to use (claude, codex)')
         .action(async (project, options) => {
         await runDoCommand(project, options);
@@ -110,7 +108,6 @@ export function createDoCommand() {
 async function runDoCommand(projectIdentifierArg, options) {
     const rafDir = getRafDir();
     let projectIdentifier = projectIdentifierArg;
-    let worktreeMode = options.worktree ?? getWorktreeDefault();
     // Validate and resolve model option
     let model;
     try {
@@ -120,44 +117,10 @@ async function runDoCommand(projectIdentifierArg, options) {
         logger.error(error.message);
         process.exit(1);
     }
-    // Variables for worktree context (set when --worktree is used)
+    // Variables for worktree context (derived from where the project is found)
     let worktreeRoot;
     let originalBranch;
     let mainBranchName = null;
-    if (worktreeMode) {
-        // Validate git repo
-        const repoRoot = getRepoRoot();
-        if (!repoRoot) {
-            logger.error('--worktree requires a git repository');
-            process.exit(1);
-        }
-        const repoBasename = getRepoBasename();
-        const rafRelativePath = path.relative(repoRoot, rafDir);
-        // Record original branch before any worktree operations
-        originalBranch = getCurrentBranch() ?? undefined;
-        // Sync main branch before worktree operations (if enabled)
-        if (getSyncMainBranch()) {
-            const syncResult = pullMainBranch();
-            mainBranchName = syncResult.mainBranch;
-            if (syncResult.success) {
-                if (syncResult.hadChanges) {
-                    logger.info(`Synced ${syncResult.mainBranch} from remote`);
-                }
-            }
-            else {
-                logger.warn(`Could not sync main branch: ${syncResult.error}`);
-            }
-        }
-        if (!projectIdentifier) {
-            // Auto-discovery flow
-            const selected = await discoverAndPickWorktreeProject(repoBasename, rafDir, rafRelativePath);
-            if (!selected) {
-                process.exit(0);
-            }
-            worktreeRoot = selected.worktreeRoot;
-            projectIdentifier = selected.projectFolder;
-        }
-    }
     // Handle no project identifier (non-worktree mode) - show interactive picker
     if (!projectIdentifier) {
         // Discover worktree projects for the current repo (if in a git repo)
@@ -183,9 +146,8 @@ async function runDoCommand(projectIdentifierArg, options) {
             }
             // Use the selected project
             projectIdentifier = selectedProject.folder;
-            // If a worktree project was selected, auto-switch to worktree mode
+            // If a worktree project was selected, record worktree context
             if (selectedProject.source === 'worktree' && selectedProject.worktreeRoot) {
-                worktreeMode = true;
                 worktreeRoot = selectedProject.worktreeRoot;
                 originalBranch = getCurrentBranch() ?? undefined;
             }
@@ -200,83 +162,21 @@ async function runDoCommand(projectIdentifierArg, options) {
     }
     // Resolve project identifier
     let resolvedProject;
-    if (worktreeMode) {
-        // Worktree mode: resolve project inside the worktree
+    if (worktreeRoot) {
+        // Worktree was set by the picker — resolve project inside the worktree
         const repoRoot = getRepoRoot();
-        const repoBasename = getRepoBasename();
         const rafRelativePath = path.relative(repoRoot, rafDir);
-        // If worktreeRoot was set by auto-discovery, use it directly
-        if (worktreeRoot) {
-            const wtRafDir = path.join(worktreeRoot, rafRelativePath);
-            const result = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
-            if (!result.path) {
-                logger.error(`Project not found in worktree: ${projectIdentifier}`);
-                process.exit(1);
-            }
-            const projectName = extractProjectName(result.path) ?? projectIdentifier;
-            resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
-        }
-        else {
-            // Explicit identifier: resolve from main repo to get folder name, then validate worktree
-            const mainResult = resolveProjectIdentifierWithDetails(rafDir, projectIdentifier);
-            let projectFolderName;
-            if (mainResult.path) {
-                // Found in main repo - use its folder name
-                projectFolderName = path.basename(mainResult.path);
-            }
-            else {
-                // Not found in main repo - try to find it in worktrees directly
-                // This handles projects that only exist in worktrees
-                const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
-                if (!fs.existsSync(worktreeBaseDir)) {
-                    logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
-                    process.exit(1);
-                }
-                // Search worktrees for the project
-                const wtProjects = listWorktreeProjects(repoBasename);
-                let found = false;
-                for (const wtProjectDir of wtProjects) {
-                    const wtPath = computeWorktreePath(repoBasename, wtProjectDir);
-                    const wtRafDir = path.join(wtPath, rafRelativePath);
-                    if (!fs.existsSync(wtRafDir))
-                        continue;
-                    const resolution = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
-                    if (resolution.path) {
-                        projectFolderName = path.basename(resolution.path);
-                        worktreeRoot = wtPath;
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
-                    process.exit(1);
-                }
-            }
-            // Compute worktree path if not already set
-            if (!worktreeRoot) {
-                worktreeRoot = computeWorktreePath(repoBasename, projectFolderName);
-            }
-            // Validate the worktree
-            const wtProjectRelPath = path.join(rafRelativePath, projectFolderName);
-            const validation = validateWorktree(worktreeRoot, wtProjectRelPath);
-            if (!validation.exists || !validation.isValidWorktree) {
-                logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
-                logger.error(`Expected worktree at: ${worktreeRoot}`);
-                process.exit(1);
-            }
-            if (!validation.hasProjectFolder || !validation.hasPlans) {
-                logger.error(`Worktree exists but project content is missing.`);
-                logger.error(`Expected project folder at: ${validation.projectPath ?? path.join(worktreeRoot, wtProjectRelPath)}`);
-                process.exit(1);
-            }
-            const projectPath = validation.projectPath;
-            const projectName = extractProjectName(projectPath) ?? projectIdentifier;
-            resolvedProject = { identifier: projectIdentifier, path: projectPath, name: projectName };
+        const wtRafDir = path.join(worktreeRoot, rafRelativePath);
+        const result = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
+        if (!result.path) {
+            logger.error(`Project not found in worktree: ${projectIdentifier}`);
+            process.exit(1);
         }
+        const projectName = extractProjectName(result.path) ?? projectIdentifier;
+        resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
     }
     else {
-        // Standard mode: check worktrees first (worktree takes priority), then main repo
+        // Auto-detect: check worktrees first (worktree takes priority), then main repo
         const repoRoot = getRepoRoot();
         const repoBasename = repoRoot ? getRepoBasename() : null;
         // Try worktree resolution first (preferred when project exists in both)
@@ -287,8 +187,6 @@ async function runDoCommand(projectIdentifierArg, options) {
                 const wtRafDir = path.join(wtResolution.worktreeRoot, rafRelativePath);
                 const wtProjectPath = path.join(wtRafDir, wtResolution.folder);
                 if (fs.existsSync(wtProjectPath)) {
-                    // Auto-switch to worktree mode
-                    worktreeMode = true;
                     worktreeRoot = wtResolution.worktreeRoot;
                     originalBranch = getCurrentBranch() ?? undefined;
                     const projectName = extractProjectName(wtResolution.folder) ?? projectIdentifier;
@@ -326,9 +224,25 @@ async function runDoCommand(projectIdentifierArg, options) {
     const autoCommit = config.autoCommit;
     // Configure logger
     logger.configure({ verbose, debug });
-    // Show post-execution picker before task execution (worktree mode only)
+    // Worktree setup: sync main branch and show post-execution picker
     let postAction = 'leave';
-    if (worktreeMode && worktreeRoot) {
+    if (worktreeRoot) {
+        if (!originalBranch) {
+            originalBranch = getCurrentBranch() ?? undefined;
+        }
+        // Sync main branch before worktree operations (if enabled)
+        if (getSyncMainBranch()) {
+            const syncResult = pullMainBranch();
+            mainBranchName = syncResult.mainBranch;
+            if (syncResult.success) {
+                if (syncResult.hadChanges) {
+                    logger.info(`Synced ${syncResult.mainBranch} from remote`);
+                }
+            }
+            else {
+                logger.warn(`Could not sync main branch: ${syncResult.error}`);
+            }
+        }
         try {
             postAction = await pickPostExecutionAction(worktreeRoot);
         }
@@ -365,6 +279,7 @@ async function runDoCommand(projectIdentifierArg, options) {
             maxRetries,
             autoCommit,
             model,
+            provider: options.provider,
             worktreeCwd: worktreeRoot,
         });
     }
@@ -374,7 +289,7 @@ async function runDoCommand(projectIdentifierArg, options) {
         process.exit(1);
     }
     // Execute post-execution action based on picker choice
-    if (worktreeMode && worktreeRoot) {
+    if (worktreeRoot) {
         const worktreeBranch = path.basename(worktreeRoot);
         if (result.success) {
             await executePostAction(postAction, worktreeRoot, worktreeBranch, originalBranch, resolvedProject.path);
@@ -497,75 +412,8 @@ async function executePostAction(action, worktreeRoot, worktreeBranch, originalB
         }
     }
 }
-/**
- * Auto-discovery flow for `raf do --worktree` without a project identifier.
- * Shows both worktree AND main-repo pending projects in an interactive picker.
- * Worktree projects above a threshold filter are included; main-repo projects
- * are always included. Duplicates are deduped with worktree taking precedence.
- *
- * @returns Selected project info or null if cancelled/no projects
- */
-async function discoverAndPickWorktreeProject(repoBasename, rafDir, rafRelativePath) {
-    // Get worktree pending projects (uses shared utility from project-picker)
-    const wtPendingProjects = getPendingWorktreeProjects(repoBasename, rafRelativePath);
-    // Find the highest-numbered completed project in the MAIN tree for threshold filter
-    const mainProjects = discoverProjects(rafDir);
-    let highestCompletedNumber = 0;
-    for (const project of mainProjects) {
-        const state = deriveProjectState(project.path);
-        if (isProjectComplete(state) && state.tasks.length > 0) {
-            if (project.number > highestCompletedNumber) {
-                highestCompletedNumber = project.number;
-            }
-        }
-    }
-    // Filter threshold: highest completed - 3 (or 0 if none completed)
-    const threshold = highestCompletedNumber > 3 ? highestCompletedNumber - 3 : 0;
-    // Apply threshold filter to worktree projects only
-    const filteredWtProjects = wtPendingProjects.filter((p) => p.number >= threshold);
-    // Get main-repo pending projects (no threshold filter)
-    const mainPendingProjects = getPendingProjects(rafDir);
-    // Merge and deduplicate: worktree versions take precedence
-    const allProjects = [...mainPendingProjects, ...filteredWtProjects];
-    const seen = new Map();
-    for (const project of allProjects) {
-        const existing = seen.get(project.folder);
-        if (!existing || project.source === 'worktree') {
-            seen.set(project.folder, project);
-        }
-    }
-    const deduped = Array.from(seen.values());
-    // Sort by project number
-    deduped.sort((a, b) => a.number - b.number);
-    if (deduped.length === 0) {
-        logger.info('No pending projects found.');
-        return null;
-    }
-    // Show interactive picker
-    const choices = deduped.map((p) => ({
-        name: formatProjectChoice(p),
-        value: p,
-    }));
-    try {
-        const selected = await select({
-            message: 'Select a project to execute:',
-            choices,
-        });
-        return {
-            worktreeRoot: selected.worktreeRoot,
-            projectFolder: selected.folder,
-        };
-    }
-    catch (error) {
-        // Handle Ctrl+C (user cancellation)
-        if (error instanceof Error && error.message.includes('User force closed')) {
-            return null;
-        }
-        throw error;
-    }
-}
 async function executeSingleProject(projectPath, projectName, options) {
-    const { timeout, verbose, debug, force, maxRetries, autoCommit, model, worktreeCwd } = options;
+    const { timeout, verbose, debug, force, maxRetries, autoCommit, model, provider, worktreeCwd } = options;
     if (!validatePlansExist(projectPath)) {
         return {
             projectName,
@@ -798,7 +646,7 @@ async function executeSingleProject(projectPath, projectName, options) {
             const isRetry = attempts > 1;
             // Resolve the model for this attempt (escalates to ceiling on retry)
             const modelResolution = resolveTaskModel(task.frontmatter, undefined, // warnings already logged above
-            ceilingModel, isRetry);
+            ceilingModel, isRetry, provider);
             // Update current model for timer callback display
             currentModel = modelResolution.model;
             // Log missing frontmatter warning on first attempt only
@@ -806,7 +654,7 @@ async function executeSingleProject(projectPath, projectName, options) {
                 logger.warn(`  No effort frontmatter found — using ceiling model`);
             }
             // Create a runner for this attempt's model
-            const taskRunner = createRunner({ model: modelResolution.model });
+            const taskRunner = createRunner({ model: modelResolution.model, provider });
             shutdownHandler.registerClaudeRunner(taskRunner);
             if (verbose && isRetry) {
                 const retryModel = resolveFullModelId(modelResolution.model);