cc-codeconductor 0.5.0 → 1.1.0

package/dist/library.js

@@ -0,0 +1,2744 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/validation/schemas.ts
+import { z } from "zod";
+function validateCouncilSpec(data) {
+  return CouncilSpecSchema.parse(data);
+}
+function validateProjectProfile(data) {
+  return ProjectProfileSchema.parse(data);
+}
+function validateConfig(data) {
+  return CodeConductorConfigSchema.parse(data);
+}
+function validateRunnerTarget(data) {
+  return RunnerTargetSchema.parse(data);
+}
+function validateModelConfig(data) {
+  return ModelConfigSchema.parse(data);
+}
+function validateAgentContract(data) {
+  return AgentContractSchema.parse(data);
+}
+function validateCouncilVerdictInput(data) {
+  return CouncilVerdictInputSchema.parse(data);
+}
+function validateConsensusConfig(data) {
+  return ConsensusConfigSchema.parse(data);
+}
+function validateCouncilVerdict(data) {
+  return CouncilVerdictSchema.parse(data);
+}
+function validateClaudeAgentFile(data) {
+  return ClaudeAgentFileSchema.parse(data);
+}
+function validateOpenCodeAgentFile(data) {
+  return OpenCodeAgentFileSchema.parse(data);
+}
+function validateGoalGraph(data) {
+  return GoalGraphSchema.parse(data);
+}
+function validateMemoryPointer(data) {
+  return MemoryPointerSchema.parse(data);
+}
+function validateMemoryIndex(data) {
+  return MemoryIndexSchema.parse(data);
+}
+function validateBacklogDocument(data) {
+  return BacklogDocumentSchema.parse(data);
+}
+function validateOpenspecState(data) {
+  return OpenspecStateSchema.parse(data);
+}
+function validateScorecardRecord(data) {
+  return ScorecardRecordSchema.parse(data);
+}
+function validateTaskOutcome(data) {
+  return TaskOutcomeSchema.parse(data);
+}
+function validateHarnessCatalog(data) {
+  return HarnessCatalogSchema.parse(data);
+}
+function validateHarnessOverlay(data) {
+  return HarnessOverlaySchema.parse(data);
+}
+function validateHarnessExperiment(data) {
+  return HarnessExperimentSchema.parse(data);
+}
+function validateHarnessSuite(data) {
+  return HarnessSuiteSchema.parse(data);
+}
+function validateCommandEnvelope(data) {
+  return CommandEnvelopeSchema.parse(data);
+}
+function validateWorkflowProfile(data) {
+  return WorkflowProfileSchema.parse(data);
+}
+function validateExecutionContext(data) {
+  return ExecutionContextSchema.parse(data);
+}
+function validatePlannerOutput(data) {
+  return PlannerOutputSchema.parse(data);
+}
+function validateAgentOutput(data) {
+  return AgentOutputSchema.parse(data);
+}
+function validateImplementerOutput(data) {
+  return ImplementerOutputSchema.parse(data);
+}
+function validateReviewerOutput(data) {
+  return ReviewerOutputSchema.parse(data);
+}
+function validateProductGraph(data) {
+  return ProductGraphSchema.parse(data);
+}
+function validateKnowledgeEntity(data) {
+  return KnowledgeEntitySchema.parse(data);
+}
+function validateDecision(data) {
+  return DecisionSchema.parse(data);
+}
+function validateEvidence(data) {
+  return EvidenceSchema.parse(data);
+}
+function validateCanonicalTaskCard(data) {
+  return CanonicalTaskCardSchema.parse(data);
+}
+function validateProductEvent(data) {
+  return ProductEventSchema.parse(data);
+}
+var CouncilAgentSpecSchema, CouncilSpecSchema, ProjectProfileSchema, CompileCheckConfigSchema, LoopConfigSchema, CodeConductorConfigSchema, RunnerTargetSchema, InstallStrategySchema, ManifestEntrySchema, InstallManifestSchema, ToolProviderNamesSchema, PermissionProviderNamesSchema, ModelConfigSchema, ContractTargetSchema, ContractFormatSchema, AgentContractSchema, CouncilFindingSchema, CouncilVerdictInputSchema, ConsensusConfigSchema, CouncilVerdictSchema, ClaudeAgentFileSchema, OpenCodeAgentFileSchema, SentryStackFrameSchema, SentryWebhookSchema, MemoryPointerSchema, MemoryIndexSchema, GoalTaskSchema, GoalGraphSchema, ConfidenceLevelSchema, ProductNodeTypeSchema, GraphRelationSchema, KnowledgeEntitySchema, DecisionSchema, EvidenceSchema, CanonicalTaskCardStatusSchema, CanonicalTaskCardSchema, ProductGraphNodeSchema, ProductGraphEdgeSchema, ProductGraphSchema, ProductMetaSchema, ProductEventTypeSchema, ProductEventSchema, OperationalStateSchema, StrategicMemorySchema, ImpactReportSchema, BusinessReviewOutputSchema, VerificationReportSchema, BacklogStatusSchema, BacklogTypeSchema, BacklogPrioritySchema, BacklogGlobalSchema, BacklogItemSchema, BacklogDocumentSchema, OpenspecTaskCardPhaseSchema, OpenspecTaskCardStatusSchema, OpenspecTaskCardSchema, OpenspecStateSchema, WorkflowCommandSchema, CcepOutputFormatSchema, CommandEnvelopeSchema, WorkflowPhaseSchema, WorkflowRiskRuleSchema, WorkflowProfileSchema, ExecutionContextSchema, PlannerOutputSchema, AgentArtifactSchema, AgentOutputSchema, ImplementerTestsSchema, ImplementerOutputSchema, ReviewAxisSchema, ReviewFindingSchema, ReviewerOutputSchema, TechnicalPlanOutputSchema, ScorecardVerdictSchema, ScorecardCriterionIdSchema, ScorecardCriterionSchema, ScorecardRecordSchema, TaskOutcomeSourceSchema, TaskOutcomeStatusSchema, TaskOutcomeSchema, HarnessComponentIdSchema, HarnessComponentLayerSchema, HarnessToggleKindSchema, HarnessCatalogEntrySchema, HarnessCatalogSchema, HarnessOverlaySchema, HarnessExperimentSchema, HarnessSuiteTaskSchema, HarnessSuiteSchema, EvaluationIndexSchema, ExecutionProfileNameSchema, ExecutionProfileSchema;
+var init_schemas = __esm(() => {
+  CouncilAgentSpecSchema = z.object({
+    id: z.string(),
+    role: z.string(),
+    context: z.enum(["repo-readonly", "prompt-only"]),
+    modelHint: z.enum([
+      "strong-reasoning",
+      "security-reasoning",
+      "balanced",
+      "practical-coding",
+      "analytical",
+      "adversarial"
+    ]),
+    focus: z.array(z.string())
+  });
+  CouncilSpecSchema = z.object({
+    name: z.string(),
+    version: z.string(),
+    description: z.string(),
+    outputContract: z.string(),
+    agents: z.array(CouncilAgentSpecSchema).min(1).refine((agents) => new Set(agents.map((a) => a.id.trim().toLowerCase())).size === agents.length, { message: "council agent ids must be unique" })
+  });
+  ProjectProfileSchema = z.object({
+    rootDir: z.string(),
+    languages: z.array(z.string()),
+    runtimes: z.array(z.string()),
+    packageManagers: z.array(z.string()),
+    frameworks: z.array(z.string()),
+    signals: z.array(z.string()),
+    confidence: z.enum(["low", "medium", "high"])
+  });
+  CompileCheckConfigSchema = z.object({
+    enabled: z.boolean(),
+    command: z.string().optional(),
+    timeoutMs: z.number().positive().optional()
+  });
+  LoopConfigSchema = z.object({
+    enabled: z.boolean().optional().default(true),
+    maxIterations: z.number().int().positive().optional().default(3),
+    maxTokenBudget: z.number().nonnegative().optional().default(0),
+    compaction: z.object({
+      enabled: z.boolean().optional().default(true),
+      historyFile: z.string().optional()
+    }).optional()
+  });
+  CodeConductorConfigSchema = z.object({
+    version: z.string(),
+    project: z.object({
+      name: z.string(),
+      profile: z.string().optional()
+    }),
+    defaults: z.object({
+      target: z.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
+      overwrite: z.boolean(),
+      locale: z.enum(["en", "es"]).optional().default("en")
+    }),
+    presets: z.object({
+      council: z.object({
+        enabled: z.boolean(),
+        version: z.string()
+      })
+    }),
+    safety: z.object({
+      destructiveCommands: z.array(z.string()),
+      secretPatterns: z.array(z.string()),
+      compileCheck: CompileCheckConfigSchema.optional()
+    }),
+    loop: LoopConfigSchema.optional()
+  });
+  RunnerTargetSchema = z.enum([
+    "opencode",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "agy",
+    "all"
+  ]);
+  InstallStrategySchema = z.enum([
+    "overwrite",
+    "append",
+    "merge-json",
+    "merge-managed",
+    "skip"
+  ]);
+  ManifestEntrySchema = z.object({
+    src: z.string(),
+    dest: z.string(),
+    strategy: InstallStrategySchema,
+    globalStrategy: InstallStrategySchema.optional(),
+    template: z.boolean().optional()
+  });
+  InstallManifestSchema = z.object({
+    target: z.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
+    entries: z.array(ManifestEntrySchema)
+  });
+  ToolProviderNamesSchema = z.record(z.string(), z.string());
+  PermissionProviderNamesSchema = z.record(z.string(), z.string());
+  ModelConfigSchema = z.object({
+    target: z.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]),
+    agents: z.record(z.string(), z.object({
+      claude: z.string().optional(),
+      opencode: z.string().optional(),
+      codex: z.string().optional(),
+      gemini: z.string().optional(),
+      cursor: z.string().optional(),
+      agy: z.string().optional(),
+      grok: z.string().optional()
+    })),
+    tools: z.record(z.string(), ToolProviderNamesSchema).optional(),
+    permissions: PermissionProviderNamesSchema.optional()
+  });
+  ContractTargetSchema = z.enum([
+    "claude",
+    "opencode",
+    "codex",
+    "gemini",
+    "cursor",
+    "agy"
+  ]);
+  ContractFormatSchema = z.object({
+    target: ContractTargetSchema,
+    options: z.record(z.unknown()).optional()
+  });
+  AgentContractSchema = z.object({
+    council: CouncilSpecSchema,
+    targets: z.array(ContractFormatSchema),
+    contractVersion: z.string(),
+    renderHints: z.record(ContractTargetSchema, z.record(z.unknown())).optional()
+  });
+  CouncilFindingSchema = z.object({
+    category: z.string(),
+    severity: z.enum(["info", "warning", "critical"]),
+    message: z.string(),
+    agentId: z.string()
+  });
+  CouncilVerdictInputSchema = z.object({
+    agentId: z.string().min(1).refine((id) => id.trim().length > 0),
+    agentRole: z.string(),
+    status: z.enum(["APPROVED", "REJECTED", "ABSTAIN"]),
+    securityVeto: z.boolean(),
+    complianceVeto: z.boolean().optional(),
+    confidence: z.number().min(0).max(1),
+    findings: z.array(CouncilFindingSchema),
+    summary: z.string()
+  });
+  ConsensusConfigSchema = z.object({
+    algorithm: z.enum(["majority", "unanimous"]),
+    allowSecurityVeto: z.boolean(),
+    allowComplianceVeto: z.boolean().optional(),
+    expectedAgentIds: z.array(z.string().min(1).refine((id) => id.trim().length > 0)).min(1).refine((ids) => new Set(ids.map((id) => id.trim().toLowerCase())).size === ids.length).optional(),
+    quorum: z.number().int().positive().optional(),
+    criticalFindingsPolicy: z.enum(["escalate", "reject", "ignore"]).optional()
+  }).refine((config) => config.algorithm !== "unanimous" || config.expectedAgentIds !== undefined, {
+    message: "unanimous consensus requires a non-empty expectedAgentIds roster",
+    path: ["expectedAgentIds"]
+  }).refine((config) => !config.allowSecurityVeto || config.expectedAgentIds === undefined || config.expectedAgentIds.some((id) => id.toLowerCase().includes("security")), {
+    message: "allowSecurityVeto requires at least one security agent in expectedAgentIds",
+    path: ["expectedAgentIds"]
+  });
+  CouncilVerdictSchema = z.object({
+    status: z.enum(["APPROVED", "REJECTED", "ESCALATED"]),
+    totalAgents: z.number(),
+    approvedCount: z.number(),
+    rejectedCount: z.number(),
+    abstainedCount: z.number(),
+    vetoApplied: z.boolean(),
+    complianceVetoApplied: z.boolean().optional(),
+    vetoByAgentId: z.string().optional(),
+    averageConfidence: z.number().min(0).max(1).optional(),
+    findings: z.array(CouncilFindingSchema),
+    summary: z.string(),
+    individualVerdicts: z.array(CouncilVerdictInputSchema)
+  });
+  ClaudeAgentFileSchema = z.object({
+    path: z.string().startsWith(".claude/"),
+    content: z.string(),
+    overwrite: z.boolean()
+  });
+  OpenCodeAgentFileSchema = z.object({
+    path: z.string().startsWith(".opencode/"),
+    content: z.string(),
+    overwrite: z.boolean()
+  });
+  SentryStackFrameSchema = z.object({
+    filename: z.string(),
+    function: z.string(),
+    lineNo: z.number(),
+    colNo: z.number().optional(),
+    context: z.array(z.string())
+  });
+  SentryWebhookSchema = z.object({
+    issueId: z.string(),
+    title: z.string(),
+    culprit: z.string(),
+    filename: z.string().optional(),
+    stackTrace: z.array(SentryStackFrameSchema),
+    environment: z.string().optional(),
+    release: z.string().optional()
+  });
+  MemoryPointerSchema = z.object({
+    topic_key: z.string().min(1).max(128),
+    id: z.number().int().positive(),
+    file: z.string().min(1),
+    summary: z.string().min(1).max(200),
+    timestamp: z.string().datetime(),
+    tags: z.array(z.string().max(64)).max(10).optional().default([])
+  });
+  MemoryIndexSchema = z.object({
+    version: z.literal(1),
+    pointers: z.array(MemoryPointerSchema)
+  });
+  GoalTaskSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    type: z.enum(["feature", "fix", "refactor", "test", "docs"]),
+    risk: z.enum(["low", "medium", "high"]),
+    status: z.enum(["pending", "in-progress", "done", "blocked"]),
+    depends_on: z.array(z.string()).optional().default([]),
+    acceptance_criteria: z.array(z.string()),
+    blocked_reason: z.string().optional(),
+    context_scope: z.enum(["isolated", "continuation", "full"]).optional().default("isolated")
+  });
+  GoalGraphSchema = z.object({
+    objective: z.string(),
+    tasks: z.array(GoalTaskSchema),
+    created_at: z.string()
+  });
+  ConfidenceLevelSchema = z.enum(["low", "medium", "high"]);
+  ProductNodeTypeSchema = z.enum([
+    "product",
+    "domain",
+    "capability",
+    "requirement",
+    "decision",
+    "component",
+    "flow",
+    "contract",
+    "metric",
+    "risk",
+    "task",
+    "evidence"
+  ]);
+  GraphRelationSchema = z.enum([
+    "implements",
+    "depends_on",
+    "documents",
+    "affects",
+    "evidences",
+    "blocks",
+    "contains"
+  ]);
+  KnowledgeEntitySchema = z.object({
+    type: ProductNodeTypeSchema,
+    id: z.string(),
+    name: z.string(),
+    source: z.string(),
+    version: z.string().optional(),
+    confidence: ConfidenceLevelSchema,
+    relations: z.array(z.object({
+      targetId: z.string(),
+      relation: GraphRelationSchema
+    })).default([]),
+    data: z.record(z.string(), z.unknown()).optional().default({})
+  });
+  DecisionSchema = z.object({
+    id: z.string(),
+    context: z.string(),
+    alternatives: z.array(z.string()).default([]),
+    chosenOption: z.string(),
+    rationale: z.string(),
+    consequences: z.array(z.string()).default([]),
+    date: z.string(),
+    linkedTasks: z.array(z.string()).default([]),
+    linkedComponents: z.array(z.string()).default([]),
+    source: z.string().optional()
+  });
+  EvidenceSchema = z.object({
+    id: z.string(),
+    source: z.string(),
+    type: z.string(),
+    timestamp: z.string(),
+    relatedTask: z.string().optional(),
+    relatedDecision: z.string().optional(),
+    confidence: z.number().min(0).max(1),
+    checksum: z.string().optional(),
+    summary: z.string().optional(),
+    data: z.record(z.string(), z.unknown()).optional()
+  });
+  CanonicalTaskCardStatusSchema = z.enum([
+    "draft",
+    "ready",
+    "in-progress",
+    "review",
+    "done",
+    "blocked"
+  ]);
+  CanonicalTaskCardSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    objective: z.string(),
+    context: z.string(),
+    acceptanceCriteria: z.array(z.string()),
+    dependencies: z.array(z.string()).default([]),
+    constraints: z.array(z.string()).default([]),
+    risk: z.enum(["low", "medium", "high"]),
+    targetFiles: z.array(z.string()).default([]),
+    agentType: z.string(),
+    evidenceRequired: z.array(z.string()).default([]),
+    status: CanonicalTaskCardStatusSchema,
+    type: z.enum(["feature", "fix", "refactor", "review", "docs", "test"]),
+    linkedCapabilities: z.array(z.string()).default([]),
+    boundaries: z.array(z.string()).default([]),
+    requiresHumanReview: z.boolean().optional(),
+    requiresTests: z.boolean().optional(),
+    contextScope: z.enum(["isolated", "continuation", "full"]).optional(),
+    actualBehavior: z.string().optional(),
+    expectedBehavior: z.string().optional(),
+    reproductionSteps: z.array(z.string()).optional(),
+    domain: z.string().optional(),
+    authorization: z.string().optional()
+  });
+  ProductGraphNodeSchema = z.object({
+    id: z.string(),
+    type: ProductNodeTypeSchema,
+    name: z.string(),
+    data: z.record(z.string(), z.unknown()).default({}),
+    source: z.string().optional(),
+    confidence: ConfidenceLevelSchema.optional(),
+    version: z.string().optional()
+  });
+  ProductGraphEdgeSchema = z.object({
+    from: z.string(),
+    to: z.string(),
+    relation: GraphRelationSchema
+  });
+  ProductGraphSchema = z.object({
+    version: z.literal(1),
+    productId: z.string(),
+    productName: z.string(),
+    nodes: z.array(ProductGraphNodeSchema),
+    edges: z.array(ProductGraphEdgeSchema),
+    updatedAt: z.string()
+  });
+  ProductMetaSchema = z.object({
+    version: z.literal(1),
+    graphVersion: z.string(),
+    lastIngestAt: z.string().optional(),
+    sourceHashes: z.record(z.string(), z.string()).default({})
+  });
+  ProductEventTypeSchema = z.enum([
+    "task.started",
+    "task.completed",
+    "decision.recorded",
+    "evidence.added",
+    "ingest.completed",
+    "goal.updated",
+    "blocker.detected",
+    "verification.completed",
+    "feedback.processed"
+  ]);
+  ProductEventSchema = z.object({
+    id: z.string(),
+    type: ProductEventTypeSchema,
+    timestamp: z.string(),
+    payload: z.record(z.string(), z.unknown()).default({})
+  });
+  OperationalStateSchema = z.object({
+    version: z.literal(1),
+    activeAgents: z.array(z.string()).default([]),
+    activeTaskIds: z.array(z.string()).default([]),
+    blockers: z.array(z.object({
+      taskId: z.string(),
+      reason: z.string(),
+      since: z.string()
+    })).default([]),
+    sprintFocus: z.string().optional(),
+    updatedAt: z.string()
+  });
+  StrategicMemorySchema = z.object({
+    version: z.literal(1),
+    kpis: z.array(z.object({
+      name: z.string(),
+      target: z.string(),
+      current: z.string().optional()
+    })).default([]),
+    quarterlyFocus: z.string().optional(),
+    tradeoffs: z.array(z.string()).default([]),
+    updatedAt: z.string()
+  });
+  ImpactReportSchema = z.object({
+    target: z.string(),
+    brokenEndpoints: z.array(z.string()).default([]),
+    brokenContracts: z.array(z.string()).default([]),
+    affectedTests: z.array(z.string()).default([]),
+    affectedFlows: z.array(z.string()).default([]),
+    affectedComponents: z.array(z.string()).default([]),
+    summary: z.string()
+  });
+  BusinessReviewOutputSchema = z.object({
+    status: z.enum(["proceed", "defer", "reject"]),
+    roiEstimate: z.string().optional(),
+    userImpact: z.string().optional(),
+    eliminationRisk: z.string().optional(),
+    questions: z.array(z.string()).default([]),
+    confidence: z.number().min(0).max(1)
+  });
+  VerificationReportSchema = z.object({
+    taskId: z.string(),
+    passed: z.boolean(),
+    checks: z.array(z.object({
+      name: z.string(),
+      passed: z.boolean(),
+      message: z.string()
+    })),
+    evidenceIds: z.array(z.string()).default([]),
+    confidence: z.number().min(0).max(1)
+  });
+  BacklogStatusSchema = z.enum([
+    "TODO",
+    "READY",
+    "PLANNED",
+    "IN_PROGRESS",
+    "BLOCKED",
+    "REVIEW",
+    "DONE"
+  ]);
+  BacklogTypeSchema = z.enum(["feature", "bug", "refactor", "tech-debt"]);
+  BacklogPrioritySchema = z.enum(["P0", "P1", "P2", "P3"]);
+  BacklogGlobalSchema = z.object({
+    product: z.string().min(1),
+    strategy: z.string().min(1),
+    policy: z.string().min(1),
+    reviewRequired: z.boolean(),
+    tddRequired: z.boolean()
+  });
+  BacklogItemSchema = z.object({
+    id: z.string().regex(/^BC-\d{3,}$/),
+    title: z.string().min(1),
+    priority: BacklogPrioritySchema,
+    status: BacklogStatusSchema,
+    type: BacklogTypeSchema,
+    owner: z.string().optional(),
+    dependencies: z.array(z.string()).default([]),
+    description: z.string().min(1),
+    scope: z.string().min(1),
+    outOfScope: z.string().default(""),
+    businessValue: z.string().optional(),
+    acceptanceCriteria: z.array(z.string().min(1)).min(1),
+    risks: z.string().optional(),
+    progress: z.number().int().min(0).max(100),
+    branch: z.string().optional(),
+    reviewer: z.string().optional(),
+    lastUpdate: z.string().optional()
+  });
+  BacklogDocumentSchema = z.object({
+    global: BacklogGlobalSchema,
+    items: z.array(BacklogItemSchema),
+    archive: z.array(BacklogItemSchema).default([])
+  });
+  OpenspecTaskCardPhaseSchema = z.enum([
+    "discover",
+    "design",
+    "implement",
+    "test",
+    "review"
+  ]);
+  OpenspecTaskCardStatusSchema = z.enum(["pending", "doing", "blocked", "done"]);
+  OpenspecTaskCardSchema = z.object({
+    id: z.string(),
+    backlogId: z.string(),
+    phase: OpenspecTaskCardPhaseSchema,
+    title: z.string(),
+    prompt: z.string(),
+    agent: z.string(),
+    modelHint: z.string().optional(),
+    dependsOn: z.array(z.string()).default([]),
+    acceptanceCriteria: z.array(z.string()),
+    status: OpenspecTaskCardStatusSchema,
+    itemHash: z.string().optional()
+  });
+  OpenspecStateSchema = z.object({
+    version: z.literal(1),
+    activeItemId: z.string().optional(),
+    taskCards: z.array(OpenspecTaskCardSchema).default([]),
+    lastScanHash: z.string().optional(),
+    lastScanAt: z.string().optional(),
+    changePaths: z.record(z.string(), z.string()).optional().default({}),
+    itemSnapshots: z.record(z.string(), z.string()).optional().default({})
+  });
+  WorkflowCommandSchema = z.enum([
+    "feature",
+    "fix",
+    "refactor",
+    "review",
+    "test-plan",
+    "tdd-cycle",
+    "api-contract",
+    "db-migration",
+    "pagespeed",
+    "openspec",
+    "backlog",
+    "scorecard",
+    "council",
+    "iterative",
+    "explore",
+    "triage",
+    "prototype",
+    "handoff",
+    "clarify",
+    "security"
+  ]);
+  CcepOutputFormatSchema = z.enum(["taskcard", "plan", "verdict"]);
+  CommandEnvelopeSchema = z.object({
+    protocolVersion: z.literal("ccep-1"),
+    command: WorkflowCommandSchema,
+    userRequest: z.string(),
+    projectId: z.string(),
+    repoContext: z.object({
+      domain: z.string().optional(),
+      stack: z.array(z.string()),
+      existingModules: z.array(z.string()).default([]),
+      architecture: z.string().optional()
+    }),
+    constraints: z.object({
+      outputFormat: CcepOutputFormatSchema,
+      needConfirmation: z.boolean(),
+      riskThreshold: z.enum(["low", "medium", "high"])
+    }),
+    executionPolicy: z.object({
+      modelMode: z.literal("structured"),
+      maxVariance: z.literal("low")
+    })
+  });
+  WorkflowPhaseSchema = z.object({
+    id: z.string(),
+    agent: z.string().optional(),
+    agents: z.array(z.string()).optional(),
+    skill: z.string().optional(),
+    type: z.string().optional(),
+    outputSchema: z.string().optional(),
+    stopGate: z.string().optional(),
+    dependsOn: z.array(z.string()).optional(),
+    requires: z.string().optional(),
+    parallelWith: z.array(z.string()).optional()
+  });
+  WorkflowRiskRuleSchema = z.object({
+    when: z.object({
+      risk: z.union([
+        z.enum(["low", "medium", "high"]),
+        z.array(z.enum(["low", "medium", "high"]))
+      ])
+    }),
+    then: z.array(z.string())
+  });
+  WorkflowProfileSchema = z.object({
+    id: z.string(),
+    version: z.number().int().positive(),
+    command: WorkflowCommandSchema,
+    taskCard: z.object({
+      type: z.string(),
+      requiredFields: z.array(z.string()),
+      optionalFields: z.array(z.string()).optional()
+    }).optional(),
+    intakeSchema: z.string().optional(),
+    phases: z.array(WorkflowPhaseSchema),
+    routing: z.object({
+      default: z.array(z.string()),
+      riskRules: z.array(WorkflowRiskRuleSchema).optional()
+    }),
+    confirmationGate: z.object({
+      stopOnHighRisk: z.boolean(),
+      stopOnQuestions: z.boolean()
+    })
+  }).refine((profile) => profile.id === profile.command, {
+    message: "Workflow profile id must match command"
+  });
+  ExecutionContextSchema = z.object({
+    envelope: CommandEnvelopeSchema,
+    profile: WorkflowProfileSchema,
+    intent: z.object({
+      type: WorkflowCommandSchema,
+      goal: z.string(),
+      domain: z.string().optional(),
+      entity: z.string().optional(),
+      operation: z.string().optional()
+    }),
+    project: z.object({
+      name: z.string(),
+      rootDir: z.string(),
+      stack: z.array(z.string()).optional()
+    }),
+    knowledge: z.record(z.string(), z.unknown()).default({}),
+    ast: z.object({
+      source: z.enum(["detect", "graphify", "manual", "product-graph"]),
+      confidence: z.enum(["low", "medium", "high"]),
+      domains: z.array(z.unknown()).optional(),
+      rules: z.array(z.string()).optional()
+    }),
+    policies: z.object({
+      architecture: z.string(),
+      testing: z.string(),
+      documentation: z.string(),
+      breakingChanges: z.string()
+    }),
+    currentPhase: z.string().optional(),
+    outputSchema: z.string()
+  });
+  PlannerOutputSchema = z.object({
+    status: z.enum(["success", "needs_clarification"]),
+    confidence: z.number().min(0).max(1),
+    goal: z.string(),
+    assumptions: z.array(z.string()),
+    risks: z.array(z.object({
+      type: z.string(),
+      description: z.string(),
+      severity: z.enum(["low", "medium", "high"])
+    })),
+    tasks: z.array(z.object({
+      id: z.string(),
+      title: z.string(),
+      priority: z.string(),
+      estimate: z.string(),
+      dependencies: z.array(z.string())
+    })),
+    questionsForUser: z.array(z.string()),
+    needsConfirmation: z.boolean()
+  });
+  AgentArtifactSchema = z.object({
+    type: z.string(),
+    path: z.string().optional(),
+    content: z.string().optional()
+  });
+  AgentOutputSchema = z.object({
+    status: z.enum(["success", "failure", "blocked", "needs_clarification"]),
+    confidence: z.number().min(0).max(1),
+    warnings: z.array(z.string()).default([]),
+    artifacts: z.array(AgentArtifactSchema).default([]),
+    next_actions: z.array(z.string()).default([])
+  });
+  ImplementerTestsSchema = z.object({
+    runner: z.string(),
+    result: z.enum(["passed", "failed"]),
+    failedTests: z.array(z.string()).optional()
+  });
+  ImplementerOutputSchema = AgentOutputSchema.extend({
+    status: z.enum(["success", "failure", "blocked"]),
+    filesChanged: z.array(z.object({
+      path: z.string(),
+      summary: z.string()
+    })).default([]),
+    tests: ImplementerTestsSchema.optional()
+  });
+  ReviewAxisSchema = z.enum([
+    "complexity",
+    "cost",
+    "performance",
+    "maintainability",
+    "security",
+    "scalability",
+    "style"
+  ]);
+  ReviewFindingSchema = z.object({
+    severity: z.enum(["CRITICAL", "WARNING", "SUGGESTION"]),
+    message: z.string(),
+    axis: z.union([ReviewAxisSchema, z.string()]),
+    path: z.string().optional(),
+    line: z.number().int().optional()
+  });
+  ReviewerOutputSchema = z.object({
+    status: z.enum(["pass", "fail"]),
+    confidence: z.number().min(0).max(1),
+    verdict: z.enum(["approved", "approved_with_warnings", "blocked"]),
+    warnings: z.array(z.string()).default([]),
+    findings: z.array(ReviewFindingSchema).default([]),
+    artifacts: z.array(AgentArtifactSchema).default([]),
+    next_actions: z.array(z.string()).default([])
+  });
+  TechnicalPlanOutputSchema = z.object({
+    approach: z.string(),
+    filesAffected: z.array(z.string()).default([]),
+    risks: z.array(z.string()).default([]),
+    openQuestions: z.array(z.string()).optional()
+  });
+  ScorecardVerdictSchema = z.enum(["PASS", "REVISE", "REJECT"]);
+  ScorecardCriterionIdSchema = z.enum([
+    "acceptance",
+    "minimal_diff",
+    "tests",
+    "regressions",
+    "conventions",
+    "documentation",
+    "context_discipline",
+    "cc_gain"
+  ]);
+  ScorecardCriterionSchema = z.object({
+    id: ScorecardCriterionIdSchema,
+    label: z.string(),
+    weight: z.number().min(0).max(1),
+    score: z.number().int().min(0).max(3),
+    notes: z.string().optional(),
+    autoSuggested: z.boolean().optional()
+  });
+  ScorecardRecordSchema = z.object({
+    id: z.string(),
+    taskId: z.string(),
+    agent: z.string(),
+    model: z.string().optional(),
+    contractVersion: z.string(),
+    evaluator: z.string().optional(),
+    criteria: z.array(ScorecardCriterionSchema),
+    weightedScore: z.number(),
+    verdict: ScorecardVerdictSchema,
+    findings: z.array(z.string()).optional().default([]),
+    createdAt: z.string(),
+    backlogId: z.string().optional(),
+    source: z.enum(["openspec", "review", "manual", "pipeline"]).optional()
+  });
+  TaskOutcomeSourceSchema = z.enum(["openspec", "review", "manual", "pipeline"]);
+  TaskOutcomeStatusSchema = z.enum([
+    "phase_done",
+    "phase_failed",
+    "pass",
+    "revise",
+    "reject"
+  ]);
+  TaskOutcomeSchema = z.object({
+    id: z.string(),
+    taskId: z.string(),
+    source: TaskOutcomeSourceSchema,
+    agent: z.string(),
+    model: z.string(),
+    contractVersion: z.string(),
+    timestamp: z.string(),
+    status: TaskOutcomeStatusSchema.optional(),
+    verdict: ScorecardVerdictSchema.optional(),
+    weightedScore: z.number().optional(),
+    taskCardId: z.string().optional(),
+    backlogId: z.string().optional(),
+    phase: z.string().optional(),
+    scorecardId: z.string().optional(),
+    tokensIn: z.number().optional(),
+    tokensOut: z.number().optional(),
+    costUsd: z.number().optional(),
+    durationMs: z.number().optional(),
+    experimentId: z.string().optional(),
+    variantId: z.string().optional(),
+    suiteTaskId: z.string().optional(),
+    harnessFingerprint: z.string().optional(),
+    disabledComponents: z.array(z.string()).optional()
+  });
+  HarnessComponentIdSchema = z.enum([
+    "wayfinding",
+    "intake",
+    "design",
+    "test_first",
+    "review",
+    "docs",
+    "confirmation_gates",
+    "compile_loop",
+    "council",
+    "product_graph"
+  ]);
+  HarnessComponentLayerSchema = z.enum([
+    "phase",
+    "gate",
+    "loop",
+    "knowledge",
+    "council"
+  ]);
+  HarnessToggleKindSchema = z.enum([
+    "ccep_phase",
+    "ccep_gates",
+    "config_loop",
+    "config_council",
+    "product_graph"
+  ]);
+  HarnessCatalogEntrySchema = z.object({
+    id: HarnessComponentIdSchema,
+    layer: HarnessComponentLayerSchema,
+    label: z.string(),
+    defaultOn: z.boolean().default(true),
+    toggle: z.object({
+      kind: HarnessToggleKindSchema,
+      phaseId: z.string().optional()
+    })
+  });
+  HarnessCatalogSchema = z.object({
+    version: z.literal(1),
+    components: z.array(HarnessCatalogEntrySchema).min(1)
+  });
+  HarnessOverlaySchema = z.object({
+    experimentId: z.string().optional(),
+    variantId: z.string(),
+    disabledComponents: z.array(HarnessComponentIdSchema),
+    disableProductGraph: z.boolean().optional().default(false),
+    contractVersion: z.string().optional(),
+    ccepProfile: z.string().optional().default("feature")
+  });
+  HarnessExperimentSchema = z.object({
+    id: z.string(),
+    suiteId: z.string(),
+    createdAt: z.string(),
+    contractVersion: z.string(),
+    components: z.array(HarnessComponentIdSchema),
+    variants: z.array(z.string()).min(1),
+    suiteTaskIds: z.array(z.string()),
+    suitePath: z.string().optional()
+  });
+  HarnessSuiteTaskSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    type: z.enum(["feature", "fix", "refactor"]),
+    risk: z.enum(["low", "medium", "high"]).default("low"),
+    prompt: z.string(),
+    scope: z.string(),
+    acceptanceCriteria: z.array(z.string()).min(1),
+    testCommand: z.string().optional()
+  });
+  HarnessSuiteSchema = z.object({
+    id: z.string(),
+    version: z.number().int().positive(),
+    fixtureDir: z.string().optional(),
+    tasks: z.array(HarnessSuiteTaskSchema).min(1)
+  });
+  EvaluationIndexSchema = z.object({
+    version: z.literal(1),
+    lastOutcomeId: z.string().optional()
+  });
+  ExecutionProfileNameSchema = z.enum(["balanced", "quality", "economical"]);
+  ExecutionProfileSchema = z.object({
+    profile: ExecutionProfileNameSchema.default("balanced"),
+    target: z.enum(["opencode", "claude", "codex", "gemini", "cursor", "agy"]).optional(),
+    overrides: z.record(z.string(), z.string()).optional().default({}),
+    subagentPolicy: z.object({
+      orchestrator: z.enum(["primary", "delegate"]).optional(),
+      testerReviewer: z.enum(["primary", "delegate"]).optional()
+    }).optional()
+  });
+});
+
+// src/utils/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+
+// src/core/goal/goal-state.ts
+var exports_goal_state = {};
+__export(exports_goal_state, {
+  writeGoal: () => writeGoal,
+  markTaskBlocked: () => markTaskBlocked,
+  loadGoal: () => loadGoal
+});
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parse, stringify } from "yaml";
+function validateGoalGraph2(graph) {
+  const ids = new Set(graph.tasks.map((t) => t.id));
+  if (ids.size !== graph.tasks.length) {
+    return err(new Error("Duplicate task IDs in goal graph"));
+  }
+  for (const task of graph.tasks) {
+    for (const dep of task.depends_on ?? []) {
+      if (!ids.has(dep)) {
+        return err(new Error(`Task "${task.id}" depends on unknown task "${dep}"`));
+      }
+    }
+  }
+  const visited = new Set;
+  const inStack = new Set;
+  function dfs(taskId) {
+    if (inStack.has(taskId))
+      return true;
+    if (visited.has(taskId))
+      return false;
+    visited.add(taskId);
+    inStack.add(taskId);
+    const task = graph.tasks.find((t) => t.id === taskId);
+    if (task) {
+      for (const dep of task.depends_on ?? []) {
+        if (dfs(dep))
+          return true;
+      }
+    }
+    inStack.delete(taskId);
+    return false;
+  }
+  for (const task of graph.tasks) {
+    if (dfs(task.id)) {
+      return err(new Error(`Cycle detected involving task "${task.id}"`));
+    }
+  }
+  return ok(graph);
+}
+async function writeGoal(projectRoot, graph) {
+  const validation = validateGoalGraph2(graph);
+  if (!validation.success)
+    return validation;
+  const dir = resolve(projectRoot, ".codeconductor");
+  await mkdir2(dir, { recursive: true });
+  const yaml = stringify(graph);
+  await writeFile2(resolve(dir, "current-goal.yml"), yaml, "utf-8");
+  return ok(undefined);
+}
+async function loadGoal(projectRoot) {
+  try {
+    const filePath = resolve(projectRoot, GOAL_FILE);
+    const content = await readFile2(filePath, "utf-8");
+    const data = parse(content);
+    const validated = GoalGraphSchema.parse(data);
+    return validateGoalGraph2(validated);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function markTaskBlocked(projectRoot, taskId, reason) {
+  const loadResult = await loadGoal(projectRoot);
+  if (!loadResult.success)
+    return loadResult;
+  const graph = loadResult.data;
+  const task = graph.tasks.find((t) => t.id === taskId);
+  if (!task) {
+    return err(new Error(`Task "${taskId}" not found in goal graph`));
+  }
+  task.status = "blocked";
+  task.blocked_reason = reason;
+  return writeGoal(projectRoot, graph);
+}
+var GOAL_FILE = ".codeconductor/current-goal.yml";
+var init_goal_state = __esm(() => {
+  init_schemas();
+});
+
+// src/core/product-graph/graph-store.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+init_schemas();
+
+// src/core/product-graph/paths.ts
+import { join } from "node:path";
+var PRODUCT_DIR = ".codeconductor";
+var PRODUCT_GRAPH_FILE = "product-graph.json";
+var EVENTS_FILE = "events.jsonl";
+var OPERATIONAL_STATE_FILE = "operational-state.json";
+var EVIDENCE_DIR = "evidence";
+function productGraphPath(projectRoot) {
+  return join(projectRoot, PRODUCT_DIR, PRODUCT_GRAPH_FILE);
+}
+function eventsPath(projectRoot) {
+  return join(projectRoot, PRODUCT_DIR, EVENTS_FILE);
+}
+function operationalStatePath(projectRoot) {
+  return join(projectRoot, PRODUCT_DIR, OPERATIONAL_STATE_FILE);
+}
+function evidenceDir(projectRoot) {
+  return join(projectRoot, PRODUCT_DIR, EVIDENCE_DIR);
+}
+
+// src/core/product-graph/graph-store.ts
+async function loadGraph(projectRoot) {
+  try {
+    const raw = await readFile(productGraphPath(projectRoot), "utf-8");
+    return ok(ProductGraphSchema.parse(JSON.parse(raw)));
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return err(new Error("Product graph not found. Run `cc ingest` first."));
+    }
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+function queryNodes(graph, type, textFilter) {
+  let nodes = graph.nodes;
+  if (type) {
+    nodes = nodes.filter((n) => n.type === type);
+  }
+  if (textFilter) {
+    const q = textFilter.toLowerCase();
+    nodes = nodes.filter((n) => n.name.toLowerCase().includes(q) || n.id.toLowerCase().includes(q) || JSON.stringify(n.data).toLowerCase().includes(q));
+  }
+  return nodes;
+}
+
+// src/core/planner/product-planner.ts
+var RISK_TO_AGENT = {
+  low: "implementer",
+  medium: "architect",
+  high: "task-coach"
+};
+function inferAgentType(task) {
+  if (task.type === "test")
+    return "tester";
+  if (task.type === "docs")
+    return "docs";
+  if (task.risk === "high" && task.type === "feature")
+    return "architect";
+  return RISK_TO_AGENT[task.risk] ?? "implementer";
+}
+function inferTargetFiles(task, graph) {
+  if (!graph)
+    return [];
+  const keywords = task.title.toLowerCase().split(/\s+/);
+  const components = queryNodes(graph, "component");
+  const matched = [];
+  for (const node of components) {
+    const path = node.data.path;
+    if (!path)
+      continue;
+    const nameLower = node.name.toLowerCase();
+    if (keywords.some((k) => nameLower.includes(k) || path.toLowerCase().includes(k))) {
+      matched.push(path);
+    }
+  }
+  return matched.slice(0, 10);
+}
+function inferEvidenceRequired(task) {
+  const base = ["acceptance_criteria_met"];
+  if (task.type === "test" || task.risk !== "low") {
+    base.push("tests_passed");
+  }
+  if (task.risk === "high") {
+    base.push("review_approved");
+  }
+  return base;
+}
+function enrichGoalWithProduct(graph, productGraph) {
+  const enrichedTasks = graph.tasks.map((task) => ({
+    ...task,
+    targetFiles: inferTargetFiles(task, productGraph),
+    agentType: inferAgentType(task),
+    evidenceRequired: inferEvidenceRequired(task)
+  }));
+  return { ...graph, enrichedTasks };
+}
+
+// src/core/orchestrator/runtime-orchestrator.ts
+init_goal_state();
+
+// src/core/memory/episodic-store.ts
+init_schemas();
+import { appendFile, mkdir as mkdir3, readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+async function appendEvent(projectRoot, event) {
+  try {
+    const full = ProductEventSchema.parse({
+      ...event,
+      id: event.id ?? `evt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+    });
+    const path = eventsPath(projectRoot);
+    await mkdir3(resolve2(projectRoot, ".codeconductor"), { recursive: true });
+    await appendFile(path, JSON.stringify(full) + `
+`, "utf-8");
+    return ok(full);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+
+// src/core/memory/operational-state.ts
+init_schemas();
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+async function loadOperationalState(projectRoot) {
+  try {
+    const raw = await readFile4(operationalStatePath(projectRoot), "utf-8");
+    return ok(OperationalStateSchema.parse(JSON.parse(raw)));
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return ok({
+        version: 1,
+        activeAgents: [],
+        activeTaskIds: [],
+        blockers: [],
+        updatedAt: new Date().toISOString()
+      });
+    }
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function saveOperationalState(projectRoot, state) {
+  try {
+    const validated = OperationalStateSchema.parse({
+      ...state,
+      updatedAt: new Date().toISOString()
+    });
+    const path = operationalStatePath(projectRoot);
+    await mkdir4(resolve3(projectRoot, ".codeconductor"), { recursive: true });
+    await writeFile3(path, JSON.stringify(validated, null, 2), "utf-8");
+    return ok(undefined);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function setActiveTask(projectRoot, taskId, agent) {
+  const load = await loadOperationalState(projectRoot);
+  if (!load.success)
+    return load;
+  const state = load.data;
+  if (!state.activeTaskIds.includes(taskId)) {
+    state.activeTaskIds.push(taskId);
+  }
+  if (agent && !state.activeAgents.includes(agent)) {
+    state.activeAgents.push(agent);
+  }
+  return saveOperationalState(projectRoot, state);
+}
+async function clearActiveTask(projectRoot, taskId) {
+  const load = await loadOperationalState(projectRoot);
+  if (!load.success)
+    return load;
+  const state = load.data;
+  state.activeTaskIds = state.activeTaskIds.filter((id) => id !== taskId);
+  state.blockers = state.blockers.filter((b) => b.taskId !== taskId);
+  return saveOperationalState(projectRoot, state);
+}
+
+// src/core/verification/verification-runner.ts
+init_schemas();
+import { existsSync } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+import { dirname, join as join2, resolve as resolve5 } from "node:path";
+
+// src/core/config/config-loader.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+import { parse as parse2 } from "yaml";
+
+// src/cli/errors.ts
+var ExitCode = {
+  SUCCESS: 0,
+  VALIDATION_ERROR: 1,
+  UNSAFE_OPERATION: 2,
+  UNSUPPORTED_PROJECT: 3,
+  CONFIG_CONFLICT: 4,
+  CREDENTIAL_LEAK: 5
+};
+
+class CliError extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "CliError";
+  }
+}
+
+class ValidationError extends CliError {
+  constructor(message, details) {
+    super(message, ExitCode.VALIDATION_ERROR, details);
+    this.name = "ValidationError";
+  }
+}
+
+// src/core/config/config-loader.ts
+init_schemas();
+var CONFIG_FILE = ".codeconductor/config.yml";
+async function loadConfig(projectRoot) {
+  try {
+    const configPath = resolve4(projectRoot, CONFIG_FILE);
+    const content = await readFile5(configPath, "utf-8");
+    const data = parse2(content);
+    if (!data) {
+      return err(new ValidationError("Empty config file"));
+    }
+    const validated = validateConfig(data);
+    return ok(validated);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      return err(error);
+    }
+    if (error.code === "ENOENT") {
+      return err(new ValidationError("Config file not found. Run `codeconductor init` first."));
+    }
+    return err(new ValidationError("Failed to load config", error));
+  }
+}
+
+// src/core/compilation/compile-checker.ts
+var DEFAULT_COMMAND = "tsc --noEmit";
+var DEFAULT_TIMEOUT_MS = 120000;
+function tokenizeCommand(cmd) {
+  const tokens = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0;i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (inSingle) {
+      if (ch === "'") {
+        inSingle = false;
+      } else {
+        current += ch;
+      }
+    } else if (inDouble) {
+      if (ch === '"') {
+        inDouble = false;
+      } else {
+        current += ch;
+      }
+    } else if (ch === "'") {
+      inSingle = true;
+    } else if (ch === '"') {
+      inDouble = true;
+    } else if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current)
+    tokens.push(current);
+  return tokens;
+}
+var ALLOWLISTED_ARGV_PREFIXES = [
+  ["tsc"],
+  ["bun", "run"],
+  ["bun", "test"],
+  ["npm", "test"],
+  ["npm", "run"],
+  ["npx", "tsc"],
+  ["pnpm", "test"],
+  ["pnpm", "run"],
+  ["yarn", "test"],
+  ["yarn", "run"]
+];
+function isAllowlistedCompileCommand(command) {
+  const parts = Array.isArray(command) ? command : tokenizeCommand(command);
+  if (parts.length === 0)
+    return false;
+  const bin = parts[0];
+  if (bin.includes("/") || bin.includes("\\"))
+    return false;
+  return ALLOWLISTED_ARGV_PREFIXES.some((prefix) => parts.length >= prefix.length && prefix.every((token, i) => parts[i] === token));
+}
+function isAllowlistedTestCommand(command) {
+  if (!isAllowlistedCompileCommand(command))
+    return false;
+  const parts = Array.isArray(command) ? command : tokenizeCommand(command);
+  return parts.some((token) => token === "test" || token.startsWith("test:"));
+}
+function minimalChildEnv() {
+  const env = {
+    PATH: process.env.PATH ?? "",
+    NODE_NO_WARNINGS: "1"
+  };
+  if (process.env.HOME)
+    env.HOME = process.env.HOME;
+  if (process.platform === "win32") {
+    if (process.env.SystemRoot)
+      env.SystemRoot = process.env.SystemRoot;
+    if (process.env.USERPROFILE)
+      env.USERPROFILE = process.env.USERPROFILE;
+  }
+  return env;
+}
+function parseTypeScriptErrors(stderr) {
+  const errors = [];
+  const tsRegex = /^(.+?)\((\d+)(?:,\s*(\d+))?\)\s*:\s*error\s+(TS\d+):\s*(.+)$/gm;
+  let match;
+  while ((match = tsRegex.exec(stderr)) !== null) {
+    errors.push({
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: match[3] ? parseInt(match[3], 10) : undefined,
+      code: match[4],
+      message: match[5],
+      raw: match[0]
+    });
+  }
+  return errors;
+}
+function parseEslintErrors(stderr) {
+  const errors = [];
+  const eslintRegex = /^(.+?):(\d+):(\d+):\s+(.+?)\s+(error|warning)(?:\s+(\S+))?\s*$/gm;
+  let match;
+  while ((match = eslintRegex.exec(stderr)) !== null) {
+    errors.push({
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      code: match[6],
+      message: match[4],
+      raw: match[0]
+    });
+  }
+  return errors;
+}
+function parseGenericErrors(stderr) {
+  const errors = [];
+  const withPosRegex = /^(.+?):(\d+):(\d+):\s+(.+)$/gm;
+  let match;
+  while ((match = withPosRegex.exec(stderr)) !== null) {
+    errors.push({
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      code: "",
+      message: match[4],
+      raw: match[0]
+    });
+  }
+  const withLineOnlyRegex = /^(.+?):\s+(\d+):\s+(.+)$/gm;
+  while ((match = withLineOnlyRegex.exec(stderr)) !== null) {
+    const already = errors.some((e) => e.file === match[1] && e.line === parseInt(match[2], 10));
+    if (!already) {
+      errors.push({
+        file: match[1],
+        line: parseInt(match[2], 10),
+        code: "",
+        message: match[3],
+        raw: match[0]
+      });
+    }
+  }
+  if (errors.length === 0) {
+    const plainRegex = /^(.+?):\s+(.+)$/gm;
+    while ((match = plainRegex.exec(stderr)) !== null) {
+      errors.push({
+        file: match[1],
+        code: "",
+        message: match[2],
+        raw: match[0]
+      });
+    }
+  }
+  return errors;
+}
+function parseCompileErrors(stderr) {
+  if (!stderr || !stderr.trim())
+    return [];
+  const tsErrors = parseTypeScriptErrors(stderr);
+  if (tsErrors.length > 0)
+    return tsErrors;
+  const eslintErrors = parseEslintErrors(stderr);
+  if (eslintErrors.length > 0)
+    return eslintErrors;
+  return parseGenericErrors(stderr);
+}
+async function runCompileCheck(options) {
+  const command = options?.command ?? DEFAULT_COMMAND;
+  const cwd = options?.cwd ?? process.cwd();
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const startTime = performance.now();
+  let timedOut = false;
+  const parts = Array.isArray(command) ? command : tokenizeCommand(command);
+  let proc;
+  try {
+    proc = Bun.spawn(parts, {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: minimalChildEnv(),
+      detached: process.platform !== "win32"
+    });
+  } catch (err2) {
+    const durationMs = performance.now() - startTime;
+    return {
+      success: false,
+      exitCode: -1,
+      stdout: "",
+      stderr: String(err2),
+      errors: [],
+      durationMs,
+      timedOut: false
+    };
+  }
+  const collectOutput = (async () => {
+    const stdoutStream = proc.stdout;
+    const stderrStream = proc.stderr;
+    const [stdout, stderr] = await Promise.all([
+      new Response(stdoutStream).text(),
+      new Response(stderrStream).text()
+    ]);
+    return { stdout, stderr, exitCode: await proc.exited };
+  })();
+  collectOutput.catch(() => {});
+  let timeoutId;
+  const timeout = new Promise((resolve5) => {
+    timeoutId = setTimeout(() => resolve5("timeout"), timeoutMs);
+  });
+  try {
+    const outcome = await Promise.race([collectOutput, timeout]);
+    if (outcome === "timeout") {
+      timedOut = true;
+      try {
+        if (process.platform === "win32") {
+          const taskkill = Bun.spawn(["taskkill", "/PID", String(proc.pid), "/T", "/F"], { stdout: "ignore", stderr: "ignore" });
+          await taskkill.exited;
+        } else {
+          process.kill(-proc.pid, "SIGKILL");
+        }
+      } catch {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }
+      await proc.exited;
+      return {
+        success: false,
+        exitCode: proc.exitCode ?? -1,
+        stdout: "",
+        stderr: `Compile check timed out after ${timeoutMs}ms`,
+        errors: [],
+        durationMs: performance.now() - startTime,
+        timedOut
+      };
+    }
+    return {
+      success: outcome.exitCode === 0,
+      exitCode: outcome.exitCode,
+      stdout: outcome.stdout,
+      stderr: outcome.stderr,
+      errors: parseCompileErrors(outcome.stderr),
+      durationMs: performance.now() - startTime,
+      timedOut
+    };
+  } catch (err2) {
+    return {
+      success: false,
+      exitCode: -1,
+      stdout: "",
+      stderr: String(err2),
+      errors: [],
+      durationMs: performance.now() - startTime,
+      timedOut
+    };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+// src/core/verification/verification-runner.ts
+import { mkdir as mkdir5, readdir, writeFile as writeFile4 } from "node:fs/promises";
+function isPassingEvidence(ev) {
+  switch (ev.type) {
+    case "verification":
+      return ev.data?.passed === true;
+    case "test": {
+      const tests = ImplementerTestsSchema.safeParse(ev.data);
+      return tests.success && tests.data.result === "passed";
+    }
+    case "review": {
+      const review = ReviewerOutputSchema.safeParse(ev.data);
+      return review.success && review.data.status === "pass" && review.data.verdict !== "blocked";
+    }
+    default:
+      return false;
+  }
+}
+function evidenceFilePath(evDir, id) {
+  const path = resolve5(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  if (dirname(path) !== resolve5(evDir)) {
+    return err(new Error(`Refusing to write evidence for "${id}" outside ${evDir}`));
+  }
+  return ok(path);
+}
+async function persistEvidence(projectRoot, evidence) {
+  const evDir = evidenceDir(projectRoot);
+  const evidencePath = evidenceFilePath(evDir, evidence.id);
+  if (!evidencePath.success)
+    return evidencePath;
+  try {
+    await mkdir5(evDir, { recursive: true });
+    await writeFile4(evidencePath.data, JSON.stringify(evidence, null, 2), "utf-8");
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+  return ok(undefined);
+}
+async function collectTaskEvidence(projectRoot, taskId) {
+  const evDir = evidenceDir(projectRoot);
+  const records = [];
+  let invalid = 0;
+  if (!existsSync(evDir))
+    return ok({ records, invalid });
+  let files;
+  try {
+    files = await readdir(evDir);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+  for (const file of files) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const raw = await readFile6(join2(evDir, file), "utf-8");
+      const ev = EvidenceSchema.parse(JSON.parse(raw));
+      if (ev.relatedTask === taskId)
+        records.push(ev);
+    } catch {
+      invalid++;
+    }
+  }
+  return ok({ records, invalid });
+}
+async function validateEvidenceIds(projectRoot, taskId, evidenceIds) {
+  const collected = await collectTaskEvidence(projectRoot, taskId);
+  if (!collected.success)
+    return collected;
+  const owned = new Map(collected.data.records.map((ev) => [ev.id, ev]));
+  let hasPassingVerification = false;
+  for (const id of evidenceIds) {
+    const record = owned.get(id);
+    if (!record) {
+      return err(new Error(`Evidence "${id}" is not a record of task ${taskId}`));
+    }
+    if (!isPassingEvidence(record)) {
+      return err(new Error(`Evidence "${id}" does not record a passing result`));
+    }
+    if (record.type === "verification")
+      hasPassingVerification = true;
+  }
+  if (!hasPassingVerification) {
+    return err(new Error(`Task ${taskId} requires at least one passing verification evidence`));
+  }
+  return ok(undefined);
+}
+async function runVerification(projectRoot, taskId, goal, options) {
+  const checks = [];
+  const evidenceIds = [];
+  let task;
+  if (goal) {
+    task = goal.tasks.find((t) => t.id === taskId);
+  } else {
+    const { loadGoal: loadGoal2 } = await Promise.resolve().then(() => (init_goal_state(), exports_goal_state));
+    const g = await loadGoal2(projectRoot);
+    if (!g.success)
+      return g;
+    task = g.data.tasks.find((t) => t.id === taskId);
+  }
+  if (!task) {
+    return err(new Error(`Task ${taskId} not found in goal`));
+  }
+  const criteriaCount = task.acceptance_criteria.length;
+  checks.push({
+    name: "acceptance_criteria_defined",
+    passed: criteriaCount > 0,
+    message: criteriaCount > 0 ? `${criteriaCount} acceptance criteria defined` : "No acceptance criteria defined"
+  });
+  const configResult = await loadConfig(projectRoot);
+  if (!configResult.success) {
+    checks.push({
+      name: "config_loaded",
+      passed: false,
+      message: `Cannot load config: ${configResult.error.message}`
+    });
+  } else {
+    const compileCheck = configResult.data.safety.compileCheck;
+    if (!compileCheck?.enabled) {
+      checks.push({
+        name: "compile_check",
+        passed: true,
+        message: "Compile check not enabled"
+      });
+    } else if (!compileCheck.command) {
+      checks.push({
+        name: "compile_check",
+        passed: false,
+        message: "Compile check enabled but no command configured"
+      });
+    } else if (!options?.allowCompileCheck && !isAllowlistedCompileCommand(compileCheck.command)) {
+      checks.push({
+        name: "compile_check",
+        passed: false,
+        message: "Compile check not executed: the command is not on the compile allowlist. Re-run with --allow-compile-check to trust it."
+      });
+    } else {
+      const compile = await runCompileCheck({
+        command: compileCheck.command,
+        cwd: projectRoot,
+        timeoutMs: compileCheck.timeoutMs
+      });
+      checks.push({
+        name: "compile_check",
+        passed: compile.success && !compile.timedOut,
+        message: compile.timedOut ? `Compile check timed out: ${compileCheck.command}` : compile.success ? `Compile check passed: ${compileCheck.command}` : `Compile check failed (exit ${compile.exitCode}): ${compileCheck.command}`
+      });
+    }
+  }
+  const collected = await collectTaskEvidence(projectRoot, taskId);
+  if (!collected.success)
+    return collected;
+  checks.push({
+    name: "evidence_readable",
+    passed: collected.data.invalid === 0,
+    message: collected.data.invalid === 0 ? "All evidence records are readable" : `${collected.data.invalid} unreadable evidence record(s)`
+  });
+  const supporting = collected.data.records.filter((ev) => ev.type !== "verification" && isPassingEvidence(ev));
+  evidenceIds.push(...supporting.map((ev) => ev.id));
+  checks.push({
+    name: "evidence_present",
+    passed: supporting.length > 0 || task.risk === "low",
+    message: supporting.length > 0 ? `${supporting.length} passing evidence record(s) for task` : task.risk === "low" ? "Low risk task — evidence optional" : "No passing evidence records found for task"
+  });
+  const passed = checks.every((c) => c.passed);
+  const evidence = {
+    id: `ev-verify-${taskId}-${Date.now()}`,
+    source: "cc verify",
+    type: "verification",
+    timestamp: new Date().toISOString(),
+    relatedTask: taskId,
+    confidence: passed ? 0.9 : 0.3,
+    summary: passed ? "Verification passed" : "Verification failed",
+    data: { passed, checks }
+  };
+  const persisted = await persistEvidence(projectRoot, evidence);
+  if (!persisted.success)
+    return persisted;
+  if (passed)
+    evidenceIds.push(evidence.id);
+  const event = await appendEvent(projectRoot, {
+    type: "verification.completed",
+    timestamp: new Date().toISOString(),
+    payload: { taskId, passed, evidenceId: evidence.id }
+  });
+  if (!event.success)
+    return event;
+  return ok({ passed, checks, evidenceIds });
+}
+async function gateTaskCompletion(projectRoot, taskId, evidenceRequired, evidenceIds) {
+  const collected = await collectTaskEvidence(projectRoot, taskId);
+  if (!collected.success)
+    return collected;
+  if (collected.data.invalid > 0)
+    return ok(false);
+  const cited = evidenceIds ? new Set(evidenceIds) : undefined;
+  const hasPassing = (type) => collected.data.records.some((ev) => (!cited || cited.has(ev.id)) && ev.type === type && isPassingEvidence(ev));
+  for (const req of evidenceRequired) {
+    switch (req) {
+      case "acceptance_criteria_met":
+        if (!hasPassing("verification"))
+          return ok(false);
+        break;
+      case "tests_passed":
+        if (!hasPassing("test"))
+          return ok(false);
+        break;
+      case "review_approved":
+        if (!hasPassing("review"))
+          return ok(false);
+        break;
+      default:
+        return ok(false);
+    }
+  }
+  return ok(true);
+}
+var TDD_EVIDENCE_SOURCE = "cc verify";
+var TDD_CAPTURED_BY = "verification-runner";
+async function captureTddSuiteEvidence(projectRoot, taskId, options) {
+  if (!options.allowCompileCheck && !isAllowlistedTestCommand(options.command)) {
+    return err(new Error("TDD suite command is not on the test allowlist. Re-run with --allow-compile-check to trust it."));
+  }
+  const result = await runCompileCheck({
+    command: options.command,
+    cwd: projectRoot
+  });
+  const suitePassed = result.success && !result.timedOut && result.exitCode === 0;
+  const suiteFailed = !result.timedOut && result.exitCode !== 0;
+  const evidence = {
+    id: `ev-tdd-${taskId}-${Date.now()}`,
+    source: TDD_EVIDENCE_SOURCE,
+    type: "tdd",
+    timestamp: new Date().toISOString(),
+    relatedTask: taskId,
+    confidence: suitePassed || suiteFailed ? 0.9 : 0.3,
+    summary: suitePassed ? "TDD suite passed" : suiteFailed ? "TDD suite failed" : "TDD suite inconclusive",
+    data: {
+      capturedBy: TDD_CAPTURED_BY,
+      suiteFailed,
+      suitePassed,
+      exitCode: result.exitCode,
+      timedOut: result.timedOut,
+      command: options.command
+    }
+  };
+  const persisted = await persistEvidence(projectRoot, evidence);
+  if (!persisted.success)
+    return persisted;
+  const event = await appendEvent(projectRoot, {
+    type: "verification.completed",
+    timestamp: new Date().toISOString(),
+    payload: {
+      taskId,
+      tdd: true,
+      suiteFailed,
+      suitePassed,
+      evidenceId: evidence.id
+    }
+  });
+  if (!event.success)
+    return event;
+  return ok({
+    evidenceId: evidence.id,
+    suiteFailed,
+    suitePassed
+  });
+}
+async function loadTddSuiteEvidence(projectRoot, taskId, evidenceId) {
+  const evDir = evidenceDir(projectRoot);
+  const path = evidenceFilePath(evDir, evidenceId);
+  if (!path.success)
+    return path;
+  let raw;
+  try {
+    raw = await readFile6(path.data, "utf-8");
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+  let ev;
+  try {
+    ev = EvidenceSchema.parse(JSON.parse(raw));
+  } catch {
+    return err(new Error(`Evidence "${evidenceId}" is not valid TDD evidence`));
+  }
+  if (ev.relatedTask !== taskId) {
+    return err(new Error(`Evidence "${evidenceId}" is not a record of task ${taskId}`));
+  }
+  if (ev.type !== "tdd" || ev.source !== TDD_EVIDENCE_SOURCE) {
+    return err(new Error(`Evidence "${evidenceId}" was not captured by the verification runner`));
+  }
+  const capturedBy = ev.data?.capturedBy;
+  const suiteFailed = ev.data?.suiteFailed;
+  const suitePassed = ev.data?.suitePassed;
+  if (capturedBy !== TDD_CAPTURED_BY || typeof suiteFailed !== "boolean" || typeof suitePassed !== "boolean") {
+    return err(new Error(`Evidence "${evidenceId}" was not captured by the verification runner`));
+  }
+  return ok({ capturedBy, suiteFailed, suitePassed });
+}
+
+// src/core/orchestrator/runtime-orchestrator.ts
+async function rollbackTaskStatus(projectRoot, graph, task, previousStatus, previousState, cause) {
+  task.status = previousStatus;
+  const write = await writeGoal(projectRoot, graph);
+  const restored = write.success ? await saveOperationalState(projectRoot, previousState) : write;
+  return restored.success ? err(cause) : err(new Error(`${cause.message} (rollback failed: ${restored.error.message})`));
+}
+function getReadyTasks(graph) {
+  const done = new Set(graph.tasks.filter((t) => t.status === "done").map((t) => t.id));
+  const blocked = new Set(graph.tasks.filter((t) => t.status === "blocked").map((t) => t.id));
+  return graph.tasks.filter((task) => {
+    if (task.status !== "pending")
+      return false;
+    if (blocked.has(task.id))
+      return false;
+    const deps = task.depends_on ?? [];
+    return deps.every((d) => done.has(d));
+  });
+}
+function goalTaskToCanonicalCard(task, objective) {
+  return {
+    id: task.id,
+    title: task.title,
+    objective,
+    context: `Task from goal graph: ${task.title}`,
+    acceptanceCriteria: task.acceptance_criteria,
+    dependencies: task.depends_on ?? [],
+    constraints: [],
+    risk: task.risk,
+    targetFiles: task.targetFiles ?? [],
+    agentType: task.agentType ?? "implementer",
+    evidenceRequired: task.evidenceRequired ?? ["acceptance_criteria_met"],
+    status: task.status === "in-progress" ? "in-progress" : task.status === "done" ? "done" : task.status === "blocked" ? "blocked" : "ready",
+    type: task.type,
+    linkedCapabilities: [],
+    boundaries: []
+  };
+}
+function buildTaskEnvelope(card, projectRoot, projectName) {
+  const command = card.type === "fix" ? "fix" : card.type === "refactor" ? "refactor" : card.type === "test" ? "test-plan" : "feature";
+  return {
+    protocolVersion: "ccep-1",
+    command,
+    userRequest: `${card.title}: ${card.objective}`,
+    projectId: projectName,
+    repoContext: {
+      stack: [],
+      existingModules: card.targetFiles,
+      domain: card.agentType
+    },
+    constraints: {
+      outputFormat: "taskcard",
+      needConfirmation: card.risk === "high",
+      riskThreshold: card.risk
+    },
+    executionPolicy: {
+      modelMode: "structured",
+      maxVariance: "low"
+    }
+  };
+}
+async function getNextTask(projectRoot, projectName) {
+  const goalResult = await loadGoal(projectRoot);
+  if (!goalResult.success)
+    return goalResult;
+  const graphResult = await loadGraph(projectRoot);
+  const productGraph = graphResult.success ? graphResult.data : undefined;
+  const enriched = enrichGoalWithProduct(goalResult.data, productGraph);
+  const ready = getReadyTasks(enriched);
+  if (ready.length === 0) {
+    return err(new Error("No ready tasks. All pending tasks have unmet dependencies or are blocked."));
+  }
+  const task = ready[0];
+  const enrichedTask = enriched.enrichedTasks.find((t) => t.id === task.id);
+  const card = goalTaskToCanonicalCard(enrichedTask, enriched.objective);
+  const envelope = buildTaskEnvelope(card, projectRoot, projectName);
+  return ok({
+    task: card,
+    envelope,
+    readyCount: ready.length
+  });
+}
+async function startTask(projectRoot, taskId, agent) {
+  const goalResult = await loadGoal(projectRoot);
+  if (!goalResult.success)
+    return goalResult;
+  const task = goalResult.data.tasks.find((t) => t.id === taskId);
+  if (!task)
+    return err(new Error(`Task ${taskId} not found`));
+  if (task.status !== "pending") {
+    return err(new Error(`Task ${taskId} is ${task.status}, expected pending`));
+  }
+  const stateBefore = await loadOperationalState(projectRoot);
+  if (!stateBefore.success)
+    return stateBefore;
+  const previousState = stateBefore.data;
+  const previousStatus = task.status;
+  task.status = "in-progress";
+  const write = await writeGoal(projectRoot, goalResult.data);
+  if (!write.success)
+    return write;
+  const active = await setActiveTask(projectRoot, taskId, agent);
+  if (!active.success) {
+    return rollbackTaskStatus(projectRoot, goalResult.data, task, previousStatus, previousState, active.error);
+  }
+  const event = await appendEvent(projectRoot, {
+    type: "task.started",
+    timestamp: new Date().toISOString(),
+    payload: { taskId, agent }
+  });
+  if (!event.success) {
+    return rollbackTaskStatus(projectRoot, goalResult.data, task, previousStatus, previousState, event.error);
+  }
+  return ok(undefined);
+}
+async function completeTask(projectRoot, taskId, evidenceIds) {
+  const goalResult = await loadGoal(projectRoot);
+  if (!goalResult.success)
+    return goalResult;
+  const task = goalResult.data.tasks.find((t) => t.id === taskId);
+  if (!task)
+    return err(new Error(`Task ${taskId} not found`));
+  if (task.status !== "in-progress") {
+    return err(new Error(`Task ${taskId} is ${task.status}, expected in-progress`));
+  }
+  const done = new Set(goalResult.data.tasks.filter((t) => t.status === "done").map((t) => t.id));
+  const unmet = (task.depends_on ?? []).filter((d) => !done.has(d));
+  if (unmet.length > 0) {
+    return err(new Error(`Task ${taskId} has unmet dependencies: ${unmet.join(", ")}`));
+  }
+  const activeState = await loadOperationalState(projectRoot);
+  if (!activeState.success)
+    return activeState;
+  if (!activeState.data.activeTaskIds.includes(taskId)) {
+    return err(new Error(`Task ${taskId} is not active. Start it before completing it.`));
+  }
+  if (!evidenceIds || evidenceIds.length === 0) {
+    return err(new Error(`Task ${taskId} cannot be completed without verification evidence`));
+  }
+  const evidence = await validateEvidenceIds(projectRoot, taskId, evidenceIds);
+  if (!evidence.success)
+    return evidence;
+  const gate = await gateTaskCompletion(projectRoot, taskId, inferEvidenceRequired(task), evidenceIds);
+  if (!gate.success)
+    return gate;
+  if (!gate.data) {
+    return err(new Error(`Task ${taskId} does not satisfy its completion evidence requirements`));
+  }
+  const previousState = activeState.data;
+  const previousStatus = task.status;
+  task.status = "done";
+  const write = await writeGoal(projectRoot, goalResult.data);
+  if (!write.success)
+    return write;
+  const cleared = await clearActiveTask(projectRoot, taskId);
+  if (!cleared.success) {
+    return rollbackTaskStatus(projectRoot, goalResult.data, task, previousStatus, previousState, cleared.error);
+  }
+  const event = await appendEvent(projectRoot, {
+    type: "task.completed",
+    timestamp: new Date().toISOString(),
+    payload: { taskId, evidenceIds }
+  });
+  if (!event.success) {
+    return rollbackTaskStatus(projectRoot, goalResult.data, task, previousStatus, previousState, event.error);
+  }
+  return ok(undefined);
+}
+function formatGoalStatus(graph) {
+  const lines = [`Objective: ${graph.objective}`, ""];
+  for (const task of graph.tasks) {
+    const icon = task.status === "done" ? "✓" : task.status === "blocked" ? "✗" : task.status === "in-progress" ? "→" : "○";
+    const deps = task.depends_on?.length ? ` (deps: ${task.depends_on.join(", ")})` : "";
+    lines.push(`${icon} [${task.status}] ${task.id}: ${task.title}${deps}`);
+  }
+  return lines.join(`
+`);
+}
+// src/domain/loop/loop-state.ts
+function createInitialState(overrides) {
+  return {
+    phase: "IDLE",
+    iteration: 0,
+    maxIterations: 3,
+    errors: [],
+    errorHistory: [],
+    tokenBudgetUsed: 0,
+    maxTokenBudget: 0,
+    ...overrides
+  };
+}
+function errorsEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  return a.every((ea, i) => ea.file === b[i].file && ea.code === b[i].code && ea.message === b[i].message && ea.line === b[i].line && ea.column === b[i].column);
+}
+function isStuckLoop(errorHistory) {
+  if (errorHistory.length < 2)
+    return false;
+  const last = errorHistory[errorHistory.length - 1];
+  const prev = errorHistory[errorHistory.length - 2];
+  return errorsEqual(last, prev);
+}
+var VALID_TRANSITIONS = {
+  IDLE: ["START", "ABORT"],
+  RUNNING: ["CODE_GENERATED", "TOKEN_BUDGET_EXCEEDED", "ABORT"],
+  CHECKING: ["COMPILE_CHECK_COMPLETED", "ABORT"],
+  FEEDBACK: ["FEEDBACK_FORMATTED", "ABORT"],
+  DONE: [],
+  FAILED: [],
+  ESCALATED: []
+};
+function loopStateMachine(state, action) {
+  if (action.type === "ABORT") {
+    if (state.phase === "DONE" || state.phase === "FAILED" || state.phase === "ESCALATED") {
+      return { state, result: "TERMINATE" };
+    }
+    return {
+      state: { ...state, phase: "FAILED" },
+      result: "TERMINATE"
+    };
+  }
+  if (state.phase === "DONE" || state.phase === "FAILED" || state.phase === "ESCALATED") {
+    return { state, result: "TERMINATE" };
+  }
+  const allowed = VALID_TRANSITIONS[state.phase];
+  if (!allowed || !allowed.includes(action.type)) {
+    return { state, result: "TERMINATE" };
+  }
+  switch (state.phase) {
+    case "IDLE": {
+      if (action.type === "START") {
+        return {
+          state: { ...state, phase: "RUNNING", iteration: 1 },
+          result: "CONTINUE"
+        };
+      }
+      break;
+    }
+    case "RUNNING": {
+      if (action.type === "CODE_GENERATED") {
+        return {
+          state: { ...state, phase: "CHECKING" },
+          result: "CONTINUE"
+        };
+      }
+      if (action.type === "TOKEN_BUDGET_EXCEEDED") {
+        return {
+          state: {
+            ...state,
+            phase: "ESCALATED",
+            tokenBudgetUsed: action.tokenUsage
+          },
+          result: "TERMINATE"
+        };
+      }
+      break;
+    }
+    case "CHECKING": {
+      if (action.type === "COMPILE_CHECK_COMPLETED") {
+        const errors = action.errors;
+        if (errors.length === 0) {
+          return {
+            state: {
+              ...state,
+              phase: "DONE",
+              errors: [],
+              errorHistory: [...state.errorHistory, []]
+            },
+            result: "TERMINATE"
+          };
+        }
+        const newHistory = [...state.errorHistory, errors];
+        if (isStuckLoop(newHistory)) {
+          return {
+            state: {
+              ...state,
+              phase: "ESCALATED",
+              errors,
+              errorHistory: newHistory
+            },
+            result: "TERMINATE"
+          };
+        }
+        if (state.iteration >= state.maxIterations) {
+          return {
+            state: {
+              ...state,
+              phase: "ESCALATED",
+              errors,
+              errorHistory: newHistory
+            },
+            result: "TERMINATE"
+          };
+        }
+        return {
+          state: {
+            ...state,
+            phase: "FEEDBACK",
+            errors,
+            errorHistory: newHistory
+          },
+          result: "CONTINUE"
+        };
+      }
+      break;
+    }
+    case "FEEDBACK": {
+      if (action.type === "FEEDBACK_FORMATTED") {
+        return {
+          state: {
+            ...state,
+            phase: "RUNNING",
+            iteration: state.iteration + 1
+          },
+          result: "CONTINUE"
+        };
+      }
+      break;
+    }
+  }
+  return { state, result: "TERMINATE" };
+}
+function createInitialTddState() {
+  return { phase: "RED", evidenceIds: [] };
+}
+function isRunnerTddEvidence(evidence) {
+  return evidence.capturedBy === "verification-runner";
+}
+function tddCycleStateMachine(state, action) {
+  if (action.type === "ABORT") {
+    if (state.phase === "FAILED") {
+      return { state, result: "TERMINATE" };
+    }
+    return { state: { ...state, phase: "FAILED" }, result: "TERMINATE" };
+  }
+  if (state.phase === "FAILED" || state.phase === "REFACTOR") {
+    return { state, result: "TERMINATE" };
+  }
+  if (!isRunnerTddEvidence(action.evidence)) {
+    return { state, result: "TERMINATE" };
+  }
+  if (state.phase === "RED") {
+    if (action.evidence.suiteFailed && !action.evidence.suitePassed) {
+      return {
+        state: {
+          phase: "GREEN",
+          evidenceIds: [...state.evidenceIds, action.evidenceId]
+        },
+        result: "CONTINUE"
+      };
+    }
+    return { state, result: "TERMINATE" };
+  }
+  if (state.phase === "GREEN") {
+    if (action.evidence.suitePassed && !action.evidence.suiteFailed) {
+      return {
+        state: {
+          phase: "REFACTOR",
+          evidenceIds: [...state.evidenceIds, action.evidenceId]
+        },
+        result: "CONTINUE"
+      };
+    }
+    return { state, result: "TERMINATE" };
+  }
+  return { state, result: "TERMINATE" };
+}
+
+// src/core/loop/git-stats.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var GIT_STATS_CACHE_TTL_MS = 3000;
+var cache;
+function countPorcelain(output) {
+  return output.split(`
+`).filter((line) => line.trim().length > 0).length;
+}
+function countNumstat(output) {
+  let total = 0;
+  for (const line of output.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const parts = line.split(/\s+/);
+    const added = parseInt(parts[0] || "0", 10);
+    const deleted = parseInt(parts[1] || "0", 10);
+    if (!Number.isNaN(added))
+      total += added;
+    if (!Number.isNaN(deleted))
+      total += deleted;
+  }
+  return total;
+}
+async function fetchGitChangeStats(cwd) {
+  try {
+    const [status, diff] = await Promise.all([
+      execFileAsync("git", ["status", "--porcelain"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 15000
+      }),
+      execFileAsync("git", ["diff", "--numstat"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 15000
+      })
+    ]);
+    return {
+      filesModified: countPorcelain(status.stdout),
+      linesChanged: countNumstat(diff.stdout)
+    };
+  } catch {
+    return { filesModified: 0, linesChanged: 0 };
+  }
+}
+async function readGitChangeStats(cwd, options) {
+  const now = options?.now ?? Date.now();
+  const fetch = options?.fetch ?? fetchGitChangeStats;
+  if (cache && cache.cwd === cwd && now - cache.at < GIT_STATS_CACHE_TTL_MS) {
+    return cache.stats;
+  }
+  const stats = await fetch(cwd);
+  cache = { cwd, at: now, stats };
+  return stats;
+}
+
+// src/core/loop/loop-engine.ts
+class LoopEngine {
+  limits;
+  startedAt;
+  constructor(limits, gitStats, startedAt = Date.now()) {
+    this.limits = limits;
+    this.gitStats = gitStats ?? ((cwd) => readGitChangeStats(cwd));
+    this.startedAt = startedAt;
+  }
+  gitStats;
+  async evaluate(scope = "all") {
+    const maxWall = this.limits.maxWallClockSeconds ?? 0;
+    if (maxWall > 0) {
+      const elapsedSeconds = (Date.now() - this.startedAt) / 1000;
+      if (elapsedSeconds > maxWall) {
+        return { kind: "timeout", elapsedSeconds, limit: maxWall };
+      }
+    }
+    if (scope === "time")
+      return null;
+    const maxFiles = this.limits.maxFilesModified ?? 0;
+    const maxLines = this.limits.maxLinesChanged ?? 0;
+    if (maxFiles <= 0 && maxLines <= 0)
+      return null;
+    const stats = await this.gitStats(this.limits.cwd ?? process.cwd());
+    if (maxFiles > 0 && stats.filesModified > maxFiles) {
+      return { kind: "files", count: stats.filesModified, limit: maxFiles };
+    }
+    if (maxLines > 0 && stats.linesChanged > maxLines) {
+      return { kind: "lines", count: stats.linesChanged, limit: maxLines };
+    }
+    return null;
+  }
+}
+function formatFeedback(errors) {
+  if (errors.length === 0)
+    return "";
+  const lines = [
+    `The previous code generation produced ${errors.length} compilation error(s).`,
+    "Please fix the following issues:",
+    ""
+  ];
+  for (let i = 0;i < errors.length; i++) {
+    const err3 = errors[i];
+    const location = [err3.file, err3.line, err3.column].filter(Boolean).join(":");
+    const codePart = err3.code ? ` [${err3.code}]` : "";
+    lines.push(`${i + 1}. ${location}${codePart}: ${err3.message}`);
+    lines.push(`   Raw: ${err3.raw}`);
+    lines.push("");
+  }
+  lines.push("Generate corrected code that resolves all errors above.");
+  return lines.join(`
+`);
+}
+function logTransition(phase, action, iteration) {
+  process.stderr.write(`[loop] ${new Date().toISOString()} phase=${phase} action=${action} iteration=${iteration}
+`);
+}
+async function runLoop(generateFn, compileCheckFn, config = {}, taskTitle = "compile-fix-loop", originalTask) {
+  const maxIterations = config.maxIterations ?? 3;
+  const maxTokenBudget = config.maxTokenBudget ?? 0;
+  const engine = new LoopEngine({
+    maxWallClockSeconds: config.maxWallClockSeconds ?? 0,
+    maxFilesModified: config.maxFilesModified ?? 0,
+    maxLinesChanged: config.maxLinesChanged ?? 0,
+    cwd: config.cwd
+  }, config.gitStats);
+  let state = createInitialState({ maxIterations, maxTokenBudget });
+  let totalErrors = 0;
+  let feedbackText;
+  let compileCheck;
+  let compileCheckSkipReason;
+  logTransition(state.phase, "INIT", state.iteration);
+  const startResult = loopStateMachine(state, { type: "START" });
+  state = startResult.state;
+  logTransition(state.phase, "START", state.iteration);
+  while (true) {
+    const hit = await engine.evaluate();
+    if (hit) {
+      return guardrailResult(hit, state, totalErrors, taskTitle, originalTask);
+    }
+    switch (state.phase) {
+      case "RUNNING": {
+        logTransition(state.phase, "GENERATE", state.iteration);
+        const genResult2 = await generateFn(feedbackText);
+        feedbackText = undefined;
+        const tokenUsage = genResult2 && typeof genResult2 === "object" && "tokenUsage" in genResult2 ? genResult2.tokenUsage : 0;
+        const newBudgetUsed = state.tokenBudgetUsed + tokenUsage;
+        if (state.maxTokenBudget > 0 && newBudgetUsed > state.maxTokenBudget) {
+          const budgetResult = loopStateMachine(state, {
+            type: "TOKEN_BUDGET_EXCEEDED",
+            tokenUsage: newBudgetUsed
+          });
+          state = budgetResult.state;
+          logTransition(state.phase, "TOKEN_BUDGET_EXCEEDED", state.iteration);
+          break;
+        }
+        const updatedState = { ...state, tokenBudgetUsed: newBudgetUsed };
+        const genResult = loopStateMachine(updatedState, { type: "CODE_GENERATED" });
+        state = genResult.state;
+        logTransition(state.phase, "CODE_GENERATED", state.iteration);
+        break;
+      }
+      case "CHECKING": {
+        logTransition(state.phase, "COMPILE_CHECK", state.iteration);
+        const compileResult = await compileCheckFn();
+        totalErrors += compileResult.errors.length;
+        if (compileResult.skipped) {
+          compileCheck = "skipped";
+          compileCheckSkipReason = compileResult.skipReason;
+        } else {
+          compileCheck = "ran";
+        }
+        const checkResult = loopStateMachine(state, {
+          type: "COMPILE_CHECK_COMPLETED",
+          errors: compileResult.errors
+        });
+        state = checkResult.state;
+        logTransition(state.phase, "COMPILE_CHECK_COMPLETED", state.iteration);
+        break;
+      }
+      case "FEEDBACK": {
+        logTransition(state.phase, "FORMAT_FEEDBACK", state.iteration);
+        feedbackText = formatFeedback(state.errors);
+        const fbResult = loopStateMachine(state, { type: "FEEDBACK_FORMATTED" });
+        state = fbResult.state;
+        logTransition(state.phase, "FEEDBACK_FORMATTED", state.iteration);
+        break;
+      }
+      case "DONE": {
+        logTransition(state.phase, "DONE", state.iteration);
+        return {
+          success: true,
+          iterations: state.iteration,
+          totalErrors,
+          finalPhase: "DONE",
+          errorHistory: state.errorHistory,
+          compileCheck,
+          compileCheckSkipReason
+        };
+      }
+      case "ESCALATED": {
+        logTransition(state.phase, "ESCALATED", state.iteration);
+        const report = buildEscalationReport(taskTitle, state, originalTask);
+        return {
+          success: false,
+          iterations: state.iteration,
+          totalErrors,
+          finalPhase: "ESCALATED",
+          escalationReport: report,
+          errorHistory: state.errorHistory,
+          compileCheck,
+          compileCheckSkipReason
+        };
+      }
+      case "FAILED": {
+        logTransition(state.phase, "FAILED", state.iteration);
+        return {
+          success: false,
+          iterations: state.iteration,
+          totalErrors,
+          finalPhase: "FAILED",
+          errorHistory: state.errorHistory,
+          compileCheck,
+          compileCheckSkipReason
+        };
+      }
+      default: {
+        logTransition(state.phase, "UNEXPECTED", state.iteration);
+        return {
+          success: false,
+          iterations: state.iteration,
+          totalErrors,
+          finalPhase: state.phase,
+          errorHistory: state.errorHistory,
+          compileCheck,
+          compileCheckSkipReason
+        };
+      }
+    }
+  }
+}
+function guardrailResult(hit, state, totalErrors, taskTitle, originalTask) {
+  const attempted = hit.kind === "timeout" ? `Time limit exceeded: ${hit.elapsedSeconds.toFixed(1)}s elapsed (max: ${hit.limit}s)` : hit.kind === "files" ? `Files modified limit exceeded: ${hit.count} files modified (max: ${hit.limit})` : `Lines changed limit exceeded: ${hit.count} lines changed (max: ${hit.limit})`;
+  const recommended = hit.kind === "timeout" ? `Operational guardrail triggered: maxWallClockSeconds limit (${hit.limit}s) exceeded. Increase limit or optimize execution time.` : hit.kind === "files" ? `Operational guardrail triggered: maxFilesModified limit (${hit.limit}) exceeded. Check for scope creep.` : `Operational guardrail triggered: maxLinesChanged limit (${hit.limit}) exceeded. Check for large diffs or unnecessary refactoring.`;
+  const action = hit.kind === "timeout" ? "TIMEOUT_GUARDRAIL" : hit.kind === "files" ? "FILES_MODIFIED_GUARDRAIL" : "LINES_CHANGED_GUARDRAIL";
+  logTransition(state.phase, action, state.iteration);
+  return {
+    success: false,
+    iterations: state.iteration,
+    totalErrors,
+    finalPhase: "ESCALATED",
+    errorHistory: state.errorHistory,
+    escalationReport: {
+      taskTitle,
+      iterationsAttempted: state.iteration,
+      errorHistory: state.errorHistory,
+      attemptedFixes: [attempted],
+      originalContext: originalTask ?? "No original task provided",
+      recommendedAction: recommended
+    }
+  };
+}
+function buildEscalationReport(taskTitle, state, originalTask) {
+  const attemptedFixes = [];
+  for (let i = 0;i < state.errorHistory.length; i++) {
+    const errs = state.errorHistory[i];
+    if (errs.length > 0) {
+      attemptedFixes.push(`Iteration ${i + 1}: ${errs.length} error(s) — ${errs.map((e) => `${e.code || "unknown"}: ${e.message}`).join("; ")}`);
+    }
+  }
+  let recommendedAction;
+  if (state.errorHistory.length >= 2) {
+    const last = state.errorHistory[state.errorHistory.length - 1];
+    const prev = state.errorHistory[state.errorHistory.length - 2];
+    const identical = last.length === prev.length && last.every((e, i) => e.file === prev[i].file && e.code === prev[i].code && e.message === prev[i].message);
+    if (identical) {
+      recommendedAction = "Errors are identical across consecutive iterations. The agent appears unable to resolve these errors automatically. Manual intervention required.";
+    } else {
+      recommendedAction = "Max iterations reached with remaining errors. Review the error pattern and consider alternative approaches.";
+    }
+  } else {
+    recommendedAction = "Max iterations reached. Review errors and consider manual fixes.";
+  }
+  return {
+    taskTitle,
+    iterationsAttempted: state.iteration,
+    errorHistory: state.errorHistory,
+    attemptedFixes,
+    originalContext: originalTask ?? "No original task provided",
+    recommendedAction
+  };
+}
+var CLEAN_COMPILE = {
+  success: true,
+  exitCode: 0,
+  stdout: "",
+  stderr: "",
+  errors: [],
+  durationMs: 0,
+  timedOut: false
+};
+function skippedCompileResult(reason) {
+  return {
+    ...CLEAN_COMPILE,
+    skipped: true,
+    skipReason: reason,
+    stderr: `compileCheck: skipped
+${reason}`
+  };
+}
+function shouldRunAgentLoop(type, agentType, phase) {
+  if (phase === "implement" || phase === "test")
+    return true;
+  if (agentType === "implementer" || agentType === "tester")
+    return true;
+  return type === "feature" || type === "fix" || type === "test";
+}
+async function advanceTddPhase(projectRoot, taskId, state, evidenceId) {
+  const loaded = await loadTddSuiteEvidence(projectRoot, taskId, evidenceId);
+  if (!loaded.success)
+    return loaded;
+  const next = tddCycleStateMachine(state, {
+    type: "SUITE_EVIDENCE",
+    evidenceId,
+    evidence: loaded.data
+  });
+  return ok(next);
+}
+async function runLoopForProject(projectRoot, options) {
+  const configResult = await loadConfig(projectRoot);
+  const loopCfg = configResult.success ? configResult.data.loop : undefined;
+  const compileCheck = configResult.success ? configResult.data.safety.compileCheck : undefined;
+  const compileCheckFn = async () => {
+    if (!compileCheck?.enabled || !compileCheck.command) {
+      return skippedCompileResult(!compileCheck?.enabled ? "Compile check is not enabled in config." : "Compile check is enabled but no command is configured.");
+    }
+    const allowed = options.allowCompileCheck === true || isAllowlistedCompileCommand(compileCheck.command);
+    if (!allowed) {
+      return skippedCompileResult("Compile check not executed: the command is not on the compile allowlist. " + "Re-run with --allow-compile-check to trust it.");
+    }
+    const result = await runCompileCheck({
+      command: compileCheck.command,
+      cwd: projectRoot,
+      timeoutMs: compileCheck.timeoutMs
+    });
+    if (result.success && result.errors.length === 0)
+      return result;
+    return {
+      ...result,
+      errors: result.errors.length > 0 ? result.errors : [
+        {
+          file: compileCheck.command,
+          code: "COMPILE",
+          message: `Compile check failed (exit ${result.exitCode})`,
+          raw: result.stderr || result.stdout
+        }
+      ]
+    };
+  };
+  return runLoop(async () => ({ tokenUsage: 0 }), compileCheckFn, {
+    cwd: projectRoot,
+    maxIterations: loopCfg?.maxIterations ?? 3,
+    maxTokenBudget: loopCfg?.maxTokenBudget ?? 0
+  }, options.taskTitle, options.originalTask);
+}
+
+// src/index.ts
+init_schemas();
+export {
+  validateWorkflowProfile,
+  validateTaskOutcome,
+  validateScorecardRecord,
+  validateRunnerTarget,
+  validateReviewerOutput,
+  validateProjectProfile,
+  validateProductGraph,
+  validateProductEvent,
+  validatePlannerOutput,
+  validateOpenspecState,
+  validateOpenCodeAgentFile,
+  validateModelConfig,
+  validateMemoryPointer,
+  validateMemoryIndex,
+  validateKnowledgeEntity,
+  validateImplementerOutput,
+  validateHarnessSuite,
+  validateHarnessOverlay,
+  validateHarnessExperiment,
+  validateHarnessCatalog,
+  validateGoalGraph,
+  validateExecutionContext,
+  validateEvidenceIds,
+  validateEvidence,
+  validateDecision,
+  validateCouncilVerdictInput,
+  validateCouncilVerdict,
+  validateCouncilSpec,
+  validateConsensusConfig,
+  validateConfig,
+  validateCommandEnvelope,
+  validateClaudeAgentFile,
+  validateCanonicalTaskCard,
+  validateBacklogDocument,
+  validateAgentOutput,
+  validateAgentContract,
+  tddCycleStateMachine,
+  startTask,
+  shouldRunAgentLoop,
+  runVerification,
+  runLoopForProject,
+  runLoop,
+  rollbackTaskStatus,
+  loopStateMachine,
+  loadTddSuiteEvidence,
+  goalTaskToCanonicalCard,
+  getReadyTasks,
+  getNextTask,
+  gateTaskCompletion,
+  formatGoalStatus,
+  formatFeedback,
+  createInitialTddState,
+  createInitialState,
+  completeTask,
+  captureTddSuiteEvidence,
+  buildTaskEnvelope,
+  advanceTddPhase,
+  WorkflowRiskRuleSchema,
+  WorkflowProfileSchema,
+  WorkflowPhaseSchema,
+  WorkflowCommandSchema,
+  VerificationReportSchema,
+  ToolProviderNamesSchema,
+  TechnicalPlanOutputSchema,
+  TaskOutcomeStatusSchema,
+  TaskOutcomeSourceSchema,
+  TaskOutcomeSchema,
+  StrategicMemorySchema,
+  SentryWebhookSchema,
+  SentryStackFrameSchema,
+  ScorecardVerdictSchema,
+  ScorecardRecordSchema,
+  ScorecardCriterionSchema,
+  ScorecardCriterionIdSchema,
+  RunnerTargetSchema,
+  ReviewerOutputSchema,
+  ReviewFindingSchema,
+  ReviewAxisSchema,
+  ProjectProfileSchema,
+  ProductNodeTypeSchema,
+  ProductMetaSchema,
+  ProductGraphSchema,
+  ProductGraphNodeSchema,
+  ProductGraphEdgeSchema,
+  ProductEventTypeSchema,
+  ProductEventSchema,
+  PlannerOutputSchema,
+  PermissionProviderNamesSchema,
+  OperationalStateSchema,
+  OpenspecTaskCardStatusSchema,
+  OpenspecTaskCardSchema,
+  OpenspecTaskCardPhaseSchema,
+  OpenspecStateSchema,
+  OpenCodeAgentFileSchema,
+  ModelConfigSchema,
+  MemoryPointerSchema,
+  MemoryIndexSchema,
+  ManifestEntrySchema,
+  LoopEngine,
+  LoopConfigSchema,
+  KnowledgeEntitySchema,
+  InstallStrategySchema,
+  InstallManifestSchema,
+  ImplementerTestsSchema,
+  ImplementerOutputSchema,
+  ImpactReportSchema,
+  HarnessToggleKindSchema,
+  HarnessSuiteTaskSchema,
+  HarnessSuiteSchema,
+  HarnessOverlaySchema,
+  HarnessExperimentSchema,
+  HarnessComponentLayerSchema,
+  HarnessComponentIdSchema,
+  HarnessCatalogSchema,
+  HarnessCatalogEntrySchema,
+  GraphRelationSchema,
+  GoalTaskSchema,
+  GoalGraphSchema,
+  ExecutionProfileSchema,
+  ExecutionProfileNameSchema,
+  ExecutionContextSchema,
+  EvidenceSchema,
+  EvaluationIndexSchema,
+  DecisionSchema,
+  CouncilVerdictSchema,
+  CouncilVerdictInputSchema,
+  CouncilSpecSchema,
+  CouncilFindingSchema,
+  CouncilAgentSpecSchema,
+  ContractTargetSchema,
+  ContractFormatSchema,
+  ConsensusConfigSchema,
+  ConfidenceLevelSchema,
+  CompileCheckConfigSchema,
+  CommandEnvelopeSchema,
+  CodeConductorConfigSchema,
+  ClaudeAgentFileSchema,
+  CcepOutputFormatSchema,
+  CanonicalTaskCardStatusSchema,
+  CanonicalTaskCardSchema,
+  BusinessReviewOutputSchema,
+  BacklogTypeSchema,
+  BacklogStatusSchema,
+  BacklogPrioritySchema,
+  BacklogItemSchema,
+  BacklogGlobalSchema,
+  BacklogDocumentSchema,
+  AgentOutputSchema,
+  AgentContractSchema,
+  AgentArtifactSchema
+};