popeye-cli 2.0.0 → 2.1.0

package/src/pipeline/bridges/review-bridge.ts

@@ -0,0 +1,371 @@
+/**
+ * Review Bridge — connects /review (rich audit-mode scanner) to the pipeline
+ * artifact + CR system when a project is pipeline-managed.
+ *
+ * When pipeline state exists, /review produces pipeline-native audit_report
+ * artifacts and Change Requests instead of injecting recovery milestones
+ * into state.json. This keeps the pipeline as the single source of truth.
+ */
+
+import { randomUUID } from 'node:crypto';
+import type { ProjectState } from '../../types/workflow.js';
+import type {
+  PipelineState,
+  PipelinePhase,
+  ArtifactEntry,
+  ArtifactRef,
+} from '../types.js';
+import type { AuditFinding as WorkflowAuditFinding, AuditCategory as WorkflowCategory, AuditSeverity as WorkflowSeverity } from '../../types/audit.js';
+import type { AuditFinding as PipelineAuditFinding, AuditSeverity as PipelineSeverity } from '../type-defs/audit.js';
+import type { ChangeRequest } from '../types.js';
+import { createArtifactManager } from '../artifact-manager.js';
+import { buildChangeRequest, formatChangeRequest, routeChangeRequest } from '../change-request.js';
+import { generateRepoSnapshot, createSnapshotArtifact } from '../repo-snapshot.js';
+import { scanProject } from '../../workflow/audit-scanner.js';
+import { analyzeProject, calculateAuditScores } from '../../workflow/audit-analyzer.js';
+import { buildSummaryReport, buildAuditReport } from '../../workflow/audit-reporter.js';
+import { loadProject, updateState } from '../../state/index.js';
+
+// ─── Types ───────────────────────────────────────────────
+
+export interface ReviewBridgeOptions {
+  projectDir: string;
+  depth?: number;
+  strict?: boolean;
+  onProgress?: (stage: string, message: string) => void;
+}
+
+export interface ReviewBridgeResult {
+  success: boolean;
+  findingsCount: number;
+  changeRequestCount: number;
+  overallScore: number;
+  recommendation: string;
+  artifactsCreated: number;
+  error?: string;
+}
+
+// ─── Pipeline Detection ──────────────────────────────────
+
+/**
+ * Check if a project is pipeline-managed.
+ * A project is pipeline-managed if its state has a pipeline object
+ * with a pipelinePhase field.
+ *
+ * @param state - The project state to check
+ * @returns True if pipeline-managed
+ */
+export function isPipelineManaged(state: ProjectState): boolean {
+  const pipeline = (state as unknown as { pipeline?: PipelineState }).pipeline;
+  return !!pipeline?.pipelinePhase;
+}
+
+/**
+ * Extract pipeline state from project state.
+ *
+ * @param state - The project state
+ * @returns Pipeline state or undefined
+ */
+export function extractPipelineState(state: ProjectState): PipelineState | undefined {
+  return (state as unknown as { pipeline?: PipelineState }).pipeline;
+}
+
+// ─── Severity Mapping ────────────────────────────────────
+
+/** Map workflow audit severity to pipeline severity */
+const SEVERITY_MAP: Record<WorkflowSeverity, PipelineSeverity> = {
+  critical: 'P0',
+  major: 'P1',
+  minor: 'P2',
+  info: 'P3',
+};
+
+export function mapSeverity(severity: WorkflowSeverity): PipelineSeverity {
+  return SEVERITY_MAP[severity];
+}
+
+// ─── Category Mapping ────────────────────────────────────
+
+/** Map workflow audit categories to pipeline audit categories */
+type PipelineCategory = 'integration' | 'config' | 'tests' | 'schema' | 'security' | 'deployment';
+
+const CATEGORY_MAP: Record<WorkflowCategory, PipelineCategory> = {
+  'feature-completeness': 'integration',
+  'integration-wiring': 'integration',
+  'test-coverage': 'tests',
+  'config-deployment': 'config',
+  'dependency-sanity': 'deployment',
+  'consistency': 'schema',
+  'security': 'security',
+  'documentation': 'deployment',
+};
+
+export function mapCategory(category: WorkflowCategory): PipelineCategory {
+  return CATEGORY_MAP[category];
+}
+
+// ─── CR Routing ──────────────────────────────────────────
+
+/** Determine CR change_type from pipeline audit category */
+const CATEGORY_TO_CHANGE_TYPE: Record<PipelineCategory, ChangeRequest['change_type']> = {
+  integration: 'architecture',
+  schema: 'architecture',
+  security: 'requirement',
+  tests: 'config',
+  config: 'config',
+  deployment: 'config',
+};
+
+export function categoryToChangeType(category: PipelineCategory): ChangeRequest['change_type'] {
+  return CATEGORY_TO_CHANGE_TYPE[category];
+}
+
+// ─── Finding Conversion ──────────────────────────────────
+
+/**
+ * Convert a workflow AuditFinding to a pipeline AuditFinding.
+ *
+ * @param finding - Workflow finding
+ * @param snapshotRef - Pipeline artifact ref for the repo snapshot
+ * @returns Pipeline-native audit finding
+ */
+export function convertFinding(
+  finding: WorkflowAuditFinding,
+  snapshotRef: ArtifactRef,
+): PipelineAuditFinding {
+  const severity = mapSeverity(finding.severity);
+  return {
+    id: finding.id,
+    severity,
+    category: mapCategory(finding.category),
+    description: `${finding.title}: ${finding.description}`,
+    evidence: [snapshotRef],
+    file_path: finding.evidence[0]?.file,
+    line_number: finding.evidence[0]?.line,
+    suggested_owner: 'AUDITOR',
+    blocking: severity === 'P0' || severity === 'P1',
+  };
+}
+
+// ─── Bridge Orchestrator ─────────────────────────────────
+
+/**
+ * Run /review through the pipeline bridge.
+ * Uses the rich audit-mode scanner but writes results as pipeline artifacts
+ * and creates Change Requests for blocking findings.
+ *
+ * Does NOT inject recovery milestones — the pipeline RECOVERY_LOOP handles fixes.
+ *
+ * @param options - Bridge options
+ * @returns Bridge result with counts and score
+ */
+export async function runReviewBridge(options: ReviewBridgeOptions): Promise<ReviewBridgeResult> {
+  const { projectDir, onProgress } = options;
+  const depth = options.depth ?? 2;
+  const strict = options.strict ?? false;
+
+  try {
+    // 1. Load state and extract pipeline
+    const state = await loadProject(projectDir);
+    const pipeline = extractPipelineState(state);
+    if (!pipeline) {
+      return { success: false, findingsCount: 0, changeRequestCount: 0, overallScore: 0, recommendation: 'error', artifactsCreated: 0, error: 'No pipeline state found' };
+    }
+
+    const artifactManager = createArtifactManager(projectDir);
+    artifactManager.ensureDocsStructure();
+    const artifacts: ArtifactEntry[] = [];
+
+    // 2. Generate fresh repo snapshot (pipeline anchor)
+    onProgress?.('bridge', 'Generating repo snapshot...');
+    const snapshot = await generateRepoSnapshot(projectDir);
+    const snapshotEntry = createSnapshotArtifact(snapshot, artifactManager, 'AUDIT');
+    artifacts.push(snapshotEntry);
+    pipeline.latestRepoSnapshot = artifactManager.toArtifactRef(snapshotEntry);
+    const snapshotRef = artifactManager.toArtifactRef(snapshotEntry);
+
+    // 3. Run rich audit-mode scanner (Stage 1: Scan)
+    onProgress?.('bridge', 'Running project scan...');
+    const scan = await scanProject(
+      projectDir,
+      state.language,
+      (msg) => onProgress?.('bridge-scan', msg),
+    );
+    const summary = buildSummaryReport(scan, state);
+
+    onProgress?.(
+      'bridge',
+      `Scan complete: ${scan.totalSourceFiles} source files, ${scan.totalLinesOfCode} LOC`,
+    );
+
+    // 4. Run AI analysis (Stage 2: Analyze)
+    onProgress?.('bridge', 'Running AI analysis...');
+    const { findings: workflowFindings, searchMetadata } = await analyzeProject(scan, state, {
+      depth,
+      strict,
+      projectDir,
+    });
+    const scores = calculateAuditScores(workflowFindings, scan);
+    const auditReport = buildAuditReport(summary, workflowFindings, scores, searchMetadata, { strict }, randomUUID());
+
+    onProgress?.(
+      'bridge',
+      `Analysis complete: score ${scores.overallScore}%, ${workflowFindings.length} findings`,
+    );
+
+    // 5. Convert findings to pipeline format
+    const pipelineFindings = workflowFindings.map((f) => convertFinding(f, snapshotRef));
+
+    // 6. Build pipeline audit report and store as artifact
+    const pipelineAuditReport = {
+      audit_id: `audit-${randomUUID().split('-')[0]}`,
+      timestamp: new Date().toISOString(),
+      repo_snapshot: snapshotRef,
+      overall_status: (auditReport.recommendation === 'pass' ? 'PASS' : 'FAIL') as 'PASS' | 'FAIL',
+      findings: pipelineFindings,
+      system_risk_score: 100 - scores.overallScore,
+      recovery_required: auditReport.recommendation === 'major-rework',
+    };
+
+    const auditJsonEntry = artifactManager.createAndStoreJson(
+      'audit_report',
+      pipelineAuditReport,
+      'AUDIT',
+    );
+    artifacts.push(auditJsonEntry);
+
+    // Store raw text report too
+    const textReport = formatAuditSummary(pipelineFindings, scores.overallScore, auditReport.recommendation);
+    const auditTextEntry = artifactManager.createAndStoreText(
+      'audit_report',
+      textReport,
+      'AUDIT',
+    );
+    artifacts.push(auditTextEntry);
+
+    // 7. Create Change Requests for blocking findings
+    const changeRequests: ChangeRequest[] = [];
+    const blockingFindings = pipelineFindings.filter((f) => f.blocking);
+
+    if (blockingFindings.length > 0) {
+      // Group by category for targeted CRs
+      const byCategory = new Map<string, typeof pipelineFindings>();
+      for (const f of blockingFindings) {
+        const group = byCategory.get(f.category) ?? [];
+        group.push(f);
+        byCategory.set(f.category, group);
+      }
+
+      for (const [category, findings] of byCategory) {
+        const changeType = categoryToChangeType(category as PipelineCategory);
+        const cr = buildChangeRequest({
+          originPhase: 'AUDIT',
+          requestedBy: 'AUDITOR',
+          changeType,
+          description: `${findings.length} blocking ${category} finding(s): ${findings.map((f) => f.description.slice(0, 80)).join('; ')}`,
+          justification: 'Blocking audit findings from /review require pipeline resolution',
+          affectedArtifacts: [snapshotRef],
+          affectedPhases: getAffectedPhases(category as PipelineCategory),
+          riskLevel: findings.some((f) => f.severity === 'P0') ? 'high' : 'medium',
+        });
+        changeRequests.push(cr);
+
+        // Store CR as artifact
+        const crEntry = artifactManager.createAndStoreText(
+          'change_request',
+          formatChangeRequest(cr),
+          'AUDIT',
+        );
+        artifacts.push(crEntry);
+
+        // Register in pipeline state for orchestrator routing
+        if (!pipeline.pendingChangeRequests) {
+          pipeline.pendingChangeRequests = [];
+        }
+        pipeline.pendingChangeRequests.push({
+          cr_id: cr.cr_id,
+          change_type: cr.change_type,
+          target_phase: routeChangeRequest(cr),
+          status: 'proposed',
+        });
+      }
+    }
+
+    // 8. Persist pipeline state
+    pipeline.artifacts.push(...artifacts);
+
+    // Update INDEX.md
+    artifactManager.updateIndex(pipeline.artifacts);
+
+    // Save updated state (pipeline object is a reference on state)
+    await updateState(projectDir, {
+      auditReportPath: auditJsonEntry.path,
+      auditLastRunAt: new Date().toISOString(),
+      auditRunId: pipelineAuditReport.audit_id,
+    } as Partial<ProjectState>);
+
+    onProgress?.(
+      'bridge',
+      `Bridge complete: ${artifacts.length} artifacts, ${changeRequests.length} CRs created`,
+    );
+
+    return {
+      success: true,
+      findingsCount: pipelineFindings.length,
+      changeRequestCount: changeRequests.length,
+      overallScore: scores.overallScore,
+      recommendation: auditReport.recommendation,
+      artifactsCreated: artifacts.length,
+    };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : 'Unknown error';
+    return { success: false, findingsCount: 0, changeRequestCount: 0, overallScore: 0, recommendation: 'error', artifactsCreated: 0, error };
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────
+
+/** Get affected phases for a finding category */
+function getAffectedPhases(category: PipelineCategory): PipelinePhase[] {
+  switch (category) {
+    case 'integration':
+    case 'schema':
+      return ['CONSENSUS_ARCHITECTURE', 'IMPLEMENTATION'];
+    case 'security':
+      return ['CONSENSUS_MASTER_PLAN', 'IMPLEMENTATION'];
+    case 'tests':
+      return ['QA_VALIDATION'];
+    case 'config':
+    case 'deployment':
+      return ['IMPLEMENTATION', 'PRODUCTION_GATE'];
+  }
+}
+
+/** Format a text summary of pipeline audit findings */
+function formatAuditSummary(
+  findings: PipelineAuditFinding[],
+  score: number,
+  recommendation: string,
+): string {
+  const lines = [
+    '# Pipeline Audit Report (via /review bridge)',
+    '',
+    `**Score:** ${score}%`,
+    `**Recommendation:** ${recommendation}`,
+    `**Findings:** ${findings.length}`,
+    `**Blocking:** ${findings.filter((f) => f.blocking).length}`,
+    '',
+    '## Findings',
+    '',
+  ];
+
+  for (const f of findings) {
+    lines.push(`### [${f.severity}] ${f.description.slice(0, 120)}`);
+    lines.push(`- Category: ${f.category}`);
+    lines.push(`- Blocking: ${f.blocking ? 'Yes' : 'No'}`);
+    if (f.file_path) lines.push(`- File: ${f.file_path}${f.line_number ? `:${f.line_number}` : ''}`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/src/pipeline/consensus/consensus-runner.ts

@@ -43,8 +43,8 @@ export interface ReviewerProviderConfig {
 }
 
 const DEFAULT_PROVIDERS: ReviewerProviderConfig[] = [
-  { provider: 'openai', model: 'gpt-4o', temperature: 0.3 },
-  { provider: 'gemini', model: 'gemini-2.0-flash', temperature: 0.3 },
+  { provider: 'openai', model: 'gpt-4.1', temperature: 0.3 },
+  { provider: 'gemini', model: 'gemini-2.5-flash', temperature: 0.3 },
 ];
 
 // ─── Consensus Runner ────────────────────────────────────
@@ -138,7 +138,7 @@ export class ConsensusRunner {
       const vote: ReviewerVote = {
         reviewer_id: 'iterative-reviewer',
         provider: 'openai',
-        model: this.config.consensusConfig?.openaiModel ?? 'gpt-4o',
+        model: this.config.consensusConfig?.openaiModel ?? 'gpt-4.1',
         temperature: this.config.consensusConfig?.temperature ?? 0.3,
         prompt_hash: createHash('sha256').update(prompt).digest('hex'),
         vote: result.approved ? 'APPROVE' : 'REJECT',

package/src/pipeline/orchestrator.ts

@@ -53,6 +53,8 @@ export interface PipelineOptions {
   projectDir: string;
   state: ProjectState;
   consensusConfig?: Partial<ConsensusConfig>;
+  /** User steering, upgrade context, or resume instructions */
+  additionalContext?: string;
   onPhaseStart?: (phase: PipelinePhase) => void;
   onPhaseComplete?: (phase: PipelinePhase, result: PhaseResult) => void;
   onProgress?: (message: string) => void;
@@ -88,6 +90,7 @@ export async function runPipeline(options: PipelineOptions): Promise<PipelineRes
     projectDir,
     state,
     consensusConfig,
+    additionalContext,
     onPhaseStart,
     onPhaseComplete,
     onProgress,
@@ -97,6 +100,11 @@ export async function runPipeline(options: PipelineOptions): Promise<PipelineRes
   const pipeline: PipelineState = (state as unknown as { pipeline?: PipelineState }).pipeline
     ?? createDefaultPipelineState();
 
+  // Persist user guidance in pipeline state so it survives resume
+  if (additionalContext && !pipeline.sessionGuidance) {
+    pipeline.sessionGuidance = additionalContext;
+  }
+
   // Create context dependencies
   const gateEngine = createGateEngine();
   const artifactManager = createArtifactManager(projectDir);

package/src/pipeline/phases/implementation.ts

@@ -26,11 +26,15 @@ export async function runImplementation(context: PhaseContext): Promise<PhaseRes
         .join('\n\n');
     }
 
-    // Run existing execution mode with optional role context
+    // Merge session guidance with role prompt so execution sees user intent
+    const guidance = pipeline.sessionGuidance;
+    const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+    // Run existing execution mode with optional role context + guidance
     const { runExecutionMode } = await import('../../workflow/execution-mode.js');
     await runExecutionMode({
       projectDir,
-      ...(combinedRolePrompt ? { systemPrompt: combinedRolePrompt } : {}),
+      ...(systemPrompt ? { systemPrompt } : {}),
     });
 
     // Generate post-implementation repo snapshot

package/src/pipeline/phases/intake.ts

@@ -27,17 +27,31 @@ export async function runIntake(context: PhaseContext): Promise<PhaseResult> {
     }
     pipeline.constitutionHash = computeConstitutionHash(projectDir);
 
-    // 3. Expand idea using existing workflow
+    // 3. Store additional_context artifact if session guidance provided
+    const guidance = pipeline.sessionGuidance ?? '';
+    if (guidance) {
+      const ctxEntry = artifactManager.createAndStoreText(
+        'additional_context',
+        guidance,
+        'INTAKE',
+      );
+      artifacts.push(ctxEntry);
+    }
+
+    // 4. Expand idea using existing workflow
     const { expandIdea, createPlan } = await import('../../workflow/plan-mode.js');
     const expandedIdea = await expandIdea(
       context.state.specification ?? context.state.idea ?? '',
       context.state.language,
     );
 
-    // 4. Create master plan using existing workflow
-    const plan = await createPlan(expandedIdea, '', context.state.language);
+    // 5. Create master plan — prepend guidance so planner sees constraints first
+    const planInput = guidance
+      ? `${guidance}\n\n---\n\n${expandedIdea}`
+      : expandedIdea;
+    const plan = await createPlan(planInput, '', context.state.language);
 
-    // 5. Store master plan as artifact
+    // 6. Store master plan as artifact
     const planEntry = artifactManager.createAndStoreText(
       'master_plan',
       plan,

package/src/pipeline/phases/recovery-loop.ts

@@ -33,9 +33,11 @@ export async function runRecoveryLoop(context: PhaseContext): Promise<PhaseResul
 
     // 3. Generate RCA via Claude with Debugger skill
     const { executePrompt } = await import('../../adapters/claude.js');
+    const guidance = pipeline.sessionGuidance;
     const rcaPrompt = [
       debuggerSkill.systemPrompt,
       '',
+      ...(guidance ? ['## User Guidance', guidance, ''] : []),
       '## Failure Evidence',
       failureEvidence,
       '',

package/src/pipeline/type-defs/artifacts.ts

@@ -32,6 +32,7 @@ export const ArtifactTypeSchema = z.enum([
   'resolved_commands',
   'constitution',
   'change_request',
+  'additional_context',
 ]);
 export type ArtifactType = z.infer<typeof ArtifactTypeSchema>;
 

package/src/pipeline/type-defs/state.ts

@@ -97,6 +97,8 @@ export const PipelineStateSchema = z.object({
   resolvedCommands: ResolvedCommandsSchema.optional(),
   /** Tracks which phase failed, for recovery routing */
   failedPhase: PipelinePhaseSchema.optional(),
+  /** Session guidance: user steering, upgrade context, or resume instructions */
+  sessionGuidance: z.string().optional(),
   /** Pending change requests that force re-routing to consensus phases (v1.1) */
   pendingChangeRequests: z.array(z.object({
     cr_id: z.string(),

package/src/types/consensus.ts

@@ -101,8 +101,8 @@ export interface ConsensusConfig {
 export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'geminiKey' | 'grokKey'> = {
   threshold: 95,
   maxIterations: 10,
-  openaiModel: 'gpt-4o',
-  geminiModel: 'gemini-2.0-flash',
+  openaiModel: 'gpt-4.1',
+  geminiModel: 'gemini-2.5-flash',
   grokModel: DEFAULT_GROK_MODEL,
   reviewer: 'openai',
   arbitrator: 'gemini',
@@ -122,7 +122,19 @@ export const AIProviderSchema = z.enum(['openai', 'gemini', 'grok']);
 /**
  * Known Gemini models (used for suggestions and display, not strict validation)
  */
-export const KNOWN_GEMINI_MODELS = ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'] as const;
+export const KNOWN_GEMINI_MODELS = [
+  'gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite',
+  'gemini-2.0-flash', 'gemini-2.0-pro',
+  'gemini-1.5-pro', 'gemini-1.5-flash',
+] as const;
+
+/**
+ * Known Grok models (used for suggestions and display, not strict validation)
+ */
+export const KNOWN_GROK_MODELS = [
+  'grok-4-0709', 'grok-3', 'grok-3-mini',
+  'grok-3-fast', 'grok-3-mini-fast', 'grok-2',
+] as const;
 
 /**
  * Zod schema for Gemini model - accepts any non-empty string to support new models
@@ -144,7 +156,7 @@ export const ConsensusConfigSchema = z.object({
   geminiKey: z.string().optional(),
   grokKey: z.string().optional(),
   openaiModel: OpenAIModelSchema,
-  geminiModel: GeminiModelSchema.default('gemini-2.0-flash'),
+  geminiModel: GeminiModelSchema.default('gemini-2.5-flash'),
   grokModel: GrokModelSchema.default(DEFAULT_GROK_MODEL),
   reviewer: AIProviderSchema.default('openai'),
   arbitrator: AIProviderSchema.default('gemini'),

package/src/types/index.ts

@@ -58,6 +58,7 @@ export {
   DEFAULT_GROK_MODEL,
   AIProviderSchema,
   KNOWN_GEMINI_MODELS,
+  KNOWN_GROK_MODELS,
   GeminiModelSchema,
   GrokModelSchema,
   type AIProvider,

package/src/types/project.ts

@@ -242,7 +242,12 @@ export interface WebsiteSpec {
 /**
  * Known OpenAI models (used for suggestions and display, not strict validation)
  */
-export const KNOWN_OPENAI_MODELS = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'] as const;
+export const KNOWN_OPENAI_MODELS = [
+  'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano',
+  'o3', 'o3-mini', 'o4-mini',
+  'gpt-4o', 'gpt-4o-mini',
+  'gpt-4-turbo', 'o1-preview', 'o1-mini',
+] as const;
 
 /**
  * OpenAI model schema - accepts any non-empty string to support new models
@@ -289,24 +294,48 @@ export interface GenerationOptions {
  * Available OpenAI models with descriptions
  */
 export const OPENAI_MODELS: Record<OpenAIModel, { description: string; recommended: string }> = {
-  'gpt-4o': {
-    description: 'Most capable, best reasoning',
+  'gpt-4.1': {
+    description: 'Smartest non-reasoning model, 1M context',
     recommended: 'Complex projects',
   },
+  'gpt-4.1-mini': {
+    description: 'Fast, strong instruction following',
+    recommended: 'Medium complexity',
+  },
+  'gpt-4.1-nano': {
+    description: 'Fastest, most cost-efficient',
+    recommended: 'Simple projects',
+  },
+  'o3': {
+    description: 'Strongest reasoning model',
+    recommended: 'Architectural decisions',
+  },
+  'o3-mini': {
+    description: 'Efficient reasoning',
+    recommended: 'Code review',
+  },
+  'o4-mini': {
+    description: 'Fast reasoning, best on STEM',
+    recommended: 'Technical analysis',
+  },
+  'gpt-4o': {
+    description: 'Multimodal, strong all-rounder',
+    recommended: 'General purpose',
+  },
   'gpt-4o-mini': {
     description: 'Fast, cost-effective',
-    recommended: 'Simple projects',
+    recommended: 'Simple tasks',
   },
   'gpt-4-turbo': {
-    description: 'High capability, faster',
-    recommended: 'Medium complexity',
+    description: 'High capability, legacy',
+    recommended: 'Backward compatibility',
   },
   'o1-preview': {
-    description: 'Advanced reasoning',
-    recommended: 'Architectural decisions',
+    description: 'Advanced reasoning (legacy)',
+    recommended: 'Legacy reasoning tasks',
   },
   'o1-mini': {
-    description: 'Efficient reasoning',
-    recommended: 'Code review',
+    description: 'Efficient reasoning (legacy)',
+    recommended: 'Legacy reasoning tasks',
   },
 };

package/src/types/workflow.ts

@@ -254,7 +254,7 @@ export const ProjectStateSchema = z.object({
   name: z.string(),
   idea: z.string(),
   language: OutputLanguageSchema,
-  openaiModel: z.enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+  openaiModel: z.string().min(1),
   phase: WorkflowPhaseSchema,
   status: ProjectStatusSchema,
   specification: z.string().optional(),