cc-codeconductor 1.1.0 → 1.2.0

package/dist/index.js

@@ -83,7 +83,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "cc-codeconductor",
-    version: "1.1.0",
+    version: "1.2.0",
     description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
     keywords: [
       "ai",
@@ -11307,6 +11307,8 @@ __export(exports_schemas, {
   TaskOutcomeSourceSchema: () => TaskOutcomeSourceSchema,
   TaskOutcomeSchema: () => TaskOutcomeSchema,
   StrategicMemorySchema: () => StrategicMemorySchema,
+  SpecAnalyzeReportSchema: () => SpecAnalyzeReportSchema,
+  SpecAnalyzeFindingSchema: () => SpecAnalyzeFindingSchema,
   SentryWebhookSchema: () => SentryWebhookSchema,
   SentryStackFrameSchema: () => SentryStackFrameSchema,
   ScorecardVerdictSchema: () => ScorecardVerdictSchema,
@@ -11494,7 +11496,7 @@ function validateCanonicalTaskCard(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 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, SpecAnalyzeFindingSchema, SpecAnalyzeReportSchema, 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(() => {
   init_zod();
   CouncilAgentSpecSchema = exports_external.object({
@@ -11986,6 +11988,24 @@ var init_schemas = __esm(() => {
     changePaths: exports_external.record(exports_external.string(), exports_external.string()).optional().default({}),
     itemSnapshots: exports_external.record(exports_external.string(), exports_external.string()).optional().default({})
   });
+  SpecAnalyzeFindingSchema = exports_external.object({
+    severity: exports_external.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]),
+    code: exports_external.string(),
+    message: exports_external.string()
+  });
+  SpecAnalyzeReportSchema = exports_external.object({
+    changePath: exports_external.string(),
+    frIds: exports_external.array(exports_external.string()),
+    scIds: exports_external.array(exports_external.string()),
+    mappedFr: exports_external.array(exports_external.string()),
+    mappedSc: exports_external.array(exports_external.string()),
+    mappedToTests: exports_external.array(exports_external.string()),
+    frCoveragePct: exports_external.number(),
+    scCoveragePct: exports_external.number(),
+    testCoveragePct: exports_external.number(),
+    findings: exports_external.array(SpecAnalyzeFindingSchema),
+    stop: exports_external.boolean()
+  });
   WorkflowCommandSchema = exports_external.enum([
     "feature",
     "fix",
@@ -11993,6 +12013,7 @@ var init_schemas = __esm(() => {
     "review",
     "test-plan",
     "tdd-cycle",
+    "spec-mutation",
     "api-contract",
     "db-migration",
     "pagespeed",
@@ -12447,6 +12468,28 @@ var init_profiles = __esm(() => {
       routing: { default: ["test", "implement", "refactor"] },
       confirmationGate: { stopOnHighRisk: false, stopOnQuestions: true }
     },
+    "spec-mutation": {
+      id: "spec-mutation",
+      version: 1,
+      command: "spec-mutation",
+      taskCard: {
+        type: "feature",
+        requiredFields: ["title", "type", "risk", "scope", "context", "acceptanceCriteria"]
+      },
+      phases: [
+        { id: "refine", agent: "task-coach", outputSchema: "planner-output", stopGate: "confirmation" },
+        { id: "spec", agent: "contract-builder", outputSchema: "api-contract", stopGate: "approval" },
+        { id: "test", agent: "tester", dependsOn: ["spec"], requires: "red-state" },
+        { id: "implement", agent: "implementer", dependsOn: ["test"], requires: "green-state" },
+        { id: "judge", agent: "reviewer", outputSchema: "review-report", dependsOn: ["implement"] },
+        { id: "mutation", agent: "tester", dependsOn: ["judge"] },
+        { id: "review", agent: "reviewer", dependsOn: ["mutation"] }
+      ],
+      routing: {
+        default: ["refine", "spec", "test", "implement", "judge", "mutation", "review"]
+      },
+      confirmationGate: baseGate
+    },
     "api-contract": {
       id: "api-contract",
       version: 1,
@@ -12494,11 +12537,12 @@ var init_profiles = __esm(() => {
         { id: "validate-backlog", agent: "orchestrator", type: "cli-gate" },
         { id: "discover", agent: "repo-explorer" },
         { id: "design", agent: "architect" },
+        { id: "analyze", agent: "orchestrator", type: "cli-gate" },
         { id: "test", agent: "tester" },
         { id: "implement", agent: "implementer", dependsOn: ["test"] },
         { id: "review", agent: "reviewer" }
       ],
-      routing: { default: ["validate-backlog", "discover", "design", "test", "implement", "review"] },
+      routing: { default: ["validate-backlog", "discover", "design", "analyze", "test", "implement", "review"] },
       confirmationGate: baseGate
     },
     backlog: {
@@ -12525,10 +12569,11 @@ var init_profiles = __esm(() => {
       command: "scorecard",
       intakeSchema: "scorecard-task-id",
       phases: [
+        { id: "analyze", agent: "orchestrator", type: "cli-gate" },
         { id: "create", agent: "orchestrator", type: "cli-gate" },
         { id: "evaluate", agent: "reviewer", outputSchema: "scorecard-record" }
       ],
-      routing: { default: ["create", "evaluate"] },
+      routing: { default: ["analyze", "create", "evaluate"] },
       confirmationGate: { stopOnHighRisk: false, stopOnQuestions: false }
     },
     council: {
@@ -16379,7 +16424,8 @@ function renderTemplate(content, modelConfig, filePath, locale = "en") {
     const sectionMatch = result.match(sectionRegex);
     if (sectionMatch) {
       for (const section of sectionMatch) {
-        const renderedSection = section.replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "").replace(/\{\{MODEL_GROK\}\}/g, agentModels.grok ?? "");
+        const targetModel = agentModels[modelConfig.target];
+        const renderedSection = section.replace(/\{\{MODEL\}\}/g, targetModel ?? "").replace(/\{\{MODEL_CLAUDE\}\}/g, agentModels.claude ?? "").replace(/\{\{MODEL_OPENCODE\}\}/g, agentModels.opencode ?? "").replace(/\{\{MODEL_CODEX\}\}/g, agentModels.codex ?? "").replace(/\{\{MODEL_GEMINI\}\}/g, agentModels.gemini ?? "").replace(/\{\{MODEL_CURSOR\}\}/g, agentModels.cursor ?? "").replace(/\{\{MODEL_GROK\}\}/g, agentModels.grok ?? "");
         result = result.replace(section, renderedSection);
       }
     }
@@ -17757,6 +17803,18 @@ function recommendAskFlow(problem) {
   ])) {
     return pick("security", "The request is authorized defensive security work, so /cc:security is the fit.");
   }
+  if (includesAny(text, [
+    "mutation testing",
+    "mutation test",
+    "mutant",
+    "stryker",
+    "pitest",
+    "mutmut",
+    "spec-mutation",
+    "gherkin"
+  ])) {
+    return pick("spec-mutation", "The request involves mutation testing or a Gherkin-locked spec gate, which is the /cc:spec-mutation contract.");
+  }
   if (includesAny(text, [
     "tdd",
     "red-green",
@@ -17826,6 +17884,11 @@ var init_recommend_flow = __esm(() => {
       slash: "/cc:tdd-cycle",
       blurb: "one red-green-refactor cycle starting from a failing test"
     },
+    {
+      command: "spec-mutation",
+      slash: "/cc:spec-mutation",
+      blurb: "spec-locked TDD with a mutation-testing gate before merge"
+    },
     {
       command: "backlog",
       slash: "/cc:backlog",
@@ -19819,7 +19882,7 @@ var init_memory_index = __esm(() => {
 });
 
 // src/core/evaluation/outcome-store.ts
-import { appendFile as appendFile2, mkdir as mkdir15, readFile as readFile21, writeFile as writeFile13 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir15, readFile as readFile21, readdir as readdir5, writeFile as writeFile13 } from "node:fs/promises";
 import { resolve as resolve21 } from "node:path";
 async function ensureEvaluationDir(projectRoot) {
   const dir = resolve21(projectRoot, EVAL_DIR);
@@ -19894,6 +19957,38 @@ async function saveScorecard(projectRoot, record) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
 }
+async function listScorecards(projectRoot, filter = {}) {
+  try {
+    const dir = resolve21(projectRoot, EVAL_DIR, SCORECARDS_DIR);
+    let files;
+    try {
+      files = await readdir5(dir);
+    } catch (e) {
+      if (e.code === "ENOENT")
+        return ok([]);
+      throw e;
+    }
+    const records = [];
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      const parsed = ScorecardRecordSchema.parse(JSON.parse(await readFile21(resolve21(dir, file), "utf-8")));
+      if (filter.backlogId && parsed.backlogId !== filter.backlogId)
+        continue;
+      if (filter.verdict && parsed.verdict !== filter.verdict)
+        continue;
+      records.push(parsed);
+    }
+    records.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return ok(records);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function hasPassingScorecard(projectRoot, backlogId) {
+  const listed = await listScorecards(projectRoot, { backlogId, verdict: "PASS" });
+  return listed.success && listed.data.length > 0;
+}
 async function loadScorecard(projectRoot, id) {
   try {
     const filePath = resolve21(projectRoot, EVAL_DIR, SCORECARDS_DIR, `${id}.json`);
@@ -20591,7 +20686,7 @@ var init_compile_checker = __esm(() => {
 import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile23 } from "node:fs/promises";
 import { dirname as dirname6, join as join16, resolve as resolve22 } from "node:path";
-import { mkdir as mkdir16, readdir as readdir5, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir16, readdir as readdir6, writeFile as writeFile15 } from "node:fs/promises";
 function isPassingEvidence(ev) {
   switch (ev.type) {
     case "verification":
@@ -20636,7 +20731,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     return ok({ records, invalid });
   let files;
   try {
-    files = await readdir5(evDir);
+    files = await readdir6(evDir);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -20806,6 +20901,13 @@ async function gateTaskCompletion(projectRoot, taskId, evidenceRequired, evidenc
   }
   return ok(true);
 }
+async function hasTddRunnerEvidence(projectRoot, taskId) {
+  const collected = await collectTaskEvidence(projectRoot, taskId);
+  if (!collected.success)
+    return false;
+  return collected.data.records.some((ev) => ev.type === "tdd" && ev.source === TDD_EVIDENCE_SOURCE && ev.data?.capturedBy === TDD_CAPTURED_BY);
+}
+var TDD_EVIDENCE_SOURCE = "cc verify", TDD_CAPTURED_BY = "verification-runner";
 var init_verification_runner = __esm(() => {
   init_schemas();
   init_config_loader();
@@ -22251,6 +22353,7 @@ var init_command_parser = __esm(() => {
     review: { outputFormat: "verdict", needConfirmation: false, riskThreshold: "low" },
     "test-plan": { outputFormat: "plan", needConfirmation: true, riskThreshold: "low" },
     "tdd-cycle": { outputFormat: "taskcard", needConfirmation: false, riskThreshold: "medium" },
+    "spec-mutation": { outputFormat: "taskcard", needConfirmation: true, riskThreshold: "high" },
     "api-contract": { outputFormat: "plan", needConfirmation: true, riskThreshold: "high" },
     "db-migration": { outputFormat: "plan", needConfirmation: true, riskThreshold: "high" },
     pagespeed: { outputFormat: "verdict", needConfirmation: false, riskThreshold: "low" },
@@ -22293,7 +22396,7 @@ var init_workflow_profile_loader = __esm(() => {
 // src/core/evaluation/harness-catalog.ts
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir17, readFile as readFile24, readdir as readdir6, rm as rm2, writeFile as writeFile16 } from "node:fs/promises";
+import { copyFile as copyFile2, mkdir as mkdir17, readFile as readFile24, readdir as readdir7, rm as rm2, writeFile as writeFile16 } from "node:fs/promises";
 import { dirname as dirname7, join as join18, resolve as resolve23 } from "node:path";
 function catalogIds(catalog = DEFAULT_HARNESS_CATALOG) {
   return catalog.components.map((c) => c.id);
@@ -22427,7 +22530,7 @@ async function restoreOverlayBackup(projectRoot) {
   const workflowsDest = resolve23(projectRoot, ".codeconductor", "workflows");
   if (existsSync5(workflowsBackup)) {
     await mkdir17(workflowsDest, { recursive: true });
-    const files = await readdir6(workflowsBackup);
+    const files = await readdir7(workflowsBackup);
     for (const file of files) {
       await copyFile2(join18(workflowsBackup, file), join18(workflowsDest, file));
     }
@@ -22453,7 +22556,7 @@ async function snapshotForBackup(projectRoot) {
   if (existsSync5(workflowsDir)) {
     const dest = join18(backupRoot, "workflows");
     await mkdir17(dest, { recursive: true });
-    const files = await readdir6(workflowsDir);
+    const files = await readdir7(workflowsDir);
     for (const file of files) {
       if (file.endsWith(".yml")) {
         await copyFile2(join18(workflowsDir, file), join18(dest, file));
@@ -24096,6 +24199,9 @@ var init_backlog_planner = __esm(() => {
 // src/core/openspec/openspec-generator.ts
 import { mkdir as mkdir19, rename as rename3, writeFile as writeFile18 } from "node:fs/promises";
 import { basename as basename3, resolve as resolve26 } from "node:path";
+function pad3(n) {
+  return String(n).padStart(3, "0");
+}
 function proposalContent(item) {
   return `# Proposal: ${item.title}
 
@@ -24111,8 +24217,8 @@ ${item.businessValue ? `**Business value:** ${item.businessValue}` : ""}
 
 ## Capabilities
 
-- **New Capabilities:** (to be refined in design phase)
-- **Modified Capabilities:** (to be refined in design phase)
+- **New Capabilities:** ${item.title}
+- **Modified Capabilities:** none
 
 ## Impact
 
@@ -24121,12 +24227,12 @@ ${item.risks ? `Risks: ${item.risks}` : "See design.md for technical impact."}
 **Out of scope:** ${item.outOfScope || "None specified."}
 `;
 }
-function designPlaceholder(item) {
+function designContent(item) {
   return `# Design: ${item.title}
 
 ## Approach
 
-(To be completed in design phase.)
+Deliver "${item.title}" inside ${item.scope}. The architect MUST refine files and risks before implementation.
 
 ## Files Affected
 
@@ -24136,40 +24242,94 @@ ${item.scope}
 
 ${item.acceptanceCriteria.map((c) => `- ${c}`).join(`
 `)}
+
+## Complexity Tracking
+
+| Violation | Why needed | Simpler alternative rejected |
+| --------- | ---------- | ---------------------------- |
+| none | — | — |
+`;
+}
+function specDelta(item) {
+  const criteria = item.acceptanceCriteria.length > 0 ? item.acceptanceCriteria : [`${item.title} is delivered`];
+  const blocks = criteria.map((criterion, index) => {
+    const n = pad3(index + 1);
+    return `### Requirement: FR-${n} ${criterion}
+
+The system MUST ${criterion}.
+
+#### Scenario: SC-${n} ${criterion}
+
+- GIVEN the current behavior in ${item.scope}
+- WHEN this change is applied
+- THEN ${criterion}
+`;
+  });
+  return `# Delta Spec: ${item.title}
+
+## ADDED Requirements
+
+${blocks.join(`
+`)}
 `;
 }
-async function writeTasksMarkdown(projectRoot, changePath, cards) {
+async function writeTasksMarkdown(projectRoot, changePath, cards, options = {}) {
   await mkdir19(resolve26(projectRoot, changePath), { recursive: true });
-  await writeFile18(resolve26(projectRoot, changePath, "tasks.md"), tasksContent(cards), "utf-8");
+  await writeFile18(resolve26(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
 }
-function tasksContent(cards) {
-  const implCards = cards.filter((c) => c.phase === "implement" || c.phase === "test");
-  const lines = ["# Implementation Tasks", ""];
-  for (const card of implCards) {
+function tasksContent(cards, options = {}) {
+  const criteria = options.acceptanceCriteria ?? [];
+  const lines = [
+    "# Implementation Tasks",
+    "",
+    "## Setup",
+    "",
+    "- [ ] Confirm scope and OpenSpec change folder",
+    "",
+    "## Foundational",
+    "",
+    "- [ ] Read existing conventions in scope",
+    "",
+    "## Requirements",
+    ""
+  ];
+  if (criteria.length === 0) {
+    lines.push("- [ ] Implementation tasks (generated after plan)");
+  } else {
+    for (const [index, criterion] of criteria.entries()) {
+      const n = pad3(index + 1);
+      if (options.tddRequired) {
+        lines.push(`- [ ] Write failing test for FR-${n} (${criterion})`);
+      }
+      lines.push(`- [ ] Implement FR-${n} (${criterion})`);
+      lines.push(`- [ ] Verify SC-${n}`);
+    }
+  }
+  const phaseCards = cards.filter((c) => c.phase === "implement" || c.phase === "test");
+  lines.push("", "## Phase cards", "");
+  for (const card of phaseCards) {
     const checked = card.status === "done" ? "x" : " ";
     lines.push(`- [${checked}] ${card.title} (${card.id})`);
   }
-  if (implCards.length === 0) {
+  if (phaseCards.length === 0) {
     lines.push("- [ ] Implementation tasks (generated after plan)");
   }
+  lines.push("", "## Polish", "", "- [ ] Run openspec analyze and scorecard create --from-diff");
   return lines.join(`
 `);
 }
-async function generateOpenspecChange(projectRoot, item, taskCards) {
+async function generateOpenspecChange(projectRoot, item, taskCards, options = {}) {
   const slug = buildChangeSlug(item);
   const changeDir = resolve26(projectRoot, "openspec", "changes", slug);
   await mkdir19(resolve26(changeDir, "specs"), { recursive: true });
+  const taskOpts = {
+    tddRequired: options.tddRequired,
+    acceptanceCriteria: options.acceptanceCriteria ?? item.acceptanceCriteria
+  };
   await writeFile18(resolve26(changeDir, "proposal.md"), proposalContent(item), "utf-8");
-  await writeFile18(resolve26(changeDir, "design.md"), designPlaceholder(item), "utf-8");
-  await writeFile18(resolve26(changeDir, "tasks.md"), tasksContent(taskCards), "utf-8");
-  const specStub = `# Delta Spec: ${item.title}
-
-## ADDED Requirements
-
-${item.acceptanceCriteria.map((c) => `- ${c}`).join(`
-`)}
-`;
-  await writeFile18(resolve26(changeDir, "specs", "delta.md"), specStub, "utf-8");
+  await writeFile18(resolve26(changeDir, "design.md"), designContent(item), "utf-8");
+  await writeFile18(resolve26(changeDir, "tasks.md"), tasksContent(taskCards, taskOpts), "utf-8");
+  await writeFile18(resolve26(changeDir, "specs", "delta.md"), specDelta(item), "utf-8");
   return `openspec/changes/${slug}`;
 }
 async function archiveChangeFolder(projectRoot, changePath) {
@@ -24198,13 +24358,362 @@ var init_openspec_generator = __esm(() => {
   init_backlog_planner();
 });
 
+// src/core/openspec/spec-quality.ts
+import { readdir as readdir8, readFile as readFile28 } from "node:fs/promises";
+import { join as join20, relative as relative5, resolve as resolve27 } from "node:path";
+function uniqueIds(matches) {
+  return [...new Set(matches ?? [])];
+}
+function requirementBlocks(content) {
+  const parts = content.split(/^### Requirement:/m);
+  return parts.slice(1).map((block) => `### Requirement:${block}`);
+}
+function assessSpecMarkdown(content, path) {
+  const issues = [];
+  const clarifications = content.match(NEEDS_CLARIFICATION) ?? [];
+  const needsClarificationCount = clarifications.length;
+  const frIds = uniqueIds(content.match(FR_ID));
+  const scIds = uniqueIds(content.match(SC_ID));
+  const usAcIds = uniqueIds(content.match(US_AC));
+  const hasTraceIds = frIds.length > 0 && (scIds.length > 0 || usAcIds.length > 0);
+  if (PLACEHOLDER.test(content)) {
+    issues.push({
+      code: "PLACEHOLDER",
+      message: 'Spec still contains a "(To be completed" placeholder',
+      path,
+      severity: "error"
+    });
+  }
+  if (needsClarificationCount > MAX_CLARIFICATIONS) {
+    issues.push({
+      code: "TOO_MANY_CLARIFICATIONS",
+      message: `Found ${needsClarificationCount} [NEEDS CLARIFICATION] markers (max ${MAX_CLARIFICATIONS})`,
+      path,
+      severity: "error"
+    });
+  }
+  if (!hasTraceIds) {
+    issues.push({
+      code: "MISSING_TRACE_IDS",
+      message: "Spec MUST include FR-### identifiers and SC-### (or US#/AC#) success criteria",
+      path,
+      severity: "error"
+    });
+  }
+  const blocks = requirementBlocks(content);
+  if (blocks.length === 0) {
+    issues.push({
+      code: "MISSING_REQUIREMENT",
+      message: 'Spec MUST include at least one "### Requirement:" block',
+      path,
+      severity: "error"
+    });
+  }
+  for (const block of blocks) {
+    const heading = block.split(`
+`, 1)[0] ?? "";
+    if (!RFC2119.test(block)) {
+      issues.push({
+        code: "MISSING_RFC2119",
+        message: `Requirement "${heading}" MUST use RFC 2119 keywords (MUST/SHALL/SHOULD/MAY)`,
+        path,
+        severity: "error"
+      });
+    }
+    if (!GWT.test(block)) {
+      issues.push({
+        code: "MISSING_GWT",
+        message: `Requirement "${heading}" MUST include a Given/When/Then scenario`,
+        path,
+        severity: "error"
+      });
+    }
+  }
+  if (HOW_LEAK.test(content) && /specs[/\\]/.test(path.replace(/\\/g, "/"))) {
+    issues.push({
+      code: "HOW_IN_SPEC",
+      message: "Spec describes stack/HOW details; keep WHAT here and HOW in design.md",
+      path,
+      severity: "warning"
+    });
+  }
+  const requirements = frIds.map((id) => ({ id, text: id }));
+  const successCriteria = [...scIds, ...usAcIds].map((id) => ({ id, text: id }));
+  const errors3 = issues.filter((i) => i.severity === "error");
+  return {
+    valid: errors3.length === 0,
+    needsClarificationCount,
+    stopForClarify: needsClarificationCount > 0 && needsClarificationCount <= MAX_CLARIFICATIONS,
+    issues,
+    requirements,
+    successCriteria
+  };
+}
+function mergeSpecQualityReports(reports) {
+  if (reports.length === 0) {
+    return {
+      valid: true,
+      needsClarificationCount: 0,
+      stopForClarify: false,
+      issues: [],
+      requirements: [],
+      successCriteria: []
+    };
+  }
+  const issues = reports.flatMap((r) => r.issues);
+  const requirements = reports.flatMap((r) => r.requirements);
+  const successCriteria = reports.flatMap((r) => r.successCriteria);
+  const needsClarificationCount = reports.reduce((sum, r) => sum + r.needsClarificationCount, 0);
+  return {
+    valid: issues.every((i) => i.severity !== "error"),
+    needsClarificationCount,
+    stopForClarify: needsClarificationCount > 0 && needsClarificationCount <= MAX_CLARIFICATIONS,
+    issues,
+    requirements,
+    successCriteria
+  };
+}
+async function walkMarkdown(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir8(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = join20(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await walkMarkdown(full));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+async function assessChangeFolder(projectRoot, changePath) {
+  const root = resolve27(projectRoot);
+  const changeRoot = resolve27(root, changePath);
+  if (!changeRoot.startsWith(root)) {
+    return {
+      valid: false,
+      needsClarificationCount: 0,
+      stopForClarify: false,
+      issues: [
+        {
+          code: "PATH_ESCAPE",
+          message: "Change path escapes the project root",
+          path: changePath,
+          severity: "error"
+        }
+      ],
+      requirements: [],
+      successCriteria: []
+    };
+  }
+  const specDir = join20(changeRoot, "specs");
+  const specFiles = await walkMarkdown(specDir);
+  const extra = ["proposal.md", "design.md"].map((name) => join20(changeRoot, name));
+  const reports = [];
+  for (const file of specFiles) {
+    const content = await readFile28(file, "utf-8");
+    reports.push(assessSpecMarkdown(content, relative5(root, file).replace(/\\/g, "/")));
+  }
+  for (const file of extra) {
+    let content;
+    try {
+      content = await readFile28(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const rel = relative5(root, file).replace(/\\/g, "/");
+    if (PLACEHOLDER.test(content)) {
+      reports.push({
+        valid: false,
+        needsClarificationCount: 0,
+        stopForClarify: false,
+        issues: [
+          {
+            code: "PLACEHOLDER",
+            message: 'Artifact still contains a "(To be completed" placeholder',
+            path: rel,
+            severity: "error"
+          }
+        ],
+        requirements: [],
+        successCriteria: []
+      });
+    }
+  }
+  if (specFiles.length === 0) {
+    reports.push({
+      valid: false,
+      needsClarificationCount: 0,
+      stopForClarify: false,
+      issues: [
+        {
+          code: "MISSING_SPEC",
+          message: "Change folder has no specs/*.md artifacts",
+          path: `${changePath.replace(/\\/g, "/")}/specs`,
+          severity: "error"
+        }
+      ],
+      requirements: [],
+      successCriteria: []
+    });
+  }
+  return mergeSpecQualityReports(reports);
+}
+var RFC2119, FR_ID, SC_ID, US_AC, GWT, NEEDS_CLARIFICATION, PLACEHOLDER, HOW_LEAK, MAX_CLARIFICATIONS = 3;
+var init_spec_quality = __esm(() => {
+  RFC2119 = /\b(MUST(?: NOT)?|SHALL(?: NOT)?|SHOULD(?: NOT)?|MAY)\b/;
+  FR_ID = /\bFR-\d{3}\b/g;
+  SC_ID = /\bSC-\d{3}\b/g;
+  US_AC = /\b(?:US|AC)#?\d+\b/g;
+  GWT = /\bGIVEN\b[\s\S]{0,400}\bWHEN\b[\s\S]{0,400}\bTHEN\b/i;
+  NEEDS_CLARIFICATION = /\[NEEDS CLARIFICATION:[^\]]*\]/gi;
+  PLACEHOLDER = /\(To be completed/i;
+  HOW_LEAK = /\b(TypeScript|PostgreSQL|Django|React|Spring Boot|package\.json|implements class)\b/i;
+});
+
+// src/core/openspec/spec-analyzer.ts
+import { readFile as readFile29 } from "node:fs/promises";
+import { join as join21, resolve as resolve28 } from "node:path";
+function unique(ids) {
+  return [...new Set(ids)];
+}
+function coverage(mapped, total) {
+  if (total === 0)
+    return 100;
+  return Math.round(mapped / total * 1000) / 10;
+}
+function mentionsId(haystack, id) {
+  return haystack.includes(id);
+}
+function testSection(tasksMarkdown) {
+  const lines = tasksMarkdown.split(`
+`);
+  const kept = [];
+  for (const line of lines) {
+    if (/\btest\b|TDD|RED|suite/i.test(line)) {
+      kept.push(line);
+    }
+  }
+  return kept.join(`
+`);
+}
+function analyzeSpecArtifacts(input) {
+  const quality = assessSpecMarkdown(input.specMarkdown, `${input.changePath}/specs`);
+  const frIds = unique(quality.requirements.map((r) => r.id));
+  const scIds = unique(quality.successCriteria.map((s) => s.id));
+  const tasks = input.tasksMarkdown;
+  const testTasks = testSection(tasks);
+  const mappedFr = frIds.filter((id) => mentionsId(tasks, id));
+  const mappedSc = scIds.filter((id) => mentionsId(tasks, id));
+  const mappedToTests = frIds.filter((id) => mentionsId(testTasks, id));
+  const findings = [];
+  for (const issue of quality.issues.filter((i) => i.severity === "error")) {
+    findings.push({
+      severity: "CRITICAL",
+      code: issue.code,
+      message: issue.message
+    });
+  }
+  if (input.tddRequired) {
+    for (const id of frIds) {
+      if (!mappedToTests.includes(id)) {
+        findings.push({
+          severity: "CRITICAL",
+          code: "TDD_FR_UNTESTED",
+          message: `${id} has no test task while TDD required is yes`
+        });
+      }
+    }
+    if (input.hasTddEvidence === false && frIds.length > 0) {
+      findings.push({
+        severity: "HIGH",
+        code: "TDD_EVIDENCE_MISSING",
+        message: "TDD required but no verification-runner suite evidence was found"
+      });
+    }
+  }
+  const policy = input.policyText ?? "";
+  const design = input.designMarkdown ?? "";
+  if (/\bMUST\b/.test(policy) && /skip TDD|ignore AGENTS|bypass review/i.test(design)) {
+    findings.push({
+      severity: "CRITICAL",
+      code: "POLICY_CONFLICT",
+      message: "design.md conflicts with a MUST in AGENTS.md / BACKLOG Global"
+    });
+  }
+  if (quality.stopForClarify) {
+    findings.push({
+      severity: "HIGH",
+      code: "NEEDS_CLARIFICATION",
+      message: "Spec has [NEEDS CLARIFICATION] markers — run ccep evaluate and stop"
+    });
+  }
+  const frCoveragePct = coverage(mappedFr.length, frIds.length);
+  const scCoveragePct = coverage(mappedSc.length, scIds.length);
+  const testCoveragePct = coverage(mappedToTests.length, frIds.length);
+  const stop = findings.some((f) => f.severity === "CRITICAL");
+  return {
+    changePath: input.changePath,
+    frIds,
+    scIds,
+    mappedFr,
+    mappedSc,
+    mappedToTests,
+    frCoveragePct,
+    scCoveragePct,
+    testCoveragePct,
+    findings,
+    stop,
+    quality
+  };
+}
+async function analyzeChangeFolder(projectRoot, changePath, options) {
+  const changeRoot = resolve28(projectRoot, changePath);
+  const specPath = join21(changeRoot, "specs", "delta.md");
+  let specMarkdown = "";
+  try {
+    specMarkdown = await readFile29(specPath, "utf-8");
+  } catch {
+    specMarkdown = "";
+  }
+  let tasksMarkdown = "";
+  try {
+    tasksMarkdown = await readFile29(join21(changeRoot, "tasks.md"), "utf-8");
+  } catch {
+    tasksMarkdown = "";
+  }
+  let designMarkdown;
+  try {
+    designMarkdown = await readFile29(join21(changeRoot, "design.md"), "utf-8");
+  } catch {
+    designMarkdown = undefined;
+  }
+  return analyzeSpecArtifacts({
+    changePath,
+    specMarkdown,
+    tasksMarkdown,
+    designMarkdown,
+    policyText: options.policyText,
+    tddRequired: options.tddRequired,
+    hasTddEvidence: options.hasTddEvidence
+  });
+}
+var init_spec_analyzer = __esm(() => {
+  init_spec_quality();
+});
+
 // src/commands/openspec.command.ts
 var exports_openspec_command = {};
 __export(exports_openspec_command, {
   openspecCommand: () => openspecCommand
 });
-import { readFile as readFile28 } from "node:fs/promises";
-import { resolve as resolve27 } from "node:path";
+import { readFile as readFile30 } from "node:fs/promises";
+import { resolve as resolve29 } from "node:path";
 async function openspecCommand(options) {
   const { subcommand, itemId, projectRoot, output, reason } = options;
   switch (subcommand) {
@@ -24214,6 +24723,8 @@ async function openspecCommand(options) {
       return handleScan(projectRoot);
     case "plan":
       return handlePlan(projectRoot, itemId);
+    case "analyze":
+      return handleAnalyze(projectRoot, itemId);
     case "status":
       return handleStatus2(projectRoot);
     case "next":
@@ -24246,7 +24757,7 @@ function fail(command, errors3, extra = {}) {
   };
 }
 async function persistBacklog(projectRoot, content) {
-  await writeFileAtomic(resolve27(projectRoot, BACKLOG_FILENAME), content);
+  await writeFileAtomic(resolve29(projectRoot, BACKLOG_FILENAME), content);
 }
 async function persistState(projectRoot, state) {
   const written = await writeOpenspecState(projectRoot, state);
@@ -24256,7 +24767,7 @@ async function persistState(projectRoot, state) {
   return { ok: true };
 }
 async function readBacklogMarkdown(projectRoot) {
-  return readFile28(resolve27(projectRoot, BACKLOG_FILENAME), "utf-8");
+  return readFile30(resolve29(projectRoot, BACKLOG_FILENAME), "utf-8");
 }
 async function transitionItem(projectRoot, item, to, progress) {
   const content = await readBacklogMarkdown(projectRoot);
@@ -24289,14 +24800,31 @@ async function handleValidate(projectRoot) {
     };
   }
   const report = validateBacklog(loadResult.data);
+  const errors3 = report.errors.map((e) => e.message);
+  const recommendations = [...report.recommendations];
+  let specValid = true;
+  const stateResult = await loadOpenspecState(projectRoot);
+  const activeId = stateResult.success ? stateResult.data.activeItemId : undefined;
+  const changePath = activeId && stateResult.success ? stateResult.data.changePaths[activeId] : undefined;
+  if (changePath && !changePath.includes("/archive/")) {
+    const specReport = await assessChangeFolder(projectRoot, changePath);
+    specValid = specReport.valid;
+    for (const issue of specReport.issues.filter((i) => i.severity === "error")) {
+      errors3.push(`${issue.path}: ${issue.message}`);
+    }
+    if (specReport.stopForClarify) {
+      recommendations.push("Spec has [NEEDS CLARIFICATION] markers — run ccep evaluate and wait for human input.");
+    }
+  }
+  const valid = report.valid && specValid;
   return {
-    code: report.valid ? 0 : 1,
+    code: valid ? 0 : 1,
     data: {
-      success: report.valid,
+      success: valid,
       command: "openspec validate",
-      valid: report.valid,
-      errors: report.errors.map((e) => e.message),
-      recommendations: report.recommendations,
+      valid,
+      errors: errors3,
+      recommendations,
       itemCount: loadResult.data.items.length,
       archiveCount: loadResult.data.archive.length
     }
@@ -24376,7 +24904,10 @@ async function handlePlan(projectRoot, itemId) {
   const planned = planTaskCardsForItem(item, doc, existingState.taskCards, existingState.itemSnapshots?.[item.id]);
   const taskCards = planned.cards;
   await ensureOpenspecConfig(projectRoot);
-  const changePath = await generateOpenspecChange(projectRoot, item, taskCards);
+  const changePath = await generateOpenspecChange(projectRoot, item, taskCards, {
+    tddRequired: doc.global.tddRequired,
+    acceptanceCriteria: item.acceptanceCriteria
+  });
   const newState = {
     ...existingState,
     version: 1,
@@ -24415,6 +24946,69 @@ async function handlePlan(projectRoot, itemId) {
     }
   };
 }
+async function handleAnalyze(projectRoot, itemId) {
+  const command = "openspec analyze";
+  const stateResult = await loadOpenspecState(projectRoot);
+  if (!stateResult.success) {
+    return fail(command, [stateResult.error.message]);
+  }
+  const targetId = itemId ?? stateResult.data.activeItemId;
+  if (!targetId) {
+    return fail(command, ["No active change. Run openspec plan or pass an item id."]);
+  }
+  const changePath = stateResult.data.changePaths[targetId];
+  if (!changePath || changePath.includes("/archive/")) {
+    return fail(command, [`No active change folder for ${targetId}`]);
+  }
+  const backlog = await loadBacklog(projectRoot);
+  const tddRequired = backlog.success ? backlog.data.global.tddRequired : false;
+  const policyParts = [];
+  for (const name of ["AGENTS.md", "BACKLOG.md"]) {
+    try {
+      policyParts.push(await readFile30(resolve29(projectRoot, name), "utf-8"));
+    } catch {}
+  }
+  const cards = itemCards(stateResult.data, targetId);
+  const tddCards = cards.filter((c) => c.phase === "test" || c.phase === "implement");
+  let hasTddEvidence;
+  if (tddCards.length > 0) {
+    hasTddEvidence = false;
+    for (const card of tddCards) {
+      if (await hasTddRunnerEvidence(projectRoot, card.id)) {
+        hasTddEvidence = true;
+        break;
+      }
+    }
+  }
+  const report = await analyzeChangeFolder(projectRoot, changePath, {
+    tddRequired,
+    policyText: policyParts.join(`
+`),
+    hasTddEvidence
+  });
+  const data = SpecAnalyzeReportSchema.parse({
+    changePath: report.changePath,
+    frIds: report.frIds,
+    scIds: report.scIds,
+    mappedFr: report.mappedFr,
+    mappedSc: report.mappedSc,
+    mappedToTests: report.mappedToTests,
+    frCoveragePct: report.frCoveragePct,
+    scCoveragePct: report.scCoveragePct,
+    testCoveragePct: report.testCoveragePct,
+    findings: report.findings,
+    stop: report.stop
+  });
+  return {
+    code: report.stop ? 1 : 0,
+    data: {
+      success: !report.stop,
+      command,
+      ...data,
+      stopForClarify: report.quality.stopForClarify
+    }
+  };
+}
 async function handleStatus2(projectRoot) {
   const loadResult = await loadBacklog(projectRoot);
   const stateResult = await loadOpenspecState(projectRoot);
@@ -24563,6 +25157,16 @@ async function handleDone(projectRoot, cardId) {
   const itemLoaded = await loadItemOrFail(projectRoot, card.backlogId, command);
   if (!itemLoaded.ok)
     return itemLoaded.response;
+  const backlog = await loadBacklog(projectRoot);
+  const tddRequired = backlog.success ? backlog.data.global.tddRequired : false;
+  if (tddRequired && (card.phase === "test" || card.phase === "implement")) {
+    const evidenced = await hasTddRunnerEvidence(projectRoot, cardId);
+    if (!evidenced) {
+      return fail(command, [
+        `Card ${cardId} (${card.phase}) requires verification-runner TDD evidence. Run captureTddSuiteEvidence before openspec done.`
+      ]);
+    }
+  }
   const state = setTaskCardStatus(loaded.state, cardId, "done");
   const cards = itemCards(state, card.backlogId);
   const doneCount = cards.filter((c) => c.status === "done").length;
@@ -24573,7 +25177,10 @@ async function handleDone(projectRoot, cardId) {
     return fail(command, [written.error]);
   const changePath = state.changePaths[card.backlogId];
   if (changePath) {
-    await writeTasksMarkdown(projectRoot, changePath, cards);
+    await writeTasksMarkdown(projectRoot, changePath, cards, {
+      tddRequired,
+      acceptanceCriteria: itemLoaded.item.acceptanceCriteria
+    });
   }
   const nextStatus = allDone ? "REVIEW" : "IN_PROGRESS";
   const transition = await transitionItem(projectRoot, itemLoaded.item, nextStatus, progress);
@@ -24659,6 +25266,12 @@ async function handleArchive(projectRoot, itemId) {
         `Cannot archive ${itemId}: global.reviewRequired needs the review phase card done`
       ]);
     }
+    const passed = await hasPassingScorecard(projectRoot, itemId);
+    if (!passed) {
+      return fail(command, [
+        `Cannot archive ${itemId}: global.reviewRequired needs a PASS scorecard for this backlog id`
+      ]);
+    }
   }
   if (itemLoaded.item.status !== "DONE") {
     const toDone = await transitionItem(projectRoot, itemLoaded.item, "DONE", 100);
@@ -24697,47 +25310,302 @@ async function handleArchive(projectRoot, itemId) {
     }
   };
 }
-var KNOWN_SUBCOMMANDS = "validate, scan, plan, status, next, start, done, block, archive";
+var KNOWN_SUBCOMMANDS = "validate, scan, plan, analyze, status, next, start, done, block, archive";
 var init_openspec_command = __esm(() => {
   init_backlog_parser();
   init_backlog_validator();
   init_backlog_scanner();
   init_backlog_planner();
   init_openspec_generator();
+  init_spec_quality();
+  init_spec_analyzer();
+  init_schemas();
+  init_verification_runner();
+  init_outcome_store();
   init_openspec_state();
   init_backlog_parser();
   init_loop_engine();
 });
 
-// src/core/evaluation/scorecard-constants.ts
-var SCORECARD_CRITERIA_DEF;
-var init_scorecard_constants = __esm(() => {
-  SCORECARD_CRITERIA_DEF = [
-    { id: "acceptance", label: "Acceptance criteria met", weight: 0.3 },
-    { id: "minimal_diff", label: "Minimal diff (no scope creep)", weight: 0.2 },
-    { id: "tests", label: "Tests present and passing", weight: 0.15 },
-    { id: "regressions", label: "No regressions introduced", weight: 0.15 },
-    { id: "conventions", label: "Code follows project conventions", weight: 0.1 },
-    { id: "documentation", label: "Documentation updated if required", weight: 0.05 },
-    { id: "context_discipline", label: "Context discipline", weight: 0.05 },
-    { id: "cc_gain", label: "Complexity diffusion (cc-gain)", weight: 0.05 }
-  ];
-});
-
-// src/core/evaluation/scorecard-calculator.ts
-function createDefaultCriteria(overrides = {}) {
-  return SCORECARD_CRITERIA_DEF.map((def) => {
-    const o = overrides[def.id];
+// src/core/hooks/hook-runner.ts
+function normalizeCommand(raw) {
+  return raw.replace(/\s+/g, " ").trim();
+}
+function stripGitBinary(command) {
+  return command.replace(/(?:^|[\\/])git(?:\.exe)?\b/i, "git");
+}
+function evaluatePath(filePath) {
+  if (SENSITIVE_PATH.test(filePath.replace(/\//g, "\\")) || SENSITIVE_PATH.test(filePath)) {
+    return deny(MSG_SECRET);
+  }
+  return allow();
+}
+function evaluateCommand(rawCommand) {
+  const command = stripGitBinary(normalizeCommand(rawCommand));
+  if (!command)
+    return allow();
+  if (SENSITIVE_PATH.test(command) && READ_LIKE.test(command)) {
+    return deny(MSG_SECRET);
+  }
+  if (isGitPush(command))
+    return deny(MSG_AUTHORITY);
+  if (/^git\s+reset\s+--hard\b/i.test(command))
+    return deny(MSG_AUTHORITY);
+  if (isForcedClean(command))
+    return deny(MSG_AUTHORITY);
+  if (isForcedBranchDelete(command))
+    return deny(MSG_AUTHORITY);
+  if (isDestructiveCheckout(command))
+    return deny(MSG_AUTHORITY);
+  if (isDestructiveRestore(command))
+    return deny(MSG_AUTHORITY);
+  if (/^git\s+rebase\b/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^git\s+push\b/i.test(command) && /(?:\s--force\b|\s-f\b)/.test(command)) {
+    return deny(MSG_AUTHORITY);
+  }
+  if (/^rm\s+-rf\s+(\*|[\\/])/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^sudo\s+/i.test(command))
+    return deny(MSG_POLICY);
+  if (/(?:curl|wget)\b.+\|\s*(sh|bash|zsh|cmd)\b/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^chmod\s+777\b/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^dd\s+/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^mkfs\b/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^git\s+commit\b/i.test(command) || /^git\s+switch\b/i.test(command) || /^docker\s+compose\b/i.test(command)) {
+    return ask();
+  }
+  return allow();
+}
+function evaluatePreTool(input) {
+  if (input.filePath) {
+    const pathVerdict = evaluatePath(input.filePath);
+    if (pathVerdict.action === "deny")
+      return pathVerdict;
+  }
+  if (input.command) {
+    return evaluateCommand(input.command);
+  }
+  return allow();
+}
+function formatHookOutput(verdict, format) {
+  if (format === "agy") {
+    if (verdict.action === "deny") {
+      return JSON.stringify({ decision: "deny", error: verdict.message });
+    }
+    if (verdict.action === "ask") {
+      return JSON.stringify({ decision: "ask" });
+    }
+    return JSON.stringify({ decision: "allow" });
+  }
+  return "";
+}
+function claudeExitCode(verdict) {
+  return verdict.action === "deny" ? 2 : 0;
+}
+function parseAgyPayload(raw) {
+  if (!raw.trim())
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    const args = parsed.arguments ?? {};
     return {
-      id: def.id,
-      label: def.label,
-      weight: def.weight,
-      score: o?.score ?? 2,
-      notes: o?.notes,
-      autoSuggested: o?.autoSuggested
+      toolName: parsed.toolName,
+      command: args.CommandLine,
+      filePath: args.TargetFile ?? args.AbsolutePath
     };
-  });
-}
+  } catch {
+    return {};
+  }
+}
+function formatSessionStart(lines) {
+  return lines.filter(Boolean).join(`
+`);
+}
+function allow() {
+  return { action: "allow", message: "", exitCode: 0 };
+}
+function ask() {
+  return { action: "ask", message: "", exitCode: 0 };
+}
+function deny(message) {
+  return { action: "deny", message, exitCode: 2 };
+}
+function isGitPush(command) {
+  return /^git\s+push\b/i.test(command);
+}
+function isForcedClean(command) {
+  if (!/^git\s+clean\b/i.test(command))
+    return false;
+  if (/\s--force\b/.test(command))
+    return true;
+  const flagMatch = command.match(/\s-([a-zA-Z]+)/g);
+  return (flagMatch ?? []).some((part) => part.includes("f") || part.includes("F"));
+}
+function isForcedBranchDelete(command) {
+  if (!/^git\s+branch\b/i.test(command))
+    return false;
+  if (/\s-D\b/.test(command))
+    return true;
+  return /\s--delete\b/.test(command) && /\s--force\b/.test(command);
+}
+function isDestructiveCheckout(command) {
+  if (!/^git\s+checkout\b/i.test(command))
+    return false;
+  if (/\s(?:-f|--force|--discard-changes|--theirs|--ours)\b/.test(command))
+    return true;
+  return /^git\s+checkout\s+-\s*$/i.test(command);
+}
+function isDestructiveRestore(command) {
+  if (!/^git\s+restore\b/i.test(command))
+    return false;
+  return /\s(?:-f|--force|--discard-changes|--theirs|--ours)\b/.test(command);
+}
+var SENSITIVE_PATH, READ_LIKE, MSG_SECRET = "Bloqueado: intento de leer archivos sensibles", MSG_AUTHORITY = "Bloqueado: El agente no tiene autoridad sobre este comando.", MSG_POLICY = "Bloqueado: Command violated security policy";
+var init_hook_runner = __esm(() => {
+  SENSITIVE_PATH = /(?:\.env\b|secrets[/\\]|id_rsa|\.pem\b|\.key\b|(?:^|[/\\])\.ssh(?:[/\\]|$)|(?:^|[/\\])\.aws(?:[/\\]|$)|(?:^|[/\\])\.kube(?:[/\\]|$))/i;
+  READ_LIKE = /(?:^|[\s;&|])(cat|less|more|head|tail|type|Get-Content|cp|copy|mv|move|scp)\b/i;
+});
+
+// src/commands/hook.command.ts
+var exports_hook_command = {};
+__export(exports_hook_command, {
+  readStdinText: () => readStdinText,
+  hookCommand: () => hookCommand
+});
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve30 } from "node:path";
+function detectFormat(explicit, stdinText) {
+  if (explicit)
+    return explicit;
+  const trimmed = stdinText.trim();
+  if (trimmed.startsWith("{"))
+    return "agy";
+  return "claude";
+}
+async function readStdinText() {
+  if (process.stdin.isTTY)
+    return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function resolvePreToolInput(options, stdinText) {
+  const fromStdin = parseAgyPayload(stdinText);
+  return {
+    command: options.command ?? process.env.CLAUDE_TOOL_INPUT_COMMAND ?? fromStdin.command,
+    filePath: options.filePath ?? process.env.CLAUDE_TOOL_INPUT_FILE_PATH ?? fromStdin.filePath,
+    toolName: fromStdin.toolName
+  };
+}
+async function sessionLines(projectRoot) {
+  const backlogPath = resolve30(projectRoot, "BACKLOG.md");
+  const profilePath = resolve30(projectRoot, ".codeconductor", "evaluation", "execution-profile.yml");
+  return [
+    "[CodeConductor] Session start",
+    "Skills: openspec, backlog, evaluation, testing-tdd — invoke via /cc-* then CLI.",
+    existsSync7(backlogPath) ? "BACKLOG.md present — run: bun run dev openspec status" : "No BACKLOG.md — author with /cc-backlog if you need an item queue.",
+    existsSync7(profilePath) ? "Scorecard profile on disk — run: bun run dev scorecard models" : "Scorecard: bun run dev scorecard create --task <id> --from-diff",
+    "Hooks: bun run dev hook pre-tool | post-tool | session-start",
+    "Eval suites: bun run dev scorecard suite-run --suite workflow-gates"
+  ];
+}
+async function hookCommand(options) {
+  const event = options.event;
+  const stdinText = options.stdinText ?? "";
+  const format = detectFormat(options.format, stdinText);
+  if (event === "session-start") {
+    const text = formatSessionStart(await sessionLines(options.projectRoot));
+    process.stdout.write(`${text}
+`);
+    return { code: 0, data: { success: true, command: "hook session-start" } };
+  }
+  if (event === "post-tool") {
+    const filePath = options.filePath ?? process.env.CLAUDE_TOOL_INPUT_FILE_PATH ?? parseAgyPayload(stdinText).filePath;
+    formatWrittenFile(filePath);
+    if (format === "agy") {
+      process.stdout.write(`{}
+`);
+    }
+    return { code: 0, data: { success: true, command: "hook post-tool" } };
+  }
+  const input = resolvePreToolInput(options, stdinText);
+  const verdict = evaluatePreTool(input);
+  if (format === "agy") {
+    process.stdout.write(`${formatHookOutput(verdict, "agy")}
+`);
+    return {
+      code: 0,
+      data: { success: verdict.action !== "deny", command: "hook pre-tool", verdict }
+    };
+  }
+  if (verdict.action === "deny") {
+    process.stderr.write(`${verdict.message}
+`);
+  }
+  return {
+    code: claudeExitCode(verdict),
+    data: { success: verdict.action !== "deny", command: "hook pre-tool", verdict }
+  };
+}
+function formatWrittenFile(filePath) {
+  if (!filePath || !existsSync7(filePath))
+    return;
+  const prettier = /\.(ts|tsx|js|jsx|mjs|cjs|json|jsonc|md|mdx|css|scss|html|astro|ya?ml)$/i;
+  const eslint = /\.(ts|tsx|js|jsx|mjs|cjs)$/i;
+  const python = /\.py$/i;
+  const opts = { stdio: "ignore", windowsHide: true };
+  if (prettier.test(filePath)) {
+    spawnSync("npx", ["--no-install", "prettier", "--write", filePath], opts);
+  }
+  if (eslint.test(filePath)) {
+    spawnSync("npx", ["--no-install", "eslint", "--fix", filePath], opts);
+  }
+  if (python.test(filePath)) {
+    spawnSync("ruff", ["format", filePath], opts);
+    spawnSync("ruff", ["check", "--fix", filePath], opts);
+  }
+}
+var init_hook_command = __esm(() => {
+  init_hook_runner();
+});
+
+// src/core/evaluation/scorecard-constants.ts
+var SCORECARD_CRITERIA_DEF;
+var init_scorecard_constants = __esm(() => {
+  SCORECARD_CRITERIA_DEF = [
+    { id: "acceptance", label: "Acceptance criteria met", weight: 0.3 },
+    { id: "minimal_diff", label: "Minimal diff (no scope creep)", weight: 0.2 },
+    { id: "tests", label: "Tests present and passing", weight: 0.15 },
+    { id: "regressions", label: "No regressions introduced", weight: 0.15 },
+    { id: "conventions", label: "Code follows project conventions", weight: 0.1 },
+    { id: "documentation", label: "Documentation updated if required", weight: 0.05 },
+    { id: "context_discipline", label: "Context discipline", weight: 0.05 },
+    { id: "cc_gain", label: "Complexity diffusion (cc-gain)", weight: 0.05 }
+  ];
+});
+
+// src/core/evaluation/scorecard-calculator.ts
+function createDefaultCriteria(overrides = {}) {
+  return SCORECARD_CRITERIA_DEF.map((def) => {
+    const o = overrides[def.id];
+    return {
+      id: def.id,
+      label: def.label,
+      weight: def.weight,
+      score: o?.score ?? 2,
+      notes: o?.notes,
+      autoSuggested: o?.autoSuggested
+    };
+  });
+}
 function computeWeightedScore(criteria) {
   let total = 0;
   for (const c of criteria) {
@@ -25106,9 +25974,19 @@ function ccGainToScorecardImpact(result) {
 
 // src/core/evaluation/scorecard-signals.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-function collectScorecardSignals(projectRoot, scopeFiles) {
+function collectScorecardSignals(projectRoot, scopeFiles, extra) {
   const findings = [];
   const overrides = {};
+  const scopeViolationCount = extra?.scopeViolationCount;
+  if (scopeViolationCount && scopeViolationCount > 0) {
+    overrides.scope = { score: 0, notes: `Found ${scopeViolationCount} scope violations`, autoSuggested: true };
+    findings.push(`Scope violation: ${scopeViolationCount} files outside scope.`);
+  }
+  const hashMismatch = extra?.hashMismatch;
+  if (hashMismatch) {
+    overrides.tests = { score: 0, notes: "Test tampering detected (hash mismatch)", autoSuggested: true };
+    findings.push("Test tampering detected via test-freeze hash mismatch.");
+  }
   let diff = "";
   try {
     diff = execFileSync3("git", ["diff", "HEAD"], {
@@ -25118,11 +25996,11 @@ function collectScorecardSignals(projectRoot, scopeFiles) {
     });
   } catch {
     findings.push("Could not read git diff; scope audit skipped.");
-    return { criteriaOverrides: overrides, findings };
+    return { criteriaOverrides: overrides, findings, scopeViolationCount, hashMismatch };
   }
   if (!diff.trim()) {
     overrides.minimal_diff = { score: 2, notes: "No diff detected", autoSuggested: true };
-    return { criteriaOverrides: overrides, findings };
+    return { criteriaOverrides: overrides, findings, scopeViolationCount, hashMismatch };
   }
   const changedFiles = new Set;
   for (const line of diff.split(`
@@ -25159,7 +26037,40 @@ function collectScorecardSignals(projectRoot, scopeFiles) {
   } catch {
     findings.push("Complexity audit skipped.");
   }
-  return { criteriaOverrides: overrides, findings };
+  return { criteriaOverrides: overrides, findings, scopeViolationCount, hashMismatch };
+}
+function applyAnalyzeSignals(hints, analyze) {
+  const criteriaOverrides = { ...hints.criteriaOverrides };
+  const findings = [...hints.findings];
+  if (analyze.frCoveragePct < 50) {
+    criteriaOverrides.acceptance = {
+      score: 0,
+      notes: `FR coverage ${analyze.frCoveragePct}%`,
+      autoSuggested: true
+    };
+    findings.push(`Acceptance auto-suggested 0: FR coverage ${analyze.frCoveragePct}%.`);
+  } else if (analyze.frCoveragePct === 100 && analyze.scCoveragePct === 100) {
+    criteriaOverrides.acceptance = {
+      score: 3,
+      notes: "All FR/SC mapped to tasks",
+      autoSuggested: true
+    };
+  } else {
+    criteriaOverrides.acceptance = {
+      score: 2,
+      notes: `FR coverage ${analyze.frCoveragePct}%, SC coverage ${analyze.scCoveragePct}%`,
+      autoSuggested: true
+    };
+  }
+  if (analyze.tddRequired && analyze.hasTddEvidence === false) {
+    criteriaOverrides.tests = {
+      score: 0,
+      notes: "TDD required but no verification-runner evidence",
+      autoSuggested: true
+    };
+    findings.push("Tests auto-suggested 0: missing verification-runner evidence.");
+  }
+  return { criteriaOverrides, findings };
 }
 function criteriaFromSignals(hints) {
   return createDefaultCriteria(hints.criteriaOverrides);
@@ -25169,12 +26080,315 @@ var init_scorecard_signals = __esm(() => {
   init_scorecard_calculator();
 });
 
+// src/core/evaluation/harness-experiment.ts
+import { existsSync as existsSync8 } from "node:fs";
+import { cp, mkdir as mkdir20, readFile as readFile31, readdir as readdir9, writeFile as writeFile19 } from "node:fs/promises";
+import { dirname as dirname8, join as join22, resolve as resolve31 } from "node:path";
+function experimentDir(projectRoot, experimentId) {
+  return resolve31(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
+}
+function experimentYamlPath(projectRoot, experimentId) {
+  return join22(experimentDir(projectRoot, experimentId), "experiment.yml");
+}
+async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
+  const candidates = suitePath ? [suitePath] : [
+    resolve31(projectRoot, "eval", "suites", suiteId, "suite.yml"),
+    resolve31(projectRoot, EVAL_DIR2, "suites", suiteId, "suite.yml")
+  ];
+  for (const path of candidates) {
+    if (!existsSync8(path))
+      continue;
+    try {
+      const suite = HarnessSuiteSchema.parse($parse(await readFile31(path, "utf-8")));
+      return ok({ ...suite, path });
+    } catch (e) {
+      return err(e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+  return err(new Error(`Harness suite not found: ${suiteId}`));
+}
+async function loadExperiment(projectRoot, experimentId) {
+  try {
+    const raw = await readFile31(experimentYamlPath(projectRoot, experimentId), "utf-8");
+    return ok(HarnessExperimentSchema.parse($parse(raw)));
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return err(new Error(`Experiment not found: ${experimentId}`));
+    }
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function listExperiments(projectRoot) {
+  const root = resolve31(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR);
+  if (!existsSync8(root))
+    return [];
+  const ids = await readdir9(root);
+  const experiments = [];
+  for (const id of ids) {
+    const loaded = await loadExperiment(projectRoot, id);
+    if (loaded.success)
+      experiments.push(loaded.data);
+  }
+  return experiments;
+}
+function formatTaskCard(task, experimentId, variantId) {
+  return [
+    "## Task Card",
+    "",
+    `**Title:** ${task.title}`,
+    `**Type:** ${task.type}`,
+    `**Risk:** ${task.risk}`,
+    `**Scope:** ${task.scope}`,
+    `**suiteTaskId:** ${task.id}`,
+    `**experimentId:** ${experimentId}`,
+    `**variantId:** ${variantId}`,
+    "",
+    "### Context",
+    "",
+    task.prompt,
+    "",
+    "### Acceptance Criteria",
+    "",
+    ...task.acceptanceCriteria.map((c) => `- [ ] ${c}`),
+    "",
+    "### Constraints",
+    "",
+    "- Stay inside the declared scope.",
+    "- Record the outcome with experiment and variant tags.",
+    "",
+    "### Scoring",
+    "",
+    "When done:",
+    "",
+    "```",
+    `bun run dev scorecard create --task ${task.id} --from-diff`,
+    `bun run dev scorecard record --task ${task.id} --verdict PASS|REVISE|REJECT --score <n> --experiment ${experimentId} --variant ${variantId} --suite-task ${task.id}`,
+    "```",
+    task.testCommand ? `
+Fixture test command: \`${task.testCommand}\`
+` : ""
+  ].join(`
+`);
+}
+function formatExperimentMarkdown(experiment) {
+  return [
+    `# Harness experiment ${experiment.id}`,
+    "",
+    `- Suite: ${experiment.suiteId}`,
+    `- Contract: ${experiment.contractVersion}`,
+    `- Created: ${experiment.createdAt}`,
+    `- Variants: ${experiment.variants.join(", ")}`,
+    `- Tasks: ${experiment.suiteTaskIds.join(", ")}`,
+    "",
+    "This runner does not invoke a model. Execute each run directory with the host",
+    "agent, then `scorecard record` with `--experiment` and `--variant`.",
+    "",
+    "Compare with:",
+    "",
+    "```",
+    `bun run dev scorecard ablation --experiment ${experiment.id}`,
+    "```",
+    ""
+  ].join(`
+`);
+}
+function generateExperimentId(suiteId, now = new Date) {
+  const date = now.toISOString().slice(0, 10).replaceAll("-", "");
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `abl-${date}-${suiteId}-${rand}`;
+}
+async function copyFixture(suitePath, fixtureDir, dest) {
+  const source = fixtureDir ? resolve31(dirname8(suitePath), fixtureDir) : join22(dirname8(suitePath), "fixture");
+  await mkdir20(dest, { recursive: true });
+  if (existsSync8(source)) {
+    await cp(source, dest, { recursive: true });
+  }
+}
+async function startHarnessExperiment(projectRoot, options) {
+  const suite = await loadHarnessSuite(projectRoot, options.suiteId, options.suitePath);
+  if (!suite.success)
+    return suite;
+  const experimentId = options.experimentId ?? generateExperimentId(suite.data.id);
+  const variants = ["baseline", ...options.components.map((id) => variantIdFor(id))];
+  const experiment = {
+    id: experimentId,
+    suiteId: suite.data.id,
+    createdAt: new Date().toISOString(),
+    contractVersion: options.contractVersion,
+    components: options.components,
+    variants,
+    suiteTaskIds: suite.data.tasks.map((t) => t.id),
+    suitePath: suite.data.path
+  };
+  const root = experimentDir(projectRoot, experimentId);
+  await mkdir20(root, { recursive: true });
+  await writeFile19(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
+  await writeFile19(join22(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
+  for (const task of suite.data.tasks) {
+    for (const variantId of variants) {
+      const runRoot = join22(root, "runs", task.id, variantDirName(variantId));
+      await copyFixture(suite.data.path, suite.data.fixtureDir, runRoot);
+      await writeConfig(runRoot, structuredClone(DEFAULT_CONFIG), true);
+      const disabled = variantId === "baseline" ? [] : options.components.filter((id) => variantIdFor(id) === variantId);
+      const overlay = await applyHarnessOverlay(runRoot, disabled, {
+        experimentId,
+        variantId,
+        contractVersion: options.contractVersion,
+        backup: false
+      });
+      if (!overlay.success)
+        return overlay;
+      await writeFile19(join22(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
+    }
+  }
+  return ok(experiment);
+}
+async function applyExperimentVariant(projectRoot, experimentId, variantId, contractVersion) {
+  const loaded = await loadExperiment(projectRoot, experimentId);
+  if (!loaded.success)
+    return loaded;
+  if (!loaded.data.variants.includes(variantId)) {
+    return err(new Error(`Unknown variant ${variantId} for ${experimentId}`));
+  }
+  const disabled = variantId === "baseline" ? [] : loaded.data.components.filter((id) => variantIdFor(id) === variantId);
+  const overlay = await applyHarnessOverlay(projectRoot, disabled, {
+    experimentId,
+    variantId,
+    contractVersion,
+    backup: true
+  });
+  if (!overlay.success)
+    return overlay;
+  return ok(loaded.data);
+}
+var EXPERIMENTS_DIR = "experiments";
+var init_harness_experiment = __esm(() => {
+  init_dist();
+  init_schemas();
+  init_codeconductor_config();
+  init_config_writer();
+  init_harness_catalog();
+});
+
+// src/core/evaluation/suite-run.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync9 } from "node:fs";
+import { resolve as resolve32 } from "node:path";
+async function runHarnessSuiteTasks(projectRoot, suiteId, suitePath) {
+  const suite = await loadHarnessSuite(projectRoot, suiteId, suitePath);
+  if (!suite.success) {
+    throw suite.error;
+  }
+  const results = [];
+  for (const task of suite.data.tasks) {
+    const started = Date.now();
+    const check = runTaskCommand(projectRoot, task);
+    const durationMs = Date.now() - started;
+    const passed = check.ok;
+    results.push({
+      id: task.id,
+      passed,
+      detail: check.detail,
+      durationMs
+    });
+    await appendOutcome(projectRoot, {
+      id: generateEvalId("out"),
+      taskId: task.id,
+      source: "pipeline",
+      agent: "evaluation",
+      model: "suite-run",
+      contractVersion: package_default.version,
+      timestamp: new Date().toISOString(),
+      status: passed ? "pass" : "reject",
+      verdict: passed ? "PASS" : "REJECT",
+      weightedScore: passed ? 3 : 0,
+      suiteTaskId: task.id,
+      durationMs
+    });
+  }
+  return {
+    suiteId: suite.data.id,
+    passed: results.filter((r) => r.passed).length,
+    failed: results.filter((r) => !r.passed).length,
+    results
+  };
+}
+function runTaskCommand(projectRoot, task) {
+  const raw = task.testCommand?.trim() ?? "";
+  if (!raw) {
+    return { ok: false, detail: "Missing testCommand" };
+  }
+  const hookMatch = raw.match(/^hook:(deny|allow)\s+(.+)$/s);
+  if (hookMatch) {
+    const expectDeny = hookMatch[1] === "deny";
+    const verdict = evaluateCommand(hookMatch[2]);
+    const denied = verdict.action === "deny";
+    const ok3 = expectDeny ? denied : !denied;
+    return {
+      ok: ok3,
+      detail: ok3 ? `${hookMatch[1]} ${hookMatch[2]}` : `expected ${hookMatch[1]}, got ${verdict.action}: ${verdict.message}`
+    };
+  }
+  const parts = tokenize(raw);
+  if (parts.length === 0) {
+    return { ok: false, detail: "Empty testCommand" };
+  }
+  const bin = parts[0] === "bun" && existsSync9(resolve32(projectRoot, "src/cli/main.ts")) ? "bun" : parts[0];
+  const args = parts[0] === "bun" ? parts.slice(1) : parts.slice(1);
+  const result = spawnSync2(bin, args, {
+    cwd: projectRoot,
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 60000
+  });
+  const ok2 = result.status === 0;
+  return {
+    ok: ok2,
+    detail: ok2 ? raw : (result.stderr || result.stdout || `exit ${result.status}`).slice(0, 400)
+  };
+}
+function tokenize(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const ch of command) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current)
+        tokens.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current)
+    tokens.push(current);
+  return tokens;
+}
+var init_suite_run = __esm(() => {
+  init_package();
+  init_hook_runner();
+  init_outcome_store();
+  init_harness_experiment();
+});
+
 // src/core/evaluation/execution-profile.ts
-import { readFile as readFile29 } from "node:fs/promises";
-import { resolve as resolve28 } from "node:path";
+import { readFile as readFile32 } from "node:fs/promises";
+import { resolve as resolve33 } from "node:path";
 async function loadExecutionProfile(projectRoot, defaultTarget = "opencode") {
   try {
-    const content = await readFile29(resolve28(projectRoot, PROFILE_FILE), "utf-8");
+    const content = await readFile32(resolve33(projectRoot, PROFILE_FILE), "utf-8");
     const data = $parse(content);
     return ExecutionProfileSchema.parse(data);
   } catch {
@@ -25254,14 +26468,14 @@ var init_execution_profile = __esm(() => {
 });
 
 // src/core/evaluation/prompt-diff.ts
-import { readFile as readFile30, readdir as readdir7 } from "node:fs/promises";
-import { join as join20, resolve as resolve29 } from "node:path";
+import { readFile as readFile33, readdir as readdir10 } from "node:fs/promises";
+import { join as join23, resolve as resolve34 } from "node:path";
 function normalizeVersion(v) {
   return v.startsWith("v") ? v : `v${v}`;
 }
 async function listPromptFiles(dir) {
   try {
-    const entries = await readdir7(dir, { withFileTypes: true });
+    const entries = await readdir10(dir, { withFileTypes: true });
     return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
   } catch {
     return [];
@@ -25304,30 +26518,30 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
   const fromV = normalizeVersion(fromVersion);
   const toV = normalizeVersion(toVersion);
   const searchRoots = [
-    resolve29(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
-    join20(ROOT_PRESETS_DIR, target, "prompts"),
-    join20(ROOT_PRESETS_DIR, "opencode", "prompts")
+    resolve34(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
+    join23(ROOT_PRESETS_DIR, target, "prompts"),
+    join23(ROOT_PRESETS_DIR, "opencode", "prompts")
   ];
   let fromDir = "";
   let toDir = "";
   for (const root of searchRoots) {
-    const f = join20(root, fromV);
-    const t = join20(root, toV);
+    const f = join23(root, fromV);
+    const t = join23(root, toV);
     try {
-      await readFile30(join20(f, "orchestrator.md"), "utf-8");
+      await readFile33(join23(f, "orchestrator.md"), "utf-8");
       fromDir = f;
       toDir = t;
       break;
     } catch {}
   }
   if (!fromDir) {
-    fromDir = join20(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
-    toDir = join20(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+    fromDir = join23(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
+    toDir = join23(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
   } else {
     try {
-      await readFile30(join20(toDir, "orchestrator.md"), "utf-8");
+      await readFile33(join23(toDir, "orchestrator.md"), "utf-8");
     } catch {
-      toDir = join20(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+      toDir = join23(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
     }
   }
   const fromFiles = await listPromptFiles(fromDir);
@@ -25345,12 +26559,12 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
     let oldText = "";
     let newText = "";
     try {
-      oldText = await readFile30(join20(fromDir, name), "utf-8");
+      oldText = await readFile33(join23(fromDir, name), "utf-8");
     } catch {
       oldText = "";
     }
     try {
-      newText = await readFile30(join20(toDir, name), "utf-8");
+      newText = await readFile33(join23(toDir, name), "utf-8");
     } catch {
       newText = "";
     }
@@ -25390,12 +26604,12 @@ var init_prompt_diff = __esm(() => {
 
 // src/core/evaluation/regression-checklist.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdir as mkdir20, readFile as readFile31, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname8, resolve as resolve30 } from "node:path";
+import { mkdir as mkdir21, readFile as readFile34, writeFile as writeFile20 } from "node:fs/promises";
+import { dirname as dirname9, resolve as resolve35 } from "node:path";
 async function loadRegressionChecklist() {
   try {
-    const path = resolve30(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
-    const content = await readFile31(path, "utf-8");
+    const path = resolve35(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
+    const content = await readFile34(path, "utf-8");
     const data = $parse(content);
     return data.checks ?? [];
   } catch {
@@ -25450,9 +26664,9 @@ async function runRegressionChecklist(projectRoot, options = {}) {
       checks,
       timestamp: new Date().toISOString()
     };
-    const outPath = resolve30(projectRoot, ".codeconductor/evaluation/regression-last.json");
-    await mkdir20(dirname8(outPath), { recursive: true });
-    await writeFile19(outPath, JSON.stringify(report, null, 2), "utf-8");
+    const outPath = resolve35(projectRoot, ".codeconductor/evaluation/regression-last.json");
+    await mkdir21(dirname9(outPath), { recursive: true });
+    await writeFile20(outPath, JSON.stringify(report, null, 2), "utf-8");
     return ok(report);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -25494,8 +26708,8 @@ var init_model_comparison = __esm(() => {
 });
 
 // src/core/evaluation/cost-quality-matrix.ts
-import { writeFile as writeFile20 } from "node:fs/promises";
-import { resolve as resolve31 } from "node:path";
+import { writeFile as writeFile21 } from "node:fs/promises";
+import { resolve as resolve36 } from "node:path";
 async function buildCostQualityMatrix(projectRoot, outcomes) {
   const agg = aggregateOutcomes(outcomes);
   const rows = Object.entries(agg.byModel).map(([model, entry]) => {
@@ -25515,7 +26729,7 @@ async function buildCostQualityMatrix(projectRoot, outcomes) {
     rows
   };
   const dir = await ensureEvaluationDir(projectRoot);
-  await writeFile20(resolve31(dir, "matrix.yml"), $stringify(matrix), "utf-8");
+  await writeFile21(resolve36(dir, "matrix.yml"), $stringify(matrix), "utf-8");
   return matrix;
 }
 function formatMatrixMarkdown(matrix) {
@@ -25538,199 +26752,9 @@ var init_cost_quality_matrix = __esm(() => {
   init_outcome_store();
 });
 
-// src/core/evaluation/harness-experiment.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { cp, mkdir as mkdir21, readFile as readFile32, readdir as readdir8, writeFile as writeFile21 } from "node:fs/promises";
-import { dirname as dirname9, join as join21, resolve as resolve32 } from "node:path";
-function experimentDir(projectRoot, experimentId) {
-  return resolve32(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
-}
-function experimentYamlPath(projectRoot, experimentId) {
-  return join21(experimentDir(projectRoot, experimentId), "experiment.yml");
-}
-async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
-  const candidates = suitePath ? [suitePath] : [
-    resolve32(projectRoot, "eval", "suites", suiteId, "suite.yml"),
-    resolve32(projectRoot, EVAL_DIR2, "suites", suiteId, "suite.yml")
-  ];
-  for (const path of candidates) {
-    if (!existsSync7(path))
-      continue;
-    try {
-      const suite = HarnessSuiteSchema.parse($parse(await readFile32(path, "utf-8")));
-      return ok({ ...suite, path });
-    } catch (e) {
-      return err(e instanceof Error ? e : new Error(String(e)));
-    }
-  }
-  return err(new Error(`Harness suite not found: ${suiteId}`));
-}
-async function loadExperiment(projectRoot, experimentId) {
-  try {
-    const raw = await readFile32(experimentYamlPath(projectRoot, experimentId), "utf-8");
-    return ok(HarnessExperimentSchema.parse($parse(raw)));
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      return err(new Error(`Experiment not found: ${experimentId}`));
-    }
-    return err(e instanceof Error ? e : new Error(String(e)));
-  }
-}
-async function listExperiments(projectRoot) {
-  const root = resolve32(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR);
-  if (!existsSync7(root))
-    return [];
-  const ids = await readdir8(root);
-  const experiments = [];
-  for (const id of ids) {
-    const loaded = await loadExperiment(projectRoot, id);
-    if (loaded.success)
-      experiments.push(loaded.data);
-  }
-  return experiments;
-}
-function formatTaskCard(task, experimentId, variantId) {
-  return [
-    "## Task Card",
-    "",
-    `**Title:** ${task.title}`,
-    `**Type:** ${task.type}`,
-    `**Risk:** ${task.risk}`,
-    `**Scope:** ${task.scope}`,
-    `**suiteTaskId:** ${task.id}`,
-    `**experimentId:** ${experimentId}`,
-    `**variantId:** ${variantId}`,
-    "",
-    "### Context",
-    "",
-    task.prompt,
-    "",
-    "### Acceptance Criteria",
-    "",
-    ...task.acceptanceCriteria.map((c) => `- [ ] ${c}`),
-    "",
-    "### Constraints",
-    "",
-    "- Stay inside the declared scope.",
-    "- Record the outcome with experiment and variant tags.",
-    "",
-    "### Scoring",
-    "",
-    "When done:",
-    "",
-    "```",
-    `bun run dev scorecard create --task ${task.id} --from-diff`,
-    `bun run dev scorecard record --task ${task.id} --verdict PASS|REVISE|REJECT --score <n> --experiment ${experimentId} --variant ${variantId} --suite-task ${task.id}`,
-    "```",
-    task.testCommand ? `
-Fixture test command: \`${task.testCommand}\`
-` : ""
-  ].join(`
-`);
-}
-function formatExperimentMarkdown(experiment) {
-  return [
-    `# Harness experiment ${experiment.id}`,
-    "",
-    `- Suite: ${experiment.suiteId}`,
-    `- Contract: ${experiment.contractVersion}`,
-    `- Created: ${experiment.createdAt}`,
-    `- Variants: ${experiment.variants.join(", ")}`,
-    `- Tasks: ${experiment.suiteTaskIds.join(", ")}`,
-    "",
-    "This runner does not invoke a model. Execute each run directory with the host",
-    "agent, then `scorecard record` with `--experiment` and `--variant`.",
-    "",
-    "Compare with:",
-    "",
-    "```",
-    `bun run dev scorecard ablation --experiment ${experiment.id}`,
-    "```",
-    ""
-  ].join(`
-`);
-}
-function generateExperimentId(suiteId, now = new Date) {
-  const date = now.toISOString().slice(0, 10).replaceAll("-", "");
-  const rand = Math.random().toString(36).slice(2, 6);
-  return `abl-${date}-${suiteId}-${rand}`;
-}
-async function copyFixture(suitePath, fixtureDir, dest) {
-  const source = fixtureDir ? resolve32(dirname9(suitePath), fixtureDir) : join21(dirname9(suitePath), "fixture");
-  await mkdir21(dest, { recursive: true });
-  if (existsSync7(source)) {
-    await cp(source, dest, { recursive: true });
-  }
-}
-async function startHarnessExperiment(projectRoot, options) {
-  const suite = await loadHarnessSuite(projectRoot, options.suiteId, options.suitePath);
-  if (!suite.success)
-    return suite;
-  const experimentId = options.experimentId ?? generateExperimentId(suite.data.id);
-  const variants = ["baseline", ...options.components.map((id) => variantIdFor(id))];
-  const experiment = {
-    id: experimentId,
-    suiteId: suite.data.id,
-    createdAt: new Date().toISOString(),
-    contractVersion: options.contractVersion,
-    components: options.components,
-    variants,
-    suiteTaskIds: suite.data.tasks.map((t) => t.id),
-    suitePath: suite.data.path
-  };
-  const root = experimentDir(projectRoot, experimentId);
-  await mkdir21(root, { recursive: true });
-  await writeFile21(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
-  await writeFile21(join21(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
-  for (const task of suite.data.tasks) {
-    for (const variantId of variants) {
-      const runRoot = join21(root, "runs", task.id, variantDirName(variantId));
-      await copyFixture(suite.data.path, suite.data.fixtureDir, runRoot);
-      await writeConfig(runRoot, structuredClone(DEFAULT_CONFIG), true);
-      const disabled = variantId === "baseline" ? [] : options.components.filter((id) => variantIdFor(id) === variantId);
-      const overlay = await applyHarnessOverlay(runRoot, disabled, {
-        experimentId,
-        variantId,
-        contractVersion: options.contractVersion,
-        backup: false
-      });
-      if (!overlay.success)
-        return overlay;
-      await writeFile21(join21(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
-    }
-  }
-  return ok(experiment);
-}
-async function applyExperimentVariant(projectRoot, experimentId, variantId, contractVersion) {
-  const loaded = await loadExperiment(projectRoot, experimentId);
-  if (!loaded.success)
-    return loaded;
-  if (!loaded.data.variants.includes(variantId)) {
-    return err(new Error(`Unknown variant ${variantId} for ${experimentId}`));
-  }
-  const disabled = variantId === "baseline" ? [] : loaded.data.components.filter((id) => variantIdFor(id) === variantId);
-  const overlay = await applyHarnessOverlay(projectRoot, disabled, {
-    experimentId,
-    variantId,
-    contractVersion,
-    backup: true
-  });
-  if (!overlay.success)
-    return overlay;
-  return ok(loaded.data);
-}
-var EXPERIMENTS_DIR = "experiments";
-var init_harness_experiment = __esm(() => {
-  init_dist();
-  init_schemas();
-  init_codeconductor_config();
-  init_config_writer();
-  init_harness_catalog();
-});
-
 // src/core/evaluation/ablation-report.ts
 import { mkdir as mkdir22, writeFile as writeFile22 } from "node:fs/promises";
-import { resolve as resolve33 } from "node:path";
+import { resolve as resolve37 } from "node:path";
 function isPass(o) {
   return o.verdict === "PASS" || o.status === "pass";
 }
@@ -25898,9 +26922,9 @@ function formatAblationMarkdown(report) {
 `);
 }
 async function persistAblationReport(projectRoot, markdown) {
-  const dir = resolve33(projectRoot, EVAL_DIR2);
+  const dir = resolve37(projectRoot, EVAL_DIR2);
   await mkdir22(dir, { recursive: true });
-  const path = resolve33(dir, "ablation-last.md");
+  const path = resolve37(dir, "ablation-last.md");
   await writeFile22(path, markdown, "utf-8");
   return path;
 }
@@ -25915,8 +26939,8 @@ var exports_scorecard_command = {};
 __export(exports_scorecard_command, {
   scorecardCommand: () => scorecardCommand
 });
-import { readFile as readFile33 } from "node:fs/promises";
-import { resolve as resolve34 } from "node:path";
+import { readFile as readFile35 } from "node:fs/promises";
+import { resolve as resolve38 } from "node:path";
 function contractVersion() {
   return package_default.version;
 }
@@ -25951,6 +26975,8 @@ async function scorecardCommand(options) {
       return handleExperiment(projectRoot, options);
     case "ablation":
       return handleAblation(projectRoot, options);
+    case "suite-run":
+      return handleSuiteRun(projectRoot, options);
     default:
       return {
         code: 1,
@@ -25958,7 +26984,7 @@ async function scorecardCommand(options) {
           success: false,
           command: "scorecard",
           errors: [
-            `Unknown subcommand: ${subcommand}. Use: create, show, record, list, aggregate, models, prompt-diff, regression, matrix, compare-models, catalog, fingerprint, experiment, ablation`
+            `Unknown subcommand: ${subcommand}. Use: create, show, record, list, aggregate, models, prompt-diff, regression, matrix, compare-models, catalog, fingerprint, experiment, ablation, suite-run`
           ]
         }
       };
@@ -25978,7 +27004,34 @@ async function handleCreate(projectRoot, options) {
         scopeFiles = item.scope.split(/[,;]/).map((s) => s.trim()).filter(Boolean);
       }
     }
-    const hints = collectScorecardSignals(projectRoot, scopeFiles);
+    let hints = collectScorecardSignals(projectRoot, scopeFiles);
+    const state = await loadOpenspecState(projectRoot);
+    const backlogId = options.taskId?.startsWith("BC-") ? options.taskId : undefined;
+    const changePath = backlogId && state.success ? state.data.changePaths[backlogId] : undefined;
+    if (changePath && !changePath.includes("/archive/")) {
+      const tddRequired = backlog.success ? backlog.data.global.tddRequired : false;
+      const cards = state.success ? state.data.taskCards.filter((c) => c.backlogId === backlogId) : [];
+      let hasEvidence;
+      if (cards.some((c) => c.phase === "test" || c.phase === "implement")) {
+        hasEvidence = false;
+        for (const card of cards) {
+          if ((card.phase === "test" || card.phase === "implement") && await hasTddRunnerEvidence(projectRoot, card.id)) {
+            hasEvidence = true;
+            break;
+          }
+        }
+      }
+      const analyze = await analyzeChangeFolder(projectRoot, changePath, {
+        tddRequired,
+        hasTddEvidence: hasEvidence
+      });
+      hints = applyAnalyzeSignals(hints, {
+        frCoveragePct: analyze.frCoveragePct,
+        scCoveragePct: analyze.scCoveragePct,
+        tddRequired,
+        hasTddEvidence: hasEvidence
+      });
+    }
     criteria = criteriaFromSignals(hints);
     findings = hints.findings;
   }
@@ -26168,12 +27221,12 @@ async function handleCompareModels(projectRoot, options) {
     outcomes = outcomes.filter((o) => options.modelsFilter.includes(o.model));
   }
   const markdown = generateModelComparisonMarkdown(outcomes, options.modelsFilter);
-  const templatePath = resolve34(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
+  const templatePath = resolve38(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
   try {
-    await readFile33(templatePath);
+    await readFile35(templatePath);
   } catch {}
   const { writeFile: writeFile23, mkdir: mkdir23 } = await import("node:fs/promises");
-  await mkdir23(resolve34(projectRoot, ".codeconductor/evaluation"), { recursive: true });
+  await mkdir23(resolve38(projectRoot, ".codeconductor/evaluation"), { recursive: true });
   await writeFile23(templatePath, markdown, "utf-8");
   return {
     code: 0,
@@ -26299,12 +27352,39 @@ async function handleAblation(projectRoot, options) {
     }
   };
 }
+async function handleSuiteRun(projectRoot, options) {
+  const suiteId = options.suiteId ?? options.taskId ?? "harness-v1";
+  try {
+    const result = await runHarnessSuiteTasks(projectRoot, suiteId, options.suitePath);
+    return {
+      code: result.failed > 0 ? 1 : 0,
+      data: {
+        success: result.failed === 0,
+        command: "scorecard suite-run",
+        ...result
+      }
+    };
+  } catch (e) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "scorecard suite-run",
+        errors: [e instanceof Error ? e.message : String(e)]
+      }
+    };
+  }
+}
 var init_scorecard_command = __esm(() => {
   init_package();
   init_config_loader();
   init_scorecard_calculator();
   init_outcome_store();
   init_scorecard_signals();
+  init_openspec_state();
+  init_spec_analyzer();
+  init_verification_runner();
+  init_suite_run();
   init_execution_profile();
   init_prompt_diff();
   init_regression_checklist();
@@ -27616,7 +28696,7 @@ var exports_seo_audit_command = {};
 __export(exports_seo_audit_command, {
   seoAuditCommand: () => seoAuditCommand
 });
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
 async function seoAuditCommand(options) {
   const { url, sitemap, format, failOn, delay: delay2, output, followRedirects, force } = options;
   if (!url && !sitemap) {
@@ -27629,7 +28709,7 @@ async function seoAuditCommand(options) {
       }
     };
   }
-  const defaultMarkdownPath = output === undefined && format === "markdown" ? join22("seo-reports", `audit-report-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)}.md`) : undefined;
+  const defaultMarkdownPath = output === undefined && format === "markdown" ? join24("seo-reports", `audit-report-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)}.md`) : undefined;
   const outputPathToWrite = output ?? defaultMarkdownPath;
   if (outputPathToWrite !== undefined) {
     const preflightError = await preflightContainedOutput(options.projectRoot, outputPathToWrite, { force });
@@ -28019,9 +29099,10 @@ Published commands (package ${package_default.version}):
   cc-help                 Show preset inventory (skills, subagents, commands)
   debt-harvest / harvest  Scan source files for deferred debt items
   ccep                    CCEP contracts: parse/profile/validate/evaluate/consensus/taskcard
-  openspec                OpenSpec loop: validate/scan/plan/status/next/start/done/block/archive
+  openspec                OpenSpec loop: validate/scan/plan/analyze/status/next/start/done/block/archive
   scorecard               Record and aggregate evaluation outcomes
-                          (catalog / fingerprint / experiment / ablation)
+                          (catalog / fingerprint / experiment / ablation / suite-run)
+  hook                    OS-agnostic agent hooks: pre-tool / post-tool / session-start
 
 v1.0.0 (in this repo, not in published ${package_default.version}):
   goal / cc-goal          Plan goal into task graph with dependencies
@@ -28104,6 +29185,7 @@ Examples:
   npx cc-codeconductor openspec validate
   npx cc-codeconductor openspec scan
   npx cc-codeconductor openspec plan BC-001
+  npx cc-codeconductor openspec analyze
   npx cc-codeconductor openspec status
   npx cc-codeconductor openspec next
   npx cc-codeconductor openspec start BC-001-discover
@@ -28407,6 +29489,7 @@ async function routeCommand(args, projectRoot) {
         "validate",
         "scan",
         "plan",
+        "analyze",
         "status",
         "next",
         "start",
@@ -28434,6 +29517,26 @@ async function routeCommand(args, projectRoot) {
         output: flags.output
       });
     }
+    case "hook": {
+      const validHookEvents = ["pre-tool", "post-tool", "session-start"];
+      if (subcommand && !validHookEvents.includes(subcommand)) {
+        return unknownSubcommand(command, subcommand, [...validHookEvents]);
+      }
+      const event = validHookEvents.includes(subcommand) ? subcommand : "pre-tool";
+      const formatRaw = options.format;
+      const format = formatRaw === "agy" || formatRaw === "claude" ? formatRaw : undefined;
+      const { hookCommand: hookCommand2, readStdinText: readStdinText2 } = await Promise.resolve().then(() => (init_hook_command(), exports_hook_command));
+      const stdinText = await readStdinText2();
+      return hookCommand2({
+        event,
+        projectRoot,
+        output: flags.output,
+        format,
+        command: typeof options.command === "string" ? options.command : undefined,
+        filePath: typeof options.file === "string" ? options.file : undefined,
+        stdinText
+      });
+    }
     case "scorecard":
     case "cc-scorecard": {
       const validSubs = [
@@ -28450,7 +29553,8 @@ async function routeCommand(args, projectRoot) {
         "catalog",
         "fingerprint",
         "experiment",
-        "ablation"
+        "ablation",
+        "suite-run"
       ];
       if (subcommand && !validSubs.includes(subcommand)) {
         return unknownSubcommand(command, subcommand, validSubs);