rafcode 3.0.0 → 3.2.1

package/src/commands/plan.ts

@@ -32,6 +32,7 @@ import {
   decodeTaskId,
   encodeTaskId,
   TASK_ID_PATTERN,
+  numericFileSort,
 } from '../utils/paths.js';
 import { sanitizeProjectName } from '../utils/validation.js';
 import {
@@ -43,11 +44,8 @@ import {
   getRepoBasename,
   getRepoRoot,
   createWorktree,
-  createWorktreeFromBranch,
-  branchExists,
   validateWorktree,
   removeWorktree,
-  computeWorktreeBaseDir,
   pullMainBranch,
   resolveWorktreeProjectByIdentifier,
 } from '../core/worktree.js';
@@ -90,8 +88,10 @@ export function createPlanCommand(): Command {
       const autoMode = options.auto ?? false;
       const worktreeMode = options.worktree ?? getWorktreeDefault();
 
+      const provider = options.provider as import('../types/config.js').HarnessProvider | undefined;
+
       if (options.resume) {
-        await runResumeCommand(options.resume, model);
+        await runResumeCommand(options.resume, model, provider);
       } else if (options.amend) {
         if (!projectName) {
           logger.error('--amend requires a project identifier');
@@ -99,16 +99,16 @@ export function createPlanCommand(): Command {
           logger.error('   or: raf plan --amend <project>');
           process.exit(1);
         }
-        await runAmendCommand(projectName, model, autoMode, worktreeMode);
+        await runAmendCommand(projectName, model, autoMode, provider);
       } else {
-        await runPlanCommand(projectName, model, autoMode, worktreeMode);
+        await runPlanCommand(projectName, model, autoMode, worktreeMode, provider);
       }
     });
 
   return command;
 }
 
-async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false): Promise<void> {
+async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -124,7 +124,6 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     const mainResult = resolveProjectIdentifierWithDetails(rafDir, projectName);
 
     let existingFolder: string | null = null;
-    let existingWorktreeMode = false;
 
     if (mainResult.path) {
       existingFolder = path.basename(mainResult.path);
@@ -134,7 +133,6 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
         const wtResult = resolveWorktreeProjectByIdentifier(repoBasename, projectName);
         if (wtResult) {
           existingFolder = wtResult.folder;
-          existingWorktreeMode = true;
         }
       }
     }
@@ -153,7 +151,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       });
 
       if (answer === 'amend') {
-        await runAmendCommand(existingFolder, model, autoMode, existingWorktreeMode);
+        await runAmendCommand(existingFolder, model, autoMode, provider);
         return;
       } else if (answer === 'cancel') {
         logger.info('Aborted.');
@@ -286,7 +284,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   }
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model, provider });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
@@ -342,7 +340,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     // Check for created plan files
     const plansDir = getPlansDir(projectPath);
     const planFiles = fs.existsSync(plansDir)
-      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort(numericFileSort)
       : [];
 
     if (planFiles.length === 0) {
@@ -367,7 +365,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       if (worktreeMode) {
         logger.info(`Worktree: ${worktreePath}`);
         logger.info(`Branch: ${worktreeBranch}`);
-        logger.info(`Run 'raf do ${finalProjectName} --worktree' to execute the plans.`);
+        logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
       } else {
         logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
       }
@@ -397,7 +395,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   }
 }
 
-async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false): Promise<void> {
+async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -406,112 +404,26 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     process.exit(1);
   }
 
+  // Auto-detect project location: check worktrees first, then main repo
   let worktreePath: string | null = null;
-  let projectPath: string;
-
-  if (worktreeMode) {
-    // Worktree mode: resolve project from worktree directory
-    const repoBasename = getRepoBasename();
-    if (!repoBasename) {
-      logger.error('--worktree requires a git repository');
-      process.exit(1);
-    }
-
-    const repoRoot = getRepoRoot()!;
-    const rafDir = getRafDir();
-    const rafRelativePath = path.relative(repoRoot, rafDir);
-
-    const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
-
-    // Search through existing worktree directories for the project
-    let matchedWorktreeDir: string | null = null;
-    let matchedProjectPath: string | null = null;
-
-    if (fs.existsSync(worktreeBaseDir)) {
-      const entries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const wtPath = path.join(worktreeBaseDir, entry.name);
-        const wtRafDir = path.join(wtPath, rafRelativePath);
-        if (!fs.existsSync(wtRafDir)) continue;
-
-        const resolution = resolveProjectIdentifierWithDetails(wtRafDir, identifier);
-        if (resolution.path) {
-          if (matchedWorktreeDir) {
-            logger.error(`Ambiguous: project "${identifier}" found in multiple worktrees`);
-            process.exit(1);
-          }
-          matchedWorktreeDir = wtPath;
-          matchedProjectPath = resolution.path;
-        }
-      }
-    }
-
-    if (!matchedWorktreeDir || !matchedProjectPath) {
-      // Worktree not found — try to recreate it
-      // First, resolve the project from the main repo to get the folder name
-      const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
-      if (!mainResolution.path) {
-        logger.error(`Project not found in any worktree or main repo: ${identifier}`);
-        logger.error(`Searched in: ${worktreeBaseDir}`);
-        process.exit(1);
-      }
-
-      const folderName = path.basename(mainResolution.path);
+  let projectPath: string | undefined;
 
-      if (branchExists(folderName)) {
-        // Branch exists — recreate worktree from it
-        const result = createWorktreeFromBranch(repoBasename, folderName);
-        if (!result.success) {
-          logger.error(`Failed to recreate worktree from branch: ${result.error}`);
-          process.exit(1);
-        }
-        matchedWorktreeDir = result.worktreePath;
-        matchedProjectPath = path.join(result.worktreePath, rafRelativePath, folderName);
-        logger.info(`Recreated worktree from branch: ${folderName}`);
-      } else {
-        // No branch — create fresh worktree and copy project files
-        // Sync main branch before creating worktree (if enabled)
-        if (getSyncMainBranch()) {
-          const syncResult = pullMainBranch();
-          if (syncResult.success) {
-            if (syncResult.hadChanges) {
-              logger.info(`Synced ${syncResult.mainBranch} from remote`);
-            }
-          } else {
-            logger.warn(`Could not sync main branch: ${syncResult.error}`);
-          }
-        }
+  const repoBasename = getRepoBasename();
+  const rafDir = getRafDir();
 
-        const result = createWorktree(repoBasename, folderName);
-        if (!result.success) {
-          logger.error(`Failed to create worktree: ${result.error}`);
-          process.exit(1);
-        }
-        matchedWorktreeDir = result.worktreePath;
-        const wtProjectPath = path.join(result.worktreePath, rafRelativePath, folderName);
-        // Copy project folder from main repo into the new worktree
-        fs.cpSync(mainResolution.path, wtProjectPath, { recursive: true });
-        matchedProjectPath = wtProjectPath;
-        logger.info(`Created fresh worktree and copied project files: ${folderName}`);
-      }
+  // 1. Try worktree resolution first (if we're in a git repo)
+  if (repoBasename) {
+    const wtResult = resolveWorktreeProjectByIdentifier(repoBasename, identifier);
+    if (wtResult) {
+      const repoRoot = getRepoRoot()!;
+      const rafRelativePath = path.relative(repoRoot, rafDir);
+      worktreePath = wtResult.worktreeRoot;
+      projectPath = path.join(wtResult.worktreeRoot, rafRelativePath, wtResult.folder);
     }
+  }
 
-    worktreePath = matchedWorktreeDir;
-    projectPath = matchedProjectPath;
-
-    // Validate the worktree is valid
-    const relProjectPath = path.relative(worktreePath, projectPath);
-    const wtValidation = validateWorktree(worktreePath, relProjectPath);
-    if (!wtValidation.isValidWorktree) {
-      logger.error(`Invalid worktree at: ${worktreePath}`);
-      logger.error('The worktree may have been removed or corrupted.');
-      process.exit(1);
-    }
-  } else {
-    // Standard mode: resolve from main repo
-    const rafDir = getRafDir();
+  // 2. Fall back to main repo
+  if (!projectPath) {
     const resolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
 
     if (!resolution.path) {
@@ -570,7 +482,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
   // Show existing tasks summary
   logger.info('Amending existing project:');
   logger.info(`  Path: ${projectPath}`);
-  if (worktreeMode && worktreePath) {
+  if (worktreePath) {
     logger.info(`  Worktree: ${worktreePath}`);
   }
   logger.info(`  Existing tasks: ${existingTasks.length}`);
@@ -616,7 +528,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
   fs.writeFileSync(inputPath, updatedInput);
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model, provider });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
@@ -636,7 +548,6 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     existingTasks,
     nextTaskNumber,
     newTaskDescription: cleanInput,
-    worktreeMode,
   });
 
   try {
@@ -652,7 +563,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
 
     // Check for new plan files
     const allPlanFiles = fs.existsSync(plansDir)
-      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort(numericFileSort)
       : [];
 
     const newPlanFiles = allPlanFiles.filter((f) => {
@@ -687,11 +598,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     if (newPlanFiles.length > 0) {
       logger.newline();
       logger.info(`Total tasks: ${allPlanFiles.length}`);
-      if (worktreeMode) {
-        logger.info(`Run 'raf do ${identifier} --worktree' to execute the new tasks.`);
-      } else {
-        logger.info(`Run 'raf do ${identifier}' to execute the new tasks.`);
-      }
+      logger.info(`Run 'raf do ${identifier}' to execute the new tasks.`);
     }
   } catch (error) {
     logger.error(`Amendment failed: ${error}`);
@@ -729,7 +636,7 @@ ${taskList}
 `;
 }
 
-async function runResumeCommand(identifier: string, model?: string): Promise<void> {
+async function runResumeCommand(identifier: string, model?: string, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -799,7 +706,7 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
   logger.newline();
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model, provider });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
@@ -817,7 +724,7 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
     // Check for created/updated plan files after resume session
     const plansDir = getPlansDir(projectPath);
     const planFiles = fs.existsSync(plansDir)
-      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort(numericFileSort)
       : [];
 
     if (planFiles.length > 0) {

package/src/core/project-manager.ts

@@ -12,6 +12,7 @@ import {
   getInputPath,
   listProjects,
   TASK_ID_PATTERN,
+  numericFileSort,
 } from '../utils/paths.js';
 import { sanitizeProjectName } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
@@ -143,7 +144,7 @@ export class ProjectManager {
     }
 
     const outcomes: Array<{ taskId: string; content: string }> = [];
-    const files = fs.readdirSync(outcomesDir).filter((f) => f.endsWith('.md')).sort();
+    const files = fs.readdirSync(outcomesDir).filter((f) => f.endsWith('.md')).sort(numericFileSort);
 
     for (const file of files) {
       const match = file.match(new RegExp(`^(${TASK_ID_PATTERN})-`));

package/src/core/pull-request.ts

@@ -4,7 +4,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { logger } from '../utils/logger.js';
 import { getModel, getModelShortName } from '../utils/config.js';
-import { extractProjectName, getInputPath, getDecisionsPath, getOutcomesDir, TASK_ID_PATTERN } from '../utils/paths.js';
+import { extractProjectName, getInputPath, getDecisionsPath, getOutcomesDir, TASK_ID_PATTERN, numericFileSort } from '../utils/paths.js';
 
 export interface PrCreateResult {
   success: boolean;
@@ -208,7 +208,7 @@ export function readProjectContext(projectPath: string): {
 
   const outcomesDir = getOutcomesDir(projectPath);
   if (fs.existsSync(outcomesDir)) {
-    const files = fs.readdirSync(outcomesDir).filter(f => f.endsWith('.md')).sort();
+    const files = fs.readdirSync(outcomesDir).filter(f => f.endsWith('.md')).sort(numericFileSort);
     const taskIdPattern = new RegExp(`^(${TASK_ID_PATTERN})-`);
     for (const file of files) {
       const match = file.match(taskIdPattern);

package/src/core/state-derivation.ts

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getPlansDir, getOutcomesDir, getInputPath, TASK_ID_PATTERN } from '../utils/paths.js';
+import { getPlansDir, getOutcomesDir, getInputPath, TASK_ID_PATTERN, numericFileSort } from '../utils/paths.js';
 import { parsePlanFrontmatter, type PlanFrontmatter } from '../utils/frontmatter.js';
 
 export type DerivedTaskStatus = 'pending' | 'completed' | 'failed' | 'blocked';
@@ -198,14 +198,14 @@ export function deriveProjectState(projectPath: string): DerivedProjectState {
 
   const planFiles = fs.readdirSync(plansDir)
     .filter((f) => f.endsWith('.md'))
-    .sort();
+    .sort(numericFileSort);
 
   // Build a map of outcome statuses
   const outcomeStatuses = new Map<string, DerivedTaskStatus>();
   if (fs.existsSync(outcomesDir)) {
     const outcomeFiles = fs.readdirSync(outcomesDir)
       .filter((f) => f.endsWith('.md'))
-      .sort();
+      .sort(numericFileSort);
 
     for (const outcomeFile of outcomeFiles) {
       const match = outcomeFile.match(new RegExp(`^(${TASK_ID_PATTERN})-`));

package/src/parsers/codex-stream-renderer.ts

@@ -13,17 +13,34 @@ import type { RenderResult } from './stream-renderer.js';
 
 export interface CodexEvent {
   type: string;
-  /** AgentMessage fields */
+  /** Claude flat-format fields (AgentMessage) */
   content?: string;
-  /** CommandExecution fields */
+  /** Claude flat-format fields (CommandExecution) */
   command?: string;
   exit_code?: number;
-  /** FileChange fields */
+  /** Claude flat-format fields (FileChange) */
   file_path?: string;
   change_kind?: string;
-  /** McpToolCall fields */
+  /** Claude flat-format fields (McpToolCall) */
   tool_name?: string;
   server_name?: string;
+  /** Real Codex nested item (for item.completed / item.started) */
+  item?: {
+    type: string;
+    text?: string;
+    command?: string;
+    exit_code?: number;
+    path?: string;
+    change_kind?: string;
+  };
+  /** Error message (for error / turn.failed events) */
+  message?: string;
+  /** Usage data (for turn.completed events) */
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+  };
 }
 
 function truncate(text: string, maxLen: number): string {
@@ -65,6 +82,23 @@ export function renderCodexStreamEvent(line: string): RenderResult {
       // Skip todo list events - minimal noise
       return { display: '', textContent: '' };
 
+    // Real Codex CLI event types (nested format)
+    case 'item.completed':
+      return renderItemCompleted(event);
+
+    case 'item.started':
+      // Skip started events — we render on completion
+      return { display: '', textContent: '' };
+
+    case 'turn.completed':
+      return renderTurnCompleted(event);
+
+    case 'error':
+      return renderError(event);
+
+    case 'turn.failed':
+      return renderTurnFailed(event);
+
     default:
       // Skip unknown event types gracefully
       return { display: '', textContent: '' };
@@ -106,3 +140,71 @@ function renderMcpToolCall(event: CodexEvent): RenderResult {
     textContent: '',
   };
 }
+
+// --- Real Codex CLI event handlers (nested format) ---
+
+function renderItemCompleted(event: CodexEvent): RenderResult {
+  const item = event.item;
+  if (!item) return { display: '', textContent: '' };
+
+  switch (item.type) {
+    case 'agent_message': {
+      const text = item.text ?? '';
+      return {
+        display: text ? text + '\n' : '',
+        textContent: text,
+      };
+    }
+    case 'command_execution': {
+      const cmd = item.command ?? '';
+      const exitCode = item.exit_code ?? 0;
+      const status = exitCode === 0 ? '✓' : `✗ exit ${exitCode}`;
+      return {
+        display: `  → Running: ${truncate(cmd, 120)} [${status}]\n`,
+        textContent: '',
+      };
+    }
+    case 'file_change': {
+      const filePath = item.path ?? 'unknown';
+      const kind = item.change_kind ?? 'modified';
+      return {
+        display: `  → File ${kind}: ${filePath}\n`,
+        textContent: '',
+      };
+    }
+    default:
+      return { display: '', textContent: '' };
+  }
+}
+
+function renderTurnCompleted(event: CodexEvent): RenderResult {
+  if (event.usage) {
+    const { input_tokens, output_tokens } = event.usage;
+    const parts: string[] = [];
+    if (input_tokens) parts.push(`in: ${input_tokens}`);
+    if (output_tokens) parts.push(`out: ${output_tokens}`);
+    if (parts.length > 0) {
+      return {
+        display: `  → Usage: ${parts.join(', ')}\n`,
+        textContent: '',
+      };
+    }
+  }
+  return { display: '', textContent: '' };
+}
+
+function renderError(event: CodexEvent): RenderResult {
+  const msg = event.message ?? 'Unknown error';
+  return {
+    display: `  ✗ Error: ${msg}\n`,
+    textContent: msg,
+  };
+}
+
+function renderTurnFailed(event: CodexEvent): RenderResult {
+  const msg = event.message ?? 'Turn failed';
+  return {
+    display: `  ✗ Failed: ${msg}\n`,
+    textContent: msg,
+  };
+}

package/src/prompts/amend.ts

@@ -6,7 +6,6 @@ export interface AmendPromptParams {
   existingTasks: Array<DerivedTask & { taskName: string }>;
   nextTaskNumber: number;
   newTaskDescription: string;
-  worktreeMode?: boolean;
 }
 
 export interface AmendPromptResult {
@@ -25,9 +24,7 @@ export function getAmendPrompt(params: AmendPromptParams): AmendPromptResult {
     existingTasks,
     nextTaskNumber,
     newTaskDescription,
-    worktreeMode,
   } = params;
-  const worktreeFlag = worktreeMode ? ' --worktree' : '';
 
   const existingTasksSummary = existingTasks
     .map((task) => {
@@ -210,7 +207,7 @@ After creating all new plan files:
 \`\`\`
 Planning complete! To exit this session and run your tasks:
   1. Press Ctrl-C twice to exit
-  2. Then run: raf do <project>${worktreeFlag}
+  2. Then run: raf do <project>
 \`\`\`
 
 ## Important Rules

package/src/prompts/config-docs.md

@@ -90,7 +90,7 @@ Example:
 
 - **Type**: boolean
 - **Default**: `false`
-- **Description**: When `true`, `raf plan` and `raf do` default to worktree mode (isolated git worktree). Can be overridden per-command with `--worktree` flag.
+- **Description**: When `true`, `raf plan` defaults to worktree mode (isolated git worktree). Can be overridden with `--worktree` flag. `raf do` auto-detects worktree projects regardless of this setting.
 
 ### `syncMainBranch` — Sync Main Branch with Remote
 

package/src/prompts/planning.ts

@@ -15,9 +15,7 @@ export interface PlanningPromptResult {
  * - userMessage: Reference to input.md file (via positional argument, triggers the LLM to start)
  */
 export function getPlanningPrompt(params: PlanningPromptParams): PlanningPromptResult {
-  const { projectPath, worktreeMode } = params;
-  const worktreeFlag = worktreeMode ? ' --worktree' : '';
-
+  const { projectPath } = params;
   const systemPrompt = `You are a project planning assistant for RAF (Ralph's Automation Framework). Your task is to analyze the user's project description and create detailed task plans.
 
 ## Your Goals
@@ -177,7 +175,7 @@ After creating all plan files:
 \`\`\`
 Planning complete! To exit this session and run your tasks:
   1. Press Ctrl-C twice to exit
-  2. Then run: raf do <project>${worktreeFlag}
+  2. Then run: raf do <project>
 \`\`\`
 
 ## Important Rules

package/src/types/config.ts

@@ -169,7 +169,6 @@ export interface DoCommandOptions {
   force?: boolean;
   model?: ClaudeModelName;
   sonnet?: boolean;
-  worktree?: boolean;
   provider?: HarnessProvider;
 }
 

package/src/utils/paths.ts

@@ -214,6 +214,16 @@ export function listProjects(rafDir: string): Array<{ number: number; name: stri
   return projects.sort((a, b) => a.number - b.number);
 }
 
+/**
+ * Numeric comparator for filenames with a leading integer prefix (e.g. "10-task.md").
+ * Ensures files sort as 1, 2, 3, ..., 10, ... instead of 1, 10, 2, ...
+ */
+export function numericFileSort(a: string, b: string): number {
+  const numA = parseInt(a, 10);
+  const numB = parseInt(b, 10);
+  return numA - numB;
+}
+
 export function getPlansDir(projectPath: string): string {
   return path.join(projectPath, 'plans');
 }