popeye-cli 2.0.0 → 2.2.0

package/src/config/popeye-md.ts

@@ -0,0 +1,139 @@
+/**
+ * Shared popeye.md configuration reader.
+ * Reads project-local config from the YAML frontmatter in popeye.md.
+ * Used by both interactive mode and CLI commands.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { OutputLanguageSchema, type OutputLanguage } from '../types/project.js';
+import type { AIProvider, GeminiModel, GrokModel } from '../types/consensus.js';
+import type { OpenAIModel } from '../types/project.js';
+
+// ─── Types ───────────────────────────────────────────────
+
+/** Project-local configuration stored in popeye.md */
+export interface PopeyeMdConfig {
+  language: OutputLanguage;
+  reviewer: AIProvider;
+  arbitrator: AIProvider;
+  enableArbitration: boolean;
+  created: string;
+  lastRun: string;
+  projectName?: string;
+  description?: string;
+  notes?: string;
+  openaiModel?: OpenAIModel;
+  geminiModel?: GeminiModel;
+  grokModel?: GrokModel;
+}
+
+// ─── Reader ──────────────────────────────────────────────
+
+/**
+ * Read popeye.md from a project directory.
+ * Parses YAML frontmatter for project configuration.
+ *
+ * @param projectDir - Absolute path to the project root
+ * @returns Parsed config or null if file doesn't exist or is invalid
+ */
+export async function readPopeyeMdConfig(projectDir: string): Promise<PopeyeMdConfig | null> {
+  const configPath = path.join(projectDir, 'popeye.md');
+
+  try {
+    const content = await fs.readFile(configPath, 'utf-8');
+
+    // Parse YAML frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return null;
+    }
+
+    const frontmatter = frontmatterMatch[1];
+    const config: Partial<PopeyeMdConfig> = {};
+
+    // Parse each line of YAML
+    for (const line of frontmatter.split('\n')) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const [, key, value] = match;
+        const cleanValue = value.trim();
+
+        switch (key) {
+          case 'language':
+            if (OutputLanguageSchema.safeParse(cleanValue).success) {
+              config.language = cleanValue as OutputLanguage;
+            }
+            break;
+          case 'reviewer':
+            if (['openai', 'gemini', 'grok'].includes(cleanValue)) {
+              config.reviewer = cleanValue as AIProvider;
+            }
+            break;
+          case 'arbitrator':
+            if (['openai', 'gemini', 'grok', 'off'].includes(cleanValue)) {
+              if (cleanValue === 'off') {
+                config.enableArbitration = false;
+              } else {
+                config.arbitrator = cleanValue as AIProvider;
+                config.enableArbitration = true;
+              }
+            }
+            break;
+          case 'created':
+            config.created = cleanValue;
+            break;
+          case 'lastRun':
+            config.lastRun = cleanValue;
+            break;
+          case 'projectName':
+            config.projectName = cleanValue;
+            break;
+          case 'openaiModel':
+            if (cleanValue.length > 0) {
+              config.openaiModel = cleanValue;
+            }
+            break;
+          case 'geminiModel':
+            if (cleanValue.length > 0) {
+              config.geminiModel = cleanValue;
+            }
+            break;
+          case 'grokModel':
+            if (cleanValue.length > 0) {
+              config.grokModel = cleanValue;
+            }
+            break;
+        }
+      }
+    }
+
+    // Extract notes section if present
+    const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n## |$)/);
+    if (notesMatch) {
+      config.notes = notesMatch[1].trim();
+    }
+
+    // Return config only if we have the essential fields
+    if (config.language && config.reviewer) {
+      return {
+        language: config.language,
+        reviewer: config.reviewer,
+        arbitrator: config.arbitrator || 'gemini',
+        enableArbitration: config.enableArbitration ?? true,
+        created: config.created || new Date().toISOString(),
+        lastRun: config.lastRun || new Date().toISOString(),
+        projectName: config.projectName,
+        description: config.description,
+        notes: config.notes,
+        openaiModel: config.openaiModel,
+        geminiModel: config.geminiModel,
+        grokModel: config.grokModel,
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/config/schema.ts

@@ -23,14 +23,17 @@ export const ConsensusSettingsSchema = z.object({
  * OpenAI API settings schema
  */
 export const OpenAISettingsSchema = z.object({
-  model: z
-    .enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'])
-    .default('gpt-4o'),
+  model: z.string().min(1).default('gpt-4.1'),
   temperature: z.number().min(0).max(2).default(0.3),
   max_tokens: z.number().min(100).max(32000).default(4096),
   available_models: z
     .array(z.string())
-    .default(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+    .default([
+      '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',
+    ]),
 });
 
 /**
@@ -55,10 +58,15 @@ export const GrokSettingsSchema = z.object({
  */
 export const APISettingsSchema = z.object({
   openai: OpenAISettingsSchema.default({
-    model: 'gpt-4o',
+    model: 'gpt-4.1',
     temperature: 0.3,
     max_tokens: 4096,
-    available_models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'],
+    available_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',
+    ],
   }),
   claude: ClaudeSettingsSchema.default({
     model: 'claude-sonnet-4-20250514',
@@ -139,10 +147,15 @@ export const ConfigSchema = z.object({
   }),
   apis: APISettingsSchema.default({
     openai: {
-      model: 'gpt-4o',
+      model: 'gpt-4.1',
       temperature: 0.3,
       max_tokens: 4096,
-      available_models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'],
+      available_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',
+      ],
     },
     claude: {
       model: 'claude-sonnet-4-20250514',

package/src/generators/all.ts

@@ -10,7 +10,8 @@ import type { GenerationResult } from './python.js';
 import { generateFullstackProject } from './fullstack.js';
 import { generateWebsiteProject } from './website.js';
 import type { WebsiteContentContext } from './website-context.js';
-import { buildWebsiteContext, validateWebsiteContext } from './website-context.js';
+import { buildWebsiteContext, validateWebsiteContext, resolveBrandAssets } from './website-context.js';
+import { loadWebsiteStrategy } from '../workflow/website-strategy.js';
 import {
   generateDesignTokensPackage as generateDesignTokensPackageImpl,
   generateUiPackage as generateUiPackageImpl,
@@ -403,6 +404,25 @@ export async function generateAllProject(
       console.warn(`[website-context] Warning: ${contextWarning}`);
     }
 
+    // Resolve brand assets (logo output path) — must happen after buildWebsiteContext
+    if (contentContext?.brand) {
+      try {
+        contentContext.brandAssets = await resolveBrandAssets(projectDir, contentContext.brand);
+      } catch {
+        // Non-fatal: brand assets are optional
+      }
+    }
+
+    // Load website strategy if previously generated (e.g. re-scaffold)
+    try {
+      const strategyData = await loadWebsiteStrategy(projectDir);
+      if (strategyData && contentContext) {
+        contentContext.strategy = strategyData.strategy;
+      }
+    } catch {
+      // Strategy won't exist on first scaffold — generated later by runPlanMode
+    }
+
     // Soft validation: log quality issues without blocking monorepo generation
     if (contentContext) {
       const validation = validateWebsiteContext(contentContext, projectName);
@@ -419,12 +439,14 @@ export async function generateAllProject(
     filesCreated.push(...fullstackResult.filesCreated);
 
     // Generate website app
+    // skipValidation: strategy is generated later by runPlanMode, not at scaffold time
     const websiteResult = await generateWebsiteProject(spec, projectDir, {
       baseDir: path.join(projectDir, 'apps', 'website'),
       workspaceMode: true,
       skipDocker: true, // Website runs outside Docker (npm run dev / npm start)
       skipReadme: false,
       contentContext: contentContext,
+      skipValidation: true,
     });
     if (!websiteResult.success) {
       return {

package/src/pipeline/artifact-manager.ts

@@ -45,6 +45,8 @@ const ARTIFACT_DIRS: Record<string, string> = {
   resolved_commands: 'checks',
   constitution: 'governance',
   change_request: 'governance',
+  additional_context: 'context',
+  skill_generation_log: 'context',
 };
 
 /** All required subdirectories under /docs/ */
@@ -62,6 +64,7 @@ const DOCS_SUBDIRS = [
   'checks',
   'journal',
   'governance',
+  'context',
 ];
 
 // ─── Helper Functions ────────────────────────────────────

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/gate-engine.ts

@@ -40,7 +40,7 @@ export interface GateResult {
 const GATE_DEFINITIONS: Record<PipelinePhase, GateDefinition> = {
   INTAKE: {
     phase: 'INTAKE',
-    requiredArtifacts: ['master_plan', 'repo_snapshot', 'constitution'],
+    requiredArtifacts: ['master_plan', 'repo_snapshot'],
     requiredChecks: [],
     allowedTransitions: ['CONSENSUS_MASTER_PLAN'],
     failTransition: 'RECOVERY_LOOP',