rafcode 2.3.0 → 2.4.1-0

package/src/types/config.ts

@@ -6,10 +6,11 @@ export type ClaudeModelAlias = 'sonnet' | 'haiku' | 'opus';
  * matching the pattern `claude-{family}-{version}` (e.g., `claude-opus-4-5-20251101`).
  */
 export type ClaudeModelName = ClaudeModelAlias | (string & { __brand?: 'FullModelId' });
-export type EffortLevel = 'low' | 'medium' | 'high';
+
+/** Task complexity label for per-task effort frontmatter. Maps to models via effortMapping. */
+export type TaskEffortLevel = 'low' | 'medium' | 'high';
 
 export type ModelScenario = 'plan' | 'execute' | 'nameGeneration' | 'failureAnalysis' | 'prGeneration' | 'config';
-export type EffortScenario = ModelScenario;
 export type CommitFormatType = 'task' | 'plan' | 'amend';
 
 export interface ModelsConfig {
@@ -21,13 +22,14 @@ export interface ModelsConfig {
   config: ClaudeModelName;
 }
 
-export interface EffortConfig {
-  plan: EffortLevel;
-  execute: EffortLevel;
-  nameGeneration: EffortLevel;
-  failureAnalysis: EffortLevel;
-  prGeneration: EffortLevel;
-  config: EffortLevel;
+/**
+ * Maps task complexity labels to model names.
+ * Used to resolve per-task effort frontmatter to a model.
+ */
+export interface EffortMappingConfig {
+  low: ClaudeModelName;
+  medium: ClaudeModelName;
+  high: ClaudeModelName;
 }
 
 export interface CommitFormatConfig {
@@ -55,16 +57,34 @@ export interface PricingConfig {
   haiku: ModelPricing;
 }
 
+/** Display options for token usage summaries. */
+export interface DisplayConfig {
+  /** Show estimated 5h rate limit window percentage. Default: true */
+  showRateLimitEstimate: boolean;
+  /** Show cache token counts in summaries. Default: true */
+  showCacheTokens: boolean;
+}
+
+/** Rate limit window configuration. */
+export interface RateLimitWindowConfig {
+  /** Sonnet-equivalent token cap for the 5h window. Default: 88000 */
+  sonnetTokenCap: number;
+}
+
 export interface RafConfig {
   models: ModelsConfig;
-  effort: EffortConfig;
+  /** Maps task complexity labels (low/medium/high) to models. Used for per-task effort frontmatter. */
+  effortMapping: EffortMappingConfig;
   timeout: number;
   maxRetries: number;
   autoCommit: boolean;
   worktree: boolean;
+  /** Sync main branch with remote before worktree/PR operations. Default: true */
+  syncMainBranch: boolean;
   commitFormat: CommitFormatConfig;
-  claudeCommand: string;
   pricing: PricingConfig;
+  display: DisplayConfig;
+  rateLimitWindow: RateLimitWindowConfig;
 }
 
 export const DEFAULT_CONFIG: RafConfig = {
@@ -76,25 +96,22 @@ export const DEFAULT_CONFIG: RafConfig = {
     prGeneration: 'sonnet',
     config: 'sonnet',
   },
-  effort: {
-    plan: 'high',
-    execute: 'medium',
-    nameGeneration: 'low',
-    failureAnalysis: 'low',
-    prGeneration: 'medium',
-    config: 'medium',
+  effortMapping: {
+    low: 'haiku',
+    medium: 'sonnet',
+    high: 'opus',
   },
   timeout: 60,
   maxRetries: 3,
   autoCommit: true,
   worktree: false,
+  syncMainBranch: true,
   commitFormat: {
     task: '{prefix}[{projectId}:{taskId}] {description}',
     plan: '{prefix}[{projectId}] Plan: {projectName}',
     amend: '{prefix}[{projectId}] Amend: {projectName}',
     prefix: 'RAF',
   },
-  claudeCommand: 'claude',
   pricing: {
     opus: {
       inputPerMTok: 15,
@@ -115,6 +132,13 @@ export const DEFAULT_CONFIG: RafConfig = {
       cacheCreatePerMTok: 1.25,
     },
   },
+  display: {
+    showRateLimitEstimate: true,
+    showCacheTokens: true,
+  },
+  rateLimitWindow: {
+    sonnetTokenCap: 88000,
+  },
 };
 
 /** Deep partial type for user config files — all fields optional at every level */
@@ -134,7 +158,9 @@ export const FULL_MODEL_ID_PATTERN = /^claude-[a-z]+-\d+(-\d+)*$/;
 
 /** @deprecated Use VALID_MODEL_ALIASES instead */
 export const VALID_MODELS = VALID_MODEL_ALIASES;
-export const VALID_EFFORTS: readonly EffortLevel[] = ['low', 'medium', 'high'];
+
+/** Valid task effort levels for plan frontmatter. */
+export const VALID_TASK_EFFORTS: readonly TaskEffortLevel[] = ['low', 'medium', 'high'];
 
 // Keep backward-compat exports used by other modules
 /** @deprecated Use DEFAULT_CONFIG instead */
@@ -142,7 +168,6 @@ export const DEFAULT_RAF_CONFIG = {
   defaultTimeout: DEFAULT_CONFIG.timeout,
   defaultMaxRetries: DEFAULT_CONFIG.maxRetries,
   autoCommit: DEFAULT_CONFIG.autoCommit,
-  claudeCommand: DEFAULT_CONFIG.claudeCommand,
 };
 
 export interface PlanCommandOptions {

package/src/utils/config.ts

@@ -8,15 +8,16 @@ import {
   UserConfig,
   VALID_MODEL_ALIASES,
   FULL_MODEL_ID_PATTERN,
-  VALID_EFFORTS,
   ClaudeModelName,
-  EffortLevel,
+  TaskEffortLevel,
   ModelScenario,
-  EffortScenario,
   CommitFormatType,
   PricingCategory,
   ModelPricing,
   PricingConfig,
+  DisplayConfig,
+  RateLimitWindowConfig,
+  EffortMappingConfig,
 } from '../types/config.js';
 
 const CONFIG_DIR = path.join(os.homedir(), '.raf');
@@ -36,8 +37,8 @@ export function getClaudeSettingsPath(): string {
 // ---- Validation ----
 
 const VALID_TOP_LEVEL_KEYS = new Set<string>([
-  'models', 'effort', 'timeout', 'maxRetries', 'autoCommit',
-  'worktree', 'commitFormat', 'claudeCommand', 'pricing',
+  'models', 'effortMapping', 'timeout', 'maxRetries', 'autoCommit',
+  'worktree', 'syncMainBranch', 'commitFormat', 'pricing', 'display', 'rateLimitWindow',
 ]);
 
 const VALID_PRICING_CATEGORIES = new Set<string>(['opus', 'sonnet', 'haiku']);
@@ -47,12 +48,14 @@ const VALID_MODEL_KEYS = new Set<string>([
   'plan', 'execute', 'nameGeneration', 'failureAnalysis', 'prGeneration', 'config',
 ]);
 
-const VALID_EFFORT_KEYS = new Set<string>([
-  'plan', 'execute', 'nameGeneration', 'failureAnalysis', 'prGeneration', 'config',
-]);
+const VALID_EFFORT_MAPPING_KEYS = new Set<string>(['low', 'medium', 'high']);
 
 const VALID_COMMIT_FORMAT_KEYS = new Set<string>(['task', 'plan', 'amend', 'prefix']);
 
+const VALID_DISPLAY_KEYS = new Set<string>(['showRateLimitEstimate', 'showCacheTokens']);
+
+const VALID_RATE_LIMIT_WINDOW_KEYS = new Set<string>(['sonnetTokenCap']);
+
 export class ConfigValidationError extends Error {
   constructor(message: string) {
     super(message);
@@ -99,16 +102,18 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
-  // effort
-  if (obj.effort !== undefined) {
-    if (typeof obj.effort !== 'object' || obj.effort === null || Array.isArray(obj.effort)) {
-      throw new ConfigValidationError('effort must be an object');
+  // effortMapping
+  if (obj.effortMapping !== undefined) {
+    if (typeof obj.effortMapping !== 'object' || obj.effortMapping === null || Array.isArray(obj.effortMapping)) {
+      throw new ConfigValidationError('effortMapping must be an object');
     }
-    const effort = obj.effort as Record<string, unknown>;
-    checkUnknownKeys(effort, VALID_EFFORT_KEYS, 'effort');
-    for (const [key, val] of Object.entries(effort)) {
-      if (typeof val !== 'string' || !(VALID_EFFORTS as readonly string[]).includes(val)) {
-        throw new ConfigValidationError(`effort.${key} must be one of: ${VALID_EFFORTS.join(', ')}`);
+    const effortMapping = obj.effortMapping as Record<string, unknown>;
+    checkUnknownKeys(effortMapping, VALID_EFFORT_MAPPING_KEYS, 'effortMapping');
+    for (const [key, val] of Object.entries(effortMapping)) {
+      if (typeof val !== 'string' || !isValidModelName(val)) {
+        throw new ConfigValidationError(
+          `effortMapping.${key} must be a short alias (${VALID_MODEL_ALIASES.join(', ')}) or a full model ID (e.g., claude-sonnet-4-5-20250929)`
+        );
       }
     }
   }
@@ -141,6 +146,13 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
+  // syncMainBranch
+  if (obj.syncMainBranch !== undefined) {
+    if (typeof obj.syncMainBranch !== 'boolean') {
+      throw new ConfigValidationError('syncMainBranch must be a boolean');
+    }
+  }
+
   // commitFormat
   if (obj.commitFormat !== undefined) {
     if (typeof obj.commitFormat !== 'object' || obj.commitFormat === null || Array.isArray(obj.commitFormat)) {
@@ -155,13 +167,6 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
-  // claudeCommand
-  if (obj.claudeCommand !== undefined) {
-    if (typeof obj.claudeCommand !== 'string' || obj.claudeCommand.trim() === '') {
-      throw new ConfigValidationError('claudeCommand must be a non-empty string');
-    }
-  }
-
   // pricing
   if (obj.pricing !== undefined) {
     if (typeof obj.pricing !== 'object' || obj.pricing === null || Array.isArray(obj.pricing)) {
@@ -183,6 +188,34 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
+  // display
+  if (obj.display !== undefined) {
+    if (typeof obj.display !== 'object' || obj.display === null || Array.isArray(obj.display)) {
+      throw new ConfigValidationError('display must be an object');
+    }
+    const display = obj.display as Record<string, unknown>;
+    checkUnknownKeys(display, VALID_DISPLAY_KEYS, 'display');
+    for (const [key, val] of Object.entries(display)) {
+      if (typeof val !== 'boolean') {
+        throw new ConfigValidationError(`display.${key} must be a boolean`);
+      }
+    }
+  }
+
+  // rateLimitWindow
+  if (obj.rateLimitWindow !== undefined) {
+    if (typeof obj.rateLimitWindow !== 'object' || obj.rateLimitWindow === null || Array.isArray(obj.rateLimitWindow)) {
+      throw new ConfigValidationError('rateLimitWindow must be an object');
+    }
+    const rlw = obj.rateLimitWindow as Record<string, unknown>;
+    checkUnknownKeys(rlw, VALID_RATE_LIMIT_WINDOW_KEYS, 'rateLimitWindow');
+    if (rlw.sonnetTokenCap !== undefined) {
+      if (typeof rlw.sonnetTokenCap !== 'number' || rlw.sonnetTokenCap <= 0 || !Number.isFinite(rlw.sonnetTokenCap)) {
+        throw new ConfigValidationError('rateLimitWindow.sonnetTokenCap must be a positive number');
+      }
+    }
+  }
+
   return config as UserConfig;
 }
 
@@ -194,8 +227,8 @@ function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
   if (overrides.models) {
     result.models = { ...defaults.models, ...overrides.models };
   }
-  if (overrides.effort) {
-    result.effort = { ...defaults.effort, ...overrides.effort };
+  if (overrides.effortMapping) {
+    result.effortMapping = { ...defaults.effortMapping, ...overrides.effortMapping };
   }
   if (overrides.commitFormat) {
     result.commitFormat = { ...defaults.commitFormat, ...overrides.commitFormat };
@@ -207,11 +240,17 @@ function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
       haiku: { ...defaults.pricing.haiku, ...overrides.pricing.haiku },
     };
   }
+  if (overrides.display) {
+    result.display = { ...defaults.display, ...overrides.display };
+  }
+  if (overrides.rateLimitWindow) {
+    result.rateLimitWindow = { ...defaults.rateLimitWindow, ...overrides.rateLimitWindow };
+  }
   if (overrides.timeout !== undefined) result.timeout = overrides.timeout;
   if (overrides.maxRetries !== undefined) result.maxRetries = overrides.maxRetries;
   if (overrides.autoCommit !== undefined) result.autoCommit = overrides.autoCommit;
   if (overrides.worktree !== undefined) result.worktree = overrides.worktree;
-  if (overrides.claudeCommand !== undefined) result.claudeCommand = overrides.claudeCommand;
+  if (overrides.syncMainBranch !== undefined) result.syncMainBranch = overrides.syncMainBranch;
 
   return result;
 }
@@ -226,7 +265,14 @@ export function resolveConfig(configPath?: string): RafConfig {
   const filePath = configPath ?? getConfigPath();
 
   if (!fs.existsSync(filePath)) {
-    return { ...DEFAULT_CONFIG, models: { ...DEFAULT_CONFIG.models }, effort: { ...DEFAULT_CONFIG.effort }, commitFormat: { ...DEFAULT_CONFIG.commitFormat } };
+    return {
+      ...DEFAULT_CONFIG,
+      models: { ...DEFAULT_CONFIG.models },
+      effortMapping: { ...DEFAULT_CONFIG.effortMapping },
+      commitFormat: { ...DEFAULT_CONFIG.commitFormat },
+      display: { ...DEFAULT_CONFIG.display },
+      rateLimitWindow: { ...DEFAULT_CONFIG.rateLimitWindow },
+    };
   }
 
   const content = fs.readFileSync(filePath, 'utf-8');
@@ -238,7 +284,7 @@ export function resolveConfig(configPath?: string): RafConfig {
 /**
  * @deprecated Use resolveConfig() instead. Kept for backward compatibility.
  */
-export function loadConfig(_rafDir: string): { defaultTimeout: number; defaultMaxRetries: number; autoCommit: boolean; claudeCommand: string } {
+export function loadConfig(_rafDir: string): { defaultTimeout: number; defaultMaxRetries: number; autoCommit: boolean } {
   return { ...DEFAULT_RAF_CONFIG };
 }
 
@@ -273,8 +319,70 @@ export function getModel(scenario: ModelScenario): ClaudeModelName {
   return getResolvedConfig().models[scenario];
 }
 
-export function getEffort(scenario: EffortScenario): EffortLevel {
-  return getResolvedConfig().effort[scenario];
+/**
+ * Get the full effort mapping config.
+ */
+export function getEffortMapping(): EffortMappingConfig {
+  return getResolvedConfig().effortMapping;
+}
+
+/**
+ * Resolve a task effort level to a model name using the effort mapping config.
+ */
+export function resolveEffortToModel(effort: TaskEffortLevel): ClaudeModelName {
+  return getResolvedConfig().effortMapping[effort];
+}
+
+/**
+ * Model tier ordering for ceiling comparison.
+ * Higher tier = more capable/expensive model.
+ * haiku (1) < sonnet (2) < opus (3)
+ */
+const MODEL_TIER_ORDER: Record<string, number> = {
+  haiku: 1,
+  sonnet: 2,
+  opus: 3,
+};
+
+/**
+ * Get the numeric tier of a model for comparison.
+ * Extracts family from full model IDs (e.g., 'claude-opus-4-6' -> 3).
+ * Unknown models default to highest tier (3) so they're never accidentally capped.
+ */
+export function getModelTier(modelName: string): number {
+  // Check short aliases first
+  const tier = MODEL_TIER_ORDER[modelName];
+  if (tier !== undefined) {
+    return tier;
+  }
+
+  // Extract family from full model ID
+  const match = modelName.match(/^claude-([a-z]+)-/);
+  if (match && match[1]) {
+    const familyTier = MODEL_TIER_ORDER[match[1]];
+    if (familyTier !== undefined) {
+      return familyTier;
+    }
+  }
+
+  // Unknown model - default to highest tier (no cap)
+  return 3;
+}
+
+/**
+ * Apply ceiling to a model based on the configured models.execute ceiling.
+ * Returns the lower-tier model between the input and the ceiling.
+ */
+export function applyModelCeiling(resolvedModel: string, ceiling?: string): string {
+  const ceilingModel = ceiling ?? getModel('execute');
+  const resolvedTier = getModelTier(resolvedModel);
+  const ceilingTier = getModelTier(ceilingModel);
+
+  // If resolved model is above ceiling, use ceiling instead
+  if (resolvedTier > ceilingTier) {
+    return ceilingModel;
+  }
+  return resolvedModel;
 }
 
 export function getCommitFormat(type: CommitFormatType): string {
@@ -301,8 +409,8 @@ export function getWorktreeDefault(): boolean {
   return getResolvedConfig().worktree;
 }
 
-export function getClaudeCommand(): string {
-  return getResolvedConfig().claudeCommand;
+export function getSyncMainBranch(): boolean {
+  return getResolvedConfig().syncMainBranch;
 }
 
 /**
@@ -327,6 +435,30 @@ export function getModelShortName(modelId: string): string {
   return modelId;
 }
 
+/**
+ * Mapping of short model aliases to their current full model IDs.
+ * These should match the latest Claude model versions.
+ */
+const MODEL_ALIAS_TO_FULL_ID: Record<string, string> = {
+  opus: 'claude-opus-4-6',
+  sonnet: 'claude-sonnet-4-5-20250929',
+  haiku: 'claude-haiku-4-5-20251001',
+};
+
+/**
+ * Resolve a model name to its full model ID.
+ * If already a full model ID, returns as-is.
+ * If a short alias (opus, sonnet, haiku), returns the corresponding full ID.
+ */
+export function resolveFullModelId(modelName: string): string {
+  const fullId = MODEL_ALIAS_TO_FULL_ID[modelName];
+  if (fullId) {
+    return fullId;
+  }
+  // Already a full ID or unknown, return as-is
+  return modelName;
+}
+
 /**
  * Map a full model ID (e.g., `claude-opus-4-6`) or short alias to a pricing category.
  * Returns null if the model cannot be mapped.
@@ -361,6 +493,41 @@ export function getPricingConfig(): PricingConfig {
   return getResolvedConfig().pricing;
 }
 
+/**
+ * Get the full display config.
+ */
+export function getDisplayConfig(): DisplayConfig {
+  return getResolvedConfig().display;
+}
+
+/**
+ * Get the full rate limit window config.
+ */
+export function getRateLimitWindowConfig(): RateLimitWindowConfig {
+  return getResolvedConfig().rateLimitWindow;
+}
+
+/**
+ * Get whether to show rate limit estimate in token summaries.
+ */
+export function getShowRateLimitEstimate(): boolean {
+  return getResolvedConfig().display.showRateLimitEstimate;
+}
+
+/**
+ * Get whether to show cache tokens in summaries.
+ */
+export function getShowCacheTokens(): boolean {
+  return getResolvedConfig().display.showCacheTokens;
+}
+
+/**
+ * Get the Sonnet-equivalent token cap for the 5h rate limit window.
+ */
+export function getSonnetTokenCap(): number {
+  return getResolvedConfig().rateLimitWindow.sonnetTokenCap;
+}
+
 /**
  * Render a commit message template by replacing {placeholder} tokens with values.
  * Unknown placeholders are left as-is.

package/src/utils/frontmatter.ts

@@ -0,0 +1,140 @@
+import { VALID_TASK_EFFORTS, TaskEffortLevel } from '../types/config.js';
+import { isValidModelName } from './config.js';
+
+/**
+ * Parsed frontmatter metadata from a plan file.
+ */
+export interface PlanFrontmatter {
+  /** Task complexity label (low/medium/high). Used to resolve model via effortMapping. */
+  effort?: TaskEffortLevel;
+  /** Explicit model override (bypasses effort mapping but still subject to ceiling). */
+  model?: string;
+}
+
+/**
+ * Result of parsing frontmatter from a plan file.
+ */
+export interface FrontmatterParseResult {
+  /** Parsed frontmatter metadata, if any valid keys were found. */
+  frontmatter: PlanFrontmatter;
+  /** Whether valid frontmatter was found (has at least effort or model). */
+  hasFrontmatter: boolean;
+  /** Warnings about invalid/unknown frontmatter values. */
+  warnings: string[];
+}
+
+/**
+ * Parse Obsidian-style frontmatter from plan file content.
+ *
+ * Supports two formats:
+ * 1. Standard format (preferred): `---` delimiter at the top and bottom
+ * 2. Legacy format (backward compatibility): properties followed by closing `---` only
+ *
+ * Standard format example:
+ * ```
+ * ---
+ * effort: medium
+ * model: sonnet
+ * ---
+ * # Task: ...
+ * ```
+ *
+ * Legacy format example:
+ * ```
+ * effort: medium
+ * model: sonnet
+ * ---
+ * # Task: ...
+ * ```
+ *
+ * The parser is lenient:
+ * - Ignores unknown keys (with a warning)
+ * - Handles missing `---` delimiter gracefully (returns empty frontmatter)
+ * - Invalid values produce warnings but don't throw
+ * - Case-insensitive value parsing for effort levels
+ */
+export function parsePlanFrontmatter(content: string): FrontmatterParseResult {
+  const result: FrontmatterParseResult = {
+    frontmatter: {},
+    hasFrontmatter: false,
+    warnings: [],
+  };
+
+  const trimmedContent = content.trimStart();
+
+  let frontmatterSection: string;
+
+  if (trimmedContent.startsWith('---')) {
+    // Standard format: ---\nkey: value\n---
+    const afterOpener = trimmedContent.substring(3);
+    // Skip the rest of the opener line (handles "---\n" or "--- \n")
+    const openerEnd = afterOpener.indexOf('\n');
+    if (openerEnd === -1) {
+      // No newline after opening delimiter - no valid frontmatter
+      return result;
+    }
+    const rest = afterOpener.substring(openerEnd + 1);
+    const closerIndex = rest.indexOf('---');
+    if (closerIndex === -1) {
+      // No closing delimiter - no valid frontmatter
+      return result;
+    }
+    frontmatterSection = rest.substring(0, closerIndex);
+  } else {
+    // Legacy format: key: value\n---
+    const delimiterIndex = content.indexOf('---');
+    if (delimiterIndex === -1) {
+      // No delimiter found - no frontmatter
+      return result;
+    }
+    frontmatterSection = content.substring(0, delimiterIndex);
+  }
+
+  // Parse key: value lines
+  const lines = frontmatterSection.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue; // Skip empty lines
+
+    // Check if it looks like a markdown heading (starts with #) - even if it has a colon
+    if (trimmed.startsWith('#')) {
+      // Markdown content started before `---` - no valid frontmatter
+      return {
+        frontmatter: {},
+        hasFrontmatter: false,
+        warnings: ['Frontmatter section contains markdown content before closing delimiter'],
+      };
+    }
+
+    // Parse key: value format
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex === -1) {
+      continue; // Skip non-property lines
+    }
+
+    const key = trimmed.substring(0, colonIndex).trim().toLowerCase();
+    const value = trimmed.substring(colonIndex + 1).trim();
+
+    if (key === 'effort') {
+      const lowerValue = value.toLowerCase();
+      if ((VALID_TASK_EFFORTS as readonly string[]).includes(lowerValue)) {
+        result.frontmatter.effort = lowerValue as TaskEffortLevel;
+        result.hasFrontmatter = true;
+      } else {
+        result.warnings.push(`Invalid effort value: "${value}". Must be one of: ${VALID_TASK_EFFORTS.join(', ')}`);
+      }
+    } else if (key === 'model') {
+      if (isValidModelName(value)) {
+        result.frontmatter.model = value;
+        result.hasFrontmatter = true;
+      } else {
+        result.warnings.push(`Invalid model value: "${value}". Must be a short alias (sonnet, haiku, opus) or a full model ID.`);
+      }
+    } else {
+      // Unknown key - ignore with warning
+      result.warnings.push(`Unknown frontmatter key: "${key}"`);
+    }
+  }
+
+  return result;
+}

package/src/utils/name-generator.ts

@@ -1,9 +1,11 @@
 import { spawn } from 'node:child_process';
 import { logger } from './logger.js';
 import { sanitizeProjectName } from './validation.js';
-import { getModel, getClaudeCommand } from './config.js';
+import { getModel } from './config.js';
 
-const NAME_GENERATION_PROMPT = `Generate a short, punchy, creative project name (1-3 words, kebab-case).
+const NAME_GENERATION_PROMPT = `Output ONLY the kebab-case name. No introduction, no explanation, no quotes.
+
+Generate a short, punchy, creative project name (1-3 words, kebab-case).
 
 Be creative! Use metaphors, analogies, or evocative words that capture the SPIRIT of the project.
 Don't literally describe what it does - make it memorable and fun.
@@ -15,26 +17,15 @@ Good examples:
 - Refactoring → 'spring-cleaning', 'phoenix', 'makeover'
 - New feature → 'moonshot', 'secret-sauce', 'magic-wand'
 
-Output ONLY the kebab-case name. No quotes, no explanation.
-
 Project description:`;
 
-const MULTI_NAME_GENERATION_PROMPT = `Generate 5 creative project names for the description below.
-
-IMPORTANT: Each name should use a DIFFERENT naming style:
-1. **Metaphorical** - Use a metaphor or analogy (e.g., 'phoenix', 'lighthouse', 'compass')
-2. **Fun/Playful** - Make it fun or quirky (e.g., 'turbo-boost', 'magic-beans', 'ninja-move')
-3. **Action-oriented** - Focus on what it does with flair (e.g., 'bug-squasher', 'speed-demon', 'data-whisperer')
-4. **Abstract** - Use abstract/poetic concepts (e.g., 'horizon', 'cascade', 'catalyst')
-5. **Cultural reference** - Reference pop culture, mythology, or literature (e.g., 'atlas', 'merlin', 'gandalf')
+const MULTI_NAME_GENERATION_PROMPT = `Output EXACTLY 5 project names, one per line. Do NOT include any introduction, explanation, preamble, numbering, or quotes.
 
 Rules:
-- Each name should be 1-3 words in kebab-case
-- Names must be lowercase with hyphens only
+- Each name: 1-3 words, kebab-case, lowercase with hyphens only
+- Use varied styles: metaphorical, playful, action-oriented, abstract, cultural reference
 - Make them memorable and evocative
-- If the project has many unrelated tasks, prefer abstract/metaphorical/fun names over descriptive ones
-
-Output format: ONLY output 5 names, one per line, no numbers, no explanations, no quotes.
+- For projects with many unrelated tasks, prefer abstract/metaphorical names
 
 Project description:`;
 
@@ -45,9 +36,8 @@ Project description:`;
 function runClaudePrint(prompt: string): Promise<string | null> {
   return new Promise((resolve) => {
     const model = getModel('nameGeneration');
-    const cmd = getClaudeCommand();
 
-    const proc = spawn(cmd, [
+    const proc = spawn('claude', [
       '--model', model,
       '--no-session-persistence',
       '-p',