@harness-engineering/cli 1.23.0 → 1.23.2

package/dist/{chunk-SM22U22L.js → chunk-BK52Z6DR.js}

@@ -1,17 +1,3 @@
-import {
-  detectEntropyDefinition,
-  handleDetectEntropy
-} from "./chunk-TJ6NLLAY.js";
-import {
-  checkPerformanceDefinition,
-  getCriticalPathsDefinition,
-  getPerfBaselinesDefinition,
-  handleCheckPerformance,
-  handleGetCriticalPaths,
-  handleGetPerfBaselines,
-  handleUpdatePerfBaselines,
-  updatePerfBaselinesDefinition
-} from "./chunk-QUKH6QCJ.js";
 import {
   analyzeDiffDefinition,
   createSelfReviewDefinition,
@@ -19,56 +5,67 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-AKVG4MMZ.js";
+} from "./chunk-KC5CTCEL.js";
 import {
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-TD6MQUV2.js";
+} from "./chunk-S5ZXT3TZ.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition
-} from "./chunk-LIWGCYON.js";
+} from "./chunk-ZYJJUPNE.js";
 import {
   assessProjectDefinition,
   handleAssessProject
-} from "./chunk-2LAEDVOC.js";
-import {
-  GENERATED_HEADER_CLAUDE,
-  GENERATED_HEADER_CODEX,
-  GENERATED_HEADER_CURSOR,
-  GENERATED_HEADER_GEMINI,
-  VALID_PLATFORMS,
-  applySyncPlan,
-  computeSyncPlan
-} from "./chunk-CJDVBBPB.js";
+} from "./chunk-ZRYDYDB2.js";
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-ENA4O4WD.js";
-import {
-  loadGraphStore
-} from "./chunk-TLDCCPUZ.js";
+} from "./chunk-2GT3HO2T.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-AIBAYANF.js";
+} from "./chunk-2DHX6TAP.js";
 import {
   resolveProjectConfig
-} from "./chunk-H7Y5CKTM.js";
+} from "./chunk-Q3XYV5UC.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-HT4VPPB4.js";
+} from "./chunk-MZAHE4DK.js";
 import {
-  TrackerConfigSchema,
-  resolveConfig
-} from "./chunk-GJRUIXUK.js";
+  detectEntropyDefinition,
+  handleDetectEntropy
+} from "./chunk-2YA4XRI3.js";
+import {
+  checkPerformanceDefinition,
+  getCriticalPathsDefinition,
+  getPerfBaselinesDefinition,
+  handleCheckPerformance,
+  handleGetCriticalPaths,
+  handleGetPerfBaselines,
+  handleUpdatePerfBaselines,
+  updatePerfBaselinesDefinition
+} from "./chunk-MHOO7NLG.js";
 import {
   resultToMcpResponse
 } from "./chunk-IDZNPTYD.js";
 import {
   sanitizePath
 } from "./chunk-W6Y7ZW3Y.js";
+import {
+  TrackerConfigSchema,
+  resolveConfig
+} from "./chunk-PGF44T2D.js";
+import {
+  GENERATED_HEADER_CLAUDE,
+  GENERATED_HEADER_CODEX,
+  GENERATED_HEADER_CURSOR,
+  GENERATED_HEADER_GEMINI,
+  VALID_PLATFORMS,
+  applySyncPlan,
+  computeSyncPlan
+} from "./chunk-3ISINLYT.js";
 import {
   resolveAllSkillsDirs,
   resolveCommunitySkillsDir,
@@ -79,23 +76,27 @@ import {
   resolveTemplatesDir
 } from "./chunk-N5G5QMS3.js";
 import {
-  CLIError,
-  ExitCode,
-  handleError
-} from "./chunk-3WGJMBKH.js";
-import {
-  SkillMetadataSchema
-} from "./chunk-SE4YPMLH.js";
+  loadGraphStore
+} from "./chunk-I47JLISV.js";
 import {
   DESTRUCTIVE_BASH,
   checkTaint,
+  detectChangeType,
   scanForInjection,
   writeTaint
-} from "./chunk-XDAIFVGC.js";
+} from "./chunk-V27WDRYV.js";
 import {
   Err,
   Ok
-} from "./chunk-ERS5EVUZ.js";
+} from "./chunk-5LMZA5LZ.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-SE4YPMLH.js";
+import {
+  CLIError,
+  ExitCode,
+  handleError
+} from "./chunk-3WGJMBKH.js";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -242,7 +243,7 @@ var generateLinterDefinition = {
 };
 async function handleGenerateLinter(input) {
   try {
-    const { generate } = await import("./dist-DZ63LLUD.js");
+    const { generate } = await import("./dist-KQSTRP36.js");
     const result = await generate({
       configPath: sanitizePath(input.configPath),
       ...input.outputDir !== void 0 && { outputDir: sanitizePath(input.outputDir) }
@@ -276,7 +277,7 @@ var validateLinterConfigDefinition = {
 };
 async function handleValidateLinterConfig(input) {
   try {
-    const { validate } = await import("./dist-DZ63LLUD.js");
+    const { validate } = await import("./dist-KQSTRP36.js");
     const result = await validate({ configPath: sanitizePath(input.configPath) });
     if ("success" in result && result.success) {
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
@@ -561,7 +562,7 @@ ${skippedMsg}`
 async function handleInitProject(input) {
   const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-LX5RVGXN.js");
+    const { TemplateEngine } = await import("./engine-JGI3MWAC.js");
     const engine = new TemplateEngine(resolveTemplatesDir());
     const safePath = sanitizePath(i.path);
     const detected = tryDetectFramework(engine, safePath, i);
@@ -582,7 +583,7 @@ var listPersonasDefinition = {
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-GWIEW4HM.js");
+  const { listPersonas } = await import("./loader-E4KNTOP2.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -606,10 +607,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-GWIEW4HM.js");
-  const { generateRuntime } = await import("./runtime-UJ4YO4CA.js");
-  const { generateAgentsMd } = await import("./agents-md-GLKJSGKT.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-LE3QF4FP.js");
+  const { loadPersona } = await import("./loader-E4KNTOP2.js");
+  const { generateRuntime } = await import("./runtime-JXQ26U4Z.js");
+  const { generateAgentsMd } = await import("./agents-md-HCCCO5PK.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-I3V7FZNV.js");
   const personasDir = resolvePersonasDir();
   const filePath = path3.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -664,7 +665,7 @@ 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-GWIEW4HM.js");
+  const { loadPersona } = await import("./loader-E4KNTOP2.js");
   const { runPersona } = await import("./runner-VMYLHWOC.js");
   const { executeSkill } = await import("./skill-executor-2BZQLHYN.js");
   const personasDir = resolvePersonasDir();
@@ -1075,6 +1076,17 @@ var SIGNAL_DOMAIN_MAP = {
   runbooks: ["incident-response"],
   "docs/runbooks": ["incident-response"]
 };
+function detectDomainsFromFiles(files) {
+  const domainSet = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const [pattern, domains] of Object.entries(SIGNAL_DOMAIN_MAP)) {
+      if (file === pattern || file.startsWith(pattern + "/")) {
+        for (const domain of domains) domainSet.add(domain);
+      }
+    }
+  }
+  return [...domainSet].sort();
+}
 function generateStackProfile(projectRoot) {
   const signals = {};
   const domainSet = /* @__PURE__ */ new Set();
@@ -1204,7 +1216,7 @@ var createSkillDefinition = {
 };
 async function handleCreateSkill(input) {
   try {
-    const { generateSkillFiles } = await import("./create-skill-U3XCFRZN.js");
+    const { generateSkillFiles } = await import("./create-skill-AO25CJFM.js");
     const result = generateSkillFiles({
       name: input.name,
       description: input.description,
@@ -1322,7 +1334,7 @@ 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-YIKUBJLQ.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-MKWF5CXR.js");
     const raw = fs10.readFileSync(roadmapFile, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) return;
@@ -1349,7 +1361,7 @@ async function triggerExternalSync(projectPath, roadmapFile) {
     }
     const token = process.env.GITHUB_TOKEN;
     if (!token) return;
-    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-YIKUBJLQ.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-MKWF5CXR.js");
     const adapter = new GitHubIssuesSyncAdapter({
       token,
       config: trackerConfig
@@ -1461,12 +1473,12 @@ var manageStateDefinition = {
   }
 };
 async function handleShow(projectPath, input) {
-  const { loadState } = await import("./dist-YIKUBJLQ.js");
+  const { loadState } = await import("./dist-MKWF5CXR.js");
   return resultToMcpResponse(await loadState(projectPath, input.stream, input.session));
 }
 async function handleLearn(projectPath, input) {
   if (!input.learning) return mcpError("Error: learning is required for learn action");
-  const { appendLearning } = await import("./dist-YIKUBJLQ.js");
+  const { appendLearning } = await import("./dist-MKWF5CXR.js");
   const result = await appendLearning(
     projectPath,
     input.learning,
@@ -1481,7 +1493,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-YIKUBJLQ.js");
+  const { appendFailure } = await import("./dist-MKWF5CXR.js");
   const result = await appendFailure(
     projectPath,
     input.description,
@@ -1494,24 +1506,24 @@ async function handleFailure(projectPath, input) {
   return resultToMcpResponse(Ok({ recorded: true }));
 }
 async function handleArchive(projectPath, input) {
-  const { archiveFailures } = await import("./dist-YIKUBJLQ.js");
+  const { archiveFailures } = await import("./dist-MKWF5CXR.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-YIKUBJLQ.js");
+  const { saveState, DEFAULT_STATE } = await import("./dist-MKWF5CXR.js");
   const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ reset: true }));
 }
 async function handleGate(projectPath, _input) {
-  const { runMechanicalGate } = await import("./dist-YIKUBJLQ.js");
+  const { runMechanicalGate } = await import("./dist-MKWF5CXR.js");
   return resultToMcpResponse(await runMechanicalGate(projectPath));
 }
 async function handleSaveHandoff(projectPath, input) {
   if (!input.handoff) return mcpError("Error: handoff is required for save-handoff action");
-  const { saveHandoff } = await import("./dist-YIKUBJLQ.js");
+  const { saveHandoff } = await import("./dist-MKWF5CXR.js");
   const result = await saveHandoff(
     projectPath,
     input.handoff,
@@ -1523,7 +1535,7 @@ async function handleSaveHandoff(projectPath, input) {
   return resultToMcpResponse(Ok({ saved: true }));
 }
 async function handleLoadHandoff(projectPath, input) {
-  const { loadHandoff } = await import("./dist-YIKUBJLQ.js");
+  const { loadHandoff } = await import("./dist-MKWF5CXR.js");
   return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
 }
 async function handleAppendEntry(projectPath, input) {
@@ -1531,7 +1543,7 @@ async function handleAppendEntry(projectPath, input) {
   if (!input.section) return mcpError("Error: section is required for append_entry action");
   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");
-  const { appendSessionEntry } = await import("./dist-YIKUBJLQ.js");
+  const { appendSessionEntry } = await import("./dist-MKWF5CXR.js");
   const result = await appendSessionEntry(
     projectPath,
     input.session,
@@ -1547,7 +1559,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-YIKUBJLQ.js");
+  const { updateSessionEntryStatus } = await import("./dist-MKWF5CXR.js");
   const result = await updateSessionEntryStatus(
     projectPath,
     input.session,
@@ -1560,7 +1572,7 @@ async function handleUpdateEntryStatus(projectPath, input) {
 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-YIKUBJLQ.js");
+  const { readSessionSection } = await import("./dist-MKWF5CXR.js");
   const result = await readSessionSection(
     projectPath,
     input.session,
@@ -1570,13 +1582,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-YIKUBJLQ.js");
+  const { readSessionSections } = await import("./dist-MKWF5CXR.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-YIKUBJLQ.js");
+  const { archiveSession } = await import("./dist-MKWF5CXR.js");
   const result = await archiveSession(projectPath, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   await autoSyncRoadmap(projectPath);
@@ -1640,7 +1652,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-YIKUBJLQ.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-MKWF5CXR.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -1678,7 +1690,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-N3DTKFCZ.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-UGBJ237T.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -1734,7 +1746,7 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-R3GV2MLM.js");
+    const { runCrossCheck } = await import("./validate-cross-check-AM4T6P2K.js");
     const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
@@ -2379,7 +2391,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-YIKUBJLQ.js");
+    const { loadState, migrateToStreams } = await import("./dist-MKWF5CXR.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -2467,7 +2479,7 @@ async function handleQueryGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-OEXTQQZC.js");
+    const { ContextQL } = await import("./dist-WU3TVNNG.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -2558,7 +2570,7 @@ async function handleSearchSimilar(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer } = await import("./dist-OEXTQQZC.js");
+    const { FusionLayer } = await import("./dist-WU3TVNNG.js");
     const fusion = new FusionLayer(store);
     const results = fusion.search(input.query, input.topK ?? 10);
     if (input.mode === "summary") {
@@ -2613,7 +2625,7 @@ async function handleFindContextFor(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer, ContextQL } = await import("./dist-OEXTQQZC.js");
+    const { FusionLayer, ContextQL } = await import("./dist-WU3TVNNG.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -2709,7 +2721,7 @@ async function handleGetRelationships(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-OEXTQQZC.js");
+    const { ContextQL } = await import("./dist-WU3TVNNG.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -2815,7 +2827,7 @@ async function handleGetImpact(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-OEXTQQZC.js");
+    const { ContextQL } = await import("./dist-WU3TVNNG.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -2947,7 +2959,7 @@ async function handleIngestSource(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const graphDir = path16.join(projectPath, ".harness", "graph");
-    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-OEXTQQZC.js");
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-WU3TVNNG.js");
     const fs17 = await import("fs/promises");
     await fs17.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
@@ -3022,7 +3034,7 @@ async function handleDetectAnomalies(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { GraphAnomalyAdapter } = await import("./dist-OEXTQQZC.js");
+    const { GraphAnomalyAdapter } = await import("./dist-WU3TVNNG.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -3062,7 +3074,7 @@ async function handleAskGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { askGraph } = await import("./dist-OEXTQQZC.js");
+    const { askGraph } = await import("./dist-WU3TVNNG.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -3080,6 +3092,138 @@ async function handleAskGraph(input) {
   }
 }
 
+// src/mcp/tools/graph/compute-blast-radius.ts
+var computeBlastRadiusDefinition = {
+  name: "compute_blast_radius",
+  description: "Simulate cascading failure propagation from a source node using probability-weighted BFS. Returns cumulative failure probability for each affected node.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      file: {
+        type: "string",
+        description: "File path (relative to project root) to simulate failure for"
+      },
+      nodeId: { type: "string", description: "Node ID to simulate failure for" },
+      probabilityFloor: {
+        type: "number",
+        description: "Minimum cumulative probability to continue traversal (default 0.05)"
+      },
+      maxDepth: {
+        type: "number",
+        description: "Maximum BFS depth (default 10)"
+      },
+      mode: {
+        type: "string",
+        enum: ["compact", "detailed"],
+        description: "Response density: compact returns summary + top 10 highest-risk nodes, detailed returns full layered cascade chain. Default: compact"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleComputeBlastRadius(input) {
+  try {
+    if (!input.nodeId && !input.file) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: either nodeId or file is required"
+          }
+        ],
+        isError: true
+      };
+    }
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { CascadeSimulator } = await import("./dist-WU3TVNNG.js");
+    let targetNodeId = input.nodeId;
+    if (!targetNodeId && input.file) {
+      const fileNodes = store.findNodes({ type: "file" });
+      const match = fileNodes.find((n) => n.path === input.file || n.id === `file:${input.file}`);
+      if (!match) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: no file node found matching path "${input.file}"`
+            }
+          ],
+          isError: true
+        };
+      }
+      targetNodeId = match.id;
+    }
+    if (input.probabilityFloor !== void 0 && (input.probabilityFloor <= 0 || input.probabilityFloor >= 1)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: probabilityFloor must be between 0 and 1 (exclusive)"
+          }
+        ],
+        isError: true
+      };
+    }
+    if (input.maxDepth !== void 0 && (input.maxDepth < 1 || input.maxDepth > 100)) {
+      return {
+        content: [{ type: "text", text: "Error: maxDepth must be between 1 and 100" }],
+        isError: true
+      };
+    }
+    const simulator = new CascadeSimulator(store);
+    const result = simulator.simulate(targetNodeId, {
+      ...input.probabilityFloor !== void 0 && {
+        probabilityFloor: input.probabilityFloor
+      },
+      ...input.maxDepth !== void 0 && { maxDepth: input.maxDepth }
+    });
+    if (input.mode === "detailed") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "detailed",
+              sourceNodeId: result.sourceNodeId,
+              sourceName: result.sourceName,
+              layers: result.layers,
+              flatSummary: result.flatSummary,
+              summary: result.summary
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            mode: "compact",
+            sourceNodeId: result.sourceNodeId,
+            sourceName: result.sourceName,
+            topRisks: result.flatSummary.slice(0, 10),
+            summary: result.summary
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
 // src/mcp/resources/graph.ts
 import * as fs14 from "fs/promises";
 import * as path17 from "path";
@@ -3198,7 +3342,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-HNJHO5YQ.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-D7B25YTM.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -3526,8 +3670,8 @@ function shouldTriggerExternalSync(input, response) {
 }
 async function handleManageRoadmap(input) {
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-YIKUBJLQ.js");
-    const { Ok: Ok2 } = await import("./dist-USY2C5JL.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-MKWF5CXR.js");
+    const { Ok: Ok2 } = await import("./dist-666AAZQ6.js");
     const projectPath = sanitizePath(input.path);
     const deps = {
       parseRoadmap,
@@ -3961,7 +4105,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-YIKUBJLQ.js");
+    const { saveHandoff } = await import("./dist-MKWF5CXR.js");
     await saveHandoff(
       projectPath,
       {
@@ -4029,7 +4173,7 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-YIKUBJLQ.js");
+    const { loadState, saveState } = await import("./dist-MKWF5CXR.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -4118,10 +4262,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-YIKUBJLQ.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-MKWF5CXR.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-YIKUBJLQ.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-MKWF5CXR.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -4130,14 +4274,14 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-YIKUBJLQ.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-MKWF5CXR.js").then(
     (core) => core.loadHandoff(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
   const graphPromise = includeSet.has("graph") ? (async () => {
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-XULF5QF7.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-BJULJYGG.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return null;
-    const { FusionLayer, ContextQL } = await import("./dist-OEXTQQZC.js");
+    const { FusionLayer, ContextQL } = await import("./dist-WU3TVNNG.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -4174,11 +4318,11 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-YIKUBJLQ.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-MKWF5CXR.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-YIKUBJLQ.js").then(async (core) => {
+  const eventsPromise = shouldIncludeEvents ? import("./dist-MKWF5CXR.js").then(async (core) => {
     const result = await core.loadEvents(projectPath, {
       session: input.session
     });
@@ -4186,7 +4330,7 @@ async function handleGatherContext(input) {
     return core.formatEventTimeline(result.value);
   }) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-NHXWKMCR.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-2IUR3OWX.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -4280,7 +4424,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-YIKUBJLQ.js");
+      const core = await import("./dist-MKWF5CXR.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -4406,7 +4550,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-2EU25RIW.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-JZETY4UR.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -4437,7 +4581,7 @@ function extractFileCount(diffParsed) {
   return files?.length ?? 0;
 }
 async function runStandardReview(projectPath, diff, diffLines, downgraded) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-2EU25RIW.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-JZETY4UR.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -4469,7 +4613,7 @@ async function runStandardReview(projectPath, diff, diffLines, downgraded) {
   };
 }
 async function runDeepReview(projectPath, diff, diffLines, _downgraded) {
-  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-YD4WI3JM.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-HIO7HBW4.js");
   const result = await handleRunCodeReview2({ path: projectPath, diff });
   const deepContent = result.content[0];
   if (!deepContent) throw new Error("Empty code review response");
@@ -4540,7 +4684,7 @@ async function handleCheckTaskIndependence(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { TaskIndependenceAnalyzer } = await import("./dist-OEXTQQZC.js");
+    const { TaskIndependenceAnalyzer } = await import("./dist-WU3TVNNG.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -4628,7 +4772,7 @@ async function handlePredictConflicts(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { ConflictPredictor } = await import("./dist-OEXTQQZC.js");
+    const { ConflictPredictor } = await import("./dist-WU3TVNNG.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -4734,7 +4878,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-XULF5QF7.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-BJULJYGG.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -4755,7 +4899,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-YIKUBJLQ.js");
+    const { detectStaleConstraints } = await import("./dist-MKWF5CXR.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -4872,10 +5016,10 @@ function countCriticalFindings(securityData) {
   return findings.filter((f) => f.severity === "error").length;
 }
 async function runHealthChecks(projectPath) {
-  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-CEDY4JU3.js");
-  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-EDSBAGR4.js");
-  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-A5Q2USYX.js");
-  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-IBSUKMVD.js");
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-XSGK44S5.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-S2H624W7.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-IDHIG7HS.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-GDKHVFUC.js");
   const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
     handleAssessProject2({
       path: projectPath,
@@ -4921,10 +5065,10 @@ function avg(values) {
 }
 async function runGraphMetrics(projectPath) {
   try {
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-XULF5QF7.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-BJULJYGG.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return ZERO_METRICS;
-    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-OEXTQQZC.js");
+    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-WU3TVNNG.js");
     const couplingAdapter = new GraphCouplingAdapter(store);
     const couplingData = couplingAdapter.computeCouplingData();
     const files = couplingData.files;
@@ -5041,60 +5185,605 @@ async function handleSearchSkills(input) {
   };
 }
 
-// src/mcp/tools/decay-trends.ts
-var getDecayTrendsDefinition = {
-  name: "get_decay_trends",
-  description: 'Get architecture decay trends over time. Returns stability score history and per-category trend analysis from timeline snapshots. Use to answer questions like "is the architecture decaying?" or "which metrics are getting worse?"',
-  inputSchema: {
-    type: "object",
-    properties: {
-      path: { type: "string", description: "Path to project root" },
-      last: {
-        type: "number",
-        description: "Number of recent snapshots to analyze (default: 10)"
-      },
-      since: {
-        type: "string",
-        description: "Show trends since this ISO date (e.g., 2026-01-01)"
-      },
-      category: {
-        type: "string",
-        description: "Filter to a single metric category",
-        enum: [
-          "circular-deps",
-          "layer-violations",
-          "complexity",
-          "coupling",
-          "forbidden-imports",
-          "module-size",
-          "dependency-depth"
-        ]
-      }
-    },
-    required: ["path"]
-  }
+// src/skill/dispatch-engine.ts
+import { execSync as execSync2 } from "child_process";
+
+// src/skill/recommendation-rules.ts
+var FALLBACK_RULES = {
+  "enforce-architecture": [
+    { signal: "circular-deps", hard: true },
+    { signal: "layer-violations", hard: true },
+    { signal: "high-coupling", metric: "fanOut", threshold: 20, weight: 0.8 },
+    { signal: "high-coupling", metric: "couplingRatio", threshold: 0.7, weight: 0.6 },
+    { signal: "change-feature", weight: 0.6 },
+    { signal: "domain-containerization", weight: 0.5 },
+    { signal: "domain-infrastructure-as-code", weight: 0.5 }
+  ],
+  "dependency-health": [
+    { signal: "high-coupling", metric: "fanOut", threshold: 15, weight: 0.7 },
+    { signal: "anomaly-outlier", weight: 0.6 },
+    { signal: "articulation-point", weight: 0.5 }
+  ],
+  tdd: [
+    { signal: "low-coverage", weight: 0.9 },
+    { signal: "change-bugfix", weight: 0.9 }
+  ],
+  "codebase-cleanup": [
+    { signal: "dead-code", weight: 0.8 },
+    { signal: "drift", weight: 0.6 }
+  ],
+  "security-scan": [
+    { signal: "security-findings", hard: true },
+    { signal: "domain-secrets", weight: 0.8 }
+  ],
+  refactoring: [
+    { signal: "high-complexity", metric: "cyclomaticComplexity", threshold: 15, weight: 0.8 },
+    { signal: "high-coupling", metric: "couplingRatio", threshold: 0.5, weight: 0.6 },
+    { signal: "change-refactor", weight: 0.9 }
+  ],
+  "detect-doc-drift": [
+    { signal: "doc-gaps", weight: 0.7 },
+    { signal: "drift", weight: 0.5 },
+    { signal: "change-docs", weight: 0.8 },
+    { signal: "domain-api-design", weight: 0.6 }
+  ],
+  perf: [
+    { signal: "perf-regression", weight: 0.8 },
+    { signal: "domain-load-testing", weight: 0.7 }
+  ],
+  "supply-chain-audit": [
+    { signal: "security-findings", weight: 0.6 },
+    { signal: "domain-secrets", weight: 0.9 }
+  ],
+  "code-review": [
+    { signal: "high-complexity", weight: 0.5 },
+    { signal: "high-coupling", weight: 0.4 },
+    { signal: "change-feature", weight: 0.7 },
+    { signal: "change-bugfix", weight: 0.6 }
+  ],
+  integrity: [
+    { signal: "drift", weight: 0.7 },
+    { signal: "dead-code", weight: 0.5 },
+    { signal: "change-refactor", weight: 0.6 }
+  ],
+  "soundness-review": [
+    { signal: "layer-violations", weight: 0.6 },
+    { signal: "circular-deps", weight: 0.5 },
+    { signal: "change-feature", weight: 0.5 },
+    { signal: "change-refactor", weight: 0.5 }
+  ],
+  debugging: [
+    { signal: "perf-regression", weight: 0.5 },
+    { signal: "anomaly-outlier", weight: 0.6 },
+    { signal: "domain-incident-response", weight: 0.7 }
+  ],
+  "hotspot-detector": [
+    { signal: "high-complexity", metric: "cyclomaticComplexity", threshold: 20, weight: 0.9 },
+    { signal: "anomaly-outlier", weight: 0.7 },
+    { signal: "articulation-point", weight: 0.8 }
+  ],
+  "cleanup-dead-code": [{ signal: "dead-code", hard: true }]
 };
-async function handleGetDecayTrends(input) {
-  let projectPath;
-  try {
-    projectPath = sanitizePath(input.path);
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
-  }
-  try {
-    const core = await import("./dist-YIKUBJLQ.js");
-    const { TimelineManager } = core;
-    const manager = new TimelineManager(projectPath);
-    const timeline = manager.load();
-    if (timeline.snapshots.length === 0) {
+
+// src/skill/recommendation-engine.ts
+function resolveMetricValue(metrics, metricName) {
+  switch (metricName) {
+    case "fanOut":
+      return metrics.maxFanOut;
+    case "couplingRatio":
+      return metrics.avgCouplingRatio;
+    case "cyclomaticComplexity":
+      return metrics.maxCyclomaticComplexity;
+    case "coverage":
+      return metrics.testCoverage !== null ? 100 - metrics.testCoverage : null;
+    default:
+      return null;
+  }
+}
+function buildSkillAddressIndex(skills) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(skills)) {
+    const addresses = entry.addresses.length > 0 ? entry.addresses : FALLBACK_RULES[name] ?? [];
+    index.set(name, { addresses, dependsOn: entry.dependsOn });
+  }
+  for (const [name, addresses] of Object.entries(FALLBACK_RULES)) {
+    if (!index.has(name)) {
+      index.set(name, { addresses, dependsOn: [] });
+    }
+  }
+  return index;
+}
+function matchHardRules(snapshot, skillIndex) {
+  const activeSignals = new Set(snapshot.signals);
+  const results = [];
+  for (const [skillName, entry] of skillIndex) {
+    const hardAddresses = entry.addresses.filter((a) => a.hard === true);
+    const matchedSignals = [];
+    const reasons = [];
+    for (const addr of hardAddresses) {
+      if (activeSignals.has(addr.signal)) {
+        matchedSignals.push(addr.signal);
+        reasons.push(`[CRITICAL] Signal '${addr.signal}' is active`);
+      }
+    }
+    if (matchedSignals.length > 0) {
+      results.push({
+        skillName,
+        score: 1,
+        urgency: "critical",
+        reasons,
+        sequence: 0,
+        // assigned later by sequencer
+        triggeredBy: matchedSignals
+      });
+    }
+  }
+  return results;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+var DEFAULT_WEIGHT = 0.5;
+function scoreByHealth(snapshot, skillIndex) {
+  const activeSignals = new Set(snapshot.signals);
+  const results = [];
+  for (const [skillName, entry] of skillIndex) {
+    const softAddresses = entry.addresses.filter((a) => !a.hard);
+    const contributions = [];
+    const triggeredBy = [];
+    const reasons = [];
+    for (const addr of softAddresses) {
+      if (!activeSignals.has(addr.signal)) continue;
+      const weight = addr.weight ?? DEFAULT_WEIGHT;
+      if (addr.metric && addr.threshold !== void 0) {
+        const actual = resolveMetricValue(snapshot.metrics, addr.metric);
+        if (actual === null) continue;
+        const distance = clamp((actual - addr.threshold) / addr.threshold, 0, 1);
+        const contribution = weight * distance;
+        contributions.push(contribution);
+        triggeredBy.push(addr.signal);
+        reasons.push(
+          `${addr.metric} = ${actual} (threshold ${addr.threshold}, distance ${distance.toFixed(2)})`
+        );
+      } else {
+        contributions.push(weight);
+        triggeredBy.push(addr.signal);
+        reasons.push(`Signal '${addr.signal}' is active (weight ${weight})`);
+      }
+    }
+    if (contributions.length === 0) continue;
+    const score = clamp(contributions.reduce((sum, c) => sum + c, 0) / contributions.length, 0, 1);
+    const urgency = score >= 0.7 ? "recommended" : "nice-to-have";
+    results.push({
+      skillName,
+      score: Math.round(score * 1e3) / 1e3,
+      // round to 3 decimal places
+      urgency,
+      reasons,
+      sequence: 0,
+      triggeredBy: [...new Set(triggeredBy)]
+    });
+  }
+  return results;
+}
+var DIAGNOSTIC_KEYWORDS = ["health", "detect", "analyze", "audit", "hotspot", "debugging"];
+var FIX_KEYWORDS = ["enforce", "cleanup", "fix", "refactor", "codebase"];
+var VALIDATION_KEYWORDS = ["verify", "test", "tdd", "review", "soundness", "integrity"];
+function classifyPhase(skillName) {
+  const lower = skillName.toLowerCase();
+  if (DIAGNOSTIC_KEYWORDS.some((kw) => lower.includes(kw))) return 0;
+  if (FIX_KEYWORDS.some((kw) => lower.includes(kw))) return 1;
+  if (VALIDATION_KEYWORDS.some((kw) => lower.includes(kw))) return 2;
+  return 3;
+}
+function heuristicComparator(recMap) {
+  return (a, b) => {
+    const phaseA = classifyPhase(a);
+    const phaseB = classifyPhase(b);
+    if (phaseA !== phaseB) return phaseA - phaseB;
+    return (recMap.get(b)?.score ?? 0) - (recMap.get(a)?.score ?? 0);
+  };
+}
+function buildDepGraph(nameSet, skillDeps) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const name of nameSet) {
+    inDegree.set(name, 0);
+    adjacency.set(name, []);
+  }
+  for (const name of nameSet) {
+    for (const dep of skillDeps.get(name) ?? []) {
+      if (!nameSet.has(dep)) continue;
+      adjacency.get(dep).push(name);
+      inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
+    }
+  }
+  return { inDegree, adjacency };
+}
+function sequenceRecommendations(recommendations, skillDeps) {
+  if (recommendations.length === 0) return [];
+  const nameSet = new Set(recommendations.map((r) => r.skillName));
+  const recMap = new Map(recommendations.map((r) => [r.skillName, r]));
+  const compare = heuristicComparator(recMap);
+  const { inDegree, adjacency } = buildDepGraph(nameSet, skillDeps);
+  const sorted = [];
+  let sequence = 1;
+  let queue = [...nameSet].filter((n) => (inDegree.get(n) ?? 0) === 0).sort(compare);
+  while (queue.length > 0) {
+    const nextQueue = [];
+    for (const name of queue) {
+      const rec = recMap.get(name);
+      rec.sequence = sequence++;
+      sorted.push(rec);
+      for (const dependent of adjacency.get(name) ?? []) {
+        const newDeg = (inDegree.get(dependent) ?? 1) - 1;
+        inDegree.set(dependent, newDeg);
+        if (newDeg === 0) nextQueue.push(dependent);
+      }
+    }
+    queue = nextQueue.sort(compare);
+  }
+  return sorted;
+}
+function recommend(snapshot, skills, options = {}) {
+  const top = options.top ?? 5;
+  if (snapshot.signals.length === 0) {
+    return {
+      recommendations: [],
+      snapshotAge: "none",
+      sequenceReasoning: "No active signals detected in health snapshot."
+    };
+  }
+  const addressIndex = buildSkillAddressIndex(skills);
+  const hardRecs = matchHardRules(snapshot, addressIndex);
+  const softRecs = scoreByHealth(snapshot, addressIndex);
+  const hardSkills = new Set(hardRecs.map((r) => r.skillName));
+  const merged = [...hardRecs, ...softRecs.filter((r) => !hardSkills.has(r.skillName))];
+  merged.sort((a, b) => b.score - a.score);
+  const limited = merged.slice(0, top);
+  const depMap = /* @__PURE__ */ new Map();
+  for (const [name, entry] of addressIndex) {
+    depMap.set(name, entry.dependsOn);
+  }
+  const sequenced = sequenceRecommendations(limited, depMap);
+  const criticalCount = sequenced.filter((r) => r.urgency === "critical").length;
+  const phases = sequenced.map((r) => `${r.sequence}. ${r.skillName}`).join(" -> ");
+  const reasoning = criticalCount > 0 ? `${criticalCount} critical issue(s) detected. Sequence: ${phases}. Critical items first, then diagnostic -> fix -> validate heuristic.` : `Sequence: ${phases}. Ordered by dependencies and diagnostic -> fix -> validate heuristic.`;
+  return {
+    recommendations: sequenced,
+    snapshotAge: "fresh",
+    sequenceReasoning: reasoning
+  };
+}
+
+// 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"
+};
+function getSignalCategory(signal) {
+  return SIGNAL_CATEGORIES[signal] ?? null;
+}
+function parseNumstatOutput(output) {
+  const lines = output.trim().split("\n").filter(Boolean);
+  let totalDiffLines = 0;
+  const changedFiles = [];
+  for (const line of lines) {
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const added = parts[0];
+    const deleted = parts[1];
+    const file = parts[2];
+    changedFiles.push(file);
+    if (added !== "-") totalDiffLines += parseInt(added, 10) || 0;
+    if (deleted !== "-") totalDiffLines += parseInt(deleted, 10) || 0;
+  }
+  return { totalDiffLines, changedFiles };
+}
+function parseNewFilesOutput(output) {
+  return output.trim().split("\n").filter(Boolean);
+}
+function getLatestCommitMessage(projectPath) {
+  try {
+    return execSync2("git log -1 --format=%s", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function gitExec(cmd, cwd) {
+  try {
+    return execSync2(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    return null;
+  }
+}
+function emptyDiffInfo() {
+  return {
+    changedFiles: [],
+    newFiles: [],
+    deletedFiles: [],
+    totalDiffLines: 0,
+    fileDiffs: /* @__PURE__ */ new Map()
+  };
+}
+function buildDiffInfoFromGit(projectPath) {
+  if (gitExec("git rev-parse --git-dir", projectPath) === null) return null;
+  const numstatOutput = gitExec("git diff --numstat HEAD", projectPath);
+  if (numstatOutput === null) return emptyDiffInfo();
+  const { totalDiffLines, changedFiles } = parseNumstatOutput(numstatOutput);
+  const newFiles = parseNewFilesOutput(
+    gitExec("git diff --diff-filter=A --name-only HEAD", projectPath) ?? ""
+  );
+  const deletedFiles = parseNewFilesOutput(
+    gitExec("git diff --diff-filter=D --name-only HEAD", projectPath) ?? ""
+  );
+  return { changedFiles, newFiles, deletedFiles, totalDiffLines, fileDiffs: /* @__PURE__ */ new Map() };
+}
+async function enrichSnapshotForDispatch(projectPath, options) {
+  let snapshot = null;
+  let snapshotFreshness = "fresh";
+  if (!options.fresh) {
+    snapshot = loadCachedSnapshot(projectPath);
+    if (snapshot && isSnapshotFresh(snapshot, projectPath)) {
+      snapshotFreshness = "cached";
+    } else {
+      snapshot = null;
+    }
+  }
+  if (!snapshot) {
+    snapshot = await captureHealthSnapshot(projectPath);
+    snapshotFreshness = "fresh";
+  }
+  const commitMessage = options.commitMessage ?? "";
+  const files = options.files ?? [];
+  const diff = {
+    changedFiles: files,
+    newFiles: [],
+    deletedFiles: [],
+    totalDiffLines: 0,
+    fileDiffs: /* @__PURE__ */ new Map()
+  };
+  const changeType = detectChangeType(commitMessage, diff);
+  const domains = detectDomainsFromFiles(files);
+  const changeSignal = `change-${changeType}`;
+  const domainSignals = domains.map((d) => `domain-${d}`);
+  const allSignals = [...snapshot.signals, changeSignal, ...domainSignals];
+  return {
+    snapshot,
+    changeType,
+    changedFiles: files,
+    domains,
+    allSignals,
+    snapshotFreshness
+  };
+}
+function computeEstimatedImpact(rec) {
+  if (rec.urgency === "critical") return "high";
+  if (rec.score >= 0.7) return "medium";
+  return "low";
+}
+function computeParallelSafe(prevTriggeredBy, currTriggeredBy) {
+  if (prevTriggeredBy.length === 0) return true;
+  const prevCategories = /* @__PURE__ */ new Set();
+  const currCategories = /* @__PURE__ */ new Set();
+  let prevHasCategory = false;
+  let currHasCategory = false;
+  for (const sig of prevTriggeredBy) {
+    const cat = getSignalCategory(sig);
+    if (cat) {
+      prevCategories.add(cat);
+      prevHasCategory = true;
+    }
+  }
+  for (const sig of currTriggeredBy) {
+    const cat = getSignalCategory(sig);
+    if (cat) {
+      currCategories.add(cat);
+      currHasCategory = true;
+    }
+  }
+  if (!prevHasCategory || !currHasCategory) return false;
+  for (const cat of currCategories) {
+    if (prevCategories.has(cat)) return false;
+  }
+  return true;
+}
+function dispatchSkills(context, options = {}) {
+  const { snapshot, changeType, domains, allSignals } = context;
+  const limit = options.limit ?? 5;
+  const enrichedSnapshot = { ...snapshot, signals: allSignals };
+  const recResult = recommend(enrichedSnapshot, {}, { top: limit });
+  const addressIndex = buildSkillAddressIndex({});
+  const skills = recResult.recommendations.map((rec, i) => {
+    const prevRec = i > 0 ? recResult.recommendations[i - 1] : null;
+    const prevTriggeredBy = prevRec?.triggeredBy ?? [];
+    const entry = addressIndex.get(rec.skillName);
+    const dependsOn = entry?.dependsOn?.length ? entry.dependsOn : void 0;
+    const dispatched = {
+      name: rec.skillName,
+      score: rec.score,
+      urgency: rec.urgency,
+      reason: rec.reasons.join("; "),
+      parallelSafe: computeParallelSafe(prevTriggeredBy, rec.triggeredBy),
+      estimatedImpact: computeEstimatedImpact(rec)
+    };
+    if (dependsOn) dispatched.dependsOn = dependsOn;
+    return dispatched;
+  });
+  return {
+    context: {
+      changeType,
+      domains,
+      signalCount: allSignals.length,
+      snapshotFreshness: context.snapshotFreshness
+    },
+    skills,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function dispatchSkillsFromGit(projectPath, options = {}) {
+  const diffInfo = buildDiffInfoFromGit(projectPath);
+  if (diffInfo === null) {
+    throw new Error("dispatch_skills requires a git repository");
+  }
+  if (diffInfo.changedFiles.length === 0) {
+    const commitMessage2 = getLatestCommitMessage(projectPath);
+    const changeType = commitMessage2 ? detectChangeType(commitMessage2, diffInfo) : "feature";
+    return {
+      context: { changeType, domains: [], signalCount: 0, snapshotFreshness: "cached" },
+      skills: [],
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const commitMessage = getLatestCommitMessage(projectPath);
+  const files = diffInfo.changedFiles;
+  const enrichOpts = { files };
+  if (commitMessage) enrichOpts.commitMessage = commitMessage;
+  if (options.fresh) enrichOpts.fresh = options.fresh;
+  const ctx = await enrichSnapshotForDispatch(projectPath, enrichOpts);
+  const dispatchOpts = {};
+  if (options.limit !== void 0) dispatchOpts.limit = options.limit;
+  return dispatchSkills(ctx, dispatchOpts);
+}
+
+// src/mcp/tools/dispatch-skills.ts
+var dispatchSkillsDefinition = {
+  name: "dispatch_skills",
+  description: "Recommend an optimal skill sequence based on what changed in the codebase. Combines health signals with change-type and domain detection from git diffs. Returns an annotated sequence with parallel-safe flags, estimated impact, and dependency info.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Project root path (defaults to cwd)"
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Changed file paths (auto-detected from git diff if omitted)"
+      },
+      commitMessage: {
+        type: "string",
+        description: "Commit message for change-type detection (auto-detected from git log if omitted)"
+      },
+      fresh: {
+        type: "boolean",
+        description: "Force a fresh health snapshot capture (default: false, uses cached)"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of skills to return (default: 5)"
+      }
+    },
+    required: []
+  }
+};
+function buildEnrichOpts(files, commitMessage, fresh) {
+  const opts = {};
+  if (files) opts.files = files;
+  if (commitMessage) opts.commitMessage = commitMessage;
+  if (fresh) opts.fresh = fresh;
+  return opts;
+}
+async function dispatchWithExplicitInput(projectRoot, files, commitMessage, fresh, limit) {
+  const ctx = await enrichSnapshotForDispatch(
+    projectRoot,
+    buildEnrichOpts(files, commitMessage, fresh)
+  );
+  const dispatchOpts = {};
+  if (limit !== 5) dispatchOpts.limit = limit;
+  return dispatchSkills(ctx, dispatchOpts);
+}
+async function dispatchFromGit(projectRoot, fresh, limit) {
+  const opts = {};
+  if (fresh) opts.fresh = fresh;
+  if (limit !== 5) opts.limit = limit;
+  return dispatchSkillsFromGit(projectRoot, opts);
+}
+async function handleDispatchSkills(input) {
+  const projectRoot = input.path || process.cwd();
+  const files = input.files;
+  const commitMessage = input.commitMessage;
+  const fresh = input.fresh ?? false;
+  const limit = input.limit ?? 5;
+  try {
+    const hasExplicitInput = files !== void 0 || commitMessage !== void 0;
+    const result = hasExplicitInput ? await dispatchWithExplicitInput(projectRoot, files, commitMessage, fresh, limit) : await dispatchFromGit(projectRoot, fresh, limit);
+    if (result.skills.length > limit) {
+      result.skills = result.skills.slice(0, limit);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown dispatch error";
+    return { content: [{ type: "text", text: JSON.stringify({ error: message }, null, 2) }] };
+  }
+}
+
+// src/mcp/tools/decay-trends.ts
+var getDecayTrendsDefinition = {
+  name: "get_decay_trends",
+  description: 'Get architecture decay trends over time. Returns stability score history and per-category trend analysis from timeline snapshots. Use to answer questions like "is the architecture decaying?" or "which metrics are getting worse?"',
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      last: {
+        type: "number",
+        description: "Number of recent snapshots to analyze (default: 10)"
+      },
+      since: {
+        type: "string",
+        description: "Show trends since this ISO date (e.g., 2026-01-01)"
+      },
+      category: {
+        type: "string",
+        description: "Filter to a single metric category",
+        enum: [
+          "circular-deps",
+          "layer-violations",
+          "complexity",
+          "coupling",
+          "forbidden-imports",
+          "module-size",
+          "dependency-depth"
+        ]
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleGetDecayTrends(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const core = await import("./dist-MKWF5CXR.js");
+    const { TimelineManager } = core;
+    const manager = new TimelineManager(projectPath);
+    const timeline = manager.load();
+    if (timeline.snapshots.length === 0) {
       return {
         content: [
           {
@@ -5195,7 +5884,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-YIKUBJLQ.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-MKWF5CXR.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -5275,7 +5964,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-YIKUBJLQ.js");
+    const { searchSymbols } = await import("./dist-MKWF5CXR.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) {
@@ -5344,7 +6033,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-YIKUBJLQ.js");
+      const { unfoldSymbol } = await import("./dist-MKWF5CXR.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}
@@ -5352,7 +6041,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-YIKUBJLQ.js");
+      const { unfoldRange } = await import("./dist-MKWF5CXR.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -5414,7 +6103,7 @@ async function handleCheckTraceability(input) {
         isError: true
       };
     }
-    const { queryTraceability } = await import("./dist-OEXTQQZC.js");
+    const { queryTraceability } = await import("./dist-WU3TVNNG.js");
     const options = {};
     if (input.spec) options.specPath = input.spec;
     if (input.feature) options.featureName = input.feature;
@@ -5537,7 +6226,7 @@ async function handlePredictFailures(input) {
     };
   }
   try {
-    const core = await import("./dist-YIKUBJLQ.js");
+    const core = await import("./dist-MKWF5CXR.js");
     const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
     const manager = new TimelineManager(projectPath);
     const includeRoadmap = input.includeRoadmap !== false;
@@ -5570,250 +6259,6 @@ async function handlePredictFailures(input) {
   }
 }
 
-// src/skill/recommendation-rules.ts
-var FALLBACK_RULES = {
-  "enforce-architecture": [
-    { signal: "circular-deps", hard: true },
-    { signal: "layer-violations", hard: true },
-    { signal: "high-coupling", metric: "fanOut", threshold: 20, weight: 0.8 },
-    { signal: "high-coupling", metric: "couplingRatio", threshold: 0.7, weight: 0.6 }
-  ],
-  "dependency-health": [
-    { signal: "high-coupling", metric: "fanOut", threshold: 15, weight: 0.7 },
-    { signal: "anomaly-outlier", weight: 0.6 },
-    { signal: "articulation-point", weight: 0.5 }
-  ],
-  tdd: [{ signal: "low-coverage", weight: 0.9 }],
-  "codebase-cleanup": [
-    { signal: "dead-code", weight: 0.8 },
-    { signal: "drift", weight: 0.6 }
-  ],
-  "security-scan": [{ signal: "security-findings", hard: true }],
-  refactoring: [
-    { signal: "high-complexity", metric: "cyclomaticComplexity", threshold: 15, weight: 0.8 },
-    { signal: "high-coupling", metric: "couplingRatio", threshold: 0.5, weight: 0.6 }
-  ],
-  "detect-doc-drift": [
-    { signal: "doc-gaps", weight: 0.7 },
-    { signal: "drift", weight: 0.5 }
-  ],
-  perf: [{ signal: "perf-regression", weight: 0.8 }],
-  "supply-chain-audit": [{ signal: "security-findings", weight: 0.6 }],
-  "code-review": [
-    { signal: "high-complexity", weight: 0.5 },
-    { signal: "high-coupling", weight: 0.4 }
-  ],
-  integrity: [
-    { signal: "drift", weight: 0.7 },
-    { signal: "dead-code", weight: 0.5 }
-  ],
-  "soundness-review": [
-    { signal: "layer-violations", weight: 0.6 },
-    { signal: "circular-deps", weight: 0.5 }
-  ],
-  debugging: [
-    { signal: "perf-regression", weight: 0.5 },
-    { signal: "anomaly-outlier", weight: 0.6 }
-  ],
-  "hotspot-detector": [
-    { signal: "high-complexity", metric: "cyclomaticComplexity", threshold: 20, weight: 0.9 },
-    { signal: "anomaly-outlier", weight: 0.7 },
-    { signal: "articulation-point", weight: 0.8 }
-  ],
-  "cleanup-dead-code": [{ signal: "dead-code", hard: true }]
-};
-
-// src/skill/recommendation-engine.ts
-function resolveMetricValue(metrics, metricName) {
-  switch (metricName) {
-    case "fanOut":
-      return metrics.maxFanOut;
-    case "couplingRatio":
-      return metrics.avgCouplingRatio;
-    case "cyclomaticComplexity":
-      return metrics.maxCyclomaticComplexity;
-    case "coverage":
-      return metrics.testCoverage !== null ? 100 - metrics.testCoverage : null;
-    default:
-      return null;
-  }
-}
-function buildSkillAddressIndex(skills) {
-  const index = /* @__PURE__ */ new Map();
-  for (const [name, entry] of Object.entries(skills)) {
-    const addresses = entry.addresses.length > 0 ? entry.addresses : FALLBACK_RULES[name] ?? [];
-    index.set(name, { addresses, dependsOn: entry.dependsOn });
-  }
-  for (const [name, addresses] of Object.entries(FALLBACK_RULES)) {
-    if (!index.has(name)) {
-      index.set(name, { addresses, dependsOn: [] });
-    }
-  }
-  return index;
-}
-function matchHardRules(snapshot, skillIndex) {
-  const activeSignals = new Set(snapshot.signals);
-  const results = [];
-  for (const [skillName, entry] of skillIndex) {
-    const hardAddresses = entry.addresses.filter((a) => a.hard === true);
-    const matchedSignals = [];
-    const reasons = [];
-    for (const addr of hardAddresses) {
-      if (activeSignals.has(addr.signal)) {
-        matchedSignals.push(addr.signal);
-        reasons.push(`[CRITICAL] Signal '${addr.signal}' is active`);
-      }
-    }
-    if (matchedSignals.length > 0) {
-      results.push({
-        skillName,
-        score: 1,
-        urgency: "critical",
-        reasons,
-        sequence: 0,
-        // assigned later by sequencer
-        triggeredBy: matchedSignals
-      });
-    }
-  }
-  return results;
-}
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-var DEFAULT_WEIGHT = 0.5;
-function scoreByHealth(snapshot, skillIndex) {
-  const activeSignals = new Set(snapshot.signals);
-  const results = [];
-  for (const [skillName, entry] of skillIndex) {
-    const softAddresses = entry.addresses.filter((a) => !a.hard);
-    const contributions = [];
-    const triggeredBy = [];
-    const reasons = [];
-    for (const addr of softAddresses) {
-      if (!activeSignals.has(addr.signal)) continue;
-      const weight = addr.weight ?? DEFAULT_WEIGHT;
-      if (addr.metric && addr.threshold !== void 0) {
-        const actual = resolveMetricValue(snapshot.metrics, addr.metric);
-        if (actual === null) continue;
-        const distance = clamp((actual - addr.threshold) / addr.threshold, 0, 1);
-        const contribution = weight * distance;
-        contributions.push(contribution);
-        triggeredBy.push(addr.signal);
-        reasons.push(
-          `${addr.metric} = ${actual} (threshold ${addr.threshold}, distance ${distance.toFixed(2)})`
-        );
-      } else {
-        contributions.push(weight);
-        triggeredBy.push(addr.signal);
-        reasons.push(`Signal '${addr.signal}' is active (weight ${weight})`);
-      }
-    }
-    if (contributions.length === 0) continue;
-    const score = clamp(contributions.reduce((sum, c) => sum + c, 0) / contributions.length, 0, 1);
-    const urgency = score >= 0.7 ? "recommended" : "nice-to-have";
-    results.push({
-      skillName,
-      score: Math.round(score * 1e3) / 1e3,
-      // round to 3 decimal places
-      urgency,
-      reasons,
-      sequence: 0,
-      triggeredBy: [...new Set(triggeredBy)]
-    });
-  }
-  return results;
-}
-var DIAGNOSTIC_KEYWORDS = ["health", "detect", "analyze", "audit", "hotspot", "debugging"];
-var FIX_KEYWORDS = ["enforce", "cleanup", "fix", "refactor", "codebase"];
-var VALIDATION_KEYWORDS = ["verify", "test", "tdd", "review", "soundness", "integrity"];
-function classifyPhase(skillName) {
-  const lower = skillName.toLowerCase();
-  if (DIAGNOSTIC_KEYWORDS.some((kw) => lower.includes(kw))) return 0;
-  if (FIX_KEYWORDS.some((kw) => lower.includes(kw))) return 1;
-  if (VALIDATION_KEYWORDS.some((kw) => lower.includes(kw))) return 2;
-  return 3;
-}
-function heuristicComparator(recMap) {
-  return (a, b) => {
-    const phaseA = classifyPhase(a);
-    const phaseB = classifyPhase(b);
-    if (phaseA !== phaseB) return phaseA - phaseB;
-    return (recMap.get(b)?.score ?? 0) - (recMap.get(a)?.score ?? 0);
-  };
-}
-function buildDepGraph(nameSet, skillDeps) {
-  const inDegree = /* @__PURE__ */ new Map();
-  const adjacency = /* @__PURE__ */ new Map();
-  for (const name of nameSet) {
-    inDegree.set(name, 0);
-    adjacency.set(name, []);
-  }
-  for (const name of nameSet) {
-    for (const dep of skillDeps.get(name) ?? []) {
-      if (!nameSet.has(dep)) continue;
-      adjacency.get(dep).push(name);
-      inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
-    }
-  }
-  return { inDegree, adjacency };
-}
-function sequenceRecommendations(recommendations, skillDeps) {
-  if (recommendations.length === 0) return [];
-  const nameSet = new Set(recommendations.map((r) => r.skillName));
-  const recMap = new Map(recommendations.map((r) => [r.skillName, r]));
-  const compare = heuristicComparator(recMap);
-  const { inDegree, adjacency } = buildDepGraph(nameSet, skillDeps);
-  const sorted = [];
-  let sequence = 1;
-  let queue = [...nameSet].filter((n) => (inDegree.get(n) ?? 0) === 0).sort(compare);
-  while (queue.length > 0) {
-    const nextQueue = [];
-    for (const name of queue) {
-      const rec = recMap.get(name);
-      rec.sequence = sequence++;
-      sorted.push(rec);
-      for (const dependent of adjacency.get(name) ?? []) {
-        const newDeg = (inDegree.get(dependent) ?? 1) - 1;
-        inDegree.set(dependent, newDeg);
-        if (newDeg === 0) nextQueue.push(dependent);
-      }
-    }
-    queue = nextQueue.sort(compare);
-  }
-  return sorted;
-}
-function recommend(snapshot, skills, options = {}) {
-  const top = options.top ?? 5;
-  if (snapshot.signals.length === 0) {
-    return {
-      recommendations: [],
-      snapshotAge: "none",
-      sequenceReasoning: "No active signals detected in health snapshot."
-    };
-  }
-  const addressIndex = buildSkillAddressIndex(skills);
-  const hardRecs = matchHardRules(snapshot, addressIndex);
-  const softRecs = scoreByHealth(snapshot, addressIndex);
-  const hardSkills = new Set(hardRecs.map((r) => r.skillName));
-  const merged = [...hardRecs, ...softRecs.filter((r) => !hardSkills.has(r.skillName))];
-  merged.sort((a, b) => b.score - a.score);
-  const limited = merged.slice(0, top);
-  const depMap = /* @__PURE__ */ new Map();
-  for (const [name, entry] of addressIndex) {
-    depMap.set(name, entry.dependsOn);
-  }
-  const sequenced = sequenceRecommendations(limited, depMap);
-  const criticalCount = sequenced.filter((r) => r.urgency === "critical").length;
-  const phases = sequenced.map((r) => `${r.sequence}. ${r.skillName}`).join(" -> ");
-  const reasoning = criticalCount > 0 ? `${criticalCount} critical issue(s) detected. Sequence: ${phases}. Critical items first, then diagnostic -> fix -> validate heuristic.` : `Sequence: ${phases}. Ordered by dependencies and diagnostic -> fix -> validate heuristic.`;
-  return {
-    recommendations: sequenced,
-    snapshotAge: "fresh",
-    sequenceReasoning: reasoning
-  };
-}
-
 // src/mcp/tools/recommend-skills.ts
 var recommendSkillsDefinition = {
   name: "recommend_skills",
@@ -5929,7 +6374,9 @@ var TOOL_DEFINITIONS = [
   getDecayTrendsDefinition,
   checkTraceabilityDefinition,
   predictFailuresDefinition,
-  recommendSkillsDefinition
+  recommendSkillsDefinition,
+  computeBlastRadiusDefinition,
+  dispatchSkillsDefinition
 ].map((def) => ({ ...def, trustedOutput: true }));
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -5984,7 +6431,9 @@ var TOOL_HANDLERS = {
   get_decay_trends: handleGetDecayTrends,
   check_traceability: handleCheckTraceability,
   predict_failures: handlePredictFailures,
-  recommend_skills: handleRecommendSkills
+  recommend_skills: handleRecommendSkills,
+  compute_blast_radius: handleComputeBlastRadius,
+  dispatch_skills: handleDispatchSkills
 };
 var RESOURCE_DEFINITIONS = [
   {
@@ -6070,7 +6519,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-YIKUBJLQ.js");
+    } = await import("./dist-MKWF5CXR.js");
     const { CLI_VERSION } = await import("./version-KFFPOQAX.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;
@@ -6147,17 +6596,18 @@ async function startServer(toolFilter) {
 }
 
 export {
-  persistToolingConfig,
-  appendFrameworkAgents,
   generateSlashCommands,
   handleOrphanDeletion,
   createGenerateSlashCommandsCommand,
-  loadOrRebuildIndex,
   handleGetImpact,
+  persistToolingConfig,
+  appendFrameworkAgents,
+  loadOrRebuildIndex,
   isSnapshotFresh,
   loadCachedSnapshot,
   captureHealthSnapshot,
   recommend,
+  dispatchSkillsFromGit,
   getToolDefinitions,
   createHarnessServer,
   startServer