rafcode 3.0.0 → 3.8.0

package/src/commands/do.ts

@@ -8,18 +8,19 @@ import { shutdownHandler } from '../core/shutdown-handler.js';
 import { stashChanges, hasUncommittedChanges, isGitRepo, getHeadCommitHash } from '../core/git.js';
 import { getExecutionPrompt } from '../prompts/execution.js';
 import { parseOutput, isRetryableFailure } from '../parsers/output-parser.js';
-import { validatePlansExist, resolveModelOption } from '../utils/validation.js';
+import { validatePlansExist } 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 type { PendingProjectInfo } 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 { formatModelDisplay, getConfig, getModel, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens, parseModelSpec, resolveFullModelId } 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 {
   formatProjectHeader,
+  formatModelMetadata,
   formatSummary,
   formatTaskProgress,
   formatTaskTokenSummary,
@@ -29,7 +30,6 @@ import { TokenTracker } from '../utils/token-tracker.js';
 import { VerboseToggle } from '../utils/verbose-toggle.js';
 import {
   deriveProjectState,
-  discoverProjects,
   getNextExecutableTask,
   getDerivedStats,
   getDerivedStatsForTasks,
@@ -44,10 +44,6 @@ import {
   getRepoRoot,
   getRepoBasename,
   getCurrentBranch,
-  computeWorktreePath,
-  computeWorktreeBaseDir,
-  validateWorktree,
-  listWorktreeProjects,
   mergeWorktreeBranch,
   removeWorktree,
   resolveWorktreeProjectByIdentifier,
@@ -57,7 +53,7 @@ import {
   rebaseOntoMain,
 } from '../core/worktree.js';
 import { createPullRequest, prPreflight } from '../core/pull-request.js';
-import type { DoCommandOptions } from '../types/config.js';
+import type { DoCommandOptions, ModelEntry } from '../types/config.js';
 
 /**
  * Post-execution action chosen by the user before task execution begins.
@@ -71,8 +67,8 @@ 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;
+  /** The resolved model entry (after ceiling is applied). */
+  entry: ModelEntry;
   /** Whether a warning should be logged about missing frontmatter. */
   missingFrontmatter: boolean;
   /** Frontmatter parsing warnings to log. */
@@ -89,26 +85,26 @@ interface TaskModelResolution {
  *
  * @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 ceilingEntry - The ceiling model entry (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,
+  ceilingEntry: ModelEntry,
   isRetry: boolean,
 ): TaskModelResolution {
   const warnings = frontmatterWarnings ? [...frontmatterWarnings] : [];
 
   // Retry escalation: always use the ceiling model on retry
   if (isRetry) {
-    return { model: ceilingModel, missingFrontmatter: false, warnings };
+    return { entry: ceilingEntry, missingFrontmatter: false, warnings };
   }
 
   // No frontmatter - fallback to ceiling with warning
   if (!frontmatter) {
     return {
-      model: ceilingModel,
+      entry: ceilingEntry,
       missingFrontmatter: true,
       warnings,
     };
@@ -116,20 +112,25 @@ function resolveTaskModel(
 
   // Explicit model in frontmatter - apply ceiling
   if (frontmatter.model) {
-    const model = applyModelCeiling(frontmatter.model, ceilingModel);
-    return { model, missingFrontmatter: false, warnings };
+    const parsed = parseModelSpec(frontmatter.model);
+    const fmEntry: ModelEntry = {
+      model: parsed.model,
+      harness: parsed.harness,
+    };
+    const result = applyModelCeiling(fmEntry, ceilingEntry);
+    return { entry: result, 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 };
+    const mappedEntry = resolveEffortToModel(frontmatter.effort);
+    const result = applyModelCeiling(mappedEntry, ceilingEntry);
+    return { entry: result, missingFrontmatter: false, warnings };
   }
 
   // Frontmatter present but no effort or model - fallback to ceiling with warning
   return {
-    model: ceilingModel,
+    entry: ceilingEntry,
     missingFrontmatter: true,
     warnings,
   };
@@ -190,6 +191,13 @@ interface ProjectExecutionResult {
   retryHistory?: TaskRetryHistory[];
 }
 
+export function formatResolvedTaskModel(entry: ModelEntry): string {
+  return formatModelMetadata(resolveFullModelId(entry.model), {
+    effort: entry.reasoningEffort,
+    fast: entry.fast === true,
+  });
+}
+
 export function createDoCommand(): Command {
   const command = new Command('do')
     .description('Execute planned tasks for a project')
@@ -199,11 +207,6 @@ export function createDoCommand(): Command {
     .option('-v, --verbose', 'Show full LLM output')
     .option('-d, --debug', 'Save all logs and show debug output')
     .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: string | undefined, options: DoCommandOptions) => {
       await runDoCommand(project, options);
     });
@@ -214,59 +217,13 @@ export function createDoCommand(): Command {
 async function runDoCommand(projectIdentifierArg: string | undefined, options: DoCommandOptions): Promise<void> {
   const rafDir = getRafDir();
   let projectIdentifier = projectIdentifierArg;
-  let worktreeMode = options.worktree ?? getWorktreeDefault();
-
-  // Validate and resolve model option
-  let model: string;
-  try {
-    model = resolveModelOption(options.model as string | undefined, options.sonnet, 'execute');
-  } catch (error) {
-    logger.error((error as Error).message);
-    process.exit(1);
-  }
+  const executeEntry = getModel('execute');
 
-  // Variables for worktree context (set when --worktree is used)
+  // Variables for worktree context (derived from where the project is found)
   let worktreeRoot: string | undefined;
   let originalBranch: string | undefined;
   let mainBranchName: string | null = 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)
@@ -298,9 +255,8 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
       // 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;
       }
@@ -316,89 +272,20 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   // Resolve project identifier
   let resolvedProject: { identifier: string; path: string; name: string } | undefined;
 
-  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: string;
-      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;
 
@@ -411,8 +298,6 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         const wtProjectPath = path.join(wtRafDir, wtResolution.folder);
 
         if (fs.existsSync(wtProjectPath)) {
-          // Auto-switch to worktree mode
-          worktreeMode = true;
           worktreeRoot = wtResolution.worktreeRoot;
           originalBranch = getCurrentBranch() ?? undefined;
 
@@ -456,9 +341,26 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   // 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: PostExecutionAction = '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);
     } catch (error) {
@@ -498,7 +400,7 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         force,
         maxRetries,
         autoCommit,
-        model,
+        executeEntry,
         worktreeCwd: worktreeRoot,
       }
     );
@@ -509,7 +411,7 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   }
 
   // Execute post-execution action based on picker choice
-  if (worktreeMode && worktreeRoot) {
+  if (worktreeRoot) {
     const worktreeBranch = path.basename(worktreeRoot);
 
     if (result.success) {
@@ -650,88 +552,6 @@ async function executePostAction(
   }
 }
 
-/**
- * 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: string,
-  rafDir: string,
-  rafRelativePath: string,
-): Promise<{ worktreeRoot?: string; projectFolder: string } | null> {
-  // 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<string, PendingProjectInfo>();
-  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;
-  }
-}
-
 interface SingleProjectOptions {
   timeout: number;
   verbose: boolean;
@@ -739,7 +559,8 @@ interface SingleProjectOptions {
   force: boolean;
   maxRetries: number;
   autoCommit: boolean;
-  model: string;
+  /** The resolved execute model entry (acts as ceiling for per-task resolution). */
+  executeEntry: ModelEntry;
   /** Worktree root directory. When set, the runner uses cwd in the worktree. */
   worktreeCwd?: string;
 }
@@ -749,7 +570,7 @@ async function executeSingleProject(
   projectName: string,
   options: SingleProjectOptions
 ): Promise<ProjectExecutionResult> {
-  const { timeout, verbose, debug, force, maxRetries, autoCommit, model, worktreeCwd } = options;
+  const { timeout, verbose, debug, force, maxRetries, autoCommit, executeEntry, worktreeCwd } = options;
 
   if (!validatePlansExist(projectPath)) {
     return {
@@ -793,8 +614,8 @@ async function executeSingleProject(
   const projectManager = new ProjectManager();
   shutdownHandler.init();
 
-  // The ceiling model for all tasks (can be overridden per-task, subject to this ceiling)
-  const ceilingModel = model;
+  // The ceiling model entry for all tasks (can be overridden per-task, subject to this ceiling)
+  const ceilingEntry = executeEntry;
 
   // Initialize token tracker for usage reporting
   const tokenTracker = new TokenTracker();
@@ -807,8 +628,8 @@ async function executeSingleProject(
   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}`);
+  const fullCeilingModelId = resolveFullModelId(ceilingEntry.model);
+  logger.dim(`RAF v${getVersion()} | Ceiling: ${fullCeilingModelId} (${ceilingEntry.harness})`);
 
   if (verbose) {
     logger.info(`Executing project: ${projectName}`);
@@ -990,6 +811,8 @@ async function executeSingleProject(
     const failureHistory: Array<{ attempt: number; reason: string }> = [];
     // Track current model for display in status line (updated in retry loop)
     let currentModel: string | undefined;
+    let currentEffort: string | undefined;
+    let currentModelFast = false;
 
     // Set up timer for elapsed time tracking
     const statusLine = createStatusLine();
@@ -1000,8 +823,11 @@ async function executeSingleProject(
         return;
       }
       // Show running status with task name and timer (updates in place)
-      const modelShortName = currentModel ? getModelShortName(currentModel) : undefined;
-      statusLine.update(formatTaskProgress(taskNumber, totalTasks, 'running', displayName, elapsed, taskId, modelShortName));
+      const modelShortName = currentModel ? formatModelDisplay(currentModel) : undefined;
+      statusLine.update(formatTaskProgress(taskNumber, totalTasks, 'running', displayName, elapsed, taskId, modelShortName, {
+        effort: currentEffort,
+        fast: currentModelFast,
+      }));
     });
     timer.start();
 
@@ -1020,12 +846,14 @@ async function executeSingleProject(
       const modelResolution = resolveTaskModel(
         task.frontmatter,
         undefined, // warnings already logged above
-        ceilingModel,
+        ceilingEntry,
         isRetry,
       );
 
       // Update current model for timer callback display
-      currentModel = modelResolution.model;
+      currentModel = modelResolution.entry.model;
+      currentEffort = task.frontmatter?.effort;
+      currentModelFast = modelResolution.entry.fast === true;
 
       // Log missing frontmatter warning on first attempt only
       if (!isRetry && modelResolution.missingFrontmatter) {
@@ -1033,14 +861,14 @@ async function executeSingleProject(
       }
 
       // Create a runner for this attempt's model
-      const taskRunner = createRunner({ model: modelResolution.model });
+      const taskRunner = createRunner({ model: modelResolution.entry.model, harness: modelResolution.entry.harness, reasoningEffort: modelResolution.entry.reasoningEffort, fast: modelResolution.entry.fast });
       shutdownHandler.registerClaudeRunner(taskRunner);
 
       if (verbose && isRetry) {
-        const retryModel = resolveFullModelId(modelResolution.model);
+        const retryModel = formatResolvedTaskModel(modelResolution.entry);
         logger.info(`  Retry ${attempts}/${maxRetries} for task ${taskLabel} (model: ${retryModel})...`);
       } else if (verbose && !isRetry) {
-        const taskModel = resolveFullModelId(modelResolution.model);
+        const taskModel = formatResolvedTaskModel(modelResolution.entry);
         logger.info(`  Model: ${taskModel}`);
       }
 
@@ -1202,8 +1030,11 @@ Task completed. No detailed report provided.
         logger.success(`  Task ${taskLabel} completed (${elapsedFormatted})`);
       } else {
         // Minimal mode: show completed task line
-        const modelShortName = currentModel ? getModelShortName(currentModel) : undefined;
-        logger.info(formatTaskProgress(taskNumber, totalTasks, 'completed', displayName, elapsedMs, task.id, modelShortName));
+        const modelShortName = currentModel ? formatModelDisplay(currentModel) : undefined;
+        logger.info(formatTaskProgress(taskNumber, totalTasks, 'completed', displayName, elapsedMs, task.id, modelShortName, {
+          effort: currentEffort,
+          fast: currentModelFast,
+        }));
       }
 
       // Track and display token usage for this task
@@ -1229,12 +1060,16 @@ Task completed. No detailed report provided.
 
       if (verbose) {
         logger.error(`  Task ${taskLabel} failed: ${failureReason} (${elapsedFormatted})`);
-        const analysisModel = getModelShortName(getModel('failureAnalysis'));
+        const analysisEntry = getModel('failureAnalysis');
+        const analysisModel = formatModelDisplay(analysisEntry.model);
         logger.info(`  Analyzing failure with ${analysisModel}...`);
       } else {
         // Minimal mode: show failed task line
-        const modelShortName = currentModel ? getModelShortName(currentModel) : undefined;
-        logger.info(formatTaskProgress(taskNumber, totalTasks, 'failed', displayName, elapsedMs, task.id, modelShortName));
+        const modelShortName = currentModel ? formatModelDisplay(currentModel) : undefined;
+        logger.info(formatTaskProgress(taskNumber, totalTasks, 'failed', displayName, elapsedMs, task.id, modelShortName, {
+          effort: currentEffort,
+          fast: currentModelFast,
+        }));
       }
 
       // Track token usage even for failed tasks (partial data still useful for totals)
@@ -1387,4 +1222,3 @@ ${stashName ? `- Stash: ${stashName}` : ''}
     retryHistory: projectRetryHistory,
   };
 }
-