@harness-engineering/cli 3.0.1 → 4.0.0

package/dist/{chunk-WWEVS7RO.js → chunk-ERILXQBP.js}

@@ -1,22 +1,34 @@
+import {
+  analyzeDiffDefinition,
+  createSelfReviewDefinition,
+  handleAnalyzeDiff,
+  handleCreateSelfReview,
+  handleRequestPeerReview,
+  requestPeerReviewDefinition
+} from "./chunk-BV45354Q.js";
 import {
   getSecurityTrendsDefinition,
   handleGetSecurityTrends,
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-HEIMJJI4.js";
+} from "./chunk-6NCREWWM.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition,
   sortFindingsBySeverity
-} from "./chunk-XX4OLNWQ.js";
+} from "./chunk-HMW3C5DP.js";
 import {
   assessProjectDefinition,
   handleAssessProject
-} from "./chunk-YQSYCBAH.js";
+} from "./chunk-TTWNGOBT.js";
+import {
+  checkDocsDefinition,
+  handleCheckDocs
+} from "./chunk-363V6GPR.js";
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-Z4AWEIBY.js";
+} from "./chunk-GXCPDAS5.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -26,18 +38,10 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-ONCPJGHY.js";
+} from "./chunk-WL3O2PKJ.js";
 import {
   getBusinessKnowledgeResource
 } from "./chunk-IOW3MW2K.js";
-import {
-  analyzeDiffDefinition,
-  createSelfReviewDefinition,
-  handleAnalyzeDiff,
-  handleCreateSelfReview,
-  handleRequestPeerReview,
-  requestPeerReviewDefinition
-} from "./chunk-BYVT5LVO.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_CODEX,
@@ -53,27 +57,23 @@ import {
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-HWTUUQOW.js";
+} from "./chunk-AK67S3O4.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-527G27VI.js";
-import {
-  resolveProjectConfig
-} from "./chunk-DE5U6KOL.js";
-import {
-  checkDocsDefinition,
-  handleCheckDocs
-} from "./chunk-MGUPSE6D.js";
+} from "./chunk-MSBJ445U.js";
 import {
   resultToMcpResponse
 } from "./chunk-RC3OI5NK.js";
+import {
+  resolveProjectConfig
+} from "./chunk-ZEYAOYJL.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-GGKRA7A7.js";
+} from "./chunk-XFHZ7GCI.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-N24HCQA4.js";
+} from "./chunk-KLPX55TI.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-LHINSVK4.js");
+    const { composeInsights } = await import("./dist-IPVFYGY2.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-6GPWOYQH.js");
+    const { TemplateEngine } = await import("./engine-DJIHY4JT.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-YAN56MT3.js");
+  const { listPersonas } = await import("./loader-UWNVTYBY.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-YAN56MT3.js");
-  const { generateRuntime } = await import("./runtime-FFIIRT2T.js");
-  const { generateAgentsMd } = await import("./agents-md-XOJE5ETA.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-ORZ4F45F.js");
+  const { loadPersona } = await import("./loader-UWNVTYBY.js");
+  const { generateRuntime } = await import("./runtime-RIWQUKBQ.js");
+  const { generateAgentsMd } = await import("./agents-md-7OSNWU52.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-XJN4UO3Q.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-YAN56MT3.js");
+  const { loadPersona } = await import("./loader-UWNVTYBY.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-LHINSVK4.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-F44CUUZG.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-LHINSVK4.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-IPVFYGY2.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-LHINSVK4.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
-  return resultToMcpResponse(await loadState(projectPath, input.stream, input.session));
+  const { readHarnessState } = await import("./state-events-F44CUUZG.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-LHINSVK4.js");
+  const { appendLearning } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { appendFailure } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { archiveFailures } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
-  const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream, input.session);
+  const { eventSourcing } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { runMechanicalGate } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { saveHandoff } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { loadHandoff } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+    const { appendSessionEntry } = await import("./dist-IPVFYGY2.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-LHINSVK4.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-F44CUUZG.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-LHINSVK4.js");
+  const { updateSessionEntryStatus } = await import("./dist-IPVFYGY2.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-F44CUUZG.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-LHINSVK4.js");
+  const { readSessionSection } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { readSessionSections } = await import("./dist-IPVFYGY2.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-LHINSVK4.js");
+  const { archiveSession } = await import("./dist-IPVFYGY2.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-IPVFYGY2.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-LHINSVK4.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-IPVFYGY2.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-GNDOMS35.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-46U5AAXE.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-QPSAOZKD.js");
+    const { runCrossCheck } = await import("./validate-cross-check-M2ZM6RFY.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-LHINSVK4.js");
+    const { migrateToStreams } = await import("./dist-IPVFYGY2.js");
+    const { readHarnessState } = await import("./state-events-F44CUUZG.js");
     await migrateToStreams(projectRoot);
-    const result = await loadState(projectRoot);
+    const result = await readHarnessState(projectRoot);
     if (result.ok) {
       return JSON.stringify(result.value, null, 2);
     }
@@ -3633,8 +3710,8 @@ async function handleIngestSource(input) {
     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 fs53 = await import("fs/promises");
+    await fs53.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -4042,7 +4119,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-XIHQPKG3.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-CC6KED3E.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");
+async function loadRoadmap(projectRoot) {
+  return resolveRoadmapStore({ projectRoot }).load();
 }
-function readRoadmapFile(projectRoot) {
-  const filePath = roadmapPath(projectRoot);
-  try {
-    return fs15.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-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,33 +4545,54 @@ 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 handleUpdate2(projectPath, input, deps) {
-  const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, Ok: Ok2 } = deps;
+function claimRefusedResponse(featureName, roadmap, currentAssignee) {
+  const message = `Claim refused: "${featureName}" is already in-progress under ${currentAssignee ?? "another owner"} (first-claim-wins). Release it first to hand off.`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ ...roadmap, claimed: false, message })
+      }
+    ],
+    isError: true
+  };
+}
+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());
     if (feature) {
-      if (input.status) feature.status = input.status;
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      if (input.status) deps.setStatus(roadmap, feature, input.status, date);
       if (input.summary !== void 0) feature.summary = input.summary;
       if (input.spec !== void 0) feature.spec = input.spec || null;
       if (input.plans !== void 0) feature.plans = input.plans;
       if (input.blocked_by !== void 0) feature.blockedBy = input.blocked_by;
       if (input.assignee !== void 0) {
-        deps.assignFeature(roadmap, feature, input.assignee, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10));
+        if (input.assignee) {
+          deps.claim(roadmap, feature, input.assignee, date);
+          if (feature.assignee !== input.assignee) {
+            return claimRefusedResponse(input.feature, roadmap, feature.assignee);
+          }
+        } else {
+          deps.release(roadmap, feature, date);
+        }
       }
       found = true;
       break;
@@ -4517,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());
@@ -4554,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) {
@@ -4563,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" }],
@@ -4577,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,
@@ -4588,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,
@@ -4595,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(
@@ -4634,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
@@ -4653,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(
@@ -4672,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({
@@ -4684,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);
@@ -4739,9 +4831,12 @@ async function handleManageRoadmap(input) {
       syncRoadmap,
       applySyncChanges,
       assignFeature,
+      setStatus,
+      claim,
+      release,
       promoteFeature,
       groomRoadmap
-    } = await import("./dist-LHINSVK4.js");
+    } = await import("./dist-IPVFYGY2.js");
     const { Ok: Ok2 } = await import("./dist-ICW4QUEW.js");
     const projectPath = projectPathPre;
     const deps = {
@@ -4750,13 +4845,16 @@ async function handleManageRoadmap(input) {
       syncRoadmap,
       applySyncChanges,
       assignFeature,
+      setStatus,
+      claim,
+      release,
       promoteFeature,
       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;
@@ -5182,7 +5280,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-LHINSVK4.js");
+    const { saveHandoff } = await import("./dist-IPVFYGY2.js");
     await saveHandoff(
       projectPath,
       {
@@ -5263,17 +5361,17 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-LHINSVK4.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-F44CUUZG.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 {
   }
 }
@@ -5424,10 +5522,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation", "businessKnowledge"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-LHINSVK4.js").then(
-    (core) => core.loadState(projectPath, void 0, input.session)
+  const statePromise = includeSet.has("state") ? import("./state-events-F44CUUZG.js").then(
+    (m) => m.readHarnessState(projectPath, { session: input.session })
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-LHINSVK4.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-IPVFYGY2.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -5436,7 +5534,7 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-LHINSVK4.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-IPVFYGY2.js").then(
     (core) => core.loadHandoff(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
   const graphPromise = includeSet.has("graph") ? (async () => {
@@ -5480,19 +5578,15 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-LHINSVK4.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-IPVFYGY2.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-LHINSVK4.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-F44CUUZG.js").then(
+    (m) => m.readAuditTimeline(projectPath, { session: input.session })
+  ) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-7IAF2ES3.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-IUAV7MOU.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -5595,7 +5689,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-LHINSVK4.js");
+      const core = await import("./dist-IPVFYGY2.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -5793,7 +5887,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-YXYY44ZC.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-JT5X3DBC.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -5828,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-YXYY44ZC.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-JT5X3DBC.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -5863,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-NENG6LW7.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-MOOWXWSQ.js");
   const result = await handleRunCodeReview2({
     path: projectPath,
     diff,
@@ -6158,7 +6252,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-LHINSVK4.js");
+    const { detectStaleConstraints } = await import("./dist-IPVFYGY2.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -6189,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";
@@ -6288,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-RHXOQNMM.js");
-  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-JEZPJ725.js");
-  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-VLKDRMRT.js");
-  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-3PIBN35B.js");
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-3KPP2D6M.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-2XYGJGT3.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-EAEKJKRM.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-U76C54W6.js");
   const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
     handleAssessProject2({
       path: projectPath,
@@ -6395,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
   };
@@ -6767,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;
 }
@@ -7047,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)) {
@@ -7134,7 +7220,7 @@ async function handleGetDecayTrends(input) {
     };
   }
   try {
-    const core = await import("./dist-LHINSVK4.js");
+    const core = await import("./dist-IPVFYGY2.js");
     const { TimelineManager } = core;
     const manager = new TimelineManager(projectPath);
     const timeline = manager.load();
@@ -7269,7 +7355,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-LHINSVK4.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-IPVFYGY2.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -7288,7 +7374,7 @@ async function handleCodeOutline(input) {
         })
       );
       fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      const { paginate: paginate2 } = await import("./dist-LHINSVK4.js");
+      const { paginate: paginate2 } = await import("./dist-IPVFYGY2.js");
       const paged = paginate2(fileStats, input.offset ?? 0, input.limit ?? 30);
       const results = [];
       for (const entry of paged.items) {
@@ -7361,7 +7447,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-LHINSVK4.js");
+    const { searchSymbols } = await import("./dist-IPVFYGY2.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) {
@@ -7430,7 +7516,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-LHINSVK4.js");
+      const { unfoldSymbol } = await import("./dist-IPVFYGY2.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}
@@ -7438,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-LHINSVK4.js");
+      const { unfoldRange } = await import("./dist-IPVFYGY2.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -7623,7 +7709,7 @@ async function handlePredictFailures(input) {
     };
   }
   try {
-    const core = await import("./dist-LHINSVK4.js");
+    const core = await import("./dist-IPVFYGY2.js");
     const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
     const manager = new TimelineManager(projectPath);
     const includeRoadmap = input.includeRoadmap !== false;
@@ -7634,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: [
         {
@@ -8732,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-LHINSVK4.js");
+    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-IPVFYGY2.js");
     const manager = new ViolationHistoryManager(historyPath);
     const history = manager.load();
     const options = { windowWeeks, minOccurrences };
@@ -8820,7 +8906,7 @@ async function handleRunCIChecks(input) {
     };
   }
   try {
-    const { runCIChecks } = await import("./dist-LHINSVK4.js");
+    const { runCIChecks } = await import("./dist-IPVFYGY2.js");
     const skip = input.checks ? VALID_CHECKS.filter((c) => !input.checks.includes(c)) : [];
     const result = await runCIChecks({
       projectRoot: projectPath,
@@ -8882,7 +8968,7 @@ async function handleGenerateBlueprint(input) {
     };
   }
   try {
-    const { ProjectScanner } = await import("./dist-LHINSVK4.js");
+    const { ProjectScanner } = await import("./dist-IPVFYGY2.js");
     const scanner = new ProjectScanner(projectPath);
     const data = await scanner.scan();
     return {
@@ -9081,7 +9167,7 @@ async function handleEmitSkillProposal(input) {
   let createProposal;
   let ProposalConflictError;
   try {
-    const core = await import("./dist-LHINSVK4.js");
+    const core = await import("./dist-IPVFYGY2.js");
     createProposal = core.createProposal;
     ProposalConflictError = core.ProposalConflictError;
   } catch (err2) {
@@ -9124,8 +9210,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";
@@ -9234,6 +9320,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",
@@ -9817,6 +9907,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) {
@@ -9826,11 +9975,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 = [
@@ -9849,20 +10018,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
@@ -9981,10 +10272,197 @@ 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 presencePattern(spec) {
+  return {
+    code: spec.code,
+    id: spec.id,
+    source: `design-component-anatomy/pattern-${spec.id}`,
+    detect(file, contents, componentType) {
+      const index = firstTrigger(contents, spec.triggers);
+      if (index === -1) return [];
+      if (anyMatch(contents, spec.mitigations)) return [];
+      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 }
+        }
+      ];
+    }
+  };
+}
+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: {
@@ -9992,7 +10470,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",
@@ -10020,31 +10498,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 {
@@ -10052,7 +10537,7 @@ async function runAudit(input) {
     summary,
     catalog: {
       conventionsApplied: [...conventionsApplied].sort(),
-      patternsApplied: []
+      patternsApplied: [...patternsApplied].sort()
     },
     meta: { mode: mode2, deferredToA11y: 0 }
   };
@@ -10084,10 +10569,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 = {
@@ -10169,8 +10655,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);
@@ -10232,10 +10718,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"];
@@ -10296,8 +10809,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;
@@ -10380,8 +10893,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);
@@ -10447,8 +10960,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,
@@ -12549,17 +13062,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;
 }
@@ -12568,7 +13081,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;
   }
@@ -12839,15 +13352,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;
@@ -12856,7 +13369,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 {
@@ -12869,8 +13382,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;
@@ -12891,13 +13404,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}`;
@@ -12918,8 +13431,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 {
   }
 }
@@ -12936,7 +13449,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",
@@ -12951,7 +13464,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",
@@ -12970,6 +13487,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"]
@@ -13010,16 +13540,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 deep mode (render + vision LLM) is not implemented in the Phase 1 MVP. Use mode: "fast".'
+      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 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);
@@ -13031,12 +13608,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);
     }
@@ -13109,18 +13688,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;
   }
@@ -13144,11 +13723,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,9 +13777,9 @@ function walkForPaths(node, breadcrumb, idx) {
     }
   }
 }
-function pushPath(map, key, path54) {
+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) {
@@ -13247,8 +13826,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",
@@ -13257,11 +13836,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;
   }
@@ -13598,7 +14177,7 @@ async function runDetectDrift(input) {
   for (const file of filesToScan) {
     let source;
     try {
-      source = fs28.readFileSync(file, "utf-8");
+      source = fs31.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -13633,7 +14212,7 @@ async function runDetectDrift(input) {
 }
 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);
@@ -13643,7 +14222,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;
   }
@@ -13651,7 +14230,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))) {
@@ -13719,8 +14298,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;
@@ -13860,9 +14439,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, "-")})`;
   }
@@ -14014,8 +14593,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) {
@@ -14047,15 +14626,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;
@@ -14152,7 +14731,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) {
@@ -14218,7 +14797,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",
@@ -14228,7 +14807,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)}`;
@@ -14236,10 +14815,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 {
@@ -14264,7 +14843,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 {
@@ -14292,7 +14871,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 {
@@ -14354,19 +14933,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 ?? "?"}`;
@@ -14442,18 +15021,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;
   }
@@ -14564,14 +15143,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;
   }
@@ -14820,7 +15399,7 @@ async function runAuditBrand(input) {
   for (const file of filesToScan) {
     let source;
     try {
-      source = fs33.readFileSync(file, "utf-8");
+      source = fs36.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -14862,7 +15441,7 @@ async function runAuditBrand(input) {
 }
 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);
@@ -14872,7 +15451,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;
   }
@@ -14880,7 +15459,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))) {
@@ -14998,15 +15577,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);
@@ -15015,7 +15594,7 @@ function runFreshen(input) {
 }
 function readFileSafe(p) {
   try {
-    return fs34.readFileSync(p, "utf-8");
+    return fs37.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -15042,8 +15621,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;
@@ -15092,11 +15671,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 = {};
     }
@@ -15104,8 +15683,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
@@ -15135,8 +15714,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. -->
@@ -15196,11 +15775,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;
@@ -15220,16 +15799,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;
   }
@@ -15264,10 +15843,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
@@ -15416,8 +15995,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
@@ -15741,27 +16320,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;
@@ -15770,7 +16349,7 @@ function loadRunState(projectRoot, runId) {
 function deleteRunState(projectRoot, runId) {
   const file = runPath(projectRoot, runId);
   try {
-    fs37.unlinkSync(file);
+    fs40.unlinkSync(file);
   } catch {
   }
 }
@@ -15778,16 +16357,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 {
     }
   }
@@ -15807,7 +16386,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;
     }
@@ -15964,7 +16543,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);
@@ -15974,7 +16553,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;
   }
@@ -15982,7 +16561,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);
   }
@@ -16166,32 +16745,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" });
           }
         }
@@ -16199,13 +16778,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" });
       }
     }
   }
@@ -16453,7 +17032,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;
     }
@@ -16573,13 +17152,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 [];
@@ -16719,7 +17298,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() {
@@ -16739,8 +17318,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;
@@ -16779,8 +17358,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;
   }
@@ -17086,7 +17665,7 @@ async function runCopyCraft(input) {
     for (const file of files) {
       let source;
       try {
-        source = fs42.readFileSync(file, "utf-8");
+        source = fs45.readFileSync(file, "utf-8");
       } catch {
         continue;
       }
@@ -17170,7 +17749,7 @@ async function runCopyCraft(input) {
 }
 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);
@@ -17180,7 +17759,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;
   }
@@ -17188,7 +17767,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);
@@ -17258,8 +17837,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
@@ -17365,25 +17944,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 {
@@ -17619,7 +18198,7 @@ async function runTestCraft(input) {
   for (const file of files) {
     let source;
     try {
-      source = fs44.readFileSync(file, "utf-8");
+      source = fs47.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -17684,7 +18263,7 @@ async function runTestCraft(input) {
 }
 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);
@@ -17694,7 +18273,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;
   }
@@ -17702,7 +18281,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);
@@ -17775,18 +18354,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);
@@ -17795,13 +18374,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);
@@ -17810,7 +18389,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 });
   }
 }
@@ -17990,7 +18569,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;
@@ -18031,10 +18610,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);
@@ -18096,12 +18675,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",
@@ -18121,12 +18700,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 [];
   }
@@ -18134,8 +18713,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;
@@ -18143,13 +18722,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);
@@ -18157,7 +18736,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);
   }
@@ -18654,7 +19233,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;
     }
@@ -18862,9 +19441,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 };
@@ -18890,7 +19583,7 @@ async function handleValidateStrategy(input) {
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
-  const { validateStrategy } = await import("./dist-LHINSVK4.js");
+  const { validateStrategy } = await import("./dist-IPVFYGY2.js");
   const result = await validateStrategy(projectPath);
   if (!result.ok) {
     return mcpJson({ present: true, valid: false, error: result.error.message });
@@ -18915,7 +19608,7 @@ async function handleReadStrategy(input) {
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-LHINSVK4.js");
+  const core = await import("./dist-IPVFYGY2.js");
   const validation = await core.validateStrategy(projectPath);
   if (!validation.ok) {
     return mcpJson({ present: true, valid: false, error: validation.error.message });
@@ -18923,10 +19616,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));
   }
@@ -18967,7 +19660,7 @@ async function handleWriteStrategy(input) {
   } catch (error) {
     return mcpError2(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-LHINSVK4.js");
+  const core = await import("./dist-IPVFYGY2.js");
   try {
     core.writeStrategyDoc(input.doc, {
       cwd: projectPath,
@@ -18982,11 +19675,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 };
 }
@@ -19011,7 +19704,7 @@ async function handleSeedPulseFromStrategy(input) {
   } catch (error) {
     return mcpError3(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-LHINSVK4.js");
+  const core = await import("./dist-IPVFYGY2.js");
   const seed = core.seedFromStrategy({ cwd: projectPath });
   return mcpJson2(seed);
 }
@@ -19045,8 +19738,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-LHINSVK4.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-IPVFYGY2.js");
   try {
     core.writePulseConfig(input.config, {
       configPath: resolvedConfigPath,
@@ -19095,7 +19788,7 @@ async function handleAcquireCompoundLock(input) {
   } catch (error) {
     return mcpError4(error instanceof Error ? error.message : String(error));
   }
-  const core = await import("./dist-LHINSVK4.js");
+  const core = await import("./dist-IPVFYGY2.js");
   try {
     const handle = core.acquireCompoundLock(
       input.category,
@@ -19256,6 +19949,7 @@ var TOOL_DEFINITIONS = [
   knowledgeCraftDefinition,
   securityCraftDefinition,
   outcomeEvalDefinition,
+  acceptanceEvalDefinition,
   validateStrategyDefinition,
   readStrategyDefinition,
   writeStrategyDefinition,
@@ -19349,6 +20043,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,
@@ -19457,7 +20152,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-LHINSVK4.js");
+    } = await import("./dist-IPVFYGY2.js");
     const { CLI_VERSION } = await import("./version-CUI434OP.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;