rafcode 2.2.0 → 2.4.0

package/src/commands/config.ts

@@ -9,10 +9,12 @@ import { logger } from '../utils/logger.js';
 import {
   getConfigPath,
   getModel,
-  getEffort,
+  getModelShortName,
   validateConfig,
   ConfigValidationError,
+  resetConfigCache,
 } from '../utils/config.js';
+import { DEFAULT_CONFIG } from '../types/config.js';
 
 interface ConfigCommandOptions {
   reset?: boolean;
@@ -153,11 +155,28 @@ async function handleReset(): Promise<void> {
 
 async function runConfigSession(initialPrompt?: string): Promise<void> {
   const configPath = getConfigPath();
-  const model = getModel('config');
-  const effort = getEffort('config');
 
-  // Set effort level env var for the Claude session
-  process.env['CLAUDE_CODE_EFFORT_LEVEL'] = effort;
+  // Try to load config, but fall back to defaults if it's broken
+  // This allows raf config to be used to fix a broken config file
+  let model: string;
+  let configError: Error | null = null;
+
+  try {
+    model = getModel('config');
+  } catch (error) {
+    // Config file has errors - fall back to defaults so the session can launch
+    configError = error instanceof Error ? error : new Error(String(error));
+    model = DEFAULT_CONFIG.models.config;
+    // Clear the cached config so subsequent calls don't use the broken cache
+    resetConfigCache();
+  }
+
+  // Warn user if config has errors, before starting the session
+  if (configError) {
+    logger.warn(`Config file has errors, using defaults: ${configError.message}`);
+    logger.warn('Fix the config in this session or run `raf config --reset` to start fresh.');
+    logger.newline();
+  }
 
   // Load config docs
   let configDocs: string;
@@ -181,8 +200,8 @@ async function runConfigSession(initialPrompt?: string): Promise<void> {
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
-  logger.info('Starting config session with Claude...');
-  logger.info(`Using model: ${model}`);
+  const configModel = getModelShortName(model);
+  logger.info(`Starting config session with ${configModel}...`);
   logger.newline();
 
   try {

package/src/commands/do.ts

@@ -13,7 +13,9 @@ import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFro
 import { pickPendingProject, getPendingProjects, getPendingWorktreeProjects } from '../ui/project-picker.js';
 import type { PendingProjectInfo } from '../ui/project-picker.js';
 import { logger } from '../utils/logger.js';
-import { getConfig, getEffort, getWorktreeDefault } from '../utils/config.js';
+import { getConfig, getWorktreeDefault, getModel, getModelShortName, resolveFullModelId, getSyncMainBranch, resolveEffortToModel, applyModelCeiling } from '../utils/config.js';
+import type { PlanFrontmatter } from '../utils/frontmatter.js';
+import { getVersion } from '../utils/version.js';
 import { createTaskTimer, formatElapsedTime } from '../utils/timer.js';
 import { createStatusLine } from '../utils/status-line.js';
 import {
@@ -49,6 +51,8 @@ import {
   mergeWorktreeBranch,
   removeWorktree,
   resolveWorktreeProjectByIdentifier,
+  pushMainBranch,
+  pullMainBranch,
 } from '../core/worktree.js';
 import { createPullRequest, prPreflight } from '../core/pull-request.js';
 import type { DoCommandOptions } from '../types/config.js';
@@ -61,6 +65,74 @@ import type { DoCommandOptions } from '../types/config.js';
  */
 export type PostExecutionAction = 'merge' | 'pr' | 'leave';
 
+/**
+ * Result of resolving a task's model from frontmatter.
+ */
+interface TaskModelResolution {
+  /** The resolved model (after ceiling is applied). */
+  model: string;
+  /** Whether a warning should be logged about missing frontmatter. */
+  missingFrontmatter: boolean;
+  /** Frontmatter parsing warnings to log. */
+  warnings: string[];
+}
+
+/**
+ * Resolve the execution model for a task from its frontmatter metadata.
+ *
+ * Resolution order:
+ * 1. Explicit `model` in frontmatter (subject to ceiling)
+ * 2. `effort` in frontmatter resolved via effortMapping (subject to ceiling)
+ * 3. Fallback to models.execute (the ceiling, with a warning)
+ *
+ * @param frontmatter - Parsed frontmatter from the plan file
+ * @param frontmatterWarnings - Warnings from frontmatter parsing
+ * @param ceilingModel - The ceiling model (usually models.execute from config)
+ * @param isRetry - Whether this is a retry attempt (escalates to ceiling)
+ */
+function resolveTaskModel(
+  frontmatter: PlanFrontmatter | undefined,
+  frontmatterWarnings: string[] | undefined,
+  ceilingModel: string,
+  isRetry: boolean,
+): TaskModelResolution {
+  const warnings = frontmatterWarnings ? [...frontmatterWarnings] : [];
+
+  // Retry escalation: always use the ceiling model on retry
+  if (isRetry) {
+    return { model: ceilingModel, missingFrontmatter: false, warnings };
+  }
+
+  // No frontmatter - fallback to ceiling with warning
+  if (!frontmatter) {
+    return {
+      model: ceilingModel,
+      missingFrontmatter: true,
+      warnings,
+    };
+  }
+
+  // Explicit model in frontmatter - apply ceiling
+  if (frontmatter.model) {
+    const model = applyModelCeiling(frontmatter.model, ceilingModel);
+    return { model, missingFrontmatter: false, warnings };
+  }
+
+  // Effort-based resolution - apply ceiling
+  if (frontmatter.effort) {
+    const mappedModel = resolveEffortToModel(frontmatter.effort);
+    const model = applyModelCeiling(mappedModel, ceilingModel);
+    return { model, missingFrontmatter: false, warnings };
+  }
+
+  // Frontmatter present but no effort or model - fallback to ceiling with warning
+  return {
+    model: ceilingModel,
+    missingFrontmatter: true,
+    warnings,
+  };
+}
+
 /**
  * Format failure history for console output.
  * Shows attempts that failed before eventual success or final failure.
@@ -166,6 +238,18 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
     // Record original branch before any worktree operations
     originalBranch = getCurrentBranch() ?? undefined;
 
+    // Sync main branch before worktree operations (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}`);
+      }
+    }
+
     if (!projectIdentifier) {
       // Auto-discovery flow
       const selected = await discoverAndPickWorktreeProject(repoBasename, rafDir, rafRelativePath);
@@ -394,7 +478,6 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         force,
         maxRetries,
         autoCommit,
-        showModel: true,
         model,
         worktreeCwd: worktreeRoot,
       }
@@ -500,6 +583,19 @@ async function executePostAction(
 
     case 'pr': {
       logger.newline();
+
+      // Push main branch to remote before PR creation (if enabled)
+      if (getSyncMainBranch()) {
+        const syncResult = pushMainBranch();
+        if (syncResult.success) {
+          if (syncResult.hadChanges) {
+            logger.info(`Pushed ${syncResult.mainBranch} to remote`);
+          }
+        } else {
+          logger.warn(`Could not push main branch: ${syncResult.error}`);
+        }
+      }
+
       logger.info(`Creating PR for branch "${worktreeBranch}"...`);
 
       const prResult = await createPullRequest(worktreeBranch, projectPath, { cwd: worktreeRoot });
@@ -658,7 +754,6 @@ interface SingleProjectOptions {
   force: boolean;
   maxRetries: number;
   autoCommit: boolean;
-  showModel: boolean;
   model: string;
   /** Worktree root directory. When set, Claude runs with cwd in the worktree. */
   worktreeCwd?: string;
@@ -669,7 +764,7 @@ async function executeSingleProject(
   projectName: string,
   options: SingleProjectOptions
 ): Promise<ProjectExecutionResult> {
-  const { timeout, verbose, debug, force, maxRetries, autoCommit, showModel, model, worktreeCwd } = options;
+  const { timeout, verbose, debug, force, maxRetries, autoCommit, model, worktreeCwd } = options;
 
   if (!validatePlansExist(projectPath)) {
     return {
@@ -709,11 +804,12 @@ async function executeSingleProject(
       : state.tasks.filter((t) => t.status !== 'completed').map((t) => t.id)
   );
 
-  // Set up shutdown handler
-  const claudeRunner = new ClaudeRunner({ model });
+  // Set up shutdown handler - we'll register runners dynamically per-task
   const projectManager = new ProjectManager();
   shutdownHandler.init();
-  shutdownHandler.registerClaudeRunner(claudeRunner);
+
+  // The ceiling model for all tasks (can be overridden per-task, subject to this ceiling)
+  const ceilingModel = model;
 
   // Initialize token tracker for usage reporting
   const tokenTracker = new TokenTracker();
@@ -725,15 +821,13 @@ async function executeSingleProject(
   // Start project timer
   const projectStartTime = Date.now();
 
+  // Resolve and display version + ceiling model info (before any tasks run)
+  const fullCeilingModelId = resolveFullModelId(ceilingModel);
+  logger.dim(`RAF v${getVersion()} | Ceiling: ${fullCeilingModelId}`);
+
   if (verbose) {
     logger.info(`Executing project: ${projectName}`);
     logger.info(`Tasks: ${state.tasks.length}, Task timeout: ${timeout} minutes`);
-
-    // Log Claude model name
-    if (showModel && model) {
-      logger.info(`Using model: ${model}`);
-    }
-
     logger.newline();
   } else {
     // Minimal mode: show project header
@@ -905,28 +999,63 @@ async function executeSingleProject(
     let attempts = 0;
     let lastOutput = '';
     let failureReason = '';
-    let lastUsageData: import('../types/config.js').UsageData | undefined;
+    // Collect usage data from all attempts (for accurate token tracking across retries)
+    const attemptUsageData: import('../types/config.js').UsageData[] = [];
     // Track failure history for each attempt (attempt number -> reason)
     const failureHistory: Array<{ attempt: number; reason: string }> = [];
 
     // Set up timer for elapsed time tracking
     const statusLine = createStatusLine();
     const timer = createTaskTimer(verbose ? undefined : (elapsed) => {
+      // When verbose is toggled ON at runtime, clear the status line and skip updates
+      if (verboseToggle.isVerbose) {
+        statusLine.clear();
+        return;
+      }
       // Show running status with task name and timer (updates in place)
       statusLine.update(formatTaskProgress(taskNumber, totalTasks, 'running', displayName, elapsed, taskId));
     });
     timer.start();
 
+    // Log frontmatter warnings once before the retry loop
+    if (task.frontmatterWarnings && task.frontmatterWarnings.length > 0) {
+      for (const warning of task.frontmatterWarnings) {
+        logger.warn(`  Frontmatter warning: ${warning}`);
+      }
+    }
+
     while (!success && attempts < maxRetries) {
       attempts++;
+      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,
+      );
+
+      // Log missing frontmatter warning on first attempt only
+      if (!isRetry && modelResolution.missingFrontmatter) {
+        logger.warn(`  No effort frontmatter found — using ceiling model`);
+      }
+
+      // Create a runner for this attempt's model
+      const taskRunner = new ClaudeRunner({ model: modelResolution.model });
+      shutdownHandler.registerClaudeRunner(taskRunner);
 
-      if (verbose && attempts > 1) {
-        logger.info(`  Retry ${attempts}/${maxRetries} for task ${taskLabel}...`);
+      if (verbose && isRetry) {
+        const retryModel = resolveFullModelId(modelResolution.model);
+        logger.info(`  Retry ${attempts}/${maxRetries} for task ${taskLabel} (model: ${retryModel})...`);
+      } else if (verbose && !isRetry) {
+        const taskModel = resolveFullModelId(modelResolution.model);
+        logger.info(`  Model: ${taskModel}`);
       }
 
       // Build execution prompt (inside loop to include retry context on retries)
       // Check if previous outcome file exists for retry context
-      const previousOutcomeFileForRetry = attempts > 1 && fs.existsSync(outcomeFilePath)
+      const previousOutcomeFileForRetry = isRetry && fs.existsSync(outcomeFilePath)
         ? outcomeFilePath
         : undefined;
 
@@ -955,22 +1084,20 @@ async function executeSingleProject(
       } : undefined;
 
       // Run Claude (use worktree root as cwd if in worktree mode)
-      const executeEffort = getEffort('execute');
       const runnerOptions = {
         timeout,
         outcomeFilePath,
         commitContext,
         cwd: worktreeCwd,
-        effortLevel: executeEffort,
         verboseCheck: () => verboseToggle.isVerbose,
       };
       const result = verbose
-        ? await claudeRunner.runVerbose(prompt, runnerOptions)
-        : await claudeRunner.run(prompt, runnerOptions);
+        ? await taskRunner.runVerbose(prompt, runnerOptions)
+        : await taskRunner.run(prompt, runnerOptions);
 
       lastOutput = result.output;
       if (result.usageData) {
-        lastUsageData = result.usageData;
+        attemptUsageData.push(result.usageData);
       }
 
       // Parse result
@@ -1088,9 +1215,9 @@ Task completed. No detailed report provided.
       }
 
       // Track and display token usage for this task
-      if (lastUsageData) {
-        const entry = tokenTracker.addTask(task.id, lastUsageData);
-        logger.dim(formatTaskTokenSummary(entry.usage, entry.cost));
+      if (attemptUsageData.length > 0) {
+        const entry = tokenTracker.addTask(task.id, attemptUsageData);
+        logger.dim(formatTaskTokenSummary(entry, (u) => tokenTracker.calculateCost(u)));
       }
 
       completedInSession.add(task.id);
@@ -1108,16 +1235,17 @@ Task completed. No detailed report provided.
 
       if (verbose) {
         logger.error(`  Task ${taskLabel} failed: ${failureReason} (${elapsedFormatted})`);
-        logger.info('  Analyzing failure...');
+        const analysisModel = getModelShortName(getModel('failureAnalysis'));
+        logger.info(`  Analyzing failure with ${analysisModel}...`);
       } else {
         // Minimal mode: show failed task line
         logger.info(formatTaskProgress(taskNumber, totalTasks, 'failed', displayName, elapsedMs, task.id));
       }
 
       // Track token usage even for failed tasks (partial data still useful for totals)
-      if (lastUsageData) {
-        const entry = tokenTracker.addTask(task.id, lastUsageData);
-        logger.dim(formatTaskTokenSummary(entry.usage, entry.cost));
+      if (attemptUsageData.length > 0) {
+        const entry = tokenTracker.addTask(task.id, attemptUsageData);
+        logger.dim(formatTaskTokenSummary(entry, (u) => tokenTracker.calculateCost(u)));
       }
 
       // Analyze failure and generate structured report

package/src/commands/plan.ts

@@ -1,5 +1,6 @@
 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';
@@ -15,7 +16,10 @@ import {
   resolveModelOption,
 } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
-import { getWorktreeDefault } from '../utils/config.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 { generateProjectNames } from '../utils/name-generator.js';
 import { pickProjectName } from '../ui/name-picker.js';
 import {
@@ -48,6 +52,7 @@ import {
   validateWorktree,
   removeWorktree,
   computeWorktreeBaseDir,
+  pullMainBranch,
 } from '../core/worktree.js';
 
 interface PlanCommandOptions {
@@ -155,7 +160,8 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   // Get or generate project name
   let finalProjectName = projectName;
   if (!finalProjectName) {
-    logger.info('Generating project name suggestions...');
+    const nameModel = getModelShortName(getModel('nameGeneration'));
+    logger.info(`Generating project name suggestions with ${nameModel}...`);
     const suggestedNames = await generateProjectNames(cleanInput);
     logger.newline();
 
@@ -184,6 +190,18 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     const repoRoot = getRepoRoot()!;
     const rafDir = getRafDir();
 
+    // 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}`);
+      }
+    }
+
     // Compute project number from main repo's RAF directory
     const projectNumber = getNextProjectNumber(rafDir);
     const sanitizedName = sanitizeProjectName(finalProjectName);
@@ -271,17 +289,25 @@ 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)
@@ -411,6 +437,18 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
         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 result = createWorktree(repoBasename, folderName);
         if (!result.success) {
           logger.error(`Failed to create worktree: ${result.error}`);
@@ -566,17 +604,25 @@ 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()
@@ -652,3 +698,44 @@ ${taskList}
 # Describe what you want to add below:
 `;
 }
+
+/**
+ * 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);
+
+  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;
+  }
+
+  // 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;
+  }
+
+  // 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
+  logger.newline();
+  const summary = formatTokenTotalSummary(result.usage, entry.cost, options);
+  console.log(summary);
+}

package/src/core/claude-runner.ts

@@ -6,12 +6,11 @@ import { logger } from '../utils/logger.js';
 import { renderStreamEvent } from '../parsers/stream-renderer.js';
 import type { UsageData } from '../types/config.js';
 import { getHeadCommitHash, getHeadCommitMessage, isFileCommittedInHead } from './git.js';
-import { getClaudeCommand, getModel } from '../utils/config.js';
+import { getModel } from '../utils/config.js';
 
 function getClaudePath(): string {
-  const cmd = getClaudeCommand();
   try {
-    return execSync(`which ${cmd}`, { encoding: 'utf-8' }).trim();
+    return execSync('which claude', { encoding: 'utf-8' }).trim();
   } catch {
     throw new Error('Claude CLI not found. Please ensure it is installed and in your PATH.');
   }
@@ -32,6 +31,12 @@ 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>)
@@ -53,12 +58,6 @@ export interface ClaudeRunnerOptions {
     /** Path to the outcome file that should be committed. */
     outcomeFilePath: string;
   };
-  /**
-   * Claude Code reasoning effort level.
-   * Sets CLAUDE_CODE_EFFORT_LEVEL env var for the spawned process.
-   * Only applied in non-interactive modes (run, runVerbose).
-   */
-  effortLevel?: 'low' | 'medium' | 'high';
   /**
    * Dynamic verbose display callback. When provided, called for each stream event
    * to determine whether to write display output to stdout. Overrides the static
@@ -287,7 +286,7 @@ export class ClaudeRunner {
     userMessage: string,
     options: ClaudeRunnerOptions = {}
   ): Promise<number> {
-    const { cwd = process.cwd(), dangerouslySkipPermissions = false } = options;
+    const { cwd = process.cwd(), dangerouslySkipPermissions = false, sessionId } = options;
 
     return new Promise((resolve) => {
       const args = ['--model', this.model];
@@ -297,6 +296,11 @@ 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);
 
@@ -415,7 +419,7 @@ export class ClaudeRunner {
     options: ClaudeRunnerOptions,
     verbose: boolean,
   ): Promise<RunResult> {
-    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, effortLevel, verboseCheck } = options;
+    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, verboseCheck } = options;
     // Ensure timeout is a positive number, fallback to 60 minutes
     const validatedTimeout = Number(timeout) > 0 ? Number(timeout) : 60;
     const timeoutMs = validatedTimeout * 60 * 1000;
@@ -437,11 +441,6 @@ export class ClaudeRunner {
       logger.debug(`Prompt length: ${prompt.length}, timeout: ${timeoutMs}ms, cwd: ${cwd}`);
       logger.debug(`Claude path: ${claudePath}`);
 
-      // Build env, optionally injecting effort level
-      const env = effortLevel
-        ? { ...process.env, CLAUDE_CODE_EFFORT_LEVEL: effortLevel }
-        : process.env;
-
       logger.debug('Spawning process...');
       // Use --output-format stream-json --verbose to get real-time streaming events
       // including tool calls, file operations, and token usage in the result event.
@@ -460,7 +459,7 @@ export class ClaudeRunner {
         'Execute the task as described in the system prompt.',
       ], {
         cwd,
-        env,
+        env: process.env,
         stdio: ['ignore', 'pipe', 'pipe'], // no stdin needed
       });
 

package/src/core/failure-analyzer.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { execSync } from 'node:child_process';
-import { getModel, getClaudeCommand } from '../utils/config.js';
+import { getModel } from '../utils/config.js';
 
 /**
  * Failure types that can be detected programmatically without using the API.
@@ -213,9 +213,8 @@ function extractRelevantOutput(output: string, maxLines: number): string {
  * Get the path to Claude CLI.
  */
 function getClaudePath(): string {
-  const cmd = getClaudeCommand();
   try {
-    return execSync(`which ${cmd}`, { encoding: 'utf-8' }).trim();
+    return execSync('which claude', { encoding: 'utf-8' }).trim();
   } catch {
     throw new Error('Claude CLI not found. Please ensure it is installed and in your PATH.');
   }
@@ -312,6 +311,7 @@ Respond with ONLY a markdown report in this exact format:
     const failureModel = getModel('failureAnalysis');
     const proc = spawn(claudePath, [
       '--model', failureModel,
+      '--no-session-persistence',
       '--dangerously-skip-permissions',
       '-p',
       prompt,