popeye-cli 1.10.0 → 2.1.0

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

@@ -0,0 +1,82 @@
+/**
+ * Artifact system types — artifact types, refs, entries, dependency edges.
+ */
+
+import { z } from 'zod';
+import { PipelinePhaseSchema } from './enums.js';
+
+// ─── Artifact Types ──────────────────────────────────────
+
+export const ArtifactTypeSchema = z.enum([
+  'master_plan',
+  'architecture',
+  'role_plan',
+  'consensus',
+  'arbitration',
+  'audit_report',
+  'rca_report',
+  'production_readiness',
+  'release_notes',
+  'deployment',
+  'rollback',
+  'repo_snapshot',
+  'build_check',
+  'test_check',
+  'lint_check',
+  'typecheck_check',
+  'placeholder_scan',
+  'qa_validation',
+  'review_decision',
+  'stuck_report',
+  'journalist_trace',
+  'resolved_commands',
+  'constitution',
+  'change_request',
+  'additional_context',
+]);
+export type ArtifactType = z.infer<typeof ArtifactTypeSchema>;
+
+// ─── Content Type ────────────────────────────────────────
+
+export const ContentTypeSchema = z.enum(['markdown', 'json']);
+export type ContentType = z.infer<typeof ContentTypeSchema>;
+
+// ─── Artifact Reference ──────────────────────────────────
+
+/** Universal pointer between packets and artifacts */
+export const ArtifactRefSchema = z.object({
+  artifact_id: z.string(),
+  path: z.string(),
+  sha256: z.string(),
+  version: z.number().int().positive(),
+  type: ArtifactTypeSchema,
+});
+export type ArtifactRef = z.infer<typeof ArtifactRefSchema>;
+
+// ─── Artifact Entry ──────────────────────────────────────
+
+/** Immutable artifact entry stored in pipeline state */
+export const ArtifactEntrySchema = z.object({
+  id: z.string(),
+  type: ArtifactTypeSchema,
+  phase: PipelinePhaseSchema,
+  version: z.number().int().positive(),
+  path: z.string(),
+  sha256: z.string(),
+  timestamp: z.string(),
+  immutable: z.literal(true),
+  content_type: ContentTypeSchema,
+  group_id: z.string(),
+  previous_id: z.string().optional(),
+});
+export type ArtifactEntry = z.infer<typeof ArtifactEntrySchema>;
+
+// ─── Dependency Edge ─────────────────────────────────────
+
+/** Dependency edge between artifacts */
+export const DependencyEdgeSchema = z.object({
+  from: ArtifactRefSchema,
+  to: ArtifactRefSchema,
+  relationship: z.enum(['depends_on', 'supersedes', 'references']),
+});
+export type DependencyEdge = z.infer<typeof DependencyEdgeSchema>;

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

@@ -0,0 +1,67 @@
+/**
+ * Audit types — findings, reports, severity classifications.
+ */
+
+import { z } from 'zod';
+import { PipelineRoleSchema } from './enums.js';
+import { ArtifactRefSchema } from './artifacts.js';
+
+// ─── Audit Severity & Category ───────────────────────────
+
+export const AuditSeveritySchema = z.enum(['P0', 'P1', 'P2', 'P3']);
+export type AuditSeverity = z.infer<typeof AuditSeveritySchema>;
+
+export const AuditCategorySchema = z.enum([
+  'integration',
+  'config',
+  'tests',
+  'schema',
+  'security',
+  'deployment',
+]);
+
+// ─── Audit Finding ───────────────────────────────────────
+
+export const AuditFindingSchema = z.object({
+  id: z.string(),
+  severity: AuditSeveritySchema,
+  category: AuditCategorySchema,
+  description: z.string(),
+  evidence: z.array(ArtifactRefSchema),
+  file_path: z.string().optional(),
+  line_number: z.number().int().optional(),
+  suggested_owner: PipelineRoleSchema,
+  blocking: z.boolean(),
+});
+export type AuditFinding = z.infer<typeof AuditFindingSchema>;
+
+// ─── Audit Report ────────────────────────────────────────
+
+export const AuditReportSchema = z.object({
+  audit_id: z.string(),
+  timestamp: z.string(),
+  repo_snapshot: ArtifactRefSchema,
+  overall_status: z.enum(['PASS', 'FAIL']),
+  findings: z.array(AuditFindingSchema),
+  system_risk_score: z.number().min(0).max(100),
+  recovery_required: z.boolean(),
+});
+export type AuditReport = z.infer<typeof AuditReportSchema>;
+
+// ─── Production Readiness ────────────────────────────────
+
+export const ProductionReadinessSchema = z.object({
+  production_id: z.string(),
+  timestamp: z.string(),
+  build_status: z.enum(['pass', 'fail', 'skip']),
+  test_status: z.enum(['pass', 'fail', 'skip']),
+  lint_status: z.enum(['pass', 'fail', 'skip']),
+  typecheck_status: z.enum(['pass', 'fail', 'skip']),
+  migration_status: z.enum(['pass', 'fail', 'skip', 'n/a']),
+  audit_status: z.enum(['PASS', 'FAIL']),
+  placeholder_scan_status: z.enum(['pass', 'fail', 'skip']),
+  security_status: z.enum(['pass', 'fail', 'skip']),
+  unresolved_blockers: z.array(z.string()),
+  final_verdict: z.enum(['PASS', 'FAIL']),
+});
+export type ProductionReadiness = z.infer<typeof ProductionReadinessSchema>;

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

@@ -0,0 +1,47 @@
+/**
+ * Gate check types — check definitions and results.
+ */
+
+import { z } from 'zod';
+import { ArtifactRefSchema } from './artifacts.js';
+
+// ─── Gate Check Types ────────────────────────────────────
+
+export const GateCheckTypeSchema = z.enum([
+  'build',
+  'test',
+  'lint',
+  'typecheck',
+  'migration',
+  'placeholder_scan',
+  'start',
+  'env_check',
+]);
+export type GateCheckType = z.infer<typeof GateCheckTypeSchema>;
+
+// ─── Gate Check Result ───────────────────────────────────
+
+export const GateCheckResultSchema = z.object({
+  check_type: GateCheckTypeSchema,
+  status: z.enum(['pass', 'fail', 'skip']),
+  command: z.string(),
+  exit_code: z.number().int(),
+  stdout_artifact: ArtifactRefSchema.optional(),
+  stderr_summary: z.string().optional(),
+  duration_ms: z.number(),
+  timestamp: z.string(),
+});
+export type GateCheckResult = z.infer<typeof GateCheckResultSchema>;
+
+// ─── Resolved Commands ───────────────────────────────────
+
+export const ResolvedCommandsSchema = z.object({
+  build: z.string().optional(),
+  test: z.string().optional(),
+  lint: z.string().optional(),
+  typecheck: z.string().optional(),
+  migrations: z.string().optional(),
+  start: z.string().optional(),
+  resolved_from: z.string(),
+});
+export type ResolvedCommands = z.infer<typeof ResolvedCommandsSchema>;

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

@@ -0,0 +1,62 @@
+/**
+ * Pipeline core enums — phase and role definitions.
+ */
+
+import { z } from 'zod';
+
+// ─── Pipeline Phases ─────────────────────────────────────
+
+export const PipelinePhaseSchema = z.enum([
+  'INTAKE',
+  'CONSENSUS_MASTER_PLAN',
+  'ARCHITECTURE',
+  'CONSENSUS_ARCHITECTURE',
+  'ROLE_PLANNING',
+  'CONSENSUS_ROLE_PLANS',
+  'IMPLEMENTATION',
+  'QA_VALIDATION',
+  'REVIEW',
+  'AUDIT',
+  'PRODUCTION_GATE',
+  'RECOVERY_LOOP',
+  'DONE',
+  'STUCK',
+]);
+export type PipelinePhase = z.infer<typeof PipelinePhaseSchema>;
+
+/** Ordered list of phases for sequential progression */
+export const PIPELINE_PHASE_ORDER: readonly PipelinePhase[] = [
+  'INTAKE',
+  'CONSENSUS_MASTER_PLAN',
+  'ARCHITECTURE',
+  'CONSENSUS_ARCHITECTURE',
+  'ROLE_PLANNING',
+  'CONSENSUS_ROLE_PLANS',
+  'IMPLEMENTATION',
+  'QA_VALIDATION',
+  'REVIEW',
+  'AUDIT',
+  'PRODUCTION_GATE',
+] as const;
+
+// ─── Pipeline Roles ──────────────────────────────────────
+
+export const PipelineRoleSchema = z.enum([
+  'DISPATCHER',
+  'ARCHITECT',
+  'DB_EXPERT',
+  'BACKEND_PROGRAMMER',
+  'FRONTEND_PROGRAMMER',
+  'WEBSITE_PROGRAMMER',
+  'QA_TESTER',
+  'REVIEWER',
+  'ARBITRATOR',
+  'DEBUGGER',
+  'AUDITOR',
+  'JOURNALIST',
+  'RELEASE_MANAGER',
+  'MARKETING_EXPERT',
+  'SOCIAL_EXPERT',
+  'UI_UX_SPECIALIST',
+]);
+export type PipelineRole = z.infer<typeof PipelineRoleSchema>;

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

@@ -0,0 +1,12 @@
+/**
+ * Pipeline types — barrel re-export.
+ * All existing `from '../pipeline/types.js'` imports continue to work.
+ */
+
+export * from './enums.js';
+export * from './artifacts.js';
+export * from './packets.js';
+export * from './audit.js';
+export * from './snapshot.js';
+export * from './checks.js';
+export * from './state.js';

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

@@ -0,0 +1,131 @@
+/**
+ * Structured packet types — plans, consensus, RCA, constraints, change requests.
+ */
+
+import { z } from 'zod';
+import { PipelinePhaseSchema, PipelineRoleSchema } from './enums.js';
+import { ArtifactRefSchema, DependencyEdgeSchema } from './artifacts.js';
+
+// ─── Constraint ──────────────────────────────────────────
+
+export const ConstraintSchema = z.object({
+  type: z.enum(['technical', 'business', 'timeline', 'compliance']),
+  description: z.string(),
+  source: ArtifactRefSchema,
+});
+export type Constraint = z.infer<typeof ConstraintSchema>;
+
+// ─── Plan Packet ─────────────────────────────────────────
+
+export const PlanPacketMetadataSchema = z.object({
+  packet_id: z.string(),
+  timestamp: z.string(),
+  phase: PipelinePhaseSchema,
+  submitted_by: PipelineRoleSchema,
+  version: z.number().int().positive(),
+});
+
+export const PlanPacketSchema = z.object({
+  metadata: PlanPacketMetadataSchema,
+  references: z.object({
+    master_plan: ArtifactRefSchema,
+    constitution: ArtifactRefSchema,
+    repo_snapshot: ArtifactRefSchema,
+  }),
+  proposed_artifacts: z.array(ArtifactRefSchema),
+  acceptance_criteria: z.array(z.string()),
+  artifact_dependencies: z.array(DependencyEdgeSchema),
+  constraints: z.array(ConstraintSchema),
+  open_questions: z.array(z.string()).optional(),
+});
+export type PlanPacket = z.infer<typeof PlanPacketSchema>;
+
+// ─── Reviewer Vote ───────────────────────────────────────
+
+export const ReviewerVoteSchema = z.object({
+  reviewer_id: z.string(),
+  provider: z.string(),
+  model: z.string(),
+  temperature: z.number(),
+  prompt_hash: z.string(),
+  vote: z.enum(['APPROVE', 'REJECT', 'CONDITIONAL']),
+  confidence: z.number().min(0).max(1),
+  blocking_issues: z.array(z.string()),
+  suggestions: z.array(z.string()),
+  evidence_refs: z.array(ArtifactRefSchema),
+});
+export type ReviewerVote = z.infer<typeof ReviewerVoteSchema>;
+
+// ─── Consensus Packet ────────────────────────────────────
+
+export const ConsensusRulesSchema = z.object({
+  threshold: z.number().min(0).max(1),
+  quorum: z.number().int().positive(),
+  min_reviewers: z.number().int().positive(),
+});
+
+export const ConsensusResultSchema = z.object({
+  approved: z.boolean(),
+  score: z.number().min(0).max(1),
+  weighted_score: z.number().min(0).max(1),
+  participating_reviewers: z.number().int(),
+});
+
+export const ArbitratorResultSchema = z.object({
+  decision: z.string(),
+  merged_patch: z.string().optional(),
+  artifact_ref: ArtifactRefSchema.optional(),
+});
+
+export const ConsensusPacketSchema = z.object({
+  metadata: z.object({
+    packet_id: z.string(),
+    timestamp: z.string(),
+    plan_packet_id: z.string(),
+  }),
+  plan_packet_reference: ArtifactRefSchema,
+  reviewer_votes: z.array(ReviewerVoteSchema),
+  consensus_rules: ConsensusRulesSchema,
+  consensus_result: ConsensusResultSchema,
+  arbitrator_result: ArbitratorResultSchema.optional(),
+  final_status: z.enum(['APPROVED', 'REJECTED', 'ARBITRATED']),
+});
+export type ConsensusPacket = z.infer<typeof ConsensusPacketSchema>;
+
+// ─── RCA Packet ──────────────────────────────────────────
+
+export const RCAPacketSchema = z.object({
+  rca_id: z.string(),
+  timestamp: z.string(),
+  incident_summary: z.string(),
+  symptoms: z.array(z.string()),
+  root_cause: z.string(),
+  responsible_layer: z.string(),
+  origin_phase: PipelinePhaseSchema,
+  governance_gap: z.string(),
+  corrective_actions: z.array(z.string()),
+  prevention: z.string(),
+  requires_phase_rewind_to: PipelinePhaseSchema.optional(),
+  requires_consensus_on: z.array(PipelinePhaseSchema).optional(),
+});
+export type RCAPacket = z.infer<typeof RCAPacketSchema>;
+
+// ─── Change Request ──────────────────────────────────────
+
+export const ChangeRequestSchema = z.object({
+  cr_id: z.string(),
+  timestamp: z.string(),
+  origin_phase: PipelinePhaseSchema,
+  requested_by: PipelineRoleSchema,
+  change_type: z.enum(['scope', 'architecture', 'dependency', 'config', 'requirement']),
+  description: z.string(),
+  justification: z.string(),
+  impact_analysis: z.object({
+    affected_artifacts: z.array(ArtifactRefSchema),
+    affected_phases: z.array(PipelinePhaseSchema),
+    risk_level: z.enum(['low', 'medium', 'high']),
+  }),
+  status: z.enum(['proposed', 'approved', 'rejected']),
+  approval_artifact: ArtifactRefSchema.optional(),
+});
+export type ChangeRequest = z.infer<typeof ChangeRequestSchema>;

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

@@ -0,0 +1,55 @@
+/**
+ * Repo snapshot types — project state capture for drift detection.
+ */
+
+import { z } from 'zod';
+
+// ─── Config File Entry ───────────────────────────────────
+
+export const ConfigFileEntrySchema = z.object({
+  path: z.string(),
+  type: z.string(),
+  content_hash: z.string(),
+  key_fields: z.record(z.string(), z.unknown()),
+});
+export type ConfigFileEntry = z.infer<typeof ConfigFileEntrySchema>;
+
+// ─── Port Entry ──────────────────────────────────────────
+
+export const PortEntrySchema = z.object({
+  port: z.number().int(),
+  service: z.string(),
+  source: z.string(),
+});
+export type PortEntry = z.infer<typeof PortEntrySchema>;
+
+// ─── Repo Snapshot ───────────────────────────────────────
+
+export const RepoSnapshotSchema = z.object({
+  snapshot_id: z.string(),
+  timestamp: z.string(),
+  tree_summary: z.string(),
+  config_files: z.array(ConfigFileEntrySchema),
+  languages_detected: z.array(z.string()),
+  package_manager: z.string().optional(),
+  scripts: z.record(z.string(), z.string()),
+  test_framework: z.string().optional(),
+  build_tool: z.string().optional(),
+  env_files: z.array(z.string()),
+  migrations_present: z.boolean(),
+  ports_entrypoints: z.array(PortEntrySchema),
+  total_files: z.number().int(),
+  total_lines: z.number().int(),
+});
+export type RepoSnapshot = z.infer<typeof RepoSnapshotSchema>;
+
+// ─── Snapshot Diff ───────────────────────────────────────
+
+/** Diff between two snapshots for drift detection */
+export interface SnapshotDiff {
+  files_added: string[];
+  files_removed: string[];
+  configs_changed: string[];
+  lines_delta: number;
+  has_drift: boolean;
+}

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

@@ -0,0 +1,167 @@
+/**
+ * Pipeline state types — the core mutable state, gate definitions, gate results.
+ */
+
+import { z } from 'zod';
+import { PipelinePhaseSchema, type PipelinePhase, PipelineRoleSchema, type PipelineRole } from './enums.js';
+import { ArtifactTypeSchema, ArtifactEntrySchema, ArtifactRefSchema, type ArtifactEntry } from './artifacts.js';
+import { GateCheckTypeSchema, GateCheckResultSchema, ResolvedCommandsSchema, type GateCheckType } from './checks.js';
+import type { ArtifactType } from './artifacts.js';
+import type { ConsensusPacket } from './packets.js';
+import type { RCAPacket } from './packets.js';
+
+// ─── Gate Definition ─────────────────────────────────────
+
+export const GateDefinitionSchema = z.object({
+  phase: PipelinePhaseSchema,
+  requiredArtifacts: z.array(ArtifactTypeSchema),
+  requiredChecks: z.array(GateCheckTypeSchema),
+  consensusThreshold: z.number().min(0).max(1).optional(),
+  minReviewers: z.number().int().positive().optional(),
+  allowedTransitions: z.array(PipelinePhaseSchema),
+  failTransition: PipelinePhaseSchema,
+});
+export type GateDefinition = z.infer<typeof GateDefinitionSchema>;
+
+// ─── Gate Result ─────────────────────────────────────────
+
+/** Result of evaluating a gate */
+export interface GateResult {
+  phase: PipelinePhase;
+  pass: boolean;
+  score?: number;
+  blockers: string[];
+  missingArtifacts: ArtifactType[];
+  failedChecks: GateCheckType[];
+  consensusScore?: number;
+  timestamp: string;
+}
+
+// ─── Skill Definition ────────────────────────────────────
+
+export interface SkillDefinition {
+  role: PipelineRole;
+  systemPrompt: string;
+  constraints: string[];
+  outputContract: string[];
+  requiredSections: string[];
+}
+
+// ─── Phase Result ────────────────────────────────────────
+
+export interface PhaseResult {
+  success: boolean;
+  phase: PipelinePhase;
+  artifacts: ArtifactEntry[];
+  errors?: string[];
+  /** For consensus phases: the consensus packet produced */
+  consensusPacket?: ConsensusPacket;
+  /** For recovery: the RCA packet produced */
+  rcaPacket?: RCAPacket;
+}
+
+// ─── Phase Context ───────────────────────────────────────
+
+/**
+ * Context passed to every phase handler.
+ * Defined as an interface so phase implementations can import it.
+ * The orchestrator constructs this before entering the phase loop.
+ */
+export interface PhaseContext {
+  projectDir: string;
+  pipeline: PipelineState;
+  skillsDir?: string;
+}
+
+// ─── Pipeline State ──────────────────────────────────────
+
+export const PipelineStateSchema = z.object({
+  pipelinePhase: PipelinePhaseSchema,
+  artifacts: z.array(ArtifactEntrySchema),
+  recoveryCount: z.number().int().min(0),
+  maxRecoveryIterations: z.number().int().positive(),
+  gateResults: z.record(z.string(), z.object({
+    phase: PipelinePhaseSchema,
+    pass: z.boolean(),
+    score: z.number().optional(),
+    blockers: z.array(z.string()),
+    missingArtifacts: z.array(ArtifactTypeSchema),
+    failedChecks: z.array(GateCheckTypeSchema),
+    consensusScore: z.number().optional(),
+    timestamp: z.string(),
+  })),
+  gateChecks: z.record(z.string(), z.array(GateCheckResultSchema)),
+  activeRoles: z.array(PipelineRoleSchema),
+  constitutionHash: z.string(),
+  latestRepoSnapshot: ArtifactRefSchema.optional(),
+  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(),
+    change_type: z.enum(['scope', 'architecture', 'dependency', 'config', 'requirement']),
+    target_phase: PipelinePhaseSchema,
+    status: z.enum(['proposed', 'approved', 'rejected']),
+  })).optional(),
+});
+export type PipelineState = z.infer<typeof PipelineStateSchema>;
+
+// ─── Pipeline Result ─────────────────────────────────────
+
+export interface PipelineResult {
+  finalPhase: PipelinePhase;
+  success: boolean;
+  artifacts: ArtifactEntry[];
+  recoveryIterations: number;
+  error?: string;
+}
+
+// ─── Consensus Modes ─────────────────────────────────────
+
+export type ConsensusMode = 'independent' | 'iterative';
+
+// ─── Helper: legacy phase mapping ────────────────────────
+
+/**
+ * Maps pipeline phases to the legacy 3-phase WorkflowPhase.
+ * Used for backward compatibility with existing state/UI code.
+ */
+export function toLegacyPhase(phase: PipelinePhase): 'plan' | 'execution' | 'complete' {
+  switch (phase) {
+    case 'INTAKE':
+    case 'CONSENSUS_MASTER_PLAN':
+    case 'ARCHITECTURE':
+    case 'CONSENSUS_ARCHITECTURE':
+    case 'ROLE_PLANNING':
+    case 'CONSENSUS_ROLE_PLANS':
+      return 'plan';
+    case 'IMPLEMENTATION':
+    case 'QA_VALIDATION':
+    case 'REVIEW':
+    case 'AUDIT':
+    case 'PRODUCTION_GATE':
+    case 'RECOVERY_LOOP':
+    case 'STUCK':
+      return 'execution';
+    case 'DONE':
+      return 'complete';
+  }
+}
+
+// ─── Default pipeline state factory ──────────────────────
+
+export function createDefaultPipelineState(): PipelineState {
+  return {
+    pipelinePhase: 'INTAKE',
+    artifacts: [],
+    recoveryCount: 0,
+    maxRecoveryIterations: 5,
+    gateResults: {},
+    gateChecks: {},
+    activeRoles: [],
+    constitutionHash: '',
+  };
+}

package/src/pipeline/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Pipeline type definitions — barrel re-export from type-defs/ sub-modules.
+ *
+ * All types are defined in src/pipeline/type-defs/ for modularity:
+ *   enums.ts     — PipelinePhase, PipelineRole
+ *   artifacts.ts — ArtifactType, ArtifactRef, ArtifactEntry, DependencyEdge
+ *   packets.ts   — PlanPacket, ConsensusPacket, ReviewerVote, RCAPacket, ChangeRequest
+ *   audit.ts     — AuditFinding, AuditReport, ProductionReadiness
+ *   snapshot.ts  — RepoSnapshot, ConfigFileEntry, PortEntry, SnapshotDiff
+ *   checks.ts    — GateCheckType, GateCheckResult, ResolvedCommands
+ *   state.ts     — PipelineState, GateResult, GateDefinition, SkillDefinition
+ *
+ * This file re-exports everything so existing imports work unchanged.
+ */
+
+export * from './type-defs/index.js';

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'),