rafcode 2.4.0 → 2.5.0-0

package/src/commands/plan.ts

@@ -1,6 +1,5 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as crypto from 'node:crypto';
 import { Command } from 'commander';
 import { ProjectManager } from '../core/project-manager.js';
 import { ClaudeRunner } from '../core/claude-runner.js';
@@ -16,10 +15,7 @@ import {
   resolveModelOption,
 } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
-import { getWorktreeDefault, getModel, getModelShortName, getDisplayConfig, getPricingConfig, getSyncMainBranch } from '../utils/config.js';
-import { TokenTracker } from '../utils/token-tracker.js';
-import { parseSessionById } from '../utils/session-parser.js';
-import { formatTokenTotalSummary, TokenSummaryOptions } from '../utils/terminal-symbols.js';
+import { getWorktreeDefault, getModel, getModelShortName, getSyncMainBranch } from '../utils/config.js';
 import { generateProjectNames } from '../utils/name-generator.js';
 import { pickProjectName } from '../ui/name-picker.js';
 import {
@@ -61,6 +57,7 @@ interface PlanCommandOptions {
   sonnet?: boolean;
   auto?: boolean;
   worktree?: boolean;
+  resume?: string;
 }
 
 export function createPlanCommand(): Command {
@@ -75,6 +72,7 @@ export function createPlanCommand(): Command {
     .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
     .option('-y, --auto', "Skip Claude's permission prompts for file operations")
     .option('-w, --worktree', 'Create a git worktree for isolated planning')
+    .option('-r, --resume <identifier>', 'Resume a planning session for an existing project')
     .action(async (projectName: string | undefined, options: PlanCommandOptions) => {
       // Validate and resolve model option
       let model: string;
@@ -88,7 +86,9 @@ export function createPlanCommand(): Command {
       const autoMode = options.auto ?? false;
       const worktreeMode = options.worktree ?? getWorktreeDefault();
 
-      if (options.amend) {
+      if (options.resume) {
+        await runResumeCommand(options.resume, model);
+      } else if (options.amend) {
         if (!projectName) {
           logger.error('--amend requires a project identifier');
           logger.error('Usage: raf plan <project> --amend');
@@ -289,25 +289,17 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     worktreeMode,
   });
 
-  // Generate session ID for token tracking
-  const sessionId = crypto.randomUUID();
-  const sessionCwd = worktreePath ?? process.cwd();
-
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
       // Run Claude session in the worktree root if in worktree mode
       cwd: worktreePath ?? undefined,
-      sessionId,
     });
 
     if (exitCode !== 0) {
       logger.warn(`Claude exited with code ${exitCode}`);
     }
 
-    // Parse session file and display token usage summary
-    displayPlanSessionTokenSummary(sessionId, sessionCwd);
-
     // Check for created plan files
     const plansDir = getPlansDir(projectPath);
     const planFiles = fs.existsSync(plansDir)
@@ -604,25 +596,17 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     worktreeMode,
   });
 
-  // Generate session ID for token tracking
-  const sessionId = crypto.randomUUID();
-  const sessionCwd = worktreePath ?? process.cwd();
-
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
       // Run Claude session in the worktree root if in worktree mode
       cwd: worktreePath ?? undefined,
-      sessionId,
     });
 
     if (exitCode !== 0) {
       logger.warn(`Claude exited with code ${exitCode}`);
     }
 
-    // Parse session file and display token usage summary
-    displayPlanSessionTokenSummary(sessionId, sessionCwd);
-
     // Check for new plan files
     const allPlanFiles = fs.existsSync(plansDir)
       ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
@@ -647,11 +631,9 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
         logger.info(`  - plans/${planFile}`);
       }
 
-      // Commit planning artifacts (input.md, decisions.md, and new plan files)
-      const newPlanPaths = newPlanFiles.map(f => path.join(plansDir, f));
+      // Commit planning artifacts (input.md, decisions.md only — plan files committed during execution)
       await commitPlanningArtifacts(projectPath, {
         cwd: worktreePath ?? undefined,
-        additionalFiles: newPlanPaths,
         isAmend: true,
       });
 
@@ -699,43 +681,104 @@ ${taskList}
 `;
 }
 
-/**
- * Display token usage summary for a plan/amend session.
- * Parses the Claude session file and displays formatted usage data.
- */
-function displayPlanSessionTokenSummary(sessionId: string, cwd: string): void {
-  const result = parseSessionById(sessionId, cwd);
+async function runResumeCommand(identifier: string, model?: string): Promise<void> {
+  // Validate environment
+  const validation = validateEnvironment();
+  reportValidation(validation);
 
-  if (!result.success) {
-    // Session file not found or couldn't be parsed - just log debug and continue
-    logger.debug(`Could not parse session file: ${result.error}`);
-    return;
+  if (!validation.valid) {
+    process.exit(1);
+  }
+
+  // First, try to resolve the project from main repo
+  const rafDir = getRafDir();
+  const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
+
+  if (!mainResolution.path) {
+    if (mainResolution.error === 'ambiguous' && mainResolution.matches) {
+      logger.error(`Ambiguous project name: ${identifier}`);
+      logger.error('Multiple projects match:');
+      for (const match of mainResolution.matches) {
+        logger.error(`  - ${match.folder}`);
+      }
+      logger.error('Please specify the project ID or full folder name.');
+    } else {
+      logger.error(`Project not found: ${identifier}`);
+    }
+    process.exit(1);
+  }
+
+  const projectPath = mainResolution.path;
+  const folderName = path.basename(projectPath);
+
+  // Determine if this is a worktree project by checking if a worktree exists
+  let resumeCwd = projectPath; // Default to main repo project path
+  const repoBasename = getRepoBasename();
+
+  if (repoBasename) {
+    const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
+
+    // Check if a worktree exists for this project
+    if (fs.existsSync(worktreeBaseDir)) {
+      const entries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
+      const worktreeEntry = entries.find(
+        (entry) => entry.isDirectory() && entry.name === folderName
+      );
+
+      if (worktreeEntry) {
+        // Worktree exists - use it as the CWD
+        const worktreePath = path.join(worktreeBaseDir, worktreeEntry.name);
+        const wtValidation = validateWorktree(worktreePath, '');
+        if (wtValidation.isValidWorktree) {
+          resumeCwd = worktreePath;
+          logger.info(`Resuming session in worktree: ${worktreePath}`);
+        } else {
+          logger.warn(`Worktree found but invalid: ${worktreePath}`);
+          logger.warn('Falling back to main repo path.');
+        }
+      }
+    }
   }
 
-  // Check if there's any usage data
-  const totalTokens = result.usage.inputTokens + result.usage.outputTokens;
-  if (totalTokens === 0) {
-    logger.debug('No token usage data found in session file');
-    return;
+  logger.info(`Project: ${folderName}`);
+  if (model) {
+    logger.info(`Model: ${model}`);
   }
+  logger.newline();
+
+  // Set up shutdown handler
+  const claudeRunner = new ClaudeRunner({ model });
+  shutdownHandler.init();
+  shutdownHandler.registerClaudeRunner(claudeRunner);
 
-  // Create tracker and add the session as a single "task"
-  const pricingConfig = getPricingConfig();
-  const tracker = new TokenTracker(pricingConfig);
-  const entry = tracker.addTask('plan', [result.usage]);
-
-  // Get display options
-  const displayConfig = getDisplayConfig();
-  const options: TokenSummaryOptions = {
-    showCacheTokens: displayConfig.showCacheTokens,
-    showRateLimitEstimate: displayConfig.showRateLimitEstimate,
-    rateLimitPercentage: displayConfig.showRateLimitEstimate
-      ? tracker.calculateRateLimitPercentage(entry.cost.totalCost)
-      : undefined,
-  };
-
-  // Display the summary
+  // Launch Claude's resume picker
+  logger.info('Starting Claude session resume picker...');
   logger.newline();
-  const summary = formatTokenTotalSummary(result.usage, entry.cost, options);
-  console.log(summary);
+
+  try {
+    const exitCode = await claudeRunner.runResume({ cwd: resumeCwd });
+
+    if (exitCode !== 0) {
+      logger.warn(`Claude exited with code ${exitCode}`);
+    }
+
+    // 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()
+      : [];
+
+    if (planFiles.length > 0) {
+      logger.newline();
+      logger.success(`Session complete! Project has ${planFiles.length} plan(s).`);
+      logger.newline();
+      logger.info('Plans:');
+      for (const planFile of planFiles) {
+        logger.info(`  - plans/${planFile}`);
+      }
+    }
+  } catch (error) {
+    logger.error(`Resume session failed: ${error}`);
+    throw error;
+  }
 }

package/src/core/claude-runner.ts

@@ -31,12 +31,6 @@ export interface ClaudeRunnerOptions {
    * Claude will still ask planning interview questions.
    */
   dangerouslySkipPermissions?: boolean;
-  /**
-   * Session ID for Claude CLI. When provided, passed as --session-id to enable
-   * locating the session file after the session ends for token tracking.
-   * Only used in interactive mode (runInteractive).
-   */
-  sessionId?: string;
   /**
    * Path to the outcome file. When provided, enables completion detection:
    * - Monitors stdout for completion markers (<promise>COMPLETE/FAILED</promise>)
@@ -286,7 +280,7 @@ export class ClaudeRunner {
     userMessage: string,
     options: ClaudeRunnerOptions = {}
   ): Promise<number> {
-    const { cwd = process.cwd(), dangerouslySkipPermissions = false, sessionId } = options;
+    const { cwd = process.cwd(), dangerouslySkipPermissions = false } = options;
 
     return new Promise((resolve) => {
       const args = ['--model', this.model];
@@ -296,11 +290,6 @@ export class ClaudeRunner {
         args.push('--dangerously-skip-permissions');
       }
 
-      // Add --session-id if provided (for token tracking)
-      if (sessionId) {
-        args.push('--session-id', sessionId);
-      }
-
       // System instructions via --append-system-prompt
       args.push('--append-system-prompt', systemPrompt);
 
@@ -375,6 +364,87 @@ export class ClaudeRunner {
     });
   }
 
+  /**
+   * Resume a Claude planning session using the interactive session picker.
+   * Launches `claude --resume` (or `claude -r`) to show available sessions for the CWD.
+   * Minimal approach - no system prompt or user message injection.
+   *
+   * @param options - Runner options (cwd)
+   */
+  async runResume(options: ClaudeRunnerOptions = {}): Promise<number> {
+    const { cwd = process.cwd() } = options;
+
+    return new Promise((resolve) => {
+      const args = ['--resume', '--model', this.model];
+
+      logger.debug(`Starting Claude session resume picker with model: ${this.model}`);
+
+      this.activeProcess = pty.spawn(getClaudePath(), args, {
+        name: 'xterm-256color',
+        cols: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+        cwd,
+        env: process.env as Record<string, string>,
+      });
+
+      // Set raw mode to pass through all input
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+
+      // Pipe input to Claude
+      const onData = (data: Buffer): void => {
+        if (this.activeProcess && !this.killed) {
+          this.activeProcess.write(data.toString());
+        }
+      };
+      process.stdin.on('data', onData);
+
+      // Store disposables for proper cleanup
+      const disposables: IDisposable[] = [];
+
+      // Pipe output to stdout
+      disposables.push(this.activeProcess.onData((data) => {
+        process.stdout.write(data);
+      }));
+
+      disposables.push(this.activeProcess.onExit(({ exitCode }) => {
+        // Cleanup stdin
+        process.stdin.off('data', onData);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+
+        // Dispose all event listeners to prevent FD leaks
+        for (const disposable of disposables) {
+          try {
+            disposable.dispose();
+          } catch {
+            // Ignore disposal errors
+          }
+        }
+
+        // Ensure PTY is fully cleaned up
+        if (this.activeProcess) {
+          try {
+            this.activeProcess.kill();
+          } catch {
+            // Ignore - process may already be dead
+          }
+          this.activeProcess = null;
+        }
+
+        if (this.killed) {
+          resolve(130); // SIGINT exit code
+        } else {
+          resolve(exitCode);
+        }
+      }));
+    });
+  }
+
   /**
    * Run Claude non-interactively and collect output.
    * Uses stream-json format internally to capture token usage data.

package/src/core/worktree.ts

@@ -442,6 +442,11 @@ export interface SyncMainBranchResult {
   error?: string;
 }
 
+export interface RebaseResult {
+  success: boolean;
+  error?: string;
+}
+
 /**
  * Detect the main branch name from the remote.
  * Uses refs/remotes/origin/HEAD, falling back to main/master.
@@ -531,7 +536,7 @@ export function pullMainBranch(cwd?: string): SyncMainBranchResult {
         });
         logger.debug(`Fetched origin/${mainBranch} (local ${mainBranch} diverged, not updated)`);
         return {
-          success: true,
+          success: false,
           mainBranch,
           hadChanges: false,
           error: `Local ${mainBranch} has diverged from origin, not updated`,
@@ -662,3 +667,34 @@ export function pushMainBranch(cwd?: string): SyncMainBranchResult {
     };
   }
 }
+
+/**
+ * Rebase the current branch onto the main branch.
+ * If the rebase fails with conflicts, aborts the rebase and returns failure.
+ *
+ * @param mainBranch - The main branch name to rebase onto (e.g., 'main' or 'master')
+ * @param cwd - The directory to run git commands in (defaults to current directory)
+ */
+export function rebaseOntoMain(mainBranch: string, cwd: string): RebaseResult {
+  try {
+    execSync(`git rebase ${mainBranch}`, {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      cwd,
+    });
+    return { success: true };
+  } catch (error) {
+    // Abort the failed rebase to restore clean state
+    try {
+      execSync('git rebase --abort', {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+        cwd,
+      });
+    } catch {
+      // Ignore abort errors
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, error: msg };
+  }
+}

package/src/parsers/stream-renderer.ts

@@ -23,11 +23,13 @@ export interface StreamEvent {
     cache_read_input_tokens?: number;
     cache_creation_input_tokens?: number;
   };
+  total_cost_usd?: number;
   modelUsage?: Record<string, {
     inputTokens?: number;
     outputTokens?: number;
     cacheReadInputTokens?: number;
     cacheCreationInputTokens?: number;
+    costUSD?: number;
   }>;
   tool_use_result?: {
     type?: string;
@@ -175,6 +177,7 @@ function extractUsageData(event: StreamEvent): UsageData | undefined {
         outputTokens: data.outputTokens ?? 0,
         cacheReadInputTokens: data.cacheReadInputTokens ?? 0,
         cacheCreationInputTokens: data.cacheCreationInputTokens ?? 0,
+        costUsd: data.costUSD ?? 0,
       };
     }
   }
@@ -185,5 +188,6 @@ function extractUsageData(event: StreamEvent): UsageData | undefined {
     cacheReadInputTokens: usage?.cache_read_input_tokens ?? 0,
     cacheCreationInputTokens: usage?.cache_creation_input_tokens ?? 0,
     modelUsage,
+    totalCostUsd: event.total_cost_usd ?? 0,
   };
 }

package/src/prompts/amend.ts

@@ -135,9 +135,10 @@ After interviewing the user about all NEW tasks, create plan files starting from
 - ${projectPath}/plans/${encodeTaskId(nextTaskNumber + 1)}-task-name.md
 - etc.
 
-Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter format uses only a closing \`---\` delimiter (no opening delimiter):
+Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter uses standard YAML format with opening and closing \`---\` delimiters:
 
 \`\`\`markdown
+---
 effort: medium
 ---
 # Task: [Task Name]
@@ -186,6 +187,7 @@ The \`effort\` field is REQUIRED in every plan file. It indicates task complexit
 
 Optionally, you can add an explicit \`model\` field to override the effort-based model selection:
 \`\`\`markdown
+---
 effort: medium
 model: opus
 ---

package/src/prompts/config-docs.md

@@ -135,49 +135,12 @@ Controls the format of git commit messages. Templates use `{placeholder}` syntax
 
 Unknown placeholders are left as-is in the output.
 
-### `pricing` — Token Cost Pricing
-
-Controls per-model token pricing used for cost estimation. Prices are in dollars per million tokens. Each model category (`opus`, `sonnet`, `haiku`) has four pricing fields:
-
-| Field | Description |
-|-------|-------------|
-| `inputPerMTok` | Cost per million input tokens |
-| `outputPerMTok` | Cost per million output tokens |
-| `cacheReadPerMTok` | Cost per million cache read tokens (discounted) |
-| `cacheCreatePerMTok` | Cost per million cache creation tokens |
-
-**Default values:**
-
-| Category | Input | Output | Cache Read | Cache Create |
-|----------|-------|--------|------------|--------------|
-| `opus` | $15 | $75 | $1.50 | $18.75 |
-| `sonnet` | $3 | $15 | $0.30 | $3.75 |
-| `haiku` | $1 | $5 | $0.10 | $1.25 |
-
-Full model IDs from CLI output (e.g., `claude-opus-4-6`) are automatically mapped to the corresponding pricing category based on the model family name.
-
-Example override:
-
-```json
-{
-  "pricing": {
-    "opus": {
-      "inputPerMTok": 10,
-      "outputPerMTok": 50
-    }
-  }
-}
-```
-
-Only specify the fields you want to change — unset fields keep their defaults.
-
 ### `display` — Token Summary Display Options
 
 Controls what information is shown in token usage summaries after tasks and in the grand total.
 
 | Key | Default | Description |
 |-----|---------|-------------|
-| `display.showRateLimitEstimate` | `true` | Show estimated 5h rate limit window percentage (e.g., `~42% of 5h window`) |
 | `display.showCacheTokens` | `true` | Show cache read/create token counts in summaries |
 
 Example:
@@ -185,34 +148,11 @@ Example:
 ```json
 {
   "display": {
-    "showRateLimitEstimate": false,
     "showCacheTokens": true
   }
 }
 ```
 
-### `rateLimitWindow` — Rate Limit Configuration
-
-Controls the rate limit estimation calculation.
-
-| Key | Default | Description |
-|-----|---------|-------------|
-| `rateLimitWindow.sonnetTokenCap` | `88000` | The Sonnet-equivalent token cap for the 5-hour window. All token usage is normalized to Sonnet-equivalent tokens using pricing ratios. |
-
-The 5h window percentage is calculated as: `(estimatedCost / sonnetCostPerToken) / sonnetTokenCap * 100`
-
-Where `sonnetCostPerToken` is derived from the configured Sonnet pricing. Heavier models (Opus) consume the window faster than lighter ones (Haiku) in proportion to their API pricing ratios.
-
-Example:
-
-```json
-{
-  "rateLimitWindow": {
-    "sonnetTokenCap": 100000
-  }
-}
-```
-
 ## Validation Rules
 
 The config is validated when loaded. Invalid configs cause an error with a descriptive message. The following rules are enforced:
@@ -224,9 +164,7 @@ The config is validated when loaded. Invalid configs cause an error with a descr
 - **`maxRetries`** must be a non-negative integer.
 - **`autoCommit`**, **`worktree`**, and **`syncMainBranch`** must be booleans.
 - **`commitFormat` values** must be strings.
-- **`pricing`** categories must be `"opus"`, `"sonnet"`, or `"haiku"`. Each field must be a non-negative number.
-- **`display` values** (`showRateLimitEstimate`, `showCacheTokens`) must be booleans.
-- **`rateLimitWindow.sonnetTokenCap`** must be a positive number.
+- **`display` values** (`showCacheTokens`) must be booleans.
 - The config file must be valid JSON containing an object (not an array or primitive).
 
 ## CLI Precedence
@@ -294,17 +232,8 @@ Uses Sonnet for planning and caps task execution at Sonnet (tasks with `effort:
     "amend": "{prefix}[{projectId}] Amend: {projectName}",
     "prefix": "RAF"
   },
-  "pricing": {
-    "opus": { "inputPerMTok": 15, "outputPerMTok": 75, "cacheReadPerMTok": 1.5, "cacheCreatePerMTok": 18.75 },
-    "sonnet": { "inputPerMTok": 3, "outputPerMTok": 15, "cacheReadPerMTok": 0.3, "cacheCreatePerMTok": 3.75 },
-    "haiku": { "inputPerMTok": 1, "outputPerMTok": 5, "cacheReadPerMTok": 0.1, "cacheCreatePerMTok": 1.25 }
-  },
   "display": {
-    "showRateLimitEstimate": true,
     "showCacheTokens": true
-  },
-  "rateLimitWindow": {
-    "sonnetTokenCap": 88000
   }
 }
 ```

package/src/prompts/planning.ts

@@ -80,9 +80,10 @@ After interviewing the user about all tasks, create plan files in the plans fold
 - ${projectPath}/plans/02-task-name.md
 - etc.
 
-Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter format uses only a closing \`---\` delimiter (no opening delimiter):
+Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter uses standard YAML format with opening and closing \`---\` delimiters:
 
 \`\`\`markdown
+---
 effort: medium
 ---
 # Task: [Task Name]
@@ -128,6 +129,7 @@ The \`effort\` field is REQUIRED in every plan file. It indicates task complexit
 
 Optionally, you can add an explicit \`model\` field to override the effort-based model selection:
 \`\`\`markdown
+---
 effort: medium
 model: opus
 ---