rafcode 2.5.1 → 3.2.1

package/src/prompts/config-docs.md

@@ -22,9 +22,9 @@ The above only changes `models.plan` — all other model settings keep their def
 
 ## Config Reference
 
-### `models` — Claude Model Selection
+### `models` — Model Selection
 
-Controls which Claude model is used for each scenario. Values can be a short alias (`"sonnet"`, `"haiku"`, `"opus"`) or a full model ID.
+Controls which model is used for each scenario. Values can be a short alias (`"sonnet"`, `"haiku"`, `"opus"`) or a full model ID.
 
 **Model ID format**: Full model IDs follow the pattern `claude-{family}-{version}`, for example:
 - `"claude-opus-4-5-20251101"` — Opus 4.5 from November 2025
@@ -45,7 +45,7 @@ Controls which Claude model is used for each scenario. Values can be a short ali
 
 ### `effortMapping` — Task Effort to Model Mapping
 
-Maps task complexity labels (in plan frontmatter) to Claude models. When a plan file has `effort: medium`, RAF resolves the execution model using this mapping.
+Maps task complexity labels (in plan frontmatter) to models. When a plan file has `effort: medium`, RAF resolves the execution model using this mapping.
 
 | Key | Default | Description |
 |-----|---------|-------------|
@@ -84,13 +84,13 @@ Example:
 
 - **Type**: boolean
 - **Default**: `true`
-- **Description**: When `true`, Claude automatically commits changes after completing each task. When `false`, changes are left uncommitted.
+- **Description**: When `true`, RAF automatically commits changes after completing each task. When `false`, changes are left uncommitted.
 
 ### `worktree` — Default Worktree Mode
 
 - **Type**: boolean
 - **Default**: `false`
-- **Description**: When `true`, `raf plan` and `raf do` default to worktree mode (isolated git worktree). Can be overridden per-command with `--worktree` flag.
+- **Description**: When `true`, `raf plan` defaults to worktree mode (isolated git worktree). Can be overridden with `--worktree` flag. `raf do` auto-detects worktree projects regardless of this setting.
 
 ### `syncMainBranch` — Sync Main Branch with Remote
 
@@ -158,7 +158,7 @@ Example:
 The config is validated when loaded. Invalid configs cause an error with a descriptive message. The following rules are enforced:
 
 - **Unknown keys are rejected** at every nesting level. Typos like `"model"` instead of `"models"` will be caught.
-- **Model values** (`models.*`, `effortMapping.*`) must be a short alias (`"sonnet"`, `"haiku"`, `"opus"`) or a full model ID matching the pattern `claude-{family}-{version}` (e.g., `"claude-sonnet-4-5-20250929"`).
+- **Model values** (`models.*`, `effortMapping.*`) must be a short alias (`"sonnet"`, `"haiku"`, `"opus"`) or a full model ID (e.g., `"claude-sonnet-4-5-20250929"`, `"o3"`).
 - **`effortMapping` keys** must be `"low"`, `"medium"`, or `"high"`.
 - **`timeout`** must be a positive finite number.
 - **`maxRetries`** must be a non-negative integer.
@@ -277,9 +277,9 @@ To reset a single setting, remove its key from the config file. Any key not pres
 
 ---
 
-## For Claude — Config Editing Session Instructions
+## Config Editing Session Instructions
 
-This section contains instructions for Claude when operating as the interactive config editor during `raf config` sessions.
+This section contains instructions for the LLM when operating as the interactive config editor during `raf config` sessions.
 
 ### Your Role
 

package/src/prompts/execution.ts

@@ -85,8 +85,8 @@ ${previousOutcomes.map((o) => `### Task ${o.taskId}\n${o.content}`).join('\n\n')
 `;
   }
 
-  // Encode task number to 2-char base36
-  const paddedTaskNumber = taskNumber.toString(36).padStart(2, '0');
+  // Encode task number to plain numeric string
+  const paddedTaskNumber = taskNumber.toString();
 
   // Build example commit message from config template
   const commitTemplate = getCommitFormat('task');

package/src/prompts/planning.ts

@@ -12,12 +12,10 @@ export interface PlanningPromptResult {
 /**
  * Generate the planning prompt with system instructions and user message separated.
  * - systemPrompt: RAF planning conventions, file structure, interview process (via --append-system-prompt)
- * - userMessage: Reference to input.md file (via positional argument, triggers Claude to start)
+ * - userMessage: Reference to input.md file (via positional argument, triggers the LLM to start)
  */
 export function getPlanningPrompt(params: PlanningPromptParams): PlanningPromptResult {
-  const { projectPath, worktreeMode } = params;
-  const worktreeFlag = worktreeMode ? ' --worktree' : '';
-
+  const { projectPath } = params;
   const systemPrompt = `You are a project planning assistant for RAF (Ralph's Automation Framework). Your task is to analyze the user's project description and create detailed task plans.
 
 ## Your Goals
@@ -37,7 +35,7 @@ Project folder: ${projectPath}
 Based on the project description, identify distinct tasks. Each task should:
 - Be independently completable
 - Have a clear outcome
-- Take roughly 10-30 minutes of work for Claude
+- Take roughly 10-30 minutes of work
 
 **CRITICAL: Order tasks by logical execution order.** Lower-numbered tasks should be completed before higher-numbered ones. Consider:
 - Setup/foundation tasks come first (e.g., defining schemas, creating interfaces)
@@ -76,8 +74,8 @@ This file serves as documentation of design choices made during planning. Append
 ### Step 3: Create Plan Files
 
 After interviewing the user about all tasks, create plan files in the plans folder:
-- ${projectPath}/plans/01-task-name.md
-- ${projectPath}/plans/02-task-name.md
+- ${projectPath}/plans/1-task-name.md
+- ${projectPath}/plans/2-task-name.md
 - etc.
 
 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:
@@ -96,7 +94,7 @@ effort: medium
 
 ## Dependencies
 [Optional section - omit if task has no dependencies]
-[Comma-separated list of task IDs this task depends on, e.g., "01, 02"]
+[Comma-separated list of task IDs this task depends on, e.g., "1, 2"]
 [If a dependency fails, this task will be automatically blocked]
 
 ## Requirements
@@ -122,7 +120,7 @@ effort: medium
 
 ### Frontmatter Requirements
 
-The \`effort\` field is REQUIRED in every plan file. It indicates task complexity and determines which Claude model will execute the task:
+The \`effort\` field is REQUIRED in every plan file. It indicates task complexity and determines which model will execute the task:
 - \`effort: low\` — Trivial/mechanical changes, simple one-file edits, config changes
 - \`effort: medium\` — Well-scoped feature work, bug fixes with clear plans, multi-file changes following existing patterns
 - \`effort: high\` — Architectural changes, complex logic, tasks requiring deep codebase understanding
@@ -151,12 +149,12 @@ For each task, analyze which other tasks must complete successfully before it ca
 **Dependency format examples:**
 \`\`\`markdown
 ## Dependencies
-01
+1
 \`\`\`
 or for multiple dependencies:
 \`\`\`markdown
 ## Dependencies
-01, 02
+1, 2
 \`\`\`
 
 **Rules for dependencies:**
@@ -169,21 +167,21 @@ or for multiple dependencies:
 
 After creating all plan files:
 1. Provide a summary of the tasks you've created, including the effort level for each task. Example:
-   - Task 01: setup-database (effort: low)
-   - Task 02: implement-auth (effort: medium)
-   - Task 03: refactor-api (effort: high)
+   - Task 1: setup-database (effort: low)
+   - Task 2: implement-auth (effort: medium)
+   - Task 3: refactor-api (effort: high)
 2. Display this exit message to the user:
 
 \`\`\`
 Planning complete! To exit this session and run your tasks:
   1. Press Ctrl-C twice to exit
-  2. Then run: raf do <project>${worktreeFlag}
+  2. Then run: raf do <project>
 \`\`\`
 
 ## Important Rules
 
 1. ALWAYS interview the user before creating plans
-2. Create plans in numbered order (01, 02, 03, etc.) reflecting logical execution order
+2. Create plans in numbered order (1, 2, 3, etc.) reflecting logical execution order
 3. Use descriptive, kebab-case names for plan files
 4. Each plan should be self-contained with all context needed
 5. Infer dependencies automatically - analyze task relationships, don't ask the user about dependencies

package/src/types/config.ts

@@ -1,12 +1,25 @@
+/** CLI harness provider */
+export type HarnessProvider = 'claude' | 'codex';
+
 /** Short alias for a Claude model family */
 export type ClaudeModelAlias = 'sonnet' | 'haiku' | 'opus';
 
+/** Short alias for a Codex model family */
+export type CodexModelAlias = 'spark' | 'codex' | 'gpt54';
+
+/** Provider-agnostic model alias (union of all provider aliases) */
+export type ModelAlias = ClaudeModelAlias | CodexModelAlias;
+
 /**
  * Accepts short aliases (`sonnet`, `haiku`, `opus`) or full model IDs
  * matching the pattern `claude-{family}-{version}` (e.g., `claude-opus-4-5-20251101`).
+ * Also accepts harness-prefixed format: `claude/opus`, `codex/gpt-5.4`.
  */
 export type ClaudeModelName = ClaudeModelAlias | (string & { __brand?: 'FullModelId' });
 
+/** Provider-agnostic model name — accepts any alias, full ID, or harness-prefixed format */
+export type ModelName = string & { __brand?: 'ModelName' };
+
 /** Task complexity label for per-task effort frontmatter. Maps to models via effortMapping. */
 export type TaskEffortLevel = 'low' | 'medium' | 'high';
 
@@ -46,9 +59,15 @@ export interface DisplayConfig {
 }
 
 export interface RafConfig {
+  /** CLI harness provider. Default: 'claude' */
+  provider: HarnessProvider;
   models: ModelsConfig;
   /** Maps task complexity labels (low/medium/high) to models. Used for per-task effort frontmatter. */
   effortMapping: EffortMappingConfig;
+  /** Codex model assignments per scenario */
+  codexModels: ModelsConfig;
+  /** Maps task complexity labels to Codex models */
+  codexEffortMapping: EffortMappingConfig;
   timeout: number;
   maxRetries: number;
   autoCommit: boolean;
@@ -60,6 +79,7 @@ export interface RafConfig {
 }
 
 export const DEFAULT_CONFIG: RafConfig = {
+  provider: 'claude',
   models: {
     plan: 'opus',
     execute: 'opus',
@@ -73,6 +93,19 @@ export const DEFAULT_CONFIG: RafConfig = {
     medium: 'opus',
     high: 'opus',
   },
+  codexModels: {
+    plan: 'gpt-5.3-codex',
+    execute: 'gpt-5.4',
+    nameGeneration: 'gpt-5.3-codex-spark',
+    failureAnalysis: 'gpt-5.3-codex-spark',
+    prGeneration: 'gpt-5.3-codex',
+    config: 'gpt-5.3-codex',
+  },
+  codexEffortMapping: {
+    low: 'gpt-5.3-codex-spark',
+    medium: 'gpt-5.3-codex',
+    high: 'gpt-5.4',
+  },
   timeout: 60,
   maxRetries: 3,
   autoCommit: true,
@@ -98,6 +131,10 @@ export type UserConfig = DeepPartial<RafConfig>;
 
 export const VALID_MODEL_ALIASES: readonly ClaudeModelAlias[] = ['sonnet', 'haiku', 'opus'];
 
+export const VALID_CODEX_MODEL_ALIASES: readonly CodexModelAlias[] = ['spark', 'codex', 'gpt54'];
+
+export const VALID_HARNESS_PROVIDERS: readonly HarnessProvider[] = ['claude', 'codex'];
+
 /**
  * Regex for full Claude model IDs (e.g., `claude-sonnet-4-5-20250929`, `claude-opus-4-5-20251101`).
  * Pattern: claude-{family}-{major}(-{minor})?(-{date})?
@@ -122,6 +159,7 @@ export interface PlanCommandOptions {
   projectName?: string;
   model?: ClaudeModelName;
   sonnet?: boolean;
+  provider?: HarnessProvider;
 }
 
 export interface DoCommandOptions {
@@ -131,7 +169,7 @@ export interface DoCommandOptions {
   force?: boolean;
   model?: ClaudeModelName;
   sonnet?: boolean;
-  worktree?: boolean;
+  provider?: HarnessProvider;
 }
 
 export interface StatusCommandOptions {

package/src/ui/project-picker.ts

@@ -1,6 +1,7 @@
 import { select } from '@inquirer/prompts';
 import { discoverProjects, deriveProjectState, getDerivedStats } from '../core/state-derivation.js';
 import { extractProjectNumber, extractProjectName, parseProjectPrefix, formatProjectNumber } from '../utils/paths.js';
+
 import { listWorktreeProjects, computeWorktreePath } from '../core/worktree.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';

package/src/utils/config.ts

@@ -7,6 +7,8 @@ import {
   DEFAULT_RAF_CONFIG,
   UserConfig,
   VALID_MODEL_ALIASES,
+  VALID_CODEX_MODEL_ALIASES,
+  VALID_HARNESS_PROVIDERS,
   FULL_MODEL_ID_PATTERN,
   ClaudeModelName,
   TaskEffortLevel,
@@ -14,6 +16,7 @@ import {
   CommitFormatType,
   DisplayConfig,
   EffortMappingConfig,
+  HarnessProvider,
 } from '../types/config.js';
 
 const CONFIG_DIR = path.join(os.homedir(), '.raf');
@@ -33,7 +36,8 @@ export function getClaudeSettingsPath(): string {
 // ---- Validation ----
 
 const VALID_TOP_LEVEL_KEYS = new Set<string>([
-  'models', 'effortMapping', 'timeout', 'maxRetries', 'autoCommit',
+  'provider', 'models', 'effortMapping', 'codexModels', 'codexEffortMapping',
+  'timeout', 'maxRetries', 'autoCommit',
   'worktree', 'syncMainBranch', 'commitFormat', 'display',
 ]);
 
@@ -62,11 +66,64 @@ function checkUnknownKeys(obj: Record<string, unknown>, validKeys: Set<string>,
   }
 }
 
+/** Regex for raw Codex model IDs (e.g., `gpt-5.4`, `gpt-5.3-codex-spark`). Requires dot-separated version. */
+const CODEX_MODEL_ID_PATTERN = /^gpt-\d+\.\d+(-.+)*$/;
+
 /**
- * Check whether a string is a valid model name — either a short alias or a full model ID.
+ * Check whether a string is a valid model name.
+ * Accepts:
+ * - Claude short aliases: sonnet, haiku, opus
+ * - Claude full IDs: claude-opus-4-6
+ * - Codex short aliases: spark, codex, gpt54
+ * - Raw Codex model IDs: gpt-5.4, gpt-5.3-codex-spark
+ * - Harness-prefixed format: claude/opus, codex/gpt-5.4
  */
 export function isValidModelName(value: string): boolean {
-  return (VALID_MODEL_ALIASES as readonly string[]).includes(value) || FULL_MODEL_ID_PATTERN.test(value);
+  // Harness-prefixed format: provider/model
+  const prefixMatch = value.match(/^(claude|codex)\/(.+)$/);
+  if (prefixMatch) {
+    const [, provider, model] = prefixMatch;
+    if (provider === 'claude') {
+      return (VALID_MODEL_ALIASES as readonly string[]).includes(model!) || FULL_MODEL_ID_PATTERN.test(model!);
+    }
+    if (provider === 'codex') {
+      return (VALID_CODEX_MODEL_ALIASES as readonly string[]).includes(model!) || CODEX_MODEL_ID_PATTERN.test(model!);
+    }
+  }
+
+  // Unprefixed: Claude aliases and full IDs
+  if ((VALID_MODEL_ALIASES as readonly string[]).includes(value) || FULL_MODEL_ID_PATTERN.test(value)) {
+    return true;
+  }
+
+  // Unprefixed: Codex aliases and raw IDs
+  if ((VALID_CODEX_MODEL_ALIASES as readonly string[]).includes(value) || CODEX_MODEL_ID_PATTERN.test(value)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Parse a model spec string into its provider and model components.
+ * - `codex/gpt-5.4` -> { provider: 'codex', model: 'gpt-5.4' }
+ * - `claude/opus` -> { provider: 'claude', model: 'opus' }
+ * - `opus` -> { provider: 'claude', model: 'opus' } (defaults to claude)
+ * - `gpt-5.4` -> { provider: 'codex', model: 'gpt-5.4' } (inferred from model format)
+ */
+export function parseModelSpec(modelSpec: string): { provider: HarnessProvider; model: string } {
+  const prefixMatch = modelSpec.match(/^(claude|codex)\/(.+)$/);
+  if (prefixMatch) {
+    return { provider: prefixMatch[1] as HarnessProvider, model: prefixMatch[2]! };
+  }
+
+  // Infer provider from model format
+  if ((VALID_CODEX_MODEL_ALIASES as readonly string[]).includes(modelSpec) || CODEX_MODEL_ID_PATTERN.test(modelSpec)) {
+    return { provider: 'codex', model: modelSpec };
+  }
+
+  // Default to claude
+  return { provider: 'claude', model: modelSpec };
 }
 
 export function validateConfig(config: unknown): UserConfig {
@@ -77,6 +134,13 @@ export function validateConfig(config: unknown): UserConfig {
   const obj = config as Record<string, unknown>;
   checkUnknownKeys(obj, VALID_TOP_LEVEL_KEYS, '');
 
+  // provider
+  if (obj.provider !== undefined) {
+    if (typeof obj.provider !== 'string' || !(VALID_HARNESS_PROVIDERS as readonly string[]).includes(obj.provider)) {
+      throw new ConfigValidationError(`provider must be one of: ${VALID_HARNESS_PROVIDERS.join(', ')}`);
+    }
+  }
+
   // models
   if (obj.models !== undefined) {
     if (typeof obj.models !== 'object' || obj.models === null || Array.isArray(obj.models)) {
@@ -109,6 +173,38 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
+  // codexModels
+  if (obj.codexModels !== undefined) {
+    if (typeof obj.codexModels !== 'object' || obj.codexModels === null || Array.isArray(obj.codexModels)) {
+      throw new ConfigValidationError('codexModels must be an object');
+    }
+    const codexModels = obj.codexModels as Record<string, unknown>;
+    checkUnknownKeys(codexModels, VALID_MODEL_KEYS, 'codexModels');
+    for (const [key, val] of Object.entries(codexModels)) {
+      if (typeof val !== 'string' || !isValidModelName(val)) {
+        throw new ConfigValidationError(
+          `codexModels.${key} must be a valid model name (e.g., gpt-5.4, gpt-5.3-codex-spark)`
+        );
+      }
+    }
+  }
+
+  // codexEffortMapping
+  if (obj.codexEffortMapping !== undefined) {
+    if (typeof obj.codexEffortMapping !== 'object' || obj.codexEffortMapping === null || Array.isArray(obj.codexEffortMapping)) {
+      throw new ConfigValidationError('codexEffortMapping must be an object');
+    }
+    const codexEffortMapping = obj.codexEffortMapping as Record<string, unknown>;
+    checkUnknownKeys(codexEffortMapping, VALID_EFFORT_MAPPING_KEYS, 'codexEffortMapping');
+    for (const [key, val] of Object.entries(codexEffortMapping)) {
+      if (typeof val !== 'string' || !isValidModelName(val)) {
+        throw new ConfigValidationError(
+          `codexEffortMapping.${key} must be a valid model name (e.g., gpt-5.4, gpt-5.3-codex-spark)`
+        );
+      }
+    }
+  }
+
   // timeout
   if (obj.timeout !== undefined) {
     if (typeof obj.timeout !== 'number' || obj.timeout <= 0 || !Number.isFinite(obj.timeout)) {
@@ -180,12 +276,19 @@ export function validateConfig(config: unknown): UserConfig {
 function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
   const result = { ...defaults };
 
+  if (overrides.provider !== undefined) result.provider = overrides.provider;
   if (overrides.models) {
     result.models = { ...defaults.models, ...overrides.models };
   }
   if (overrides.effortMapping) {
     result.effortMapping = { ...defaults.effortMapping, ...overrides.effortMapping };
   }
+  if (overrides.codexModels) {
+    result.codexModels = { ...defaults.codexModels, ...overrides.codexModels };
+  }
+  if (overrides.codexEffortMapping) {
+    result.codexEffortMapping = { ...defaults.codexEffortMapping, ...overrides.codexEffortMapping };
+  }
   if (overrides.commitFormat) {
     result.commitFormat = { ...defaults.commitFormat, ...overrides.commitFormat };
   }
@@ -215,6 +318,8 @@ export function resolveConfig(configPath?: string): RafConfig {
       ...DEFAULT_CONFIG,
       models: { ...DEFAULT_CONFIG.models },
       effortMapping: { ...DEFAULT_CONFIG.effortMapping },
+      codexModels: { ...DEFAULT_CONFIG.codexModels },
+      codexEffortMapping: { ...DEFAULT_CONFIG.codexEffortMapping },
       commitFormat: { ...DEFAULT_CONFIG.commitFormat },
       display: { ...DEFAULT_CONFIG.display },
     };
@@ -260,22 +365,37 @@ export function resetConfigCache(): void {
   _cachedConfig = null;
 }
 
-export function getModel(scenario: ModelScenario): ClaudeModelName {
-  return getResolvedConfig().models[scenario];
+export function getModel(scenario: ModelScenario, provider?: HarnessProvider): ClaudeModelName {
+  const config = getResolvedConfig();
+  const effectiveProvider = provider ?? config.provider;
+  if (effectiveProvider === 'codex') {
+    return config.codexModels[scenario];
+  }
+  return config.models[scenario];
 }
 
 /**
  * Get the full effort mapping config.
  */
-export function getEffortMapping(): EffortMappingConfig {
-  return getResolvedConfig().effortMapping;
+export function getEffortMapping(provider?: HarnessProvider): EffortMappingConfig {
+  const config = getResolvedConfig();
+  const effectiveProvider = provider ?? config.provider;
+  if (effectiveProvider === 'codex') {
+    return config.codexEffortMapping;
+  }
+  return config.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];
+export function resolveEffortToModel(effort: TaskEffortLevel, provider?: HarnessProvider): ClaudeModelName {
+  const config = getResolvedConfig();
+  const effectiveProvider = provider ?? config.provider;
+  if (effectiveProvider === 'codex') {
+    return config.codexEffortMapping[effort];
+  }
+  return config.effortMapping[effort];
 }
 
 /**
@@ -289,19 +409,35 @@ const MODEL_TIER_ORDER: Record<string, number> = {
   opus: 3,
 };
 
+/** Codex model tier ordering: spark (1) < codex (2) < gpt-5.4 (3) */
+const CODEX_MODEL_TIER_ORDER: Record<string, number> = {
+  spark: 1,
+  'gpt-5.3-codex-spark': 1,
+  codex: 2,
+  'gpt-5.3-codex': 2,
+  gpt54: 3,
+  'gpt-5.4': 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
+  // Check Claude short aliases first
   const tier = MODEL_TIER_ORDER[modelName];
   if (tier !== undefined) {
     return tier;
   }
 
-  // Extract family from full model ID
+  // Check Codex model tiers
+  const codexTier = CODEX_MODEL_TIER_ORDER[modelName];
+  if (codexTier !== undefined) {
+    return codexTier;
+  }
+
+  // Extract family from full Claude model ID
   const match = modelName.match(/^claude-([a-z]+)-/);
   if (match && match[1]) {
     const familyTier = MODEL_TIER_ORDER[match[1]];
@@ -364,11 +500,19 @@ export function getSyncMainBranch(): boolean {
  * Returns the original string if no known alias can be extracted.
  */
 export function getModelShortName(modelId: string): string {
-  // Already a short alias
+  // Already a short Claude alias
   if (modelId === 'opus' || modelId === 'sonnet' || modelId === 'haiku') {
     return modelId;
   }
-  // Extract family from full model ID: claude-{family}-{version}
+  // Codex short aliases
+  if (modelId === 'spark' || modelId === 'codex' || modelId === 'gpt54') {
+    return modelId;
+  }
+  // Codex model IDs -> short names
+  if (modelId === 'gpt-5.3-codex-spark') return 'spark';
+  if (modelId === 'gpt-5.3-codex') return 'codex';
+  if (modelId === 'gpt-5.4') return 'gpt54';
+  // Extract family from full Claude model ID: claude-{family}-{version}
   const match = modelId.match(/^claude-([a-z]+)-/);
   if (match) {
     const family = match[1];
@@ -388,14 +532,26 @@ 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',
+  spark: 'gpt-5.3-codex-spark',
+  codex: 'gpt-5.3-codex',
+  gpt54: 'gpt-5.4',
 };
 
 /**
  * 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.
+ * If a short alias, returns the corresponding full ID.
+ * Handles harness-prefixed format: strips prefix and resolves.
  */
 export function resolveFullModelId(modelName: string): string {
+  // Handle harness-prefixed format
+  const prefixMatch = modelName.match(/^(claude|codex)\/(.+)$/);
+  if (prefixMatch) {
+    const model = prefixMatch[2]!;
+    const fullId = MODEL_ALIAS_TO_FULL_ID[model];
+    return fullId ?? model;
+  }
+
   const fullId = MODEL_ALIAS_TO_FULL_ID[modelName];
   if (fullId) {
     return fullId;

package/src/utils/name-generator.ts

@@ -30,7 +30,7 @@ Rules:
 Project description:`;
 
 /**
- * Run Claude CLI with the given prompt and return stdout.
+ * Run the CLI with the given prompt and return stdout.
  * Uses spawn with --no-session-persistence to avoid cluttering session history.
  */
 function runClaudePrint(prompt: string): Promise<string | null> {
@@ -65,7 +65,7 @@ function runClaudePrint(prompt: string): Promise<string | null> {
       clearTimeout(timeoutHandle);
       if (exitCode !== 0) {
         if (stderr) {
-          logger.debug(`Claude CLI stderr: ${stderr}`);
+          logger.debug(`CLI stderr: ${stderr}`);
         }
         resolve(null);
       } else {
@@ -75,14 +75,14 @@ function runClaudePrint(prompt: string): Promise<string | null> {
 
     proc.on('error', (error) => {
       clearTimeout(timeoutHandle);
-      logger.debug(`Claude CLI spawn error: ${error}`);
+      logger.debug(`CLI spawn error: ${error}`);
       resolve(null);
     });
   });
 }
 
 /**
- * Generate a single project name using Claude.
+ * Generate a single project name using the LLM.
  * Falls back to extracting words from the description if the API call fails.
  */
 export async function generateProjectName(description: string): Promise<string> {
@@ -96,7 +96,7 @@ export async function generateProjectName(description: string): Promise<string>
       }
     }
   } catch (error) {
-    logger.debug(`Failed to generate name with Claude: ${error}`);
+    logger.debug(`Failed to generate name: ${error}`);
   }
 
   // Fallback to extracting words from description
@@ -104,7 +104,7 @@ export async function generateProjectName(description: string): Promise<string>
 }
 
 /**
- * Generate multiple project name suggestions using Claude.
+ * Generate multiple project name suggestions using the LLM.
  * Returns 3-5 unique names with varied styles.
  */
 export async function generateProjectNames(description: string): Promise<string[]> {
@@ -115,7 +115,7 @@ export async function generateProjectNames(description: string): Promise<string[
       return names;
     }
   } catch (error) {
-    logger.debug(`Failed to generate names with Claude: ${error}`);
+    logger.debug(`Failed to generate names: ${error}`);
   }
 
   // Fallback: generate a single fallback name
@@ -125,7 +125,7 @@ export async function generateProjectNames(description: string): Promise<string[
 }
 
 /**
- * Call Claude to generate a single project name.
+ * Call the LLM to generate a single project name.
  */
 async function callSonnetForName(description: string): Promise<string | null> {
   const fullPrompt = `${NAME_GENERATION_PROMPT}\n${description}`;
@@ -133,7 +133,7 @@ async function callSonnetForName(description: string): Promise<string | null> {
 }
 
 /**
- * Call Claude to generate multiple project names.
+ * Call the LLM to generate multiple project names.
  */
 async function callSonnetForMultipleNames(description: string): Promise<string[]> {
   const fullPrompt = `${MULTI_NAME_GENERATION_PROMPT}\n${description}`;