@harness-engineering/cli 3.1.0 → 4.0.1

package/dist/{chunk-ZOUJP3EY.js → chunk-RG3TNIUB.js}

@@ -1,22 +1,34 @@
+import {
+  analyzeDiffDefinition,
+  createSelfReviewDefinition,
+  handleAnalyzeDiff,
+  handleCreateSelfReview,
+  handleRequestPeerReview,
+  requestPeerReviewDefinition
+} from "./chunk-OQ6KOQEV.js";
 import {
   getSecurityTrendsDefinition,
   handleGetSecurityTrends,
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-DNX35Q5K.js";
+} from "./chunk-M7F2PPN3.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition,
   sortFindingsBySeverity
-} from "./chunk-C2ZGWMTN.js";
+} from "./chunk-EYMOPFSD.js";
 import {
   assessProjectDefinition,
   handleAssessProject
-} from "./chunk-YF3AY6KS.js";
+} from "./chunk-6SCYTIF4.js";
+import {
+  checkDocsDefinition,
+  handleCheckDocs
+} from "./chunk-I3CGCZJF.js";
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-PZX2Y3RV.js";
+} from "./chunk-SDMV4QHM.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -26,18 +38,10 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-RGQXHCCH.js";
+} from "./chunk-7PJCK7UE.js";
 import {
   getBusinessKnowledgeResource
 } from "./chunk-IOW3MW2K.js";
-import {
-  analyzeDiffDefinition,
-  createSelfReviewDefinition,
-  handleAnalyzeDiff,
-  handleCreateSelfReview,
-  handleRequestPeerReview,
-  requestPeerReviewDefinition
-} from "./chunk-ERZCC5VH.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_CODEX,
@@ -49,31 +53,27 @@ import {
 } from "./chunk-3ISINLYT.js";
 import {
   loadGraphStore
-} from "./chunk-CLI4K2CH.js";
+} from "./chunk-4U5LDFCY.js";
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-UBTMPO5H.js";
+} from "./chunk-36GQREOE.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-OQFEFVIN.js";
-import {
-  resolveProjectConfig
-} from "./chunk-XZ2Q4UTW.js";
-import {
-  checkDocsDefinition,
-  handleCheckDocs
-} from "./chunk-HIPBU2Q4.js";
+} from "./chunk-JPVOI7GP.js";
 import {
   resultToMcpResponse
 } from "./chunk-RC3OI5NK.js";
+import {
+  resolveProjectConfig
+} from "./chunk-SEA2PFVI.js";
 import {
   sanitizePath
 } from "./chunk-W6Y7ZW3Y.js";
 import {
   loadOrRebuildIndex
-} from "./chunk-27AJKSQY.js";
+} from "./chunk-WBVCN35T.js";
 import {
   resolveCommunitySkillsDir,
   resolveGlobalCommunitySkillsDir,
@@ -82,15 +82,18 @@ import {
   resolveProjectSkillsDir,
   resolveSkillsDir,
   resolveTemplatesDir
-} from "./chunk-6B6UN6SG.js";
+} from "./chunk-UTJJJDNN.js";
 import {
   SkillMetadataSchema
 } from "./chunk-HIK6OEUF.js";
+import {
+  findFiles
+} from "./chunk-Y6SUQC32.js";
 import {
   findConfigFile,
   loadConfig,
   resolveConfig
-} from "./chunk-YQAFKOOL.js";
+} from "./chunk-XAVMTAUT.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -104,8 +107,10 @@ import {
   ConflictError,
   DEFAULT_TOKEN_BUDGET,
   DESTRUCTIVE_BASH,
+  SIGNAL_CATEGORY_MAP,
   StructuralStrategy,
   TruncationStrategy,
+  applyRoadmapDiff,
   checkTaint,
   computeLoadPlan,
   createTrackerClient,
@@ -118,10 +123,13 @@ import {
   loadTrackerClientConfigFromProject,
   loadTrackerSyncConfig,
   paginate,
+  reconcilePassed,
+  resolveRoadmapStore,
+  roadmapSourceExists,
   scanForInjection,
   serializeEnvelope,
   writeTaint
-} from "./chunk-A65QO5KN.js";
+} from "./chunk-MMLQPHZ5.js";
 import {
   Err,
   INDEXED_FILE_KINDS,
@@ -317,7 +325,6 @@ release-readiness.json
 skills-index.json
 stack-profile.json
 metrics/
-events.jsonl
 .install-id
 telemetry.json
 .telemetry-notice-shown
@@ -738,7 +745,7 @@ async function handleInsightsSummary(input) {
     const skip = Array.isArray(input.skip) ? input.skip.filter(
       (k) => typeof k === "string" && INSIGHTS_KEYS.includes(k)
     ) : void 0;
-    const { composeInsights } = await import("./dist-3HW4LCHE.js");
+    const { composeInsights } = await import("./dist-6D2F2J57.js");
     const report = await composeInsights(projectPath, {
       ...skip && skip.length > 0 && { skip }
     });
@@ -914,7 +921,7 @@ ${skippedMsg}`
 async function handleInitProject(input) {
   const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-E7H5U3AC.js");
+    const { TemplateEngine } = await import("./engine-YUA6IYOG.js");
     const engine = new TemplateEngine(resolveTemplatesDir());
     const safePath = sanitizePath(i.path);
     const detected = tryDetectFramework(engine, safePath, i);
@@ -936,7 +943,7 @@ var listPersonasDefinition = {
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-RGQJYERV.js");
+  const { listPersonas } = await import("./loader-QOJQ6NZM.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -960,10 +967,10 @@ async function handleGeneratePersonaArtifacts(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.name)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.name}`)));
   }
-  const { loadPersona } = await import("./loader-RGQJYERV.js");
-  const { generateRuntime } = await import("./runtime-Q3ORD7LW.js");
-  const { generateAgentsMd } = await import("./agents-md-YYCLGMBF.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-JEYYCBOC.js");
+  const { loadPersona } = await import("./loader-QOJQ6NZM.js");
+  const { generateRuntime } = await import("./runtime-XK6ZCHKE.js");
+  const { generateAgentsMd } = await import("./agents-md-VJLYEH2S.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-HO4WKGNG.js");
   const personasDir = resolvePersonasDir();
   const filePath = path4.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -1018,9 +1025,9 @@ async function handleRunPersona(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.persona)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.persona}`)));
   }
-  const { loadPersona } = await import("./loader-RGQJYERV.js");
+  const { loadPersona } = await import("./loader-QOJQ6NZM.js");
   const { runPersona } = await import("./runner-AAEF2TXY.js");
-  const { executeSkill } = await import("./skill-executor-MOCUIAYS.js");
+  const { executeSkill } = await import("./skill-executor-BGUCAVBU.js");
   const personasDir = resolvePersonasDir();
   const filePath = path4.join(personasDir, `${input.persona}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -1460,11 +1467,16 @@ function loadOrGenerateProfile(projectRoot) {
   return profile;
 }
 
-// src/mcp/tools/event-emitter.ts
+// src/mcp/tools/skill-telemetry.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+var SKILL_EVENTS_FILE = join4(".harness", "metrics", "skill-events.jsonl");
 async function emitSkillEvent(projectPath, event) {
   try {
-    const { emitEvent } = await import("./dist-3HW4LCHE.js");
-    await emitEvent(projectPath, event);
+    const metricsDir = join4(projectPath, ".harness", "metrics");
+    mkdirSync2(metricsDir, { recursive: true });
+    const record = { ...event, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    appendFileSync2(join4(metricsDir, "skill-events.jsonl"), JSON.stringify(record) + "\n");
   } catch {
   }
 }
@@ -1536,9 +1548,10 @@ async function handleRunSkill(input) {
   }
   if (input.path) {
     const projectPath = sanitizePath(input.path);
-    const stateFile = path6.join(projectPath, ".harness", "state.json");
-    if (fs5.existsSync(stateFile)) {
-      const stateContent = fs5.readFileSync(stateFile, "utf-8");
+    const { readHarnessState, isEmptyHarnessState } = await import("./state-events-ECQAIZLU.js");
+    const stateResult = await readHarnessState(projectPath);
+    if (stateResult.ok && !isEmptyHarnessState(stateResult.value)) {
+      const stateContent = JSON.stringify(stateResult.value, null, 2);
       content += `
 
 ---
@@ -1733,25 +1746,25 @@ import * as fs10 from "fs";
 import * as path11 from "path";
 async function autoSyncRoadmap(projectPath) {
   try {
-    const roadmapFile = path11.join(projectPath, "docs", "roadmap.md");
-    if (!fs10.existsSync(roadmapFile)) return;
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-3HW4LCHE.js");
-    const raw = fs10.readFileSync(roadmapFile, "utf-8");
-    const parseResult = parseRoadmap(raw);
-    if (!parseResult.ok) return;
-    const roadmap = parseResult.value;
-    const syncResult = syncRoadmap({ projectPath, roadmap });
+    if (!roadmapSourceExists(projectPath)) return;
+    const { syncRoadmap, applySyncChanges } = await import("./dist-6D2F2J57.js");
+    const store = resolveRoadmapStore({ projectRoot: projectPath });
+    const loaded = await store.load();
+    if (!loaded.ok) return;
+    const roadmap = loaded.value;
+    const before = structuredClone(roadmap);
+    const syncResult = await syncRoadmap({ projectPath, roadmap });
     if (!syncResult.ok || syncResult.value.length === 0) {
-      await triggerExternalSync(projectPath, roadmapFile);
+      await triggerExternalSync(projectPath);
       return;
     }
     applySyncChanges(roadmap, syncResult.value);
-    fs10.writeFileSync(roadmapFile, serializeRoadmap(roadmap), "utf-8");
-    await triggerExternalSync(projectPath, roadmapFile);
+    await applyRoadmapDiff(store, before, roadmap);
+    await triggerExternalSync(projectPath);
   } catch {
   }
 }
-async function triggerExternalSync(projectPath, roadmapFile) {
+async function triggerExternalSync(projectPath) {
   try {
     const trackerConfig = loadTrackerSyncConfig(projectPath);
     if (!trackerConfig) return;
@@ -1765,12 +1778,12 @@ async function triggerExternalSync(projectPath, roadmapFile) {
       console.warn("[roadmap-sync] GITHUB_TOKEN not found \u2014 external sync skipped");
       return;
     }
-    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-3HW4LCHE.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-6D2F2J57.js");
     const adapter = new GitHubIssuesSyncAdapter({
       token,
       config: trackerConfig
     });
-    const result = await fullSync(roadmapFile, adapter, trackerConfig);
+    const result = await fullSync(projectPath, adapter, trackerConfig);
     if (result.errors.length > 0) {
       for (const err2 of result.errors) {
         console.error(
@@ -1817,7 +1830,8 @@ var manageStateDefinition = {
           "task-start",
           "task-complete",
           "phase-start",
-          "phase-complete"
+          "phase-complete",
+          "task-transition"
         ],
         description: "Action to perform"
       },
@@ -1856,18 +1870,42 @@ var manageStateDefinition = {
         type: "string",
         enum: ["active", "resolved", "superseded"],
         description: "New status for the entry: active, resolved, or superseded (required for update_entry_status)"
-      }
+      },
+      taskId: { type: "string", description: "Task id (required for task-transition)" },
+      toLane: {
+        type: "string",
+        enum: ["planned", "claimed", "in_progress", "in_review", "done", "blocked", "canceled"],
+        description: "Target lane (required for task-transition)"
+      },
+      dependsOn: {
+        type: "array",
+        items: { type: "string" },
+        description: "Dependency task ids; when set, the task is registered before transitioning"
+      },
+      evidence: {
+        type: "array",
+        items: { type: "string" },
+        description: "PR/commit/test refs (required to enter done)"
+      },
+      force: {
+        type: "boolean",
+        description: "Force an off-table transition (requires actor+reason)"
+      },
+      actor: { type: "string", description: "Actor for a forced transition" },
+      reason: { type: "string", description: "Reason for a forced transition" }
     },
     required: ["path", "action"]
   }
 };
 async function handleShow(projectPath, input) {
-  const { loadState } = await import("./dist-3HW4LCHE.js");
-  return resultToMcpResponse(await loadState(projectPath, input.stream, input.session));
+  const { readHarnessState } = await import("./state-events-ECQAIZLU.js");
+  return resultToMcpResponse(
+    await readHarnessState(projectPath, { stream: input.stream, session: input.session })
+  );
 }
 async function handleLearn(projectPath, input) {
   if (!input.learning) return mcpError("Error: learning is required for learn action");
-  const { appendLearning } = await import("./dist-3HW4LCHE.js");
+  const { appendLearning } = await import("./dist-6D2F2J57.js");
   const result = await appendLearning(
     projectPath,
     input.learning,
@@ -1882,7 +1920,7 @@ async function handleLearn(projectPath, input) {
 async function handleFailure(projectPath, input) {
   if (!input.description) return mcpError("Error: description is required for failure action");
   if (!input.failureType) return mcpError("Error: failureType is required for failure action");
-  const { appendFailure } = await import("./dist-3HW4LCHE.js");
+  const { appendFailure } = await import("./dist-6D2F2J57.js");
   const result = await appendFailure(
     projectPath,
     input.description,
@@ -1901,19 +1939,22 @@ async function handleFailure(projectPath, input) {
   return resultToMcpResponse(Ok({ recorded: true }));
 }
 async function handleArchive(projectPath, input) {
-  const { archiveFailures } = await import("./dist-3HW4LCHE.js");
+  const { archiveFailures } = await import("./dist-6D2F2J57.js");
   const result = await archiveFailures(projectPath, input.stream, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ archived: true }));
 }
 async function handleReset(projectPath, input) {
-  const { saveState, DEFAULT_STATE } = await import("./dist-3HW4LCHE.js");
-  const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream, input.session);
+  const { eventSourcing } = await import("./dist-6D2F2J57.js");
+  const result = await eventSourcing.resetEventLog(projectPath, {
+    stream: input.stream,
+    session: input.session
+  });
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ reset: true }));
 }
 async function handleGate(projectPath, input) {
-  const { runMechanicalGate } = await import("./dist-3HW4LCHE.js");
+  const { runMechanicalGate } = await import("./dist-6D2F2J57.js");
   const result = await runMechanicalGate(projectPath);
   if (result.ok) {
     await emitSkillEvent(projectPath, {
@@ -1933,7 +1974,7 @@ async function handleGate(projectPath, input) {
 }
 async function handleSaveHandoff(projectPath, input) {
   if (!input.handoff) return mcpError("Error: handoff is required for save-handoff action");
-  const { saveHandoff } = await import("./dist-3HW4LCHE.js");
+  const { saveHandoff } = await import("./dist-6D2F2J57.js");
   const result = await saveHandoff(
     projectPath,
     input.handoff,
@@ -1955,7 +1996,7 @@ async function handleSaveHandoff(projectPath, input) {
   return resultToMcpResponse(Ok({ saved: true }));
 }
 async function handleLoadHandoff(projectPath, input) {
-  const { loadHandoff } = await import("./dist-3HW4LCHE.js");
+  const { loadHandoff } = await import("./dist-6D2F2J57.js");
   return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
 }
 async function handleAppendEntry(projectPath, input) {
@@ -1963,7 +2004,7 @@ async function handleAppendEntry(projectPath, input) {
   if (!input.authorSkill) return mcpError("Error: authorSkill is required for append_entry action");
   if (!input.content) return mcpError("Error: content is required for append_entry action");
   if (input.session) {
-    const { appendSessionEntry } = await import("./dist-3HW4LCHE.js");
+    const { appendSessionEntry } = await import("./dist-6D2F2J57.js");
     const result = await appendSessionEntry(
       projectPath,
       input.session,
@@ -1976,16 +2017,17 @@ async function handleAppendEntry(projectPath, input) {
   if (input.section !== "decisions") {
     return mcpError("Error: session is required for non-decisions sections");
   }
-  const { loadState, saveState } = await import("./dist-3HW4LCHE.js");
-  const lr = await loadState(projectPath, input.stream);
-  if (!lr.ok) return resultToMcpResponse(lr);
-  lr.value.decisions.push({
-    date: (/* @__PURE__ */ new Date()).toISOString(),
-    decision: input.content,
-    context: input.authorSkill
-  });
-  const sr = await saveState(projectPath, lr.value, input.stream);
-  if (!sr.ok) return resultToMcpResponse(sr);
+  const { randomUUID: randomUUID10 } = await import("crypto");
+  const { emitCoreEvent } = await import("./state-events-ECQAIZLU.js");
+  const r = await emitCoreEvent(
+    projectPath,
+    {
+      type: "decision_recorded",
+      payload: { id: randomUUID10(), text: input.content, context: input.authorSkill }
+    },
+    { stream: input.stream }
+  );
+  if (!r.ok) return resultToMcpResponse(r);
   return resultToMcpResponse(Ok({ appended: true, target: "global-state" }));
 }
 async function handleUpdateEntryStatus(projectPath, input) {
@@ -1994,7 +2036,7 @@ async function handleUpdateEntryStatus(projectPath, input) {
   if (!input.entryId) return mcpError("Error: entryId is required for update_entry_status action");
   if (!input.newStatus)
     return mcpError("Error: newStatus is required for update_entry_status action");
-  const { updateSessionEntryStatus } = await import("./dist-3HW4LCHE.js");
+  const { updateSessionEntryStatus } = await import("./dist-6D2F2J57.js");
   const result = await updateSessionEntryStatus(
     projectPath,
     input.session,
@@ -2002,12 +2044,21 @@ async function handleUpdateEntryStatus(projectPath, input) {
     input.entryId,
     input.newStatus
   );
+  if (result.ok && input.section === "decisions" && input.newStatus === "resolved") {
+    try {
+      const { emitApprovalResolved } = await import("./state-events-ECQAIZLU.js");
+      await emitApprovalResolved(projectPath, input.entryId, input.newStatus, {
+        stream: input.stream
+      });
+    } catch {
+    }
+  }
   return resultToMcpResponse(result);
 }
 async function handleReadSection(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for read_section action");
   if (!input.section) return mcpError("Error: section is required for read_section action");
-  const { readSessionSection } = await import("./dist-3HW4LCHE.js");
+  const { readSessionSection } = await import("./dist-6D2F2J57.js");
   const result = await readSessionSection(
     projectPath,
     input.session,
@@ -2017,13 +2068,13 @@ async function handleReadSection(projectPath, input) {
 }
 async function handleReadSections(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for read_sections action");
-  const { readSessionSections } = await import("./dist-3HW4LCHE.js");
+  const { readSessionSections } = await import("./dist-6D2F2J57.js");
   const result = await readSessionSections(projectPath, input.session);
   return resultToMcpResponse(result);
 }
 async function handleArchiveSession(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for archive_session action");
-  const { archiveSession } = await import("./dist-3HW4LCHE.js");
+  const { archiveSession } = await import("./dist-6D2F2J57.js");
   const { buildArchiveHooks } = await import("@harness-engineering/orchestrator");
   const hooks = buildArchiveHooks({ projectPath });
   const result = await archiveSession(projectPath, input.session, { hooks });
@@ -2063,6 +2114,30 @@ async function handlePhaseComplete(projectPath, input) {
   }
   return resultToMcpResponse(Ok({ synced: true, trigger: "phase-complete" }));
 }
+async function handleTaskTransition(projectPath, input) {
+  if (!input.taskId) return mcpError("Error: taskId is required for task-transition action");
+  if (!input.toLane) return mcpError("Error: toLane is required for task-transition action");
+  const { eventSourcing } = await import("./dist-6D2F2J57.js");
+  const scope = { stream: input.stream, session: input.session };
+  if (input.dependsOn) {
+    const reg = await eventSourcing.registerTask(projectPath, input.taskId, input.dependsOn, scope);
+    if (!reg.ok) return resultToMcpResponse(reg);
+  }
+  const result = await eventSourcing.transitionLane(
+    projectPath,
+    input.taskId,
+    input.toLane,
+    {
+      ...input.evidence !== void 0 ? { evidence: input.evidence } : {},
+      ...input.force !== void 0 ? { force: input.force } : {},
+      ...input.actor !== void 0 ? { actor: input.actor } : {},
+      ...input.reason !== void 0 ? { reason: input.reason } : {}
+    },
+    scope
+  );
+  if (!result.ok) return resultToMcpResponse(result);
+  return resultToMcpResponse(Ok({ taskId: input.taskId, lane: input.toLane }));
+}
 var ACTION_HANDLERS = {
   show: handleShow,
   learn: handleLearn,
@@ -2080,7 +2155,8 @@ var ACTION_HANDLERS = {
   "task-start": handleTaskStart,
   "task-complete": handleTaskComplete,
   "phase-start": handlePhaseStart,
-  "phase-complete": handlePhaseComplete
+  "phase-complete": handlePhaseComplete,
+  "task-transition": handleTaskTransition
 };
 async function handleManageState(input) {
   try {
@@ -2105,7 +2181,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-3HW4LCHE.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-6D2F2J57.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -2143,7 +2219,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-REG3HWYC.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-CHU2E3OU.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -2199,7 +2275,7 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-4ITA72DF.js");
+    const { runCrossCheck } = await import("./validate-cross-check-J5PVGICB.js");
     const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
@@ -2708,11 +2784,11 @@ function resolveOutputDir(platform, opts) {
 }
 async function confirmDeletion(files) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     rl.question(`
 Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
       rl.close();
-      resolve9(answer.toLowerCase() === "y");
+      resolve11(answer.toLowerCase() === "y");
     });
   });
 }
@@ -3022,9 +3098,10 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-3HW4LCHE.js");
+    const { migrateToStreams } = await import("./dist-6D2F2J57.js");
+    const { readHarnessState } = await import("./state-events-ECQAIZLU.js");
     await migrateToStreams(projectRoot);
-    const result = await loadState(projectRoot);
+    const result = await readHarnessState(projectRoot);
     if (result.ok) {
       return JSON.stringify(result.value, null, 2);
     }
@@ -3140,7 +3217,7 @@ async function handleQueryGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-OWHMNL4W.js");
+    const { ContextQL } = await import("./dist-DWBTZXR5.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -3222,7 +3299,7 @@ async function handleSearchSimilar(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer } = await import("./dist-OWHMNL4W.js");
+    const { FusionLayer } = await import("./dist-DWBTZXR5.js");
     const fusion = new FusionLayer(store);
     const results = fusion.search(input.query, input.topK ?? 10);
     if (input.mode === "summary") {
@@ -3277,7 +3354,7 @@ async function handleFindContextFor(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer, ContextQL } = await import("./dist-OWHMNL4W.js");
+    const { FusionLayer, ContextQL } = await import("./dist-DWBTZXR5.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -3382,7 +3459,7 @@ async function handleGetRelationships(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-OWHMNL4W.js");
+    const { ContextQL } = await import("./dist-DWBTZXR5.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -3500,7 +3577,7 @@ async function handleGetImpact(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-OWHMNL4W.js");
+    const { ContextQL } = await import("./dist-DWBTZXR5.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -3632,9 +3709,9 @@ async function handleIngestSource(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const graphDir = path16.join(projectPath, ".harness", "graph");
-    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-OWHMNL4W.js");
-    const fs50 = await import("fs/promises");
-    await fs50.mkdir(graphDir, { recursive: true });
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-DWBTZXR5.js");
+    const fs53 = await import("fs/promises");
+    await fs53.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -3656,13 +3733,13 @@ async function handleIngestSource(input) {
       results.push(gitResult);
     }
     if (input.source === "business-signals" || input.source === "all") {
-      const { createExtractionRunner } = await import("./dist-OWHMNL4W.js");
+      const { createExtractionRunner } = await import("./dist-DWBTZXR5.js");
       const extractedDir = path16.join(projectPath, ".harness", "knowledge", "extracted");
       const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
       results.push(signalsResult);
     }
     if (input.source === "diagrams" || input.source === "all") {
-      const { DiagramParser } = await import("./dist-OWHMNL4W.js");
+      const { DiagramParser } = await import("./dist-DWBTZXR5.js");
       const diagramParser = new DiagramParser(store);
       const diagramResult = await diagramParser.ingest(projectPath);
       results.push(diagramResult);
@@ -3728,7 +3805,7 @@ async function handleDetectAnomalies(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { GraphAnomalyAdapter } = await import("./dist-OWHMNL4W.js");
+    const { GraphAnomalyAdapter } = await import("./dist-DWBTZXR5.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -3777,7 +3854,7 @@ async function handleAskGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { askGraph } = await import("./dist-OWHMNL4W.js");
+    const { askGraph } = await import("./dist-DWBTZXR5.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -3841,7 +3918,7 @@ async function handleComputeBlastRadius(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { CascadeSimulator } = await import("./dist-OWHMNL4W.js");
+    const { CascadeSimulator } = await import("./dist-DWBTZXR5.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.file) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -4042,7 +4119,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-S2FRZF4Y.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-KPVGBGDY.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -4078,7 +4155,7 @@ async function handleManageRoadmapFileLess(input, client) {
     case "sync":
       return handleSync();
     case "groom":
-      return err("Error: groom is only supported in file-based roadmap mode (docs/roadmap.md).");
+      return err("Error: groom is only supported in file-based roadmap mode.");
     default:
       return err(`Error: unknown action`);
   }
@@ -4278,7 +4355,7 @@ function renderRoadmap(features) {
 // src/mcp/tools/roadmap.ts
 var manageRoadmapDefinition = {
   name: "manage_roadmap",
-  description: 'Manage the project roadmap: show, add, update, remove, promote, sync, groom features, or query by filter. Reads and writes docs/roadmap.md. The "promote" action transitions an existing row toward planned (backlog\u2192planned) and links its spec atomically \u2014 creating a new planned row under the "Intake" lane if the feature does not exist \u2014 returning a structured RoadmapPromoteResult envelope. The "groom" action tidies the roadmap: it demotes unactionable planned rows (no spec & no plan) to backlog and moves completed features into docs/roadmap-archive.md, returning the list of changes.',
+  description: 'Manage the project roadmap: show, add, update, remove, promote, sync, groom features, or query by filter. Reads and writes the project roadmap (sharded or single-file). The "promote" action transitions an existing row toward planned (backlog\u2192planned) and links its spec atomically \u2014 creating a new planned row under the "Intake" lane if the feature does not exist \u2014 returning a structured RoadmapPromoteResult envelope. The "groom" action tidies the roadmap: it demotes unactionable planned rows (no spec & no plan) to backlog and moves completed features into docs/roadmap-archive.md, returning the list of changes.',
   inputSchema: {
     type: "object",
     properties: {
@@ -4339,22 +4416,12 @@ var manageRoadmapDefinition = {
     required: ["path", "action"]
   }
 };
-function roadmapPath(projectRoot) {
-  return path18.join(projectRoot, "docs", "roadmap.md");
-}
-function readRoadmapFile(projectRoot) {
-  const filePath = roadmapPath(projectRoot);
-  try {
-    return fs15.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
+async function loadRoadmap(projectRoot) {
+  return resolveRoadmapStore({ projectRoot }).load();
 }
-function writeRoadmapFile(projectRoot, content) {
-  const filePath = roadmapPath(projectRoot);
-  const dir = path18.dirname(filePath);
-  fs15.mkdirSync(dir, { recursive: true });
-  fs15.writeFileSync(filePath, content, "utf-8");
+async function persistRoadmap(projectRoot, before, after) {
+  const store = resolveRoadmapStore({ projectRoot });
+  return applyRoadmapDiff(store, before, after);
 }
 function archiveFilePath(projectRoot) {
   return path18.join(projectRoot, "docs", "roadmap-archive.md");
@@ -4393,17 +4460,16 @@ function roadmapNotFoundError() {
     content: [
       {
         type: "text",
-        text: "Error: docs/roadmap.md not found. Create a roadmap first."
+        text: "Error: roadmap not found. Create a roadmap first."
       }
     ],
     isError: true
   };
 }
-function handleShow3(projectPath, input, deps) {
-  const { parseRoadmap, Ok: Ok2 } = deps;
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+async function handleShow3(projectPath, input, deps) {
+  const { Ok: Ok2 } = deps;
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
   let roadmap = result.value;
   if (input.milestone) {
@@ -4459,15 +4525,15 @@ function buildFeatureFromInput(input) {
     updatedAt: null
   };
 }
-function handleAdd2(projectPath, input, deps) {
-  const { parseRoadmap, serializeRoadmap, Ok: Ok2 } = deps;
+async function handleAdd2(projectPath, input, deps) {
+  const { Ok: Ok2 } = deps;
   const validationError = validateAddFields(input);
   if (validationError) return validationError;
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
   const roadmap = result.value;
+  const before = structuredClone(roadmap);
   const milestone = roadmap.milestones.find(
     (m) => m.name.toLowerCase() === input.milestone.toLowerCase()
   );
@@ -4479,7 +4545,8 @@ function handleAdd2(projectPath, input, deps) {
   }
   milestone.features.push(buildFeatureFromInput(input));
   roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-  writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+  const persisted = await persistRoadmap(projectPath, before, roadmap);
+  if (!persisted.ok) return resultToMcpResponse(persisted);
   return resultToMcpResponse(Ok2(roadmap));
 }
 function claimRefusedResponse(featureName, roadmap, currentAssignee) {
@@ -4494,19 +4561,19 @@ function claimRefusedResponse(featureName, roadmap, currentAssignee) {
     isError: true
   };
 }
-function handleUpdate2(projectPath, input, deps) {
-  const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, Ok: Ok2 } = deps;
+async function handleUpdate2(projectPath, input, deps) {
+  const { syncRoadmap, applySyncChanges, Ok: Ok2 } = deps;
   if (!input.feature) {
     return {
       content: [{ type: "text", text: "Error: feature is required for update action" }],
       isError: true
     };
   }
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
   const roadmap = result.value;
+  const before = structuredClone(roadmap);
   let found = false;
   for (const m of roadmap.milestones) {
     const feature = m.features.find((f) => f.name.toLowerCase() === input.feature.toLowerCase());
@@ -4537,27 +4604,31 @@ function handleUpdate2(projectPath, input, deps) {
       isError: true
     };
   }
-  const cascade = syncRoadmap({ projectPath, roadmap });
-  if (cascade.ok && cascade.value.length > 0) {
-    applySyncChanges(roadmap, cascade.value);
+  const cascade = await syncRoadmap({ projectPath, roadmap });
+  if (cascade.ok) {
+    const unblocking = cascade.value.filter((change) => change.to !== "blocked");
+    if (unblocking.length > 0) {
+      applySyncChanges(roadmap, unblocking);
+    }
   }
   roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-  writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+  const persisted = await persistRoadmap(projectPath, before, roadmap);
+  if (!persisted.ok) return resultToMcpResponse(persisted);
   return resultToMcpResponse(Ok2(roadmap));
 }
-function handleRemove2(projectPath, input, deps) {
-  const { parseRoadmap, serializeRoadmap, Ok: Ok2 } = deps;
+async function handleRemove2(projectPath, input, deps) {
+  const { Ok: Ok2 } = deps;
   if (!input.feature) {
     return {
       content: [{ type: "text", text: "Error: feature is required for remove action" }],
       isError: true
     };
   }
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
   const roadmap = result.value;
+  const before = structuredClone(roadmap);
   let found = false;
   for (const m of roadmap.milestones) {
     const idx = m.features.findIndex((f) => f.name.toLowerCase() === input.feature.toLowerCase());
@@ -4574,7 +4645,8 @@ function handleRemove2(projectPath, input, deps) {
     };
   }
   roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-  writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+  const persisted = await persistRoadmap(projectPath, before, roadmap);
+  if (!persisted.ok) return resultToMcpResponse(persisted);
   return resultToMcpResponse(Ok2(roadmap));
 }
 function promoteEnvelopeResponse(envelope2) {
@@ -4583,8 +4655,8 @@ function promoteEnvelopeResponse(envelope2) {
     isError: envelope2.ok === false
   };
 }
-function handlePromote2(projectPath, input, deps) {
-  const { parseRoadmap, serializeRoadmap, promoteFeature } = deps;
+async function handlePromote2(projectPath, input, deps) {
+  const { promoteFeature } = deps;
   if (!input.feature) {
     return {
       content: [{ type: "text", text: "Error: feature is required for promote action" }],
@@ -4597,9 +4669,8 @@ function handlePromote2(projectPath, input, deps) {
       isError: true
     };
   }
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) {
     return promoteEnvelopeResponse({
       ok: false,
@@ -4608,6 +4679,7 @@ function handlePromote2(projectPath, input, deps) {
       detail: result.error.message
     });
   }
+  const before = structuredClone(result.value);
   const { result: envelope2, nextRoadmap } = promoteFeature(result.value, {
     feature: input.feature,
     spec: input.spec,
@@ -4615,30 +4687,28 @@ function handlePromote2(projectPath, input, deps) {
   });
   if (envelope2.ok && envelope2.transitioned !== "noop") {
     nextRoadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      writeRoadmapFile(projectPath, serializeRoadmap(nextRoadmap));
-    } catch (error) {
+    const persisted = await persistRoadmap(projectPath, before, nextRoadmap);
+    if (!persisted.ok) {
       return promoteEnvelopeResponse({
         ok: false,
         reason: "write-failed",
         feature: input.feature,
-        detail: error instanceof Error ? error.message : String(error)
+        detail: persisted.error.message
       });
     }
   }
   return promoteEnvelopeResponse(envelope2);
 }
-function handleQuery2(projectPath, input, deps) {
-  const { parseRoadmap, Ok: Ok2 } = deps;
+async function handleQuery2(projectPath, input, deps) {
+  const { Ok: Ok2 } = deps;
   if (!input.filter) {
     return {
       content: [{ type: "text", text: "Error: filter is required for query action" }],
       isError: true
     };
   }
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
   const roadmap = result.value;
   const allFeatures = roadmap.milestones.flatMap(
@@ -4654,14 +4724,14 @@ function handleQuery2(projectPath, input, deps) {
   }
   return resultToMcpResponse(Ok2(filtered));
 }
-function handleSync2(projectPath, input, deps) {
-  const { parseRoadmap, serializeRoadmap, syncRoadmap, Ok: Ok2 } = deps;
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+async function handleSync2(projectPath, input, deps) {
+  const { syncRoadmap, Ok: Ok2 } = deps;
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
   const roadmap = result.value;
-  const syncResult = syncRoadmap({
+  const before = structuredClone(roadmap);
+  const syncResult = await syncRoadmap({
     projectPath,
     roadmap,
     forceSync: input.force_sync ?? false
@@ -4673,17 +4743,18 @@ function handleSync2(projectPath, input, deps) {
   }
   if (input.apply) {
     deps.applySyncChanges(roadmap, changes);
-    writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+    const persisted = await persistRoadmap(projectPath, before, roadmap);
+    if (!persisted.ok) return resultToMcpResponse(persisted);
     return resultToMcpResponse(Ok2({ changes, applied: true, roadmap }));
   }
   return resultToMcpResponse(Ok2({ changes, applied: false }));
 }
-function handleGroom(projectPath, _input, deps) {
-  const { parseRoadmap, serializeRoadmap, groomRoadmap, Ok: Ok2 } = deps;
-  const raw = readRoadmapFile(projectPath);
-  if (raw === null) return roadmapNotFoundError();
-  const result = parseRoadmap(raw);
+async function handleGroom(projectPath, _input, deps) {
+  const { groomRoadmap, Ok: Ok2 } = deps;
+  if (!roadmapSourceExists(projectPath)) return roadmapNotFoundError();
+  const result = await loadRoadmap(projectPath);
   if (!result.ok) return resultToMcpResponse(result);
+  const before = structuredClone(result.value);
   const { roadmap: groomed, archived, changes } = groomRoadmap(result.value);
   if (changes.length === 0) {
     return resultToMcpResponse(
@@ -4692,7 +4763,8 @@ function handleGroom(projectPath, _input, deps) {
   }
   appendToArchive(projectPath, archived, groomed.frontmatter.project, deps);
   groomed.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-  writeRoadmapFile(projectPath, serializeRoadmap(groomed));
+  const persisted = await persistRoadmap(projectPath, before, groomed);
+  if (!persisted.ok) return resultToMcpResponse(persisted);
   const demoted = changes.filter((c) => c.kind === "demoted").length;
   return resultToMcpResponse(
     Ok2({
@@ -4704,7 +4776,7 @@ function handleGroom(projectPath, _input, deps) {
   );
 }
 var readOnlyActions = /* @__PURE__ */ new Set(["show", "query"]);
-function dispatchAction(action, projectPath, input, deps) {
+async function dispatchAction(action, projectPath, input, deps) {
   switch (action) {
     case "show":
       return handleShow3(projectPath, input, deps);
@@ -4764,7 +4836,7 @@ async function handleManageRoadmap(input) {
       release,
       promoteFeature,
       groomRoadmap
-    } = await import("./dist-3HW4LCHE.js");
+    } = await import("./dist-6D2F2J57.js");
     const { Ok: Ok2 } = await import("./dist-ICW4QUEW.js");
     const projectPath = projectPathPre;
     const deps = {
@@ -4780,9 +4852,9 @@ async function handleManageRoadmap(input) {
       groomRoadmap,
       Ok: Ok2
     };
-    const response = dispatchAction(input.action, projectPath, input, deps);
+    const response = await dispatchAction(input.action, projectPath, input, deps);
     if (shouldTriggerExternalSync(input, response)) {
-      await triggerExternalSync(projectPath, roadmapPath(projectPath)).catch(() => {
+      await triggerExternalSync(projectPath).catch(() => {
       });
     }
     return response;
@@ -5208,7 +5280,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-3HW4LCHE.js");
+    const { saveHandoff } = await import("./dist-6D2F2J57.js");
     await saveHandoff(
       projectPath,
       {
@@ -5289,17 +5361,17 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-3HW4LCHE.js");
-    const stateResult = await loadState(projectPath, stream);
-    if (stateResult.ok) {
-      const state = stateResult.value;
-      state.decisions.push({
-        date: (/* @__PURE__ */ new Date()).toISOString(),
-        decision: `[${type}:${id}] ${decision}`,
-        context: "pending user response"
-      });
-      await saveState(projectPath, state, stream);
-    }
+    const { emitCoreEvent, emitUserInputCaptured, emitApprovalRequested } = await import("./state-events-ECQAIZLU.js");
+    await emitCoreEvent(
+      projectPath,
+      {
+        type: "decision_recorded",
+        payload: { id, text: `[${type}:${id}] ${decision}`, context: "pending user response" }
+      },
+      { stream }
+    );
+    await emitUserInputCaptured(projectPath, decision, id, { stream });
+    await emitApprovalRequested(projectPath, id, type, decision, { stream });
   } catch {
   }
 }
@@ -5450,10 +5522,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation", "businessKnowledge"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-3HW4LCHE.js").then(
-    (core) => core.loadState(projectPath, void 0, input.session)
+  const statePromise = includeSet.has("state") ? import("./state-events-ECQAIZLU.js").then(
+    (m) => m.readHarnessState(projectPath, { session: input.session })
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-3HW4LCHE.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-6D2F2J57.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -5462,14 +5534,14 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-3HW4LCHE.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-6D2F2J57.js").then(
     (core) => core.loadHandoff(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
   const graphPromise = includeSet.has("graph") ? (async () => {
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-HHXN5FLP.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-STFGYKZH.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return null;
-    const { FusionLayer, ContextQL } = await import("./dist-OWHMNL4W.js");
+    const { FusionLayer, ContextQL } = await import("./dist-DWBTZXR5.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -5506,19 +5578,15 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-3HW4LCHE.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-6D2F2J57.js").then(
     (core) => core.readSessionSections(projectPath, input.session)
   ) : Promise.resolve(null);
   const shouldIncludeEvents = input.includeEvents !== void 0 ? input.includeEvents : includeSet.has("events") || !!input.session && !input.include;
-  const eventsPromise = shouldIncludeEvents ? import("./dist-3HW4LCHE.js").then(async (core) => {
-    const result = await core.loadEvents(projectPath, {
-      session: input.session
-    });
-    if (!result.ok) return null;
-    return core.formatEventTimeline(result.value);
-  }) : Promise.resolve(null);
+  const eventsPromise = shouldIncludeEvents ? import("./state-events-ECQAIZLU.js").then(
+    (m) => m.readAuditTimeline(projectPath, { session: input.session })
+  ) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-G3LKBOYA.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-64KTEGIE.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -5621,7 +5689,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-3HW4LCHE.js");
+      const core = await import("./dist-6D2F2J57.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -5819,7 +5887,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-U6VJ6AUJ.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-BPHADTRQ.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -5854,7 +5922,7 @@ function extractFileCount(diffParsed) {
   return files?.length ?? 0;
 }
 async function runStandardReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-U6VJ6AUJ.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-BPHADTRQ.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -5889,7 +5957,7 @@ async function runStandardReview(projectPath, diff, diffLines, downgraded, offse
   };
 }
 async function runDeepReview(projectPath, diff, diffLines, _downgraded, offset, limit) {
-  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-WUHG7PHO.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-2TFQ5OAE.js");
   const result = await handleRunCodeReview2({
     path: projectPath,
     diff,
@@ -5969,7 +6037,7 @@ async function handleCheckTaskIndependence(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { TaskIndependenceAnalyzer } = await import("./dist-OWHMNL4W.js");
+    const { TaskIndependenceAnalyzer } = await import("./dist-DWBTZXR5.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -6057,7 +6125,7 @@ async function handlePredictConflicts(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { ConflictPredictor } = await import("./dist-OWHMNL4W.js");
+    const { ConflictPredictor } = await import("./dist-DWBTZXR5.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -6163,7 +6231,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-HHXN5FLP.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-STFGYKZH.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -6184,7 +6252,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-3HW4LCHE.js");
+    const { detectStaleConstraints } = await import("./dist-6D2F2J57.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -6215,6 +6283,7 @@ async function handleDetectStaleConstraints(input) {
 init_dist2();
 
 // src/skill/health-snapshot.ts
+init_dist2();
 import { execSync } from "child_process";
 import * as fs16 from "fs";
 import * as path19 from "path";
@@ -6314,10 +6383,10 @@ function countCriticalFindings(securityData) {
   return findings.filter((f) => f.severity === "error").length;
 }
 async function runHealthChecks(projectPath) {
-  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-B6ENHUAU.js");
-  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-5KPP4ID4.js");
-  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-3JBKCGJJ.js");
-  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-JDHTRBGC.js");
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-KOTAPAHD.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-YQH2NYXY.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-DBW2INZU.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-4W2P5ZGI.js");
   const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
     handleAssessProject2({
       path: projectPath,
@@ -6374,10 +6443,10 @@ function avg(values) {
 }
 async function runGraphMetrics(projectPath) {
   try {
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-HHXN5FLP.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-STFGYKZH.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return ZERO_METRICS;
-    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-OWHMNL4W.js");
+    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-DWBTZXR5.js");
     const couplingAdapter = new GraphCouplingAdapter(store);
     const couplingData = couplingAdapter.computeCouplingData();
     const files = couplingData.files;
@@ -6421,11 +6490,12 @@ async function captureHealthSnapshot(projectPath) {
     runGraphMetrics(projectPath)
   ]);
   const signals = deriveSignals(checks, metrics);
+  const reconciledChecks = reconcilePassed(checks, signals);
   const snapshot = {
     capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
     gitHead,
     projectPath,
-    checks,
+    checks: reconciledChecks,
     metrics,
     signals
   };
@@ -6793,17 +6863,7 @@ function recommend(snapshot, skills, options = {}) {
 }
 
 // src/skill/dispatch-engine.ts
-var SIGNAL_CATEGORIES = {
-  "circular-deps": "structure",
-  "layer-violations": "structure",
-  "high-coupling": "structure",
-  "dead-code": "quality",
-  drift: "quality",
-  "doc-gaps": "quality",
-  "security-findings": "security",
-  "perf-regression": "performance",
-  "low-coverage": "coverage"
-};
+var SIGNAL_CATEGORIES = SIGNAL_CATEGORY_MAP;
 function getSignalCategory(signal) {
   return SIGNAL_CATEGORIES[signal] ?? null;
 }
@@ -7073,7 +7133,7 @@ async function handleDispatchSkills(input) {
     let skillTriggers;
     if (trigger) {
       try {
-        const { loadOrRebuildIndex: loadOrRebuildIndex2 } = await import("./index-builder-3AOQ3ZII.js");
+        const { loadOrRebuildIndex: loadOrRebuildIndex2 } = await import("./index-builder-52IJJHJC.js");
         const index = loadOrRebuildIndex2("claude-code", projectRoot);
         skillTriggers = /* @__PURE__ */ new Map();
         for (const [name, entry] of Object.entries(index.skills)) {
@@ -7160,7 +7220,7 @@ async function handleGetDecayTrends(input) {
     };
   }
   try {
-    const core = await import("./dist-3HW4LCHE.js");
+    const core = await import("./dist-6D2F2J57.js");
     const { TimelineManager } = core;
     const manager = new TimelineManager(projectPath);
     const timeline = manager.load();
@@ -7295,7 +7355,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-3HW4LCHE.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-6D2F2J57.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -7314,7 +7374,7 @@ async function handleCodeOutline(input) {
         })
       );
       fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      const { paginate: paginate2 } = await import("./dist-3HW4LCHE.js");
+      const { paginate: paginate2 } = await import("./dist-6D2F2J57.js");
       const paged = paginate2(fileStats, input.offset ?? 0, input.limit ?? 30);
       const results = [];
       for (const entry of paged.items) {
@@ -7387,7 +7447,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-3HW4LCHE.js");
+    const { searchSymbols } = await import("./dist-6D2F2J57.js");
     const result = await searchSymbols(input.query, directory, input.glob);
     const lines = [`Search: "${result.query}" \u2014 ${result.matches.length} matches`];
     for (const match of result.matches) {
@@ -7456,7 +7516,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-3HW4LCHE.js");
+      const { unfoldSymbol } = await import("./dist-6D2F2J57.js");
       const result = await unfoldSymbol(filePath, input.symbol);
       const header = result.warning ? `${result.file}:${result.startLine}-${result.endLine} ${result.warning}
 ` : `${result.file}:${result.startLine}-${result.endLine}
@@ -7464,7 +7524,7 @@ async function handleCodeUnfold(input) {
       return { content: [{ type: "text", text: header + result.content }] };
     }
     if (input.startLine != null && input.endLine != null) {
-      const { unfoldRange } = await import("./dist-3HW4LCHE.js");
+      const { unfoldRange } = await import("./dist-6D2F2J57.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -7526,7 +7586,7 @@ async function handleCheckTraceability(input) {
         isError: true
       };
     }
-    const { queryTraceability } = await import("./dist-OWHMNL4W.js");
+    const { queryTraceability } = await import("./dist-DWBTZXR5.js");
     const options = {};
     if (input.spec) options.specPath = input.spec;
     if (input.feature) options.featureName = input.feature;
@@ -7649,7 +7709,7 @@ async function handlePredictFailures(input) {
     };
   }
   try {
-    const core = await import("./dist-3HW4LCHE.js");
+    const core = await import("./dist-6D2F2J57.js");
     const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
     const manager = new TimelineManager(projectPath);
     const includeRoadmap = input.includeRoadmap !== false;
@@ -7660,7 +7720,7 @@ async function handlePredictFailures(input) {
     };
     if (input.horizon !== void 0) opts.horizon = input.horizon;
     if (input.category) opts.categories = [input.category];
-    const result = engine.predict(opts);
+    const result = await engine.predict(opts);
     return {
       content: [
         {
@@ -8532,7 +8592,7 @@ function handleContentMode(content, pipeline, budget, source) {
   };
 }
 async function handleIntentMode(projectPath, intent, pipeline, budget, filterContent) {
-  const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-HHXN5FLP.js");
+  const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-STFGYKZH.js");
   const store = await loadGraphStore2(projectPath);
   if (!store) {
     return {
@@ -8545,7 +8605,7 @@ async function handleIntentMode(projectPath, intent, pipeline, budget, filterCon
       isError: true
     };
   }
-  const { PackedSummaryCache, FusionLayer, ContextQL } = await import("./dist-OWHMNL4W.js");
+  const { PackedSummaryCache, FusionLayer, ContextQL } = await import("./dist-DWBTZXR5.js");
   const cache = new PackedSummaryCache(store);
   const cachedEnvelope = cache.get(intent);
   if (cachedEnvelope) {
@@ -8758,7 +8818,7 @@ async function handleDetectConstraintEmergence(input) {
     }
     const nodePath = await import("path");
     const historyPath = nodePath.resolve(projectPath, ".harness/arch/violation-history.json");
-    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-3HW4LCHE.js");
+    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-6D2F2J57.js");
     const manager = new ViolationHistoryManager(historyPath);
     const history = manager.load();
     const options = { windowWeeks, minOccurrences };
@@ -8846,7 +8906,7 @@ async function handleRunCIChecks(input) {
     };
   }
   try {
-    const { runCIChecks } = await import("./dist-3HW4LCHE.js");
+    const { runCIChecks } = await import("./dist-6D2F2J57.js");
     const skip = input.checks ? VALID_CHECKS.filter((c) => !input.checks.includes(c)) : [];
     const result = await runCIChecks({
       projectRoot: projectPath,
@@ -8908,7 +8968,7 @@ async function handleGenerateBlueprint(input) {
     };
   }
   try {
-    const { ProjectScanner } = await import("./dist-3HW4LCHE.js");
+    const { ProjectScanner } = await import("./dist-6D2F2J57.js");
     const scanner = new ProjectScanner(projectPath);
     const data = await scanner.scan();
     return {
@@ -9076,45 +9136,68 @@ var emitSkillProposalDefinition = {
     required: ["path", "kind", "proposedBy", "justification", "content"]
   }
 };
-async function handleEmitSkillProposal(input) {
-  let projectPath;
-  try {
-    projectPath = sanitizePath(input.path);
-  } catch (err2) {
-    return mcpError(err2 instanceof Error ? err2.message : "Invalid path");
+function validateNewSkillProposal(input) {
+  if (!input.content.skillYaml || !input.content.skillMd) {
+    return "new-skill proposals require both skillYaml and skillMd";
+  }
+  if (input.targetSkill) {
+    return "targetSkill is forbidden on new-skill proposals";
+  }
+  if (input.content.diff) {
+    return "diff is forbidden on new-skill proposals (use skillYaml/skillMd)";
+  }
+  return null;
+}
+function validateRefinementProposal(input) {
+  if (!input.targetSkill) {
+    return "refinement proposals require targetSkill";
   }
+  if (!input.content.diff) {
+    return "refinement proposals require a unified diff";
+  }
+  if (input.content.skillYaml || input.content.skillMd) {
+    return "skillYaml/skillMd are forbidden on refinement proposals (encode in diff)";
+  }
+  return null;
+}
+function validateProposalCrossFields(input) {
   if (input.kind === "new-skill") {
-    if (!input.content.skillYaml || !input.content.skillMd) {
-      return mcpError("new-skill proposals require both skillYaml and skillMd");
-    }
-    if (input.targetSkill) {
-      return mcpError("targetSkill is forbidden on new-skill proposals");
-    }
-    if (input.content.diff) {
-      return mcpError("diff is forbidden on new-skill proposals (use skillYaml/skillMd)");
-    }
-  } else if (input.kind === "refinement") {
-    if (!input.targetSkill) {
-      return mcpError("refinement proposals require targetSkill");
-    }
-    if (!input.content.diff) {
-      return mcpError("refinement proposals require a unified diff");
-    }
-    if (input.content.skillYaml || input.content.skillMd) {
-      return mcpError("skillYaml/skillMd are forbidden on refinement proposals (encode in diff)");
-    }
+    return validateNewSkillProposal(input);
   }
-  let createProposal;
-  let ProposalConflictError;
+  if (input.kind === "refinement") {
+    return validateRefinementProposal(input);
+  }
+  return null;
+}
+async function loadCoreProposalApi() {
   try {
-    const core = await import("./dist-3HW4LCHE.js");
-    createProposal = core.createProposal;
-    ProposalConflictError = core.ProposalConflictError;
+    const core = await import("./dist-6D2F2J57.js");
+    return {
+      createProposal: core.createProposal,
+      ProposalConflictError: core.ProposalConflictError
+    };
   } catch (err2) {
     return mcpError(
       `Failed to load proposal store: ${err2 instanceof Error ? err2.message : "unknown error"}`
     );
   }
+}
+async function handleEmitSkillProposal(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (err2) {
+    return mcpError(err2 instanceof Error ? err2.message : "Invalid path");
+  }
+  const validationError = validateProposalCrossFields(input);
+  if (validationError) {
+    return mcpError(validationError);
+  }
+  const core = await loadCoreProposalApi();
+  if ("content" in core) {
+    return core;
+  }
+  const { createProposal, ProposalConflictError } = core;
   try {
     const proposal = await createProposal(projectPath, {
       kind: input.kind,
@@ -9150,8 +9233,8 @@ async function handleEmitSkillProposal(input) {
 }
 
 // src/mcp/tools/audit-anatomy.ts
-import * as fs19 from "fs";
-import * as path22 from "path";
+import * as fs22 from "fs";
+import * as path24 from "path";
 
 // src/audit/component-anatomy/parsers/ast.ts
 import * as fs18 from "fs";
@@ -9260,6 +9343,10 @@ function findTypeDeclaration(sourceFile, typeName) {
   return null;
 }
 
+// src/audit/component-anatomy/resolvers/component-type.ts
+import * as fs20 from "fs";
+import * as path23 from "path";
+
 // src/audit/component-anatomy/catalog/conventions/button.ts
 var buttonConvention = {
   componentType: "Button",
@@ -9843,6 +9930,65 @@ function lookupConvention(componentType) {
   return conventionByType.get(componentType) ?? null;
 }
 
+// src/audit/component-anatomy/parsers/jsdoc.ts
+function extractLeadingJsDoc(source) {
+  const re = /^\s*(?:#![^\n]*\n)?\s*(?:['"]use (?:client|server)['"];?\s*)?\s*\/\*\*([\s\S]*?)\*\//;
+  const match = re.exec(source);
+  if (!match) return null;
+  return match[1].split("\n").map((line) => line.replace(/^\s*\*?\s?/, "")).join("\n").trim();
+}
+function readJsDocTag(jsdoc, tag) {
+  const escaped = tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`@${escaped}\\b[ \\t]*(.*)$`, "gm");
+  const values = [];
+  for (const m of jsdoc.matchAll(re)) {
+    values.push((m[1] ?? "").trim());
+  }
+  return values;
+}
+function readJsDocTagValue(jsdoc, tag) {
+  const [first] = readJsDocTag(jsdoc, tag);
+  return first ? first : null;
+}
+
+// src/audit/component-anatomy/parsers/design-registry.ts
+import * as fs19 from "fs";
+import * as path22 from "path";
+function parseComponentRegistry(designMd) {
+  const lines = designMd.split("\n");
+  const headingIdx = lines.findIndex((l) => /^#{1,6}\s+Component Registry\b/i.test(l));
+  if (headingIdx === -1) return [];
+  const entries = [];
+  for (let i = headingIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#{1,6}\s+/.test(line)) break;
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) continue;
+    const cells = trimmed.slice(1, trimmed.endsWith("|") ? -1 : void 0).split("|").map((c) => c.trim());
+    const [type, file] = cells;
+    if (!type || !file) continue;
+    if (/^type$/i.test(type) || /^:?-{2,}:?$/.test(type)) continue;
+    entries.push({ type, file });
+  }
+  return entries;
+}
+function findDesignMd(fromPath) {
+  let dir = path22.dirname(path22.resolve(fromPath));
+  for (; ; ) {
+    let names;
+    try {
+      names = fs19.readdirSync(dir);
+    } catch {
+      names = [];
+    }
+    const hit = names.find((n) => n.toLowerCase() === "design.md");
+    if (hit) return path22.join(dir, hit);
+    const parent = path22.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
 // src/audit/component-anatomy/resolvers/component-type.ts
 var componentTypeSet = new Set(getCatalogTypes());
 function resolveComponentType(filePath, fileContents) {
@@ -9852,11 +9998,31 @@ function resolveComponentType(filePath, fileContents) {
   if (registryType !== null) return registryType;
   return resolveFromExportName(fileContents);
 }
-function resolveFromJSDoc(_filePath, _fileContents) {
-  return null;
-}
-function resolveFromDesignRegistry(_filePath) {
-  return null;
+function resolveFromJSDoc(_filePath, fileContents) {
+  const jsdoc = extractLeadingJsDoc(fileContents);
+  if (jsdoc === null) return null;
+  return readJsDocTagValue(jsdoc, "component-type");
+}
+var registryCache = /* @__PURE__ */ new Map();
+function resolveFromDesignRegistry(filePath) {
+  const designPath = findDesignMd(filePath);
+  if (designPath === null) return null;
+  let byFile = registryCache.get(designPath);
+  if (!byFile) {
+    byFile = /* @__PURE__ */ new Map();
+    let contents;
+    try {
+      contents = fs20.readFileSync(designPath, "utf8");
+    } catch {
+      contents = "";
+    }
+    const designDir = path23.dirname(designPath);
+    for (const entry of parseComponentRegistry(contents)) {
+      byFile.set(path23.resolve(designDir, entry.file), entry.type);
+    }
+    registryCache.set(designPath, byFile);
+  }
+  return byFile.get(path23.resolve(filePath)) ?? null;
 }
 function resolveFromExportName(fileContents) {
   const patterns = [
@@ -9875,20 +10041,142 @@ function resolveFromExportName(fileContents) {
   return null;
 }
 
+// src/audit/component-anatomy/resolvers/source-of-truth.ts
+import * as fs21 from "fs";
+
+// src/audit/component-anatomy/parsers/anatomy-tags.ts
+var JSDOC_SOURCE_REF = "design-component-anatomy/jsdoc";
+function fixHint(name, axis) {
+  return `Add the \`${name}\` ${axis} to this component, or drop the \`@anatomy-${axis} ${name}\` tag if it no longer applies.`;
+}
+function parseFlaggedPart(value, axis) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const name = tokens[0];
+  if (!name) return null;
+  const flags = new Set(tokens.slice(1).map((t) => t.toLowerCase()));
+  return {
+    name,
+    required: flags.has("required"),
+    ...flags.has("exclusive") ? { exclusive: true } : {},
+    fixHint: fixHint(name, axis)
+  };
+}
+function parsePipeList(value, axis) {
+  return value.split("|").map((n) => n.trim()).filter(Boolean).map((name) => ({ name, required: false, fixHint: fixHint(name, axis) }));
+}
+function buildAnatomyRuleFromJsDoc(jsdoc, componentType) {
+  const slots = readJsDocTag(jsdoc, "anatomy-slot").map((v) => parseFlaggedPart(v, "slot")).filter((p) => p !== null);
+  const states = readJsDocTag(jsdoc, "anatomy-state").map((v) => parseFlaggedPart(v, "state")).filter((p) => p !== null);
+  const variants = readJsDocTag(jsdoc, "anatomy-variant").flatMap(
+    (v) => parsePipeList(v, "variant")
+  );
+  const sizes = readJsDocTag(jsdoc, "anatomy-size").flatMap((v) => parsePipeList(v, "size"));
+  if (slots.length === 0 && states.length === 0 && variants.length === 0 && sizes.length === 0) {
+    return null;
+  }
+  return { componentType, slots, states, variants, sizes, source: { ref: JSDOC_SOURCE_REF } };
+}
+
+// src/audit/component-anatomy/parsers/design-overrides.ts
+var SINGULAR = { slots: "slot", states: "state", variants: "variant", sizes: "size" };
+var SOURCE_REF = "design-component-anatomy/design-md";
+function partFrom(raw, axis) {
+  const m = /^([A-Za-z0-9][A-Za-z0-9-]*)\s*(?:\(([^)]*)\))?/.exec(raw.trim());
+  const name = m?.[1];
+  if (!name) return null;
+  const flags = (m?.[2] ?? "").toLowerCase();
+  return {
+    name,
+    required: /\brequired\b/.test(flags),
+    .../\bexclusive\b/.test(flags) ? { exclusive: true } : {},
+    fixHint: `Add the \`${name}\` ${SINGULAR[axis]} to this component (declared in the DESIGN.md anatomy override).`
+  };
+}
+function parseAnatomyOverrides(designMd) {
+  const lines = designMd.split("\n");
+  const out = /* @__PURE__ */ new Map();
+  let i = lines.findIndex((l) => /^#{1,6}\s+Component Anatomy Overrides\b/i.test(l));
+  if (i === -1) return out;
+  let current = null;
+  let currentAxis = null;
+  const flush = () => {
+    if (!current) return;
+    out.set(current.type, {
+      componentType: current.type,
+      slots: current.axes.slots,
+      states: current.axes.states,
+      variants: current.axes.variants,
+      sizes: current.axes.sizes,
+      source: { ref: SOURCE_REF }
+    });
+  };
+  for (i += 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#{1,2}\s/.test(line)) break;
+    const compHeading = /^#{3,6}\s+(.+?)\s*$/.exec(line);
+    if (compHeading) {
+      flush();
+      current = {
+        type: compHeading[1].trim(),
+        axes: { slots: [], states: [], variants: [], sizes: [] }
+      };
+      currentAxis = null;
+      continue;
+    }
+    if (!current) continue;
+    const axisMatch = /^\s*(slots|states|variants|sizes)\s*:\s*(.*)$/i.exec(line);
+    if (axisMatch) {
+      currentAxis = axisMatch[1].toLowerCase();
+      const inline = axisMatch[2].trim();
+      if (inline) {
+        for (const tok of inline.split(",")) {
+          const part = partFrom(tok, currentAxis);
+          if (part) current.axes[currentAxis].push(part);
+        }
+        currentAxis = null;
+      }
+      continue;
+    }
+    const listItem = /^\s*[-*]\s+(.*)$/.exec(line);
+    if (listItem && currentAxis) {
+      const part = partFrom(listItem[1], currentAxis);
+      if (part) current.axes[currentAxis].push(part);
+    }
+  }
+  flush();
+  return out;
+}
+
 // src/audit/component-anatomy/resolvers/source-of-truth.ts
 function resolveAnatomyRules(filePath, fileContents, componentType) {
   if (componentType === null) return null;
-  const jsdocRule = resolveFromJSDoc2(filePath, fileContents, componentType);
+  const jsdocRule = resolveFromJSDoc2(fileContents, componentType);
   if (jsdocRule !== null) return jsdocRule;
   const overrideRule = resolveFromDesignOverrides(filePath, componentType);
   if (overrideRule !== null) return overrideRule;
   return lookupConvention(componentType);
 }
-function resolveFromJSDoc2(_filePath, _fileContents, _componentType) {
-  return null;
-}
-function resolveFromDesignOverrides(_filePath, _componentType) {
-  return null;
+function resolveFromJSDoc2(fileContents, componentType) {
+  const jsdoc = extractLeadingJsDoc(fileContents);
+  if (jsdoc === null) return null;
+  return buildAnatomyRuleFromJsDoc(jsdoc, componentType);
+}
+var overridesCache = /* @__PURE__ */ new Map();
+function resolveFromDesignOverrides(filePath, componentType) {
+  const designPath = findDesignMd(filePath);
+  if (designPath === null) return null;
+  let byType = overridesCache.get(designPath);
+  if (!byType) {
+    let contents;
+    try {
+      contents = fs21.readFileSync(designPath, "utf8");
+    } catch {
+      contents = "";
+    }
+    byType = parseAnatomyOverrides(contents);
+    overridesCache.set(designPath, byType);
+  }
+  return byType.get(componentType) ?? null;
 }
 
 // src/audit/component-anatomy/findings/severity.ts
@@ -10007,10 +10295,199 @@ function runConventionRule(rule, parsed, options) {
   return findings;
 }
 
+// src/audit/component-anatomy/catalog/patterns/index.ts
+function lineAt(contents, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < contents.length; i++) {
+    if (contents[i] === "\n") line += 1;
+  }
+  return line;
+}
+var anyMatch = (contents, res) => res.some((re) => re.test(contents));
+function firstTrigger(contents, triggers) {
+  let best = -1;
+  for (const re of triggers) {
+    const m = re.exec(contents);
+    if (m && (best === -1 || m.index < best)) best = m.index;
+  }
+  return best;
+}
+function buildPresenceFinding(spec, file, contents, componentType, index) {
+  const line = lineAt(contents, index);
+  const snippet = (contents.split("\n")[line - 1] ?? "").trim();
+  return {
+    code: spec.code,
+    severity: "warn",
+    file,
+    line,
+    componentType,
+    message: spec.message,
+    evidence: { snippet },
+    rule: { id: spec.code, source: `design-component-anatomy/pattern-${spec.id}` },
+    fix: { kind: "manual", description: spec.fix }
+  };
+}
+function detectPresence(spec, file, contents, componentType) {
+  const index = firstTrigger(contents, spec.triggers);
+  if (index === -1) return [];
+  if (anyMatch(contents, spec.mitigations)) return [];
+  return [buildPresenceFinding(spec, file, contents, componentType, index)];
+}
+function presencePattern(spec) {
+  return {
+    code: spec.code,
+    id: spec.id,
+    source: `design-component-anatomy/pattern-${spec.id}`,
+    detect: (file, contents, componentType) => detectPresence(spec, file, contents, componentType)
+  };
+}
+var SPECS = [
+  {
+    code: "ANAT-P001",
+    id: "map-without-empty",
+    triggers: [/\.map\s*\(/],
+    mitigations: [
+      /\.length\s*===\s*0/,
+      /\.length\s*<\s*1/,
+      /\.length\s*>\s*0/,
+      /\.length\s*\?/,
+      /\blength\s*&&/,
+      /\?\.length\b/,
+      /\bisEmpty\b/,
+      /\bEmptyState\b/,
+      /\bno\s+(results|items|data|entries)\b/i
+    ],
+    message: "List rendered with `.map(...)` but no empty state was found. An empty list renders as a blank region \u2014 add a length-zero branch (e.g. an EmptyState).",
+    fix: "Guard the list: `items.length === 0 ? <EmptyState/> : items.map(...)`."
+  },
+  {
+    code: "ANAT-P002",
+    id: "fetch-without-loading",
+    triggers: [/\bfetch\s*\(/, /\buse(Query|SWR|Swr|Mutation)\b/, /\baxios\s*[.(]/, /\bawait\s+/],
+    mitigations: [
+      /\bis?Loading\b/i,
+      /\bisPending\b/i,
+      /\bpending\b/i,
+      /\bSkeleton\b/,
+      /\bSpinner\b/,
+      /<Suspense\b/,
+      /\bplaceholder\b/i
+    ],
+    message: "Async data loading found but no loading state. The surface renders empty until data resolves \u2014 add a loading boundary (skeleton, spinner, or Suspense).",
+    fix: "Render a loading affordance while the request is in flight (e.g. `if (isLoading) return <Skeleton/>`)."
+  },
+  {
+    code: "ANAT-P003",
+    id: "fetch-without-error",
+    triggers: [/\bfetch\s*\(/, /\buse(Query|SWR|Swr|Mutation)\b/, /\baxios\s*[.(]/, /\bawait\s+/],
+    mitigations: [
+      /\bis?Error\b/i,
+      /\berror\b/i,
+      /\bcatch\s*\(/,
+      /\.catch\s*\(/,
+      /\bErrorState\b/,
+      /\bErrorBoundary\b/,
+      /role=["']alert["']/
+    ],
+    message: "Async data loading found but no error state. A failed request renders nothing or throws \u2014 handle and display the error case.",
+    fix: "Add an error branch (e.g. `if (isError) return <ErrorState/>`) or a try/catch around the request."
+  },
+  {
+    code: "ANAT-P004",
+    id: "conditional-render-without-fallback",
+    triggers: [/\{\s*[\w.]*(data|items|list|results|rows|user|profile)[\w.]*\s*&&/i],
+    mitigations: [/\?\s*\(?</, /\?\?/, /\bEmptyState\b/, /:\s*null/, /:\s*</, /\.length\s*===\s*0/],
+    message: "Data-driven `{value && <\u2026>}` render with no fallback. When `value` is falsy the region collapses silently \u2014 provide an explicit empty/else branch.",
+    fix: "Use a ternary with a fallback: `value ? <View/> : <EmptyState/>`."
+  },
+  {
+    code: "ANAT-P005",
+    id: "form-without-submit-feedback",
+    triggers: [/<form\b/i, /\bonSubmit\b/, /\bhandleSubmit\b/],
+    mitigations: [
+      /\bisSubmitting\b/i,
+      /\bpending\b/i,
+      /\bsuccess\b/i,
+      /\berror\b/i,
+      /\bdisabled\b/,
+      /role=["']alert["']/,
+      /\btoast\b/i
+    ],
+    message: "Form submission found but no submit feedback (pending / success / error). The user gets no signal that submit worked or failed.",
+    fix: "Disable the submit control while pending and surface a success/error state after submission."
+  },
+  {
+    code: "ANAT-P006",
+    id: "modal-without-dismiss",
+    triggers: [/<(Modal|Dialog|Drawer|Sheet|Popover)\b/],
+    mitigations: [/\bonClose\b/, /\bonDismiss\b/, /\bonOpenChange\b/, /\bclose\b/i, /\bonCancel\b/],
+    message: "Modal/Dialog/Drawer used with no dismiss affordance (`onClose` / `onDismiss` / `onOpenChange`). A modal the user cannot close is a trap.",
+    fix: "Wire a dismiss handler (`onClose` / `onOpenChange`) and a visible close control."
+  },
+  {
+    code: "ANAT-P007",
+    id: "async-action-without-pending",
+    triggers: [
+      /on[A-Z]\w*=\{?\s*async\b/,
+      /\bhandle\w*\s*=\s*async\b/,
+      /async\s+function\s+handle/i
+    ],
+    mitigations: [
+      /\bdisabled\b/,
+      /\bis?Pending\b/i,
+      /\bis?Loading\b/i,
+      /\bis?Submitting\b/i,
+      /\bSpinner\b/
+    ],
+    message: "Async action handler with no pending state. Without disabling/feedback the user can double-submit and gets no progress signal.",
+    fix: "Track a pending flag and disable the control (and show a spinner) while the action runs."
+  },
+  {
+    code: "ANAT-P008",
+    id: "list-without-key",
+    triggers: [/\.map\s*\(\s*\(?[^)]*\)?\s*=>\s*</],
+    mitigations: [/\bkey=/],
+    message: "Elements rendered from `.map(...)` with no `key` prop. Missing keys break reconciliation (lost state, mis-ordered DOM).",
+    fix: "Add a stable `key` to the top-level mapped element: `items.map((i) => <Row key={i.id} />)`."
+  },
+  {
+    code: "ANAT-P009",
+    id: "router-without-not-found",
+    triggers: [/<Routes\b/, /<Switch\b/, /\bcreateBrowserRouter\b/],
+    mitigations: [
+      /path=["']\*["']/,
+      /path=["']\/\*["']/,
+      /\bNotFound\b/,
+      /\bcatchAll\b/i,
+      /\b404\b/
+    ],
+    message: "Route table with no catch-all / not-found route. Unmatched URLs render a blank page.",
+    fix: 'Add a catch-all route (`<Route path="*" element={<NotFound/>} />`).'
+  },
+  {
+    code: "ANAT-P010",
+    id: "destructive-action-without-confirm",
+    triggers: [
+      /\b(onDelete|handleDelete|handleRemove|onRemove)\b/,
+      /\b(delete|remove|destroy)\w*\s*\(/i
+    ],
+    mitigations: [
+      /\bconfirm\s*\(/i,
+      /\bAlertDialog\b/,
+      /\bConfirm(ation)?(Dialog|Modal)?\b/,
+      /\bareYouSure\b/i,
+      /\bwindow\.confirm\b/
+    ],
+    message: "Destructive action (delete/remove) with no confirmation step. A single click irreversibly destroys data.",
+    fix: "Gate the action behind a confirmation (e.g. an AlertDialog) before performing it."
+  }
+];
+var PATTERN_CHECKS = SPECS.map(presencePattern);
+
 // src/mcp/tools/audit-anatomy.ts
 var auditAnatomyDefinition = {
   name: "audit_anatomy",
-  description: "Audit components for anatomy completeness. Emits ANAT-D* findings for component definitions missing required slots/states (e.g., Button missing `content`). In v1 vertical slice runs the Button convention only; pattern-presence checks (ANAT-P*) return empty pending follow-up.",
+  description: "Audit components for anatomy completeness. Emits ANAT-D* findings for component definitions missing required slots/states (e.g., Button missing `content`). In v1 vertical slice runs the component conventions, plus 10 ANAT-P* composition patterns (missing empty/loading/error states, modal dismiss, submit feedback, list keys, route 404, destructive-action confirm, \u2026) in full mode.",
   inputSchema: {
     type: "object",
     properties: {
@@ -10018,7 +10495,7 @@ var auditAnatomyDefinition = {
       mode: {
         type: "string",
         enum: ["fast", "full"],
-        description: "fast = conventions only (cheap AST scan). full = conventions + patterns. In v1 both modes run conventions only because pattern engine is not yet wired."
+        description: "fast = conventions only (cheap AST scan); full additionally runs the ANAT-P* composition patterns."
       },
       files: {
         type: "array",
@@ -10046,31 +10523,38 @@ async function runAudit(input) {
   const projectRoot = sanitizePath(input.path);
   const candidateFiles = input.files ?? [];
   const conventionsApplied = /* @__PURE__ */ new Set();
+  const patternsApplied = /* @__PURE__ */ new Set();
   let totalFiles = 0;
   for (const candidatePath of candidateFiles) {
-    const absolute = path22.isAbsolute(candidatePath) ? candidatePath : path22.join(projectRoot, candidatePath);
+    const absolute = path24.isAbsolute(candidatePath) ? candidatePath : path24.join(projectRoot, candidatePath);
     let contents;
     try {
-      contents = fs19.readFileSync(absolute, "utf8");
+      contents = fs22.readFileSync(absolute, "utf8");
     } catch {
       continue;
     }
     totalFiles += 1;
+    const fileRelative = path24.relative(projectRoot, absolute).replaceAll("\\", "/") || absolute;
     const componentType = resolveComponentType(absolute, contents);
+    if (mode2 === "full") {
+      for (const pattern of PATTERN_CHECKS) {
+        const patternFindings = pattern.detect(fileRelative, contents, componentType);
+        if (patternFindings.length > 0) patternsApplied.add(pattern.id);
+        findings.push(...patternFindings);
+      }
+    }
     if (componentType === null) continue;
     const rule = resolveAnatomyRules(absolute, contents, componentType);
     if (rule === null) continue;
     const parsed = parseComponentDefinitionFromSource(absolute, contents);
     if (parsed === null) continue;
     conventionsApplied.add(rule.componentType);
-    const fileRelative = path22.relative(projectRoot, absolute).replaceAll("\\", "/") || absolute;
     const runnerOptions = { filePath: fileRelative };
     if (input.designStrictness !== void 0) {
       runnerOptions.strictness = input.designStrictness;
     }
     const fileFindings = runConventionRule(rule, parsed, runnerOptions);
     findings.push(...fileFindings);
-    void mode2;
   }
   const summary = buildSummary(findings, totalFiles, Date.now() - start);
   return {
@@ -10078,7 +10562,7 @@ async function runAudit(input) {
     summary,
     catalog: {
       conventionsApplied: [...conventionsApplied].sort(),
-      patternsApplied: []
+      patternsApplied: [...patternsApplied].sort()
     },
     meta: { mode: mode2, deferredToA11y: 0 }
   };
@@ -10110,10 +10594,11 @@ async function handleAuditAnatomy(input) {
 // src/mcp/tools/design-craft.ts
 init_dist2();
 import * as crypto2 from "crypto";
+import { execSync as execSync3 } from "child_process";
 
 // src/design-craft/phases/critique.ts
-import * as fs20 from "fs";
-import * as path23 from "path";
+import * as fs23 from "fs";
+import * as path25 from "path";
 
 // src/shared/craft/findings/derived.ts
 var TIER_BAND = {
@@ -10195,8 +10680,8 @@ function parseFindingResponse(raw) {
 }
 function readSource(target) {
   if (typeof target.source === "string") return target.source;
-  const resolved = path23.isAbsolute(target.file) ? target.file : path23.resolve(process.cwd(), target.file);
-  return fs20.readFileSync(resolved, "utf8");
+  const resolved = path25.isAbsolute(target.file) ? target.file : path25.resolve(process.cwd(), target.file);
+  return fs23.readFileSync(resolved, "utf8");
 }
 function formatPrompt(template, targetId, source) {
   return template.replace(/\{target\}/g, targetId).replace(/\{source\}/g, source);
@@ -10258,10 +10743,37 @@ async function runCritique(args) {
   }
   return findings;
 }
+function readImage(imagePath) {
+  const resolved = path25.isAbsolute(imagePath) ? imagePath : path25.resolve(process.cwd(), imagePath);
+  const imageBuffer = fs23.readFileSync(resolved);
+  const ext = path25.extname(resolved).toLowerCase();
+  const mediaType = ext === ".jpg" || ext === ".jpeg" ? "image/jpeg" : ext === ".webp" ? "image/webp" : "image/png";
+  return { imageBuffer, mediaType };
+}
+async function runVisionCritique(args) {
+  const findings = [];
+  for (const target of args.targets) {
+    const image = readImage(target.image);
+    const targetId = target.component ?? target.file;
+    for (const rubric of args.rubrics) {
+      const prompt = formatPrompt(
+        rubric.prompt,
+        targetId,
+        "(the rendered component is attached as an image \u2014 judge the visual result, not source code)"
+      );
+      const raw = await args.provider.callVision(prompt, image);
+      const parsed = parseFindingResponse(raw);
+      findings.push(
+        parsed ? buildFinding(target, rubric, parsed) : buildSentinelFinding(target, rubric, raw)
+      );
+    }
+  }
+  return findings;
+}
 
 // src/design-craft/phases/polish.ts
-import * as fs21 from "fs";
-import * as path24 from "path";
+import * as fs24 from "fs";
+import * as path26 from "path";
 var TIER_VALUES2 = ["foundational", "polish", "aspirational"];
 var IMPACT_VALUES2 = ["small", "medium", "large"];
 var CONFIDENCE_VALUES2 = ["high", "medium", "low"];
@@ -10322,8 +10834,8 @@ function parsePolishResponse(raw) {
 }
 function readSource2(target) {
   if (typeof target.source === "string") return target.source;
-  const resolved = path24.isAbsolute(target.file) ? target.file : path24.resolve(process.cwd(), target.file);
-  return fs21.readFileSync(resolved, "utf8");
+  const resolved = path26.isAbsolute(target.file) ? target.file : path26.resolve(process.cwd(), target.file);
+  return fs24.readFileSync(resolved, "utf8");
 }
 function patternIsPlausible(source, pattern) {
   if (pattern.applicableTo.length === 0) return true;
@@ -10406,8 +10918,8 @@ async function runPolish(args) {
 }
 
 // src/design-craft/phases/benchmark.ts
-import * as fs22 from "fs";
-import * as path25 from "path";
+import * as fs25 from "fs";
+import * as path27 from "path";
 var CONFIDENCE_VALUES3 = ["high", "medium", "low"];
 function isConfidence3(v) {
   return typeof v === "string" && CONFIDENCE_VALUES3.includes(v);
@@ -10473,8 +10985,8 @@ function parseBenchmarkResponse(raw) {
 }
 function readSource3(target) {
   if (typeof target.source === "string") return target.source;
-  const resolved = path25.isAbsolute(target.file) ? target.file : path25.resolve(process.cwd(), target.file);
-  return fs22.readFileSync(resolved, "utf8");
+  const resolved = path27.isAbsolute(target.file) ? target.file : path27.resolve(process.cwd(), target.file);
+  return fs25.readFileSync(resolved, "utf8");
 }
 var CONFIDENCE_RANK = {
   high: 3,
@@ -12575,17 +13087,17 @@ import {
 } from "@harness-engineering/intelligence";
 
 // src/shared/craft/llm/orchestrator-md.ts
-import * as fs23 from "fs";
-import * as path26 from "path";
+import * as fs26 from "fs";
+import * as path28 from "path";
 import { parse as parse4 } from "yaml";
 var FILENAME = "harness.orchestrator.md";
 function findOrchestratorMd(startDir) {
-  let cur = path26.resolve(startDir);
-  const root = path26.parse(cur).root;
+  let cur = path28.resolve(startDir);
+  const root = path28.parse(cur).root;
   while (cur !== root) {
-    const candidate = path26.join(cur, FILENAME);
-    if (fs23.existsSync(candidate)) return candidate;
-    cur = path26.dirname(cur);
+    const candidate = path28.join(cur, FILENAME);
+    if (fs26.existsSync(candidate)) return candidate;
+    cur = path28.dirname(cur);
   }
   return null;
 }
@@ -12594,7 +13106,7 @@ function readBackendsFromOrchestratorMd(startDir) {
   if (file === null) return null;
   let raw;
   try {
-    raw = fs23.readFileSync(file, "utf-8");
+    raw = fs26.readFileSync(file, "utf-8");
   } catch {
     return null;
   }
@@ -12865,15 +13377,15 @@ function stringField(obj, key) {
 }
 
 // src/design-craft/measurement/usage.ts
-import * as fs24 from "fs";
-import * as path27 from "path";
-var DEFAULT_RELATIVE_PATH = path27.join(".harness", "design-craft", "usage.json");
+import * as fs27 from "fs";
+import * as path29 from "path";
+var DEFAULT_RELATIVE_PATH = path29.join(".harness", "design-craft", "usage.json");
 function emptyCounters() {
   return { rubrics: {}, patterns: {}, exemplars: {} };
 }
 function resolveStorePath(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  return path27.resolve(root, DEFAULT_RELATIVE_PATH);
+  return path29.resolve(root, DEFAULT_RELATIVE_PATH);
 }
 function isCounters(value) {
   if (value === null || typeof value !== "object") return false;
@@ -12882,7 +13394,7 @@ function isCounters(value) {
 }
 function readCountersFromDisk(filePath) {
   try {
-    const raw = fs24.readFileSync(filePath, "utf8");
+    const raw = fs27.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isCounters(parsed)) return emptyCounters();
     return {
@@ -12895,8 +13407,8 @@ function readCountersFromDisk(filePath) {
   }
 }
 function writeCountersToDisk(filePath, counters) {
-  fs24.mkdirSync(path27.dirname(filePath), { recursive: true });
-  fs24.writeFileSync(filePath, JSON.stringify(counters, null, 2), "utf8");
+  fs27.mkdirSync(path29.dirname(filePath), { recursive: true });
+  fs27.writeFileSync(filePath, JSON.stringify(counters, null, 2), "utf8");
 }
 function bumpCounter(family, id, projectRoot, count = 1) {
   if (id.length === 0 || count <= 0) return;
@@ -12917,13 +13429,13 @@ function recordCite(exemplarId, projectRoot) {
 }
 
 // src/design-craft/measurement/signal.ts
-import * as fs25 from "fs";
-import * as path28 from "path";
+import * as fs28 from "fs";
+import * as path30 from "path";
 import * as crypto from "crypto";
-var EVENTS_RELATIVE_PATH = path28.join(".harness", "design-craft", "signal-events.jsonl");
-var PROPOSALS_RELATIVE_DIR = path28.join(".harness", "design-craft", "proposals");
+var EVENTS_RELATIVE_PATH = path30.join(".harness", "design-craft", "signal-events.jsonl");
+var PROPOSALS_RELATIVE_DIR = path30.join(".harness", "design-craft", "proposals");
 function resolveEventsPath(storeRoot) {
-  return path28.resolve(storeRoot ?? process.cwd(), EVENTS_RELATIVE_PATH);
+  return path30.resolve(storeRoot ?? process.cwd(), EVENTS_RELATIVE_PATH);
 }
 function fingerprintFinding(finding) {
   const raw = `${finding.code}|${finding.tier}|${finding.cite.rubricOrPatternId}`;
@@ -12944,8 +13456,8 @@ function recordSignalEvent(finding, projectRoot, storeRoot) {
   };
   try {
     const file = resolveEventsPath(storeRoot);
-    fs25.mkdirSync(path28.dirname(file), { recursive: true });
-    fs25.appendFileSync(file, JSON.stringify(event) + "\n", "utf8");
+    fs28.mkdirSync(path30.dirname(file), { recursive: true });
+    fs28.appendFileSync(file, JSON.stringify(event) + "\n", "utf8");
   } catch {
   }
 }
@@ -12962,7 +13474,7 @@ var designCraftToolDefinition = {
       mode: {
         type: "string",
         enum: ["fast", "deep"],
-        description: "fast (code-only LLM critique) or deep (render + vision). MVP supports fast only."
+        description: "fast (code-only LLM critique) or deep (vision critique of rendered screenshots \u2014 requires `captures`)."
       },
       phases: {
         type: "array",
@@ -12977,7 +13489,11 @@ var designCraftToolDefinition = {
       autoCapture: {
         type: "string",
         enum: ["prompt", "auto", "skip"],
-        description: `B' detect-and-offer behavior when preconditions are missing. MVP: only "skip" is fully implemented.`
+        description: 'Deep-mode capture behavior when no `captures` are supplied. "skip" never runs the capture command; "prompt"/"auto" run `captureCommand` when one is configured.'
+      },
+      captureCommand: {
+        type: "string",
+        description: "Deep-mode render+screenshot command. Receives the candidate files via the HARNESS_DESIGN_CRAFT_FILES env var (JSON array) and must print a JSON array of { file, image, component? } to stdout. Used to obtain captures without a built-in browser."
       },
       designStrictness: {
         type: "string",
@@ -12996,6 +13512,19 @@ var designCraftToolDefinition = {
           },
           required: ["file", "component"]
         }
+      },
+      captures: {
+        type: "array",
+        description: 'Deep-mode (vision) captures: rendered component screenshots. Required when mode="deep" and the critique phase runs. Each entry: { file, image, component? }, where `image` is a path to a PNG/JPEG/WebP screenshot (the CLI does not render components itself).',
+        items: {
+          type: "object",
+          properties: {
+            file: { type: "string" },
+            image: { type: "string" },
+            component: { type: "string" }
+          },
+          required: ["file", "image"]
+        }
       }
     },
     required: ["path"]
@@ -13036,16 +13565,63 @@ function summarizeLlmCalls(provider) {
 async function runDesignCraft(input) {
   return runPipeline(input);
 }
-async function runPipeline(input) {
-  const mode2 = input.mode ?? "fast";
-  if (mode2 === "deep") {
+function runCaptureCommand(command, files, exec) {
+  let stdout;
+  try {
+    stdout = exec ? exec(command, files) : execSync3(command, {
+      encoding: "utf-8",
+      env: { ...process.env, HARNESS_DESIGN_CRAFT_FILES: JSON.stringify(files) },
+      maxBuffer: 16 * 1024 * 1024
+    });
+  } catch (err2) {
+    return Err({
+      message: `design-craft capture command failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return Err({
+      message: 'design-craft capture command did not emit valid JSON. Expected `[{ "file": "...", "image": "..." }]` on stdout.'
+    });
+  }
+  if (!Array.isArray(parsed)) {
+    return Err({
+      message: "design-craft capture command output must be a JSON array of { file, image }."
+    });
+  }
+  const captures = [];
+  for (const item of parsed) {
+    if (item !== null && typeof item === "object" && typeof item.file === "string" && typeof item.image === "string") {
+      const entry = item;
+      const capture = { file: entry.file, image: entry.image };
+      if (typeof entry.component === "string") capture.component = entry.component;
+      captures.push(capture);
+    }
+  }
+  if (captures.length === 0) {
     return Err({
-      message: 'design-craft deep mode (render + vision LLM) is not implemented in the Phase 1 MVP. Use mode: "fast".'
+      message: "design-craft capture command produced no valid { file, image } entries."
     });
   }
+  return Ok(captures);
+}
+async function runPipeline(input) {
+  const mode2 = input.mode ?? "fast";
   const phases = selectPhases(input.phases);
   const autoCapture = input.autoCapture ?? "prompt";
-  if (autoCapture !== "skip") {
+  let captures = input.captures ?? [];
+  const needsCaptures = mode2 === "deep" && phases.includes("critique") && captures.length === 0;
+  if (needsCaptures && input.captureCommand && autoCapture !== "skip") {
+    const captured = runCaptureCommand(input.captureCommand, input.files ?? [], input.__runCapture);
+    if (!captured.ok) return captured;
+    captures = captured.value;
+  }
+  if (mode2 === "deep" && phases.includes("critique") && captures.length === 0) {
+    return Err({
+      message: 'design-craft deep mode critiques rendered screenshots \u2014 supply `captures` ([{ file, image }]) or configure `captureCommand` to render them (the CLI does not render components itself). Or use mode: "fast".'
+    });
   }
   const provider = input.__testProvider ?? getProvider();
   const critiqueTargets = buildTargetsFromFiles(input.files);
@@ -13057,12 +13633,14 @@ async function runPipeline(input) {
   const findings = [];
   const scores = [];
   let rubricsApplied = [];
-  if (phases.includes("critique") && critiqueTargets.length > 0) {
+  if (phases.includes("critique")) {
     const rubrics = [...SEED_RUBRICS];
-    rubricsApplied = rubrics.map((r) => r.id);
-    const critiqueFindings = await runCritique({ targets: critiqueTargets, rubrics, provider });
+    const critiqueFindings = mode2 === "deep" ? await runVisionCritique({ targets: captures, rubrics, provider }) : critiqueTargets.length > 0 ? await runCritique({ targets: critiqueTargets, rubrics, provider }) : [];
+    if (critiqueFindings.length > 0 || mode2 === "deep") {
+      rubricsApplied = rubrics.map((r) => r.id);
+    }
     findings.push(...critiqueFindings);
-    if (recordMeasurement) {
+    if (recordMeasurement && critiqueFindings.length > 0) {
       for (const rubric of rubrics) recordTrigger(rubric.id, measurementRoot);
       for (const f of critiqueFindings) recordSignalEvent(f, measurementRoot, measurementRoot);
     }
@@ -13135,18 +13713,18 @@ async function handleDesignCraft(input) {
 }
 
 // src/drift/index.ts
-import * as fs28 from "fs";
-import * as path31 from "path";
+import * as fs31 from "fs";
+import * as path33 from "path";
 
 // src/drift/resolvers/tokens.ts
-import * as fs26 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path31 from "path";
 function loadTokenSet(projectRoot) {
-  const tokenPath = path29.join(projectRoot, "design-system", "tokens.json");
-  if (!fs26.existsSync(tokenPath)) return null;
+  const tokenPath = path31.join(projectRoot, "design-system", "tokens.json");
+  if (!fs29.existsSync(tokenPath)) return null;
   let raw;
   try {
-    raw = fs26.readFileSync(tokenPath, "utf-8");
+    raw = fs29.readFileSync(tokenPath, "utf-8");
   } catch {
     return null;
   }
@@ -13170,11 +13748,11 @@ function extractTokens(root) {
   return set;
 }
 function loadTokenPathIndex(projectRoot) {
-  const tokenPath = path29.join(projectRoot, "design-system", "tokens.json");
-  if (!fs26.existsSync(tokenPath)) return null;
+  const tokenPath = path31.join(projectRoot, "design-system", "tokens.json");
+  if (!fs29.existsSync(tokenPath)) return null;
   let raw;
   try {
-    raw = fs26.readFileSync(tokenPath, "utf-8");
+    raw = fs29.readFileSync(tokenPath, "utf-8");
   } catch {
     return null;
   }
@@ -13198,23 +13776,7 @@ function extractPathIndex(root) {
 }
 function walkForPaths(node, breadcrumb, idx) {
   if ("$value" in node) {
-    const tokenPath = breadcrumb.join(".");
-    const $type = typeof node.$type === "string" ? node.$type : void 0;
-    const $value = node.$value;
-    if ($type === "color" && typeof $value === "string") {
-      pushPath(idx.colorPath, $value.toLowerCase(), tokenPath);
-    } else if ($type === "fontFamily" && typeof $value === "string") {
-      pushPath(idx.fontFamilyPath, $value.toLowerCase(), tokenPath);
-    } else if ($type === "fontFamily" && Array.isArray($value)) {
-      for (const f of $value) {
-        if (typeof f === "string") pushPath(idx.fontFamilyPath, f.toLowerCase(), tokenPath);
-      }
-    } else if (($type === "dimension" || $type === "spacing") && typeof $value === "string") {
-      const px = parsePxValue($value);
-      if (px !== null) pushPath(idx.spacingPath, px, tokenPath);
-    } else if (($type === "dimension" || $type === "spacing") && typeof $value === "number") {
-      pushPath(idx.spacingPath, $value, tokenPath);
-    }
+    collectPathInto(node, breadcrumb, idx);
     return;
   }
   for (const [key, value] of Object.entries(node)) {
@@ -13224,33 +13786,23 @@ function walkForPaths(node, breadcrumb, idx) {
     }
   }
 }
-function pushPath(map, key, path54) {
+function collectPathInto(node, breadcrumb, idx) {
+  const tokenPath = breadcrumb.join(".");
+  const $type = typeof node.$type === "string" ? node.$type : void 0;
+  const $value = node.$value;
+  const parts = classifyTokenValue($type, $value);
+  for (const c of parts.colors) pushPath(idx.colorPath, c, tokenPath);
+  for (const f of parts.fontFamilies) pushPath(idx.fontFamilyPath, f, tokenPath);
+  for (const px of parts.spacingPx) pushPath(idx.spacingPath, px, tokenPath);
+}
+function pushPath(map, key, path56) {
   const list = map.get(key) ?? [];
-  list.push(path54);
+  list.push(path56);
   map.set(key, list);
 }
 function walk(node, breadcrumb, set) {
   if ("$value" in node) {
-    const tokenPath = breadcrumb.join(".");
-    const $type = typeof node.$type === "string" ? node.$type : void 0;
-    const $value = node.$value;
-    if (node.$deprecated === true || isHarnessDeprecated(node.$extensions)) {
-      set.deprecatedTokens.add(tokenPath);
-    }
-    if ($type === "color" && typeof $value === "string") {
-      set.colors.add($value.toLowerCase());
-    } else if ($type === "fontFamily" && typeof $value === "string") {
-      set.fontFamilies.add($value.toLowerCase());
-    } else if ($type === "fontFamily" && Array.isArray($value)) {
-      for (const f of $value) {
-        if (typeof f === "string") set.fontFamilies.add(f.toLowerCase());
-      }
-    } else if (($type === "dimension" || $type === "spacing") && typeof $value === "string") {
-      const px = parsePxValue($value);
-      if (px !== null) set.spacingPx.add(px);
-    } else if (($type === "dimension" || $type === "spacing") && typeof $value === "number") {
-      set.spacingPx.add($value);
-    }
+    collectTokenInto(node, breadcrumb, set);
     return;
   }
   for (const [key, value] of Object.entries(node)) {
@@ -13260,6 +13812,46 @@ function walk(node, breadcrumb, set) {
     }
   }
 }
+function collectTokenInto(node, breadcrumb, set) {
+  const tokenPath = breadcrumb.join(".");
+  const $type = typeof node.$type === "string" ? node.$type : void 0;
+  const $value = node.$value;
+  if (node.$deprecated === true || isHarnessDeprecated(node.$extensions)) {
+    set.deprecatedTokens.add(tokenPath);
+  }
+  const parts = classifyTokenValue($type, $value);
+  for (const c of parts.colors) set.colors.add(c);
+  for (const f of parts.fontFamilies) set.fontFamilies.add(f);
+  for (const px of parts.spacingPx) set.spacingPx.add(px);
+}
+function classifyTokenValue($type, $value) {
+  return {
+    colors: colorValues($type, $value),
+    fontFamilies: fontFamilyValues($type, $value),
+    spacingPx: spacingValues($type, $value)
+  };
+}
+function colorValues($type, $value) {
+  if ($type === "color" && typeof $value === "string") return [$value.toLowerCase()];
+  return [];
+}
+function fontFamilyValues($type, $value) {
+  if ($type !== "fontFamily") return [];
+  if (typeof $value === "string") return [$value.toLowerCase()];
+  if (Array.isArray($value)) {
+    return $value.filter((f) => typeof f === "string").map((f) => f.toLowerCase());
+  }
+  return [];
+}
+function spacingValues($type, $value) {
+  if ($type !== "dimension" && $type !== "spacing") return [];
+  if (typeof $value === "string") {
+    const px = parsePxValue($value);
+    return px !== null ? [px] : [];
+  }
+  if (typeof $value === "number") return [$value];
+  return [];
+}
 function isHarnessDeprecated(extensions) {
   if (!extensions || typeof extensions !== "object") return false;
   const harness = extensions["harness"];
@@ -13273,8 +13865,8 @@ function parsePxValue(s) {
 }
 
 // src/drift/resolvers/component-registry.ts
-import * as fs27 from "fs";
-import * as path30 from "path";
+import * as fs30 from "fs";
+import * as path32 from "path";
 var HTML_PRIMITIVE_MAP = {
   Button: "button",
   Input: "input",
@@ -13283,11 +13875,11 @@ var HTML_PRIMITIVE_MAP = {
   Anchor: "a"
 };
 function loadComponentRegistry(projectRoot) {
-  const designMdPath = path30.join(projectRoot, "design-system", "DESIGN.md");
-  if (!fs27.existsSync(designMdPath)) return null;
+  const designMdPath = path32.join(projectRoot, "design-system", "DESIGN.md");
+  if (!fs30.existsSync(designMdPath)) return null;
   let raw;
   try {
-    raw = fs27.readFileSync(designMdPath, "utf-8");
+    raw = fs30.readFileSync(designMdPath, "utf-8");
   } catch {
     return null;
   }
@@ -13607,40 +14199,76 @@ function extractLine2(source, offset) {
 
 // src/drift/index.ts
 var DEFAULT_GLOB_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".css", ".scss"];
-async function runDetectDrift(input) {
-  const startedAt = Date.now();
+function resolveDriftConfig(input) {
   const projectRoot = sanitizePath(input.path);
-  const mode2 = input.mode ?? "fast";
-  const strictness = input.designStrictness ?? "standard";
   const tokenBypassEnabled = input.rules?.tokenBypass !== false;
   const primitiveAdoptionEnabled = input.rules?.primitiveAdoption !== false;
-  const tokens = tokenBypassEnabled ? loadTokenSet(projectRoot) : null;
-  const registry = primitiveAdoptionEnabled ? loadComponentRegistry(projectRoot) : null;
+  return {
+    projectRoot,
+    mode: input.mode ?? "fast",
+    strictness: input.designStrictness ?? "standard",
+    tokenBypassEnabled,
+    primitiveAdoptionEnabled,
+    tokens: tokenBypassEnabled ? loadTokenSet(projectRoot) : null,
+    registry: primitiveAdoptionEnabled ? loadComponentRegistry(projectRoot) : null
+  };
+}
+function computeRulesApplied(config) {
   const rulesApplied = [];
-  if (tokenBypassEnabled && tokens !== null) rulesApplied.push("token-bypass");
-  if (primitiveAdoptionEnabled && registry !== null) rulesApplied.push("primitive-adoption");
-  const filesToScan = await collectFiles(projectRoot, input.files);
+  if (config.tokenBypassEnabled && config.tokens !== null) rulesApplied.push("token-bypass");
+  if (config.primitiveAdoptionEnabled && config.registry !== null) {
+    rulesApplied.push("primitive-adoption");
+  }
+  return rulesApplied;
+}
+function scanFile(file, config) {
+  let source;
+  try {
+    source = fs31.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
   const findings = [];
-  for (const file of filesToScan) {
-    let source;
-    try {
-      source = fs28.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    if (tokenBypassEnabled && tokens !== null) {
-      findings.push(...runTokenBypassRule({ source, file, tokens, strictness }));
-    }
-    if (primitiveAdoptionEnabled && registry !== null) {
-      findings.push(...runPrimitiveAdoptionRule({ source, file, registry, strictness }));
-    }
+  if (config.tokenBypassEnabled && config.tokens !== null) {
+    findings.push(
+      ...runTokenBypassRule({ source, file, tokens: config.tokens, strictness: config.strictness })
+    );
   }
+  if (config.primitiveAdoptionEnabled && config.registry !== null) {
+    findings.push(
+      ...runPrimitiveAdoptionRule({
+        source,
+        file,
+        registry: config.registry,
+        strictness: config.strictness
+      })
+    );
+  }
+  return findings;
+}
+function scanFiles(files, config) {
+  const findings = [];
+  for (const file of files) {
+    findings.push(...scanFile(file, config));
+  }
+  return findings;
+}
+function summarizeFindings(findings) {
   const bySeverity = { error: 0, warn: 0, info: 0 };
   const byCode2 = {};
   for (const f of findings) {
     bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1;
     byCode2[f.code] = (byCode2[f.code] ?? 0) + 1;
   }
+  return { bySeverity, byCode: byCode2 };
+}
+async function runDetectDrift(input) {
+  const startedAt = Date.now();
+  const config = resolveDriftConfig(input);
+  const rulesApplied = computeRulesApplied(config);
+  const filesToScan = await collectFiles(config.projectRoot, input.files);
+  const findings = scanFiles(filesToScan, config);
+  const { bySeverity, byCode: byCode2 } = summarizeFindings(findings);
   return {
     findings,
     summary: {
@@ -13651,15 +14279,15 @@ async function runDetectDrift(input) {
     },
     catalog: { rulesApplied },
     meta: {
-      mode: mode2,
-      tokensLoaded: tokens !== null,
-      registryLoaded: registry !== null
+      mode: config.mode,
+      tokensLoaded: config.tokens !== null,
+      registryLoaded: config.registry !== null
     }
   };
 }
 async function collectFiles(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path31.isAbsolute(f) ? f : path31.join(projectRoot, f));
+    return explicitFiles.map((f) => path33.isAbsolute(f) ? f : path33.join(projectRoot, f));
   }
   const out = [];
   walk2(projectRoot, out, 0);
@@ -13669,7 +14297,7 @@ function walk2(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs28.readdirSync(dir, { withFileTypes: true });
+    entries = fs31.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -13677,7 +14305,7 @@ function walk2(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path31.join(dir, entry.name);
+    const full = path33.join(dir, entry.name);
     if (entry.isDirectory()) {
       walk2(full, out, depth + 1);
     } else if (entry.isFile() && DEFAULT_GLOB_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
@@ -13745,8 +14373,8 @@ async function handleDetectDrift(input) {
 }
 
 // src/align/index.ts
-import * as fs30 from "fs";
-import * as path34 from "path";
+import * as fs33 from "fs";
+import * as path36 from "path";
 
 // src/align/classifier/token-import.ts
 var NAMED_IMPORT = /^\s*import\s*\{\s*tokens(?:\s+as\s+\w+)?\s*\}\s*from\s+['"][^'"]+['"];?\s*$/m;
@@ -13886,9 +14514,9 @@ function sourceLine(source, line) {
 }
 
 // src/align/codemods/common.ts
-import * as path32 from "path";
+import * as path34 from "path";
 function renderTokenReference(file, tokenPath) {
-  const ext = path32.extname(file).toLowerCase();
+  const ext = path34.extname(file).toLowerCase();
   if (ext === ".css" || ext === ".scss") {
     return `var(--${tokenPath.replace(/\./g, "-")})`;
   }
@@ -14040,8 +14668,8 @@ function emitPrimitiveSuggestion(finding) {
 }
 
 // src/align/revert/state.ts
-import * as fs29 from "fs";
-import * as path33 from "path";
+import * as fs32 from "fs";
+import * as path35 from "path";
 import { createHash as createHash2 } from "crypto";
 var LAST_BATCH_PATH = ".harness/align/last-batch.json";
 function hashContent(content) {
@@ -14073,15 +14701,15 @@ function saveLastBatch(projectRoot, outcomes, mode2, fileReader) {
     mode: mode2,
     entries
   };
-  const full = path33.join(projectRoot, LAST_BATCH_PATH);
-  fs29.mkdirSync(path33.dirname(full), { recursive: true });
-  fs29.writeFileSync(full, JSON.stringify(batch, null, 2) + "\n", "utf-8");
+  const full = path35.join(projectRoot, LAST_BATCH_PATH);
+  fs32.mkdirSync(path35.dirname(full), { recursive: true });
+  fs32.writeFileSync(full, JSON.stringify(batch, null, 2) + "\n", "utf-8");
 }
 function loadLastBatch(projectRoot) {
-  const full = path33.join(projectRoot, LAST_BATCH_PATH);
-  if (!fs29.existsSync(full)) return null;
+  const full = path35.join(projectRoot, LAST_BATCH_PATH);
+  if (!fs32.existsSync(full)) return null;
   try {
-    const raw = fs29.readFileSync(full, "utf-8");
+    const raw = fs32.readFileSync(full, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || !Array.isArray(parsed.entries)) return null;
     return parsed;
@@ -14178,7 +14806,7 @@ function persistRunArtifacts(args) {
   saveLastBatch(args.projectRoot, args.outcomes, args.mode, (file) => {
     const cached = args.sourceCache.get(file);
     if (cached !== void 0) return cached;
-    return fs30.readFileSync(file, "utf-8");
+    return fs33.readFileSync(file, "utf-8");
   });
 }
 async function runRevert(projectRoot, mode2, dryRun, startedAt) {
@@ -14244,7 +14872,7 @@ function readForRevert(file, sourceCache) {
   const cached = sourceCache.get(file);
   if (cached !== void 0) return { kind: "ok", text: cached };
   try {
-    return { kind: "ok", text: fs30.readFileSync(file, "utf-8") };
+    return { kind: "ok", text: fs33.readFileSync(file, "utf-8") };
   } catch (err2) {
     return {
       kind: "failed",
@@ -14254,7 +14882,7 @@ function readForRevert(file, sourceCache) {
 }
 function tryWrite(file, content) {
   try {
-    fs30.writeFileSync(file, content, "utf-8");
+    fs33.writeFileSync(file, content, "utf-8");
     return null;
   } catch (err2) {
     return `cannot write source file: ${err2 instanceof Error ? err2.message : String(err2)}`;
@@ -14262,10 +14890,10 @@ function tryWrite(file, content) {
 }
 async function loadFindings(projectRoot, input, mode2) {
   if (mode2 === "pipeline") {
-    const handoffPath = path34.join(projectRoot, HANDOFF_PATH);
-    if (!fs30.existsSync(handoffPath)) return [];
+    const handoffPath = path36.join(projectRoot, HANDOFF_PATH);
+    if (!fs33.existsSync(handoffPath)) return [];
     try {
-      const raw = fs30.readFileSync(handoffPath, "utf-8");
+      const raw = fs33.readFileSync(handoffPath, "utf-8");
       const parsed = JSON.parse(raw);
       return parsed.pipeline?.driftFindings ?? [];
     } catch {
@@ -14290,7 +14918,7 @@ async function processFinding(finding, tokenPaths, sourceCache, dryRun) {
   }
   let source;
   try {
-    source = sourceCache.get(finding.file) ?? fs30.readFileSync(finding.file, "utf-8");
+    source = sourceCache.get(finding.file) ?? fs33.readFileSync(finding.file, "utf-8");
     sourceCache.set(finding.file, source);
   } catch (err2) {
     return {
@@ -14318,7 +14946,7 @@ async function processFinding(finding, tokenPaths, sourceCache, dryRun) {
   }
   if (!dryRun) {
     try {
-      fs30.writeFileSync(finding.file, result.newSource, "utf-8");
+      fs33.writeFileSync(finding.file, result.newSource, "utf-8");
       sourceCache.set(finding.file, result.newSource);
     } catch (err2) {
       return {
@@ -14380,19 +15008,19 @@ function aggregateOutput(outcomes, meta) {
   };
 }
 function writePipelineFixesApplied(projectRoot, outcomes) {
-  const handoffPath = path34.join(projectRoot, HANDOFF_PATH);
+  const handoffPath = path36.join(projectRoot, HANDOFF_PATH);
   let handoff = {};
-  if (fs30.existsSync(handoffPath)) {
+  if (fs33.existsSync(handoffPath)) {
     try {
-      handoff = JSON.parse(fs30.readFileSync(handoffPath, "utf-8"));
+      handoff = JSON.parse(fs33.readFileSync(handoffPath, "utf-8"));
     } catch {
       handoff = {};
     }
   }
   handoff.pipeline = handoff.pipeline ?? {};
   handoff.pipeline.fixesApplied = outcomes;
-  fs30.mkdirSync(path34.dirname(handoffPath), { recursive: true });
-  fs30.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
+  fs33.mkdirSync(path36.dirname(handoffPath), { recursive: true });
+  fs33.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
 }
 function findingKey(finding) {
   return `${finding.code}@${finding.file}:${finding.line ?? "?"}`;
@@ -14468,18 +15096,18 @@ async function handleAlignDesignSystem(input) {
 }
 
 // src/brand/index.ts
-import * as fs33 from "fs";
-import * as path37 from "path";
+import * as fs36 from "fs";
+import * as path39 from "path";
 
 // src/brand/resolvers/design-md-brand.ts
-import * as fs31 from "fs";
-import * as path35 from "path";
+import * as fs34 from "fs";
+import * as path37 from "path";
 function loadBrandRules(projectRoot) {
-  const designMdPath = path35.join(projectRoot, "design-system", "DESIGN.md");
-  if (!fs31.existsSync(designMdPath)) return null;
+  const designMdPath = path37.join(projectRoot, "design-system", "DESIGN.md");
+  if (!fs34.existsSync(designMdPath)) return null;
   let raw;
   try {
-    raw = fs31.readFileSync(designMdPath, "utf-8");
+    raw = fs34.readFileSync(designMdPath, "utf-8");
   } catch {
     return null;
   }
@@ -14590,14 +15218,14 @@ function parseAssets(block) {
 }
 
 // src/brand/resolvers/token-extensions.ts
-import * as fs32 from "fs";
-import * as path36 from "path";
+import * as fs35 from "fs";
+import * as path38 from "path";
 function loadBrandTokenIndex(projectRoot) {
-  const tokenPath = path36.join(projectRoot, "design-system", "tokens.json");
-  if (!fs32.existsSync(tokenPath)) return null;
+  const tokenPath = path38.join(projectRoot, "design-system", "tokens.json");
+  if (!fs35.existsSync(tokenPath)) return null;
   let raw;
   try {
-    raw = fs32.readFileSync(tokenPath, "utf-8");
+    raw = fs35.readFileSync(tokenPath, "utf-8");
   } catch {
     return null;
   }
@@ -14827,56 +15455,39 @@ function checkText(text, position, sourceFile, file, phrasesLc, strictness, seen
 
 // src/brand/index.ts
 var DEFAULT_GLOB_EXTENSIONS2 = [".ts", ".tsx", ".js", ".jsx", ".css", ".scss"];
+function resolveOptions(input) {
+  return {
+    mode: input.mode ?? "fast",
+    strictness: input.designStrictness ?? "standard",
+    tokenMisuseEnabled: input.rules?.tokenMisuse !== false,
+    voiceEnabled: input.rules?.voice !== false
+  };
+}
 async function runAuditBrand(input) {
   const startedAt = Date.now();
   const projectRoot = sanitizePath(input.path);
-  const mode2 = input.mode ?? "fast";
-  const strictness = input.designStrictness ?? "standard";
-  const tokenMisuseEnabled = input.rules?.tokenMisuse !== false;
-  const voiceEnabled = input.rules?.voice !== false;
+  const { mode: mode2, strictness, tokenMisuseEnabled, voiceEnabled } = resolveOptions(input);
   const brandRules = voiceEnabled ? loadBrandRules(projectRoot) : null;
   const brandTokens = tokenMisuseEnabled ? loadBrandTokenIndex(projectRoot) : null;
+  const tokenActive = tokenMisuseEnabled && brandTokens !== null;
+  const voiceActive = isVoiceRuleActive(voiceEnabled, brandRules);
   const rulesApplied = [];
-  if (tokenMisuseEnabled && brandTokens !== null) rulesApplied.push("token-misuse");
-  if (voiceEnabled && brandRules?.voice && brandRules.voice.forbiddenPhrases.length > 0) {
-    rulesApplied.push("forbidden-phrases");
-  }
+  if (tokenActive) rulesApplied.push("token-misuse");
+  if (voiceActive) rulesApplied.push("forbidden-phrases");
   const filesToScan = collectFiles2(projectRoot, input.files);
-  const findings = [];
-  for (const file of filesToScan) {
-    let source;
-    try {
-      source = fs33.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    if (tokenMisuseEnabled && brandTokens !== null) {
-      findings.push(...runTokenMisuseRule({ source, file, brandTokens, strictness }));
-    }
-    if (voiceEnabled && brandRules?.voice && brandRules.voice.forbiddenPhrases.length > 0) {
-      findings.push(
-        ...runForbiddenPhrasesRule({
-          source,
-          file,
-          forbiddenPhrases: brandRules.voice.forbiddenPhrases,
-          strictness
-        })
-      );
-    }
-  }
-  const bySeverity = { error: 0, warn: 0, info: 0 };
-  const byCode2 = {};
-  for (const f of findings) {
-    bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1;
-    byCode2[f.code] = (byCode2[f.code] ?? 0) + 1;
-  }
+  const findings = scanFiles2(filesToScan, {
+    tokenActive,
+    voiceActive,
+    brandTokens,
+    brandRules,
+    strictness
+  });
   return {
     findings,
     summary: {
       totalFiles: filesToScan.length,
       durationMs: Date.now() - startedAt,
-      bySeverity,
-      byCode: byCode2
+      ...tallyFindings(findings)
     },
     catalog: { rulesApplied },
     meta: {
@@ -14886,9 +15497,58 @@ async function runAuditBrand(input) {
     }
   };
 }
+function isVoiceRuleActive(voiceEnabled, brandRules) {
+  return voiceEnabled && brandRules?.voice != null && brandRules.voice.forbiddenPhrases.length > 0;
+}
+function scanFiles2(files, ctx) {
+  const findings = [];
+  for (const file of files) {
+    let source;
+    try {
+      source = fs36.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    findings.push(...scanSource(source, file, ctx));
+  }
+  return findings;
+}
+function scanSource(source, file, ctx) {
+  const findings = [];
+  if (ctx.tokenActive && ctx.brandTokens !== null) {
+    findings.push(
+      ...runTokenMisuseRule({
+        source,
+        file,
+        brandTokens: ctx.brandTokens,
+        strictness: ctx.strictness
+      })
+    );
+  }
+  if (ctx.voiceActive && ctx.brandRules?.voice) {
+    findings.push(
+      ...runForbiddenPhrasesRule({
+        source,
+        file,
+        forbiddenPhrases: ctx.brandRules.voice.forbiddenPhrases,
+        strictness: ctx.strictness
+      })
+    );
+  }
+  return findings;
+}
+function tallyFindings(findings) {
+  const bySeverity = { error: 0, warn: 0, info: 0 };
+  const byCode2 = {};
+  for (const f of findings) {
+    bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1;
+    byCode2[f.code] = (byCode2[f.code] ?? 0) + 1;
+  }
+  return { bySeverity, byCode: byCode2 };
+}
 function collectFiles2(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path37.isAbsolute(f) ? f : path37.join(projectRoot, f));
+    return explicitFiles.map((f) => path39.isAbsolute(f) ? f : path39.join(projectRoot, f));
   }
   const out = [];
   walk4(projectRoot, out, 0);
@@ -14898,7 +15558,7 @@ function walk4(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs33.readdirSync(dir, { withFileTypes: true });
+    entries = fs36.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -14906,7 +15566,7 @@ function walk4(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path37.join(dir, entry.name);
+    const full = path39.join(dir, entry.name);
     if (entry.isDirectory()) {
       walk4(full, out, depth + 1);
     } else if (entry.isFile() && DEFAULT_GLOB_EXTENSIONS2.some((ext) => entry.name.endsWith(ext))) {
@@ -15024,15 +15684,15 @@ var VerifierRegistry = class {
 };
 
 // src/design-pipeline/phases/freshen.ts
-import * as fs34 from "fs";
-import * as path38 from "path";
+import * as fs37 from "fs";
+import * as path40 from "path";
 function runFreshen(input) {
   const { projectRoot, context } = input;
-  context.graphAvailable = fs34.existsSync(path38.join(projectRoot, ".harness", "graph"));
-  const designMdPath = path38.join(projectRoot, "design-system", "DESIGN.md");
-  const tokensJsonPath = path38.join(projectRoot, "design-system", "tokens.json");
-  context.inputs.designMdExists = fs34.existsSync(designMdPath);
-  context.inputs.tokensJsonExists = fs34.existsSync(tokensJsonPath);
+  context.graphAvailable = fs37.existsSync(path40.join(projectRoot, ".harness", "graph"));
+  const designMdPath = path40.join(projectRoot, "design-system", "DESIGN.md");
+  const tokensJsonPath = path40.join(projectRoot, "design-system", "tokens.json");
+  context.inputs.designMdExists = fs37.existsSync(designMdPath);
+  context.inputs.tokensJsonExists = fs37.existsSync(tokensJsonPath);
   if (context.inputs.designMdExists) {
     const content = readFileSafe(designMdPath);
     context.inputs.componentRegistryExists = content !== null && /^##\s+component\s+registry\b/im.test(content);
@@ -15041,7 +15701,7 @@ function runFreshen(input) {
 }
 function readFileSafe(p) {
   try {
-    return fs34.readFileSync(p, "utf-8");
+    return fs37.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -15068,8 +15728,8 @@ async function runDetect(input) {
 }
 
 // src/design-pipeline/phases/fix.ts
-import * as fs35 from "fs";
-import * as path39 from "path";
+import * as fs38 from "fs";
+import * as path41 from "path";
 var MAX_ITERATIONS = 5;
 async function runFix(input) {
   const { projectRoot, context, mode: mode2, files, designStrictness } = input;
@@ -15118,11 +15778,11 @@ async function safelyRedetect(projectRoot, mode2, files, designStrictness) {
   }
 }
 function writePipelineHandoff(projectRoot, context) {
-  const handoffPath = path39.join(projectRoot, ".harness", "handoff.json");
+  const handoffPath = path41.join(projectRoot, ".harness", "handoff.json");
   let handoff = {};
-  if (fs35.existsSync(handoffPath)) {
+  if (fs38.existsSync(handoffPath)) {
     try {
-      handoff = JSON.parse(fs35.readFileSync(handoffPath, "utf-8"));
+      handoff = JSON.parse(fs38.readFileSync(handoffPath, "utf-8"));
     } catch {
       handoff = {};
     }
@@ -15130,8 +15790,8 @@ function writePipelineHandoff(projectRoot, context) {
   handoff.pipeline = {
     driftFindings: context.driftFindings
   };
-  fs35.mkdirSync(path39.dirname(handoffPath), { recursive: true });
-  fs35.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n");
+  fs38.mkdirSync(path41.dirname(handoffPath), { recursive: true });
+  fs38.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n");
 }
 
 // src/design-pipeline/phases/audit.ts
@@ -15161,8 +15821,8 @@ async function runAudit2(input) {
 }
 
 // src/design-pipeline/phases/fill.ts
-import * as fs36 from "fs";
-import * as path40 from "path";
+import * as fs39 from "fs";
+import * as path42 from "path";
 var DESIGN_MD_STUB = `# Design System
 
 <!-- TODO: author this file. See harness-design skill for guidance. -->
@@ -15222,11 +15882,11 @@ async function runFill(input) {
 }
 function bootstrapMissingInputs(input) {
   const { projectRoot, context } = input;
-  const designMdPath = path40.join(projectRoot, "design-system", "DESIGN.md");
-  const tokensJsonPath = path40.join(projectRoot, "design-system", "tokens.json");
-  if (!fs36.existsSync(designMdPath)) {
-    fs36.mkdirSync(path40.dirname(designMdPath), { recursive: true });
-    fs36.writeFileSync(designMdPath, DESIGN_MD_STUB);
+  const designMdPath = path42.join(projectRoot, "design-system", "DESIGN.md");
+  const tokensJsonPath = path42.join(projectRoot, "design-system", "tokens.json");
+  if (!fs39.existsSync(designMdPath)) {
+    fs39.mkdirSync(path42.dirname(designMdPath), { recursive: true });
+    fs39.writeFileSync(designMdPath, DESIGN_MD_STUB);
     context.bootstrapped.designMd = true;
     context.inputs.designMdExists = true;
     context.inputs.componentRegistryExists = true;
@@ -15246,16 +15906,16 @@ function bootstrapMissingInputs(input) {
       }
     }
   }
-  if (!fs36.existsSync(tokensJsonPath)) {
-    fs36.mkdirSync(path40.dirname(tokensJsonPath), { recursive: true });
-    fs36.writeFileSync(tokensJsonPath, TOKENS_JSON_STUB);
+  if (!fs39.existsSync(tokensJsonPath)) {
+    fs39.mkdirSync(path42.dirname(tokensJsonPath), { recursive: true });
+    fs39.writeFileSync(tokensJsonPath, TOKENS_JSON_STUB);
     context.bootstrapped.tokensJson = true;
     context.inputs.tokensJsonExists = true;
   }
 }
 function readFileSafe2(p) {
   try {
-    return fs36.readFileSync(p, "utf-8");
+    return fs39.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -15290,10 +15950,10 @@ async function invokeCraftPolish(input) {
 function appendToFile(p, content) {
   let existing = "";
   try {
-    existing = fs36.readFileSync(p, "utf-8");
+    existing = fs39.readFileSync(p, "utf-8");
   } catch {
   }
-  fs36.writeFileSync(p, existing + content);
+  fs39.writeFileSync(p, existing + content);
 }
 
 // src/design-pipeline/phases/report.ts
@@ -15442,8 +16102,8 @@ async function handleDesignPipeline(input) {
 }
 
 // src/naming-craft/index.ts
-import * as fs38 from "fs";
-import * as path42 from "path";
+import * as fs41 from "fs";
+import * as path44 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/naming-craft/extract/identifiers.ts
@@ -15459,47 +16119,61 @@ function extractIdentifiers(file, source) {
   const out = [];
   const sourceLines = source.split("\n");
   function visit5(node, parentBodyLineSize) {
-    if (ts4.isFunctionDeclaration(node) && node.name !== void 0) {
-      pushIdentifier(
-        node.name.text,
-        "function",
-        node,
-        sourceFile,
-        sourceLines,
-        out,
-        parentBodyLineSize
-      );
-    }
-    if ((ts4.isInterfaceDeclaration(node) || ts4.isTypeAliasDeclaration(node) || ts4.isClassDeclaration(node)) && node.name !== void 0) {
-      pushIdentifier(
-        node.name.text,
-        "type",
-        node,
-        sourceFile,
-        sourceLines,
-        out,
-        parentBodyLineSize
-      );
-    }
-    if (ts4.isVariableStatement(node)) {
-      for (const decl of node.declarationList.declarations) {
-        for (const binding of collectBindingNames(decl.name)) {
-          const kind = decl.initializer !== void 0 && (ts4.isArrowFunction(decl.initializer) || ts4.isFunctionExpression(decl.initializer)) ? "function" : "variable";
-          pushIdentifier(binding, kind, decl, sourceFile, sourceLines, out, parentBodyLineSize);
-        }
-      }
-    }
-    let nextParentBodyLineSize = parentBodyLineSize;
-    if ((ts4.isFunctionDeclaration(node) || ts4.isFunctionExpression(node) || ts4.isArrowFunction(node) || ts4.isMethodDeclaration(node)) && node.body !== void 0) {
-      const start = sourceFile.getLineAndCharacterOfPosition(node.body.getStart(sourceFile)).line;
-      const end = sourceFile.getLineAndCharacterOfPosition(node.body.getEnd()).line;
-      nextParentBodyLineSize = end - start + 1;
-    }
+    collectDeclaredIdentifiers(node, sourceFile, sourceLines, out, parentBodyLineSize);
+    const nextParentBodyLineSize = computeChildBodyLineSize(node, sourceFile, parentBodyLineSize);
     ts4.forEachChild(node, (child) => visit5(child, nextParentBodyLineSize));
   }
   visit5(sourceFile, null);
   return out;
 }
+function collectDeclaredIdentifiers(node, sourceFile, sourceLines, out, parentBodyLineSize) {
+  if (ts4.isFunctionDeclaration(node) && node.name !== void 0) {
+    pushIdentifier(
+      node.name.text,
+      "function",
+      node,
+      sourceFile,
+      sourceLines,
+      out,
+      parentBodyLineSize
+    );
+    return;
+  }
+  if (isTypeLikeDeclaration(node) && node.name !== void 0) {
+    pushIdentifier(node.name.text, "type", node, sourceFile, sourceLines, out, parentBodyLineSize);
+    return;
+  }
+  if (ts4.isVariableStatement(node)) {
+    pushVariableIdentifiers(node, sourceFile, sourceLines, out, parentBodyLineSize);
+  }
+}
+function isTypeLikeDeclaration(node) {
+  return ts4.isInterfaceDeclaration(node) || ts4.isTypeAliasDeclaration(node) || ts4.isClassDeclaration(node);
+}
+function pushVariableIdentifiers(node, sourceFile, sourceLines, out, parentBodyLineSize) {
+  for (const decl of node.declarationList.declarations) {
+    for (const binding of collectBindingNames(decl.name)) {
+      const kind = variableInitializerKind(decl.initializer);
+      pushIdentifier(binding, kind, decl, sourceFile, sourceLines, out, parentBodyLineSize);
+    }
+  }
+}
+function variableInitializerKind(initializer) {
+  return initializer !== void 0 && (ts4.isArrowFunction(initializer) || ts4.isFunctionExpression(initializer)) ? "function" : "variable";
+}
+function computeChildBodyLineSize(node, sourceFile, parentBodyLineSize) {
+  const body = functionBodyOf(node);
+  if (body === void 0) return parentBodyLineSize;
+  const start = sourceFile.getLineAndCharacterOfPosition(body.getStart(sourceFile)).line;
+  const end = sourceFile.getLineAndCharacterOfPosition(body.getEnd()).line;
+  return end - start + 1;
+}
+function functionBodyOf(node) {
+  if ((ts4.isFunctionDeclaration(node) || ts4.isFunctionExpression(node) || ts4.isArrowFunction(node) || ts4.isMethodDeclaration(node)) && node.body !== void 0) {
+    return node.body;
+  }
+  return void 0;
+}
 function pushIdentifier(name, kind, node, sourceFile, sourceLines, out, parentBodyLineSize) {
   const { line: zeroLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
   const line = zeroLine + 1;
@@ -15767,27 +16441,27 @@ function isConfidence4(v) {
 }
 
 // src/shared/craft/runs/store.ts
-import * as fs37 from "fs";
-import * as path41 from "path";
+import * as fs40 from "fs";
+import * as path43 from "path";
 var RUN_TTL_MS = 24 * 60 * 60 * 1e3;
 function runsDir(projectRoot) {
-  return path41.join(projectRoot, ".harness", "craft", "runs");
+  return path43.join(projectRoot, ".harness", "craft", "runs");
 }
 function runPath(projectRoot, runId) {
-  return path41.join(runsDir(projectRoot), `${runId}.json`);
+  return path43.join(runsDir(projectRoot), `${runId}.json`);
 }
 function saveRunState(projectRoot, state) {
   const dir = runsDir(projectRoot);
-  fs37.mkdirSync(dir, { recursive: true });
+  fs40.mkdirSync(dir, { recursive: true });
   const file = runPath(projectRoot, state.runId);
-  fs37.writeFileSync(file, JSON.stringify(state, null, 2));
+  fs40.writeFileSync(file, JSON.stringify(state, null, 2));
   return { runFile: file };
 }
 function loadRunState(projectRoot, runId) {
   const file = runPath(projectRoot, runId);
-  if (!fs37.existsSync(file)) return null;
+  if (!fs40.existsSync(file)) return null;
   try {
-    const raw = fs37.readFileSync(file, "utf-8");
+    const raw = fs40.readFileSync(file, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -15796,7 +16470,7 @@ function loadRunState(projectRoot, runId) {
 function deleteRunState(projectRoot, runId) {
   const file = runPath(projectRoot, runId);
   try {
-    fs37.unlinkSync(file);
+    fs40.unlinkSync(file);
   } catch {
   }
 }
@@ -15804,16 +16478,16 @@ function pruneOldRuns(projectRoot, now = Date.now()) {
   const dir = runsDir(projectRoot);
   let entries;
   try {
-    entries = fs37.readdirSync(dir, { withFileTypes: true });
+    entries = fs40.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const full = path41.join(dir, entry.name);
+    const full = path43.join(dir, entry.name);
     try {
-      const stat = fs37.statSync(full);
-      if (now - stat.mtimeMs > RUN_TTL_MS) fs37.unlinkSync(full);
+      const stat = fs40.statSync(full);
+      if (now - stat.mtimeMs > RUN_TTL_MS) fs40.unlinkSync(full);
     } catch {
     }
   }
@@ -15833,7 +16507,7 @@ function gatherProjectContext(input) {
   for (const file of files) {
     let source;
     try {
-      source = fs38.readFileSync(file, "utf-8");
+      source = fs41.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -15990,7 +16664,7 @@ async function finalizeNamingCraft(input) {
 }
 function collectFiles3(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path42.isAbsolute(f) ? f : path42.join(projectRoot, f));
+    return explicitFiles.map((f) => path44.isAbsolute(f) ? f : path44.join(projectRoot, f));
   }
   const out = [];
   walk5(projectRoot, out, 0);
@@ -16000,7 +16674,7 @@ function walk5(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs38.readdirSync(dir, { withFileTypes: true });
+    entries = fs41.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -16008,7 +16682,7 @@ function walk5(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path42.join(dir, entry.name);
+    const full = path44.join(dir, entry.name);
     if (entry.isDirectory()) walk5(full, out, depth + 1);
     else if (entry.isFile() && EXTENSIONS.some((ext) => entry.name.endsWith(ext))) out.push(full);
   }
@@ -16192,32 +16866,32 @@ async function handleNamingCraftFinalize(input) {
 }
 
 // src/spec-craft/index.ts
-import * as fs40 from "fs";
+import * as fs43 from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/spec-craft/extract/discover.ts
-import * as fs39 from "fs";
-import * as path43 from "path";
+import * as fs42 from "fs";
+import * as path45 from "path";
 function discoverSpecs(projectRoot, kindsFilter) {
   const wantProposal = kindsFilter === void 0 || kindsFilter.includes("proposal");
   const wantADR = kindsFilter === void 0 || kindsFilter.includes("adr");
   const out = [];
   if (wantProposal) {
-    const changesDir = path43.join(projectRoot, "docs", "changes");
-    if (fs39.existsSync(changesDir)) {
-      for (const entry of fs39.readdirSync(changesDir, { withFileTypes: true })) {
+    const changesDir = path45.join(projectRoot, "docs", "changes");
+    if (fs42.existsSync(changesDir)) {
+      for (const entry of fs42.readdirSync(changesDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".")) continue;
-        const topicDir = path43.join(changesDir, entry.name);
-        const direct = path43.join(topicDir, "proposal.md");
-        if (fs39.existsSync(direct)) {
+        const topicDir = path45.join(changesDir, entry.name);
+        const direct = path45.join(topicDir, "proposal.md");
+        if (fs42.existsSync(direct)) {
           out.push({ file: direct, kind: "proposal" });
         }
-        for (const sub of fs39.readdirSync(topicDir, { withFileTypes: true })) {
+        for (const sub of fs42.readdirSync(topicDir, { withFileTypes: true })) {
           if (!sub.isDirectory()) continue;
           if (sub.name.startsWith(".")) continue;
-          const subProposal = path43.join(topicDir, sub.name, "proposal.md");
-          if (fs39.existsSync(subProposal)) {
+          const subProposal = path45.join(topicDir, sub.name, "proposal.md");
+          if (fs42.existsSync(subProposal)) {
             out.push({ file: subProposal, kind: "proposal" });
           }
         }
@@ -16225,13 +16899,13 @@ function discoverSpecs(projectRoot, kindsFilter) {
     }
   }
   if (wantADR) {
-    const decisionsDir = path43.join(projectRoot, "docs", "knowledge", "decisions");
-    if (fs39.existsSync(decisionsDir)) {
-      for (const entry of fs39.readdirSync(decisionsDir, { withFileTypes: true })) {
+    const decisionsDir = path45.join(projectRoot, "docs", "knowledge", "decisions");
+    if (fs42.existsSync(decisionsDir)) {
+      for (const entry of fs42.readdirSync(decisionsDir, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         if (!entry.name.endsWith(".md")) continue;
         if (entry.name.startsWith(".") || entry.name.toUpperCase() === "README.MD") continue;
-        out.push({ file: path43.join(decisionsDir, entry.name), kind: "adr" });
+        out.push({ file: path45.join(decisionsDir, entry.name), kind: "adr" });
       }
     }
   }
@@ -16479,7 +17153,7 @@ async function runSpecCraft(input) {
   for (const spec of specs) {
     let source;
     try {
-      source = fs40.readFileSync(spec.file, "utf-8");
+      source = fs43.readFileSync(spec.file, "utf-8");
     } catch {
       continue;
     }
@@ -16599,13 +17273,13 @@ async function handleSpecCraft(input) {
 }
 
 // src/copy-craft/index.ts
-import * as fs42 from "fs";
-import * as path46 from "path";
+import * as fs45 from "fs";
+import * as path48 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/copy-craft/extract/source.ts
 import ts5 from "typescript";
-import * as path44 from "path";
+import * as path46 from "path";
 var LOG_LEVELS = ["log", "info", "warn", "warning", "error", "debug", "trace", "fatal"];
 function extractFromSource(input) {
   if (!/\.(?:ts|tsx|js|jsx)$/i.test(input.file)) return [];
@@ -16745,7 +17419,7 @@ function isLikelyLogger(name) {
 }
 function fileMatchesCliPaths(file, cliPaths) {
   const paths = cliPaths ?? defaultCliOutputPaths();
-  const normalized = file.split(path44.sep).join("/");
+  const normalized = file.split(path46.sep).join("/");
   return paths.some((p) => normalized.includes(p));
 }
 function defaultCliOutputPaths() {
@@ -16765,8 +17439,8 @@ function cleanCommentText(raw) {
 
 // src/copy-craft/extract/commits.ts
 import { spawnSync } from "child_process";
-import * as fs41 from "fs";
-import * as path45 from "path";
+import * as fs44 from "fs";
+import * as path47 from "path";
 var GIT_TIMEOUT_MS = 1e4;
 function extractCommits(input) {
   const { projectRoot, since = "1 month ago", limit = 100 } = input;
@@ -16805,8 +17479,8 @@ function extractCommits(input) {
 function isGitRepo(projectRoot) {
   let dir = projectRoot;
   for (let i = 0; i < 10; i++) {
-    if (fs41.existsSync(path45.join(dir, ".git"))) return true;
-    const parent = path45.dirname(dir);
+    if (fs44.existsSync(path47.join(dir, ".git"))) return true;
+    const parent = path47.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -17095,79 +17769,24 @@ async function runCopyCraft(input) {
   const rubrics = SEED_RUBRICS4;
   const enabledSurfaces = new Set(input.surfaces ?? ALL_SURFACES);
   const items = [];
-  const counts = {
-    error: 0,
-    log: 0,
-    "cli-output": 0,
-    commit: 0,
-    "pr-description": 0,
-    comment: 0
-  };
   const skippedSurfaces = [];
   const sourceSurfaces = ["error", "log", "cli-output", "comment"].filter(
     (s) => enabledSurfaces.has(s)
   );
   if (sourceSurfaces.length > 0) {
-    const files = collectSourceFiles(projectRoot, input.files).slice(0, maxFiles);
-    for (const file of files) {
-      let source;
-      try {
-        source = fs42.readFileSync(file, "utf-8");
-      } catch {
-        continue;
-      }
-      const extracted = extractFromSource({
-        file,
-        source,
-        surfaces: sourceSurfaces,
-        ...input.cliOutputPaths !== void 0 && { cliOutputPaths: input.cliOutputPaths }
-      });
-      const capped = extracted.slice(0, maxItemsPerFile);
-      for (const item of capped) {
-        counts[item.surface]++;
-        items.push(item);
-      }
-    }
-  }
-  if (enabledSurfaces.has("commit")) {
-    const result = extractCommits({
-      projectRoot,
-      ...input.commitsSince !== void 0 && { since: input.commitsSince }
-    });
-    if (result.skipReason !== void 0) {
-      skippedSurfaces.push({ surface: "commit", reason: result.skipReason });
-    } else {
-      for (const item of result.items) {
-        counts.commit++;
-        items.push(item);
-      }
-    }
-  }
-  if (enabledSurfaces.has("pr-description")) {
-    const result = extractPRDescriptions({
-      projectRoot,
-      ...input.prLimit !== void 0 && { limit: input.prLimit }
-    });
-    if (result.skipReason !== void 0) {
-      skippedSurfaces.push({ surface: "pr-description", reason: result.skipReason });
-    } else {
-      for (const item of result.items) {
-        counts["pr-description"]++;
-        items.push(item);
-      }
-    }
-  }
-  const findings = [];
-  for (const item of items) {
-    for (const rubric of rubrics) {
-      if (!rubricApplies2(rubric, item.surface)) continue;
-      try {
-        const finding = await critiqueOne3({ item, rubric, provider });
-        if (finding !== null) findings.push(finding);
-      } catch {
-      }
-    }
+    items.push(
+      ...collectSourceItems({
+        projectRoot,
+        files: input.files,
+        sourceSurfaces,
+        maxFiles,
+        maxItemsPerFile,
+        cliOutputPaths: input.cliOutputPaths
+      })
+    );
   }
+  collectGitItems(input, projectRoot, enabledSurfaces, items, skippedSurfaces);
+  const findings = await critiqueItems(items, rubrics, provider);
   const surfacesScanned = ALL_SURFACES.filter(
     (s) => enabledSurfaces.has(s) && !skippedSurfaces.some((sk) => sk.surface === s)
   );
@@ -17188,15 +17807,92 @@ async function runCopyCraft(input) {
         rubricsApplied: rubrics.map((r) => r.id),
         surfacesScanned
       },
-      counts,
+      counts: tallyCounts(items),
       skippedSurfaces,
       runId: randomUUID5()
     }
   };
 }
+function collectSourceItems(args) {
+  const out = [];
+  const files = collectSourceFiles(args.projectRoot, args.files).slice(0, args.maxFiles);
+  for (const file of files) {
+    let source;
+    try {
+      source = fs45.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const extracted = extractFromSource({
+      file,
+      source,
+      surfaces: args.sourceSurfaces,
+      ...args.cliOutputPaths !== void 0 && { cliOutputPaths: args.cliOutputPaths }
+    });
+    out.push(...extracted.slice(0, args.maxItemsPerFile));
+  }
+  return out;
+}
+function collectExtractionResult(result, surface, items, skippedSurfaces) {
+  if (result.skipReason !== void 0) {
+    skippedSurfaces.push({ surface, reason: result.skipReason });
+  } else {
+    items.push(...result.items);
+  }
+}
+function collectGitItems(input, projectRoot, enabledSurfaces, items, skippedSurfaces) {
+  if (enabledSurfaces.has("commit")) {
+    collectExtractionResult(
+      extractCommits({
+        projectRoot,
+        ...input.commitsSince !== void 0 && { since: input.commitsSince }
+      }),
+      "commit",
+      items,
+      skippedSurfaces
+    );
+  }
+  if (enabledSurfaces.has("pr-description")) {
+    collectExtractionResult(
+      extractPRDescriptions({
+        projectRoot,
+        ...input.prLimit !== void 0 && { limit: input.prLimit }
+      }),
+      "pr-description",
+      items,
+      skippedSurfaces
+    );
+  }
+}
+async function critiqueItems(items, rubrics, provider) {
+  const findings = [];
+  for (const item of items) {
+    for (const rubric of rubrics) {
+      if (!rubricApplies2(rubric, item.surface)) continue;
+      try {
+        const finding = await critiqueOne3({ item, rubric, provider });
+        if (finding !== null) findings.push(finding);
+      } catch {
+      }
+    }
+  }
+  return findings;
+}
+function tallyCounts(items) {
+  const counts = {
+    error: 0,
+    log: 0,
+    "cli-output": 0,
+    commit: 0,
+    "pr-description": 0,
+    comment: 0
+  };
+  for (const item of items) counts[item.surface]++;
+  return counts;
+}
 function collectSourceFiles(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path46.isAbsolute(f) ? f : path46.join(projectRoot, f));
+    return explicitFiles.map((f) => path48.isAbsolute(f) ? f : path48.join(projectRoot, f));
   }
   const out = [];
   walk6(projectRoot, out, 0);
@@ -17206,7 +17902,7 @@ function walk6(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs42.readdirSync(dir, { withFileTypes: true });
+    entries = fs45.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -17214,7 +17910,7 @@ function walk6(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path46.join(dir, entry.name);
+    const full = path48.join(dir, entry.name);
     if (entry.isDirectory()) walk6(full, out, depth + 1);
     else if (entry.isFile() && SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext)))
       out.push(full);
@@ -17284,8 +17980,8 @@ async function handleCopyCraft(input) {
 }
 
 // src/test-craft/index.ts
-import * as fs44 from "fs";
-import * as path48 from "path";
+import * as fs47 from "fs";
+import * as path50 from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 
 // src/test-craft/extract/framework.ts
@@ -17391,25 +18087,25 @@ function extractCallbackText(node, fullSource) {
 }
 
 // src/test-craft/extract/source-pair.ts
-import * as fs43 from "fs";
-import * as path47 from "path";
+import * as fs46 from "fs";
+import * as path49 from "path";
 var MAX_SOURCE_CHARS = 2e3;
 function resolveSourceFile(testFile) {
-  const dir = path47.dirname(testFile);
+  const dir = path49.dirname(testFile);
   const ext = /\.tsx$/.test(testFile) ? ".tsx" : ".ts";
-  const base = path47.basename(testFile).replace(/\.(?:test|spec)\.(?:tsx?|jsx?)$/, "");
+  const base = path49.basename(testFile).replace(/\.(?:test|spec)\.(?:tsx?|jsx?)$/, "");
   const candidates = [
     // Sibling (most common in co-located setups)
-    path47.join(dir, base + ext),
+    path49.join(dir, base + ext),
     // tests/ peer to src/
-    path47.join(dir, "..", "src", base + ext),
+    path49.join(dir, "..", "src", base + ext),
     // tests/ one level deeper than src/
-    path47.join(dir, "..", "..", "src", base + ext)
+    path49.join(dir, "..", "..", "src", base + ext)
   ];
   for (const candidate of candidates) {
-    if (fs43.existsSync(candidate)) {
+    if (fs46.existsSync(candidate)) {
       try {
-        const raw = fs43.readFileSync(candidate, "utf-8");
+        const raw = fs46.readFileSync(candidate, "utf-8");
         const content = raw.length > MAX_SOURCE_CHARS ? raw.slice(0, MAX_SOURCE_CHARS) + "\n[\u2026truncated for prompt cost\u2026]" : raw;
         return { file: candidate, content };
       } catch {
@@ -17631,57 +18327,15 @@ async function runTestCraft(input) {
   const sourcePairEnabled = input.sourcePair !== false;
   const frameworksFilter = input.frameworks !== void 0 ? new Set(input.frameworks) : null;
   const files = collectTestFiles(projectRoot, input.files).slice(0, maxFiles);
-  const allTests = [];
-  const frameworksDetected = {
-    vitest: 0,
-    jest: 0,
-    mocha: 0,
-    playwright: 0,
-    unknown: 0
-  };
-  let testsSkippedOrTodo = 0;
-  let sourcePairedCount = 0;
-  const sourcePairCache = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    let source;
-    try {
-      source = fs44.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const framework = detectFramework(source);
-    if (frameworksFilter !== null && !frameworksFilter.has(framework)) continue;
-    frameworksDetected[framework]++;
-    const extracted = extractTests({ file, source, framework });
-    const capped = extracted.slice(0, maxTestsPerFile);
-    for (const test of capped) {
-      if (test.todo) {
-        testsSkippedOrTodo++;
-        continue;
-      }
-      allTests.push(test);
-    }
-    if (sourcePairEnabled && !sourcePairCache.has(file)) {
-      const result = resolveSourceFile(file);
-      sourcePairCache.set(file, result);
-      if (result !== null) sourcePairedCount++;
-    }
-  }
+  const extraction = extractTestsFromFiles(files, {
+    frameworksFilter,
+    maxTestsPerFile,
+    sourcePairEnabled
+  });
   const findings = [];
-  for (const test of allTests) {
-    const pair = sourcePairEnabled ? sourcePairCache.get(test.file) ?? null : null;
-    for (const rubric of rubrics) {
-      try {
-        const finding = await critiqueOne4({
-          test,
-          rubric,
-          provider,
-          ...pair !== null ? { sourcePair: pair } : {}
-        });
-        if (finding !== null) findings.push(finding);
-      } catch {
-      }
-    }
+  for (const test of extraction.allTests) {
+    const pair = sourcePairEnabled ? extraction.sourcePairCache.get(test.file) ?? null : null;
+    findings.push(...await critiqueTest(test, rubrics, provider, pair));
   }
   const totalCost = sumCosts4(provider);
   return {
@@ -17699,18 +18353,83 @@ async function runTestCraft(input) {
       catalog: { rubricsApplied: rubrics.map((r) => r.id) },
       counts: {
         filesScanned: files.length,
-        testsExtracted: allTests.length,
-        testsSkippedOrTodo,
-        sourcePaired: sourcePairedCount
+        testsExtracted: extraction.allTests.length,
+        testsSkippedOrTodo: extraction.testsSkippedOrTodo,
+        sourcePaired: extraction.sourcePairedCount
       },
-      frameworksDetected,
+      frameworksDetected: extraction.frameworksDetected,
       runId: randomUUID6()
     }
   };
 }
+function readFileOrNull(file) {
+  try {
+    return fs47.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function collectNonTodoTests(tests, out) {
+  let skipped = 0;
+  for (const test of tests) {
+    if (test.todo) skipped++;
+    else out.push(test);
+  }
+  return skipped;
+}
+function extractTestsFromFiles(files, opts) {
+  const allTests = [];
+  const frameworksDetected = {
+    vitest: 0,
+    jest: 0,
+    mocha: 0,
+    playwright: 0,
+    unknown: 0
+  };
+  let testsSkippedOrTodo = 0;
+  let sourcePairedCount = 0;
+  const sourcePairCache = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const source = readFileOrNull(file);
+    if (source === null) continue;
+    const framework = detectFramework(source);
+    if (opts.frameworksFilter !== null && !opts.frameworksFilter.has(framework)) continue;
+    frameworksDetected[framework]++;
+    const capped = extractTests({ file, source, framework }).slice(0, opts.maxTestsPerFile);
+    testsSkippedOrTodo += collectNonTodoTests(capped, allTests);
+    if (opts.sourcePairEnabled && !sourcePairCache.has(file)) {
+      const result = resolveSourceFile(file);
+      sourcePairCache.set(file, result);
+      if (result !== null) sourcePairedCount++;
+    }
+  }
+  return {
+    allTests,
+    frameworksDetected,
+    testsSkippedOrTodo,
+    sourcePairedCount,
+    sourcePairCache
+  };
+}
+async function critiqueTest(test, rubrics, provider, pair) {
+  const findings = [];
+  for (const rubric of rubrics) {
+    try {
+      const finding = await critiqueOne4({
+        test,
+        rubric,
+        provider,
+        ...pair !== null ? { sourcePair: pair } : {}
+      });
+      if (finding !== null) findings.push(finding);
+    } catch {
+    }
+  }
+  return findings;
+}
 function collectTestFiles(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path48.isAbsolute(f) ? f : path48.join(projectRoot, f));
+    return explicitFiles.map((f) => path50.isAbsolute(f) ? f : path50.join(projectRoot, f));
   }
   const out = [];
   walk7(projectRoot, out, 0);
@@ -17720,7 +18439,7 @@ function walk7(dir, out, depth) {
   if (depth > 10) return;
   let entries;
   try {
-    entries = fs44.readdirSync(dir, { withFileTypes: true });
+    entries = fs47.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -17728,7 +18447,7 @@ function walk7(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path48.join(dir, entry.name);
+    const full = path50.join(dir, entry.name);
     if (entry.isDirectory()) walk7(full, out, depth + 1);
     else if (entry.isFile() && TEST_FILE_EXTS.some((ext) => entry.name.endsWith(ext))) {
       out.push(full);
@@ -17801,18 +18520,18 @@ async function handleTestCraft(input) {
 }
 
 // src/knowledge-craft/index.ts
-import * as fs46 from "fs";
-import * as path50 from "path";
+import * as fs49 from "fs";
+import * as path52 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 
 // src/knowledge-craft/extract/discover.ts
-import * as fs45 from "fs";
-import * as path49 from "path";
+import * as fs48 from "fs";
+import * as path51 from "path";
 var KNOWLEDGE_ROOT = "docs/knowledge";
 var DEFAULT_EXCLUDED_DIRS = ["decisions"];
 function discoverKnowledgeEntries(projectRoot, extraExcludeDirs) {
-  const root = path49.join(projectRoot, KNOWLEDGE_ROOT);
-  if (!fs45.existsSync(root)) return [];
+  const root = path51.join(projectRoot, KNOWLEDGE_ROOT);
+  if (!fs48.existsSync(root)) return [];
   const exclude = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDED_DIRS, ...extraExcludeDirs ?? []]);
   const out = [];
   walk8(root, root, out, exclude);
@@ -17821,13 +18540,13 @@ function discoverKnowledgeEntries(projectRoot, extraExcludeDirs) {
 function walk8(dir, root, out, exclude) {
   let entries;
   try {
-    entries = fs45.readdirSync(dir, { withFileTypes: true });
+    entries = fs48.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const full = path49.join(dir, entry.name);
+    const full = path51.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (exclude.has(entry.name)) continue;
       walk8(full, root, out, exclude);
@@ -17836,7 +18555,7 @@ function walk8(dir, root, out, exclude) {
     if (!entry.isFile()) continue;
     if (!entry.name.endsWith(".md")) continue;
     if (entry.name.toLowerCase() === "readme.md") continue;
-    const rel = path49.relative(root, full).replaceAll("\\", "/");
+    const rel = path51.relative(root, full).replaceAll("\\", "/");
     out.push({ file: full, relative: rel });
   }
 }
@@ -18016,7 +18735,7 @@ async function runKnowledgeCraft(input) {
   for (const entry of entries) {
     let content;
     try {
-      content = fs46.readFileSync(entry.file, "utf-8");
+      content = fs49.readFileSync(entry.file, "utf-8");
     } catch {
       filesSkipped++;
       continue;
@@ -18057,10 +18776,10 @@ async function runKnowledgeCraft(input) {
 }
 function collectEntries(projectRoot, input) {
   if (input.files !== void 0 && input.files.length > 0) {
-    const root = path50.join(projectRoot, KNOWLEDGE_ROOT);
+    const root = path52.join(projectRoot, KNOWLEDGE_ROOT);
     return input.files.map((f) => ({
       file: f,
-      relative: path50.relative(root, f).replaceAll("\\", "/")
+      relative: path52.relative(root, f).replaceAll("\\", "/")
     }));
   }
   return discoverKnowledgeEntries(projectRoot, input.excludeDirs);
@@ -18122,12 +18841,12 @@ async function handleKnowledgeCraft(input) {
 }
 
 // src/security-craft/index.ts
-import * as fs48 from "fs";
+import * as fs51 from "fs";
 import { randomUUID as randomUUID8 } from "crypto";
 
 // src/security-craft/extract/discover.ts
-import * as fs47 from "fs";
-import * as path51 from "path";
+import * as fs50 from "fs";
+import * as path53 from "path";
 var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -18147,12 +18866,12 @@ var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
 ]);
 var TEST_FILE_PATTERN = /\.(test|spec)\.(ts|tsx|js|jsx|mjs|cjs)$/i;
 function discoverSourceFiles(projectRoot, packagesFilter) {
-  const packagesDir = path51.join(projectRoot, "packages");
-  if (!fs47.existsSync(packagesDir)) return [];
+  const packagesDir = path53.join(projectRoot, "packages");
+  if (!fs50.existsSync(packagesDir)) return [];
   const out = [];
   let entries;
   try {
-    entries = fs47.readdirSync(packagesDir, { withFileTypes: true });
+    entries = fs50.readdirSync(packagesDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -18160,8 +18879,8 @@ function discoverSourceFiles(projectRoot, packagesFilter) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     if (packagesFilter !== void 0 && !packagesFilter.includes(entry.name)) continue;
-    const srcDir = path51.join(packagesDir, entry.name, "src");
-    if (!fs47.existsSync(srcDir)) continue;
+    const srcDir = path53.join(packagesDir, entry.name, "src");
+    if (!fs50.existsSync(srcDir)) continue;
     walk9(srcDir, out);
   }
   return out;
@@ -18169,13 +18888,13 @@ function discoverSourceFiles(projectRoot, packagesFilter) {
 function walk9(dir, out) {
   let entries;
   try {
-    entries = fs47.readdirSync(dir, { withFileTypes: true });
+    entries = fs50.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const full = path51.join(dir, entry.name);
+    const full = path53.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.has(entry.name)) continue;
       walk9(full, out);
@@ -18183,7 +18902,7 @@ function walk9(dir, out) {
     }
     if (!entry.isFile()) continue;
     if (TEST_FILE_PATTERN.test(entry.name)) continue;
-    const ext = path51.extname(entry.name);
+    const ext = path53.extname(entry.name);
     if (!SOURCE_EXTENSIONS2.has(ext)) continue;
     out.push(full);
   }
@@ -18437,21 +19156,30 @@ function findSecretMarker(node) {
   if (ts7.isIdentifier(node) && SECRET_NAME_PATTERN.test(node.text)) return node.text;
   if (ts7.isPropertyAccessExpression(node) && ts7.isIdentifier(node.name) && SECRET_NAME_PATTERN.test(node.name.text))
     return node.name.text;
-  if (ts7.isTemplateExpression(node)) {
-    for (const span of node.templateSpans) {
-      const sub = findSecretMarker(span.expression);
-      if (sub !== void 0) return sub;
-    }
+  if (ts7.isTemplateExpression(node)) return findSecretInTemplate(node);
+  if (ts7.isObjectLiteralExpression(node)) return findSecretInObjectLiteral(node);
+  return void 0;
+}
+function findSecretInTemplate(node) {
+  for (const span of node.templateSpans) {
+    const sub = findSecretMarker(span.expression);
+    if (sub !== void 0) return sub;
   }
-  if (ts7.isObjectLiteralExpression(node)) {
-    for (const prop of node.properties) {
-      if (ts7.isPropertyAssignment(prop) && ts7.isIdentifier(prop.name) && SECRET_NAME_PATTERN.test(prop.name.text)) {
-        return prop.name.text;
-      }
-      if (ts7.isShorthandPropertyAssignment(prop) && SECRET_NAME_PATTERN.test(prop.name.text)) {
-        return prop.name.text;
-      }
-    }
+  return void 0;
+}
+function findSecretInObjectLiteral(node) {
+  for (const prop of node.properties) {
+    const marker = secretMarkerFromProperty(prop);
+    if (marker !== void 0) return marker;
+  }
+  return void 0;
+}
+function secretMarkerFromProperty(prop) {
+  if (ts7.isPropertyAssignment(prop) && ts7.isIdentifier(prop.name) && SECRET_NAME_PATTERN.test(prop.name.text)) {
+    return prop.name.text;
+  }
+  if (ts7.isShorthandPropertyAssignment(prop) && SECRET_NAME_PATTERN.test(prop.name.text)) {
+    return prop.name.text;
   }
   return void 0;
 }
@@ -18623,21 +19351,28 @@ function sliceAroundLine(source, line, maxChars) {
   if (source.length <= maxChars) return source;
   const lines = source.split("\n");
   const targetIdx = Math.max(0, Math.min(lines.length - 1, line - 1));
+  const { lo, hi } = expandWindow(lines, targetIdx, maxChars);
+  return lines.slice(lo, hi + 1).join("\n");
+}
+function lineLen(lines, idx) {
+  return lines[idx]?.length ?? 0;
+}
+function expandWindow(lines, targetIdx, maxChars) {
   let lo = targetIdx;
   let hi = targetIdx;
-  let len = lines[targetIdx]?.length ?? 0;
+  let len = lineLen(lines, targetIdx);
   while (len < maxChars && (lo > 0 || hi < lines.length - 1)) {
     if (lo > 0) {
       lo--;
-      len += (lines[lo]?.length ?? 0) + 1;
+      len += lineLen(lines, lo) + 1;
       if (len >= maxChars) break;
     }
     if (hi < lines.length - 1) {
       hi++;
-      len += (lines[hi]?.length ?? 0) + 1;
+      len += lineLen(lines, hi) + 1;
     }
   }
-  return lines.slice(lo, hi + 1).join("\n");
+  return { lo, hi };
 }
 function parseFencedJson6(raw) {
   const match = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
@@ -18680,7 +19415,7 @@ async function runSecurityCraft(input) {
   for (const file of candidateFiles) {
     let source;
     try {
-      source = fs48.readFileSync(file, "utf-8");
+      source = fs51.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -18832,7 +19567,7 @@ async function resolveAnalysisProvider(model) {
   }
 }
 async function emptyGraphStore() {
-  const { GraphStore } = await import("./dist-OWHMNL4W.js");
+  const { GraphStore } = await import("./dist-DWBTZXR5.js");
   return new GraphStore();
 }
 function validateInput(input) {
@@ -18888,9 +19623,123 @@ function errorResponse(message) {
   };
 }
 
+// src/mcp/tools/acceptance-eval.ts
+import { readFile as readFile2 } from "fs/promises";
+var acceptanceEvalDefinition = {
+  name: "acceptance_eval",
+  description: "Pre-execution LLM-judgment: does a spec carry measurable, testable, complete acceptance criteria? The upstream twin of outcome_eval. Reads the spec's success/acceptance section, emits a confidence-rated AcceptanceVerdict (MEASURABLE | NOT_MEASURABLE | INCONCLUSIVE) with criteriaFindings (a, advisory), coverageFindings (b, advisory) and a rationale. Authority is DERIVED in TypeScript, never trusted from the LLM: a high-confidence NOT_MEASURABLE is blocking; every other verdict is advisory. testGlobs/testContent are optional evidence for (b) \u2014 omitting them degrades coverage findings to advisory-empty but never affects the measurability gate.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      specPath: {
+        type: "string",
+        description: "Absolute or repo-relative path to the spec markdown to judge"
+      },
+      testGlobs: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional globs locating test files; their contents supply the (b) coverage evidence. Ignored when testContent is provided. Absolute globs are recommended; relative globs resolve against the MCP server cwd."
+      },
+      testContent: {
+        type: "string",
+        description: "Optional pre-collected test snippets (the (b) evidence). Takes precedence over testGlobs."
+      },
+      model: {
+        type: "string",
+        description: "Optional model override for the acceptance-eval LLM call"
+      }
+    },
+    required: ["specPath"]
+  }
+};
+async function resolveAnalysisProvider2(model) {
+  try {
+    const intelligence = await import("@harness-engineering/intelligence");
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) return null;
+    const Provider = intelligence.AnthropicAnalysisProvider;
+    if (typeof Provider !== "function") return null;
+    return new Provider(model !== void 0 ? { apiKey, defaultModel: model } : { apiKey });
+  } catch {
+    return null;
+  }
+}
+function validateInput2(input) {
+  if (typeof input?.specPath !== "string" || input.specPath.length === 0) {
+    return "acceptance_eval: `specPath` is required";
+  }
+  return null;
+}
+async function resolveTestContent(input) {
+  if (typeof input.testContent === "string" && input.testContent.length > 0) {
+    return input.testContent;
+  }
+  if (!Array.isArray(input.testGlobs) || input.testGlobs.length === 0) {
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const pattern of input.testGlobs) {
+    const normalized = pattern.replace(/\\/g, "/");
+    let files;
+    try {
+      files = await findFiles(normalized);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      try {
+        parts.push(`// ${file}
+${await readFile2(file, "utf8")}`);
+      } catch {
+      }
+    }
+  }
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+async function handleAcceptanceEval(input) {
+  const validationError = validateInput2(input);
+  if (validationError !== null) return errorResponse2(validationError);
+  try {
+    const { AcceptanceEvaluator } = await import("@harness-engineering/intelligence");
+    const provider = await resolveAnalysisProvider2(input.model);
+    const evaluator = new AcceptanceEvaluator(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      provider ?? unconfiguredProvider2(),
+      input.model !== void 0 ? { model: input.model } : {}
+    );
+    const testContent = await resolveTestContent(input);
+    const verdict = await evaluator.evaluate({
+      specPath: input.specPath,
+      ...testContent !== void 0 && { testContent }
+    });
+    return { content: [{ type: "text", text: JSON.stringify(verdict, null, 2) }] };
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return errorResponse2(`acceptance_eval failed: ${message}`);
+  }
+}
+function unconfiguredProvider2() {
+  return {
+    analyze: () => Promise.reject(
+      new Error(
+        "No analysis provider configured (set ANTHROPIC_API_KEY). Degrading to an inconclusive, advisory verdict."
+      )
+    )
+  };
+}
+function errorResponse2(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+
 // src/mcp/tools/strategy.ts
-import * as fs49 from "fs/promises";
-import * as path52 from "path";
+import * as fs52 from "fs/promises";
+import * as path54 from "path";
 var STRATEGY_FILENAME = "STRATEGY.md";
 function mcpJson(payload, isError = false) {
   return { content: [{ type: "text", text: JSON.stringify(payload) }], isError };
@@ -18916,7 +19765,7 @@ async function handleValidateStrategy(input) {
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
-  const { validateStrategy } = await import("./dist-3HW4LCHE.js");
+  const { validateStrategy } = await import("./dist-6D2F2J57.js");
   const result = await validateStrategy(projectPath);
   if (!result.ok) {
     return mcpJson({ present: true, valid: false, error: result.error.message });
@@ -18941,7 +19790,7 @@ async function handleReadStrategy(input) {
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-3HW4LCHE.js");
+  const core = await import("./dist-6D2F2J57.js");
   const validation = await core.validateStrategy(projectPath);
   if (!validation.ok) {
     return mcpJson({ present: true, valid: false, error: validation.error.message });
@@ -18949,10 +19798,10 @@ async function handleReadStrategy(input) {
   if (!validation.value.present) {
     return mcpJson({ present: false, valid: true });
   }
-  const strategyPath = path52.join(projectPath, STRATEGY_FILENAME);
+  const strategyPath = path54.join(projectPath, STRATEGY_FILENAME);
   let raw;
   try {
-    raw = await fs49.readFile(strategyPath, "utf-8");
+    raw = await fs52.readFile(strategyPath, "utf-8");
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
@@ -18993,7 +19842,7 @@ async function handleWriteStrategy(input) {
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-3HW4LCHE.js");
+  const core = await import("./dist-6D2F2J57.js");
   try {
     core.writeStrategyDoc(input.doc, {
       cwd: projectPath,
@@ -19008,11 +19857,11 @@ async function handleWriteStrategy(input) {
       true
     );
   }
-  return mcpJson({ written: true, path: path52.join(projectPath, STRATEGY_FILENAME) });
+  return mcpJson({ written: true, path: path54.join(projectPath, STRATEGY_FILENAME) });
 }
 
 // src/mcp/tools/pulse.ts
-import * as path53 from "path";
+import * as path55 from "path";
 function mcpJson2(payload, isError = false) {
   return { content: [{ type: "text", text: JSON.stringify(payload) }], isError };
 }
@@ -19037,7 +19886,7 @@ async function handleSeedPulseFromStrategy(input) {
   } catch (error) {
     return mcpError3(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-3HW4LCHE.js");
+  const core = await import("./dist-6D2F2J57.js");
   const seed = core.seedFromStrategy({ cwd: projectPath });
   return mcpJson2(seed);
 }
@@ -19071,8 +19920,8 @@ async function handleWritePulseConfig(input) {
   } catch (error) {
     return mcpError3(error instanceof Error ? error.message : String(error));
   }
-  const resolvedConfigPath = input.configPath !== void 0 ? path53.isAbsolute(input.configPath) ? input.configPath : path53.join(projectPath, input.configPath) : path53.join(projectPath, "harness.config.json");
-  const core = await import("./dist-3HW4LCHE.js");
+  const resolvedConfigPath = input.configPath !== void 0 ? path55.isAbsolute(input.configPath) ? input.configPath : path55.join(projectPath, input.configPath) : path55.join(projectPath, "harness.config.json");
+  const core = await import("./dist-6D2F2J57.js");
   try {
     core.writePulseConfig(input.config, {
       configPath: resolvedConfigPath,
@@ -19121,7 +19970,7 @@ async function handleAcquireCompoundLock(input) {
   } catch (error) {
     return mcpError4(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-3HW4LCHE.js");
+  const core = await import("./dist-6D2F2J57.js");
   try {
     const handle = core.acquireCompoundLock(
       input.category,
@@ -19282,6 +20131,7 @@ var TOOL_DEFINITIONS = [
   knowledgeCraftDefinition,
   securityCraftDefinition,
   outcomeEvalDefinition,
+  acceptanceEvalDefinition,
   validateStrategyDefinition,
   readStrategyDefinition,
   writeStrategyDefinition,
@@ -19375,6 +20225,7 @@ var TOOL_HANDLERS = {
   knowledge_craft: handleKnowledgeCraft,
   security_craft: handleSecurityCraft,
   outcome_eval: handleOutcomeEval,
+  acceptance_eval: handleAcceptanceEval,
   validate_strategy: handleValidateStrategy,
   read_strategy: handleReadStrategy,
   write_strategy: handleWriteStrategy,
@@ -19483,7 +20334,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-3HW4LCHE.js");
+    } = await import("./dist-6D2F2J57.js");
     const { CLI_VERSION } = await import("./version-CUI434OP.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;