@harness-engineering/cli 1.21.0 → 1.22.0

package/dist/{chunk-TMSGI27F.js → chunk-DJEBBENF.js}

@@ -1,7 +1,7 @@
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-WXI5ONCU.js";
+} from "./chunk-IK5GSLW6.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -11,7 +11,7 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-UVJFBKCX.js";
+} from "./chunk-FSLFBLYW.js";
 import {
   analyzeDiffDefinition,
   createSelfReviewDefinition,
@@ -19,15 +19,19 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-6GEYPBDU.js";
+} from "./chunk-ZEIEUCZL.js";
 import {
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-H6LXAH66.js";
+} from "./chunk-DXYOAQQC.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition
-} from "./chunk-L6LTNZQZ.js";
+} from "./chunk-B4WHXHF7.js";
+import {
+  assessProjectDefinition,
+  handleAssessProject
+} from "./chunk-5FBWWMY2.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_CODEX,
@@ -40,25 +44,25 @@ import {
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-SPUK5W4W.js";
+} from "./chunk-J7W4LTRK.js";
 import {
   loadGraphStore
-} from "./chunk-CZZXE6BL.js";
+} from "./chunk-ASS5TD2Y.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-HUDEBSR2.js";
+} from "./chunk-W6MPLFXU.js";
 import {
   resolveProjectConfig
 } from "./chunk-H7Y5CKTM.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-YF5ROTWR.js";
+} from "./chunk-5QTWFO24.js";
 import {
   TrackerConfigSchema,
   resolveConfig
-} from "./chunk-SZ5TGZMI.js";
+} from "./chunk-GRJ7A4WT.js";
 import {
   resultToMcpResponse
 } from "./chunk-IDZNPTYD.js";
@@ -81,13 +85,13 @@ import {
 } from "./chunk-3WGJMBKH.js";
 import {
   SkillMetadataSchema
-} from "./chunk-HKUX2X7O.js";
+} from "./chunk-SE4YPMLH.js";
 import {
   DESTRUCTIVE_BASH,
   checkTaint,
   scanForInjection,
   writeTaint
-} from "./chunk-YZYBQZVL.js";
+} from "./chunk-U44JNY3Y.js";
 import {
   Err,
   Ok
@@ -557,7 +561,7 @@ ${skippedMsg}`
 async function handleInitProject(input) {
   const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-EOXMI5MD.js");
+    const { TemplateEngine } = await import("./engine-4MY2U5RZ.js");
     const engine = new TemplateEngine(resolveTemplatesDir());
     const safePath = sanitizePath(i.path);
     const detected = tryDetectFramework(engine, safePath, i);
@@ -578,7 +582,7 @@ var listPersonasDefinition = {
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-7S4FYAPP.js");
+  const { listPersonas } = await import("./loader-AV5XEMER.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -602,10 +606,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-7S4FYAPP.js");
-  const { generateRuntime } = await import("./runtime-XKOHGGRC.js");
-  const { generateAgentsMd } = await import("./agents-md-TDTLYAQU.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-Z4IUJBZL.js");
+  const { loadPersona } = await import("./loader-AV5XEMER.js");
+  const { generateRuntime } = await import("./runtime-KQTJRK3H.js");
+  const { generateAgentsMd } = await import("./agents-md-PM7LO74M.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-OTTEERPF.js");
   const personasDir = resolvePersonasDir();
   const filePath = path3.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -660,9 +664,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-7S4FYAPP.js");
+  const { loadPersona } = await import("./loader-AV5XEMER.js");
   const { runPersona } = await import("./runner-VMYLHWOC.js");
-  const { executeSkill } = await import("./skill-executor-XEVDGXUM.js");
+  const { executeSkill } = await import("./skill-executor-2BZQLHYN.js");
   const personasDir = resolvePersonasDir();
   const filePath = path3.join(personasDir, `${input.persona}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -842,7 +846,26 @@ var TIER_1_SKILLS = /* @__PURE__ */ new Set([
 function isTier1Skill(skillName) {
   return TIER_1_SKILLS.has(skillName);
 }
-function scoreSkill(entry, queryTerms, profile, recentFiles, skillName) {
+function computeHealthScore(entry, snapshot) {
+  if (entry.addresses.length === 0) return 0;
+  const activeSignals = new Set(snapshot.signals);
+  const hasWeights = entry.addresses.some((a) => a.weight !== void 0);
+  if (hasWeights) {
+    let totalWeight = 0;
+    let matchedWeight = 0;
+    for (const addr of entry.addresses) {
+      const w = addr.weight ?? 0.5;
+      totalWeight += w;
+      if (activeSignals.has(addr.signal)) {
+        matchedWeight += w;
+      }
+    }
+    return totalWeight > 0 ? matchedWeight / totalWeight : 0;
+  }
+  const matched = entry.addresses.filter((a) => activeSignals.has(a.signal)).length;
+  return matched / entry.addresses.length;
+}
+function scoreSkill(entry, queryTerms, profile, recentFiles, skillName, healthSnapshot) {
   const matchedKeywords = entry.keywords.filter(
     (kw) => queryTerms.some(
       (term) => kw.toLowerCase().includes(term.toLowerCase()) || term.toLowerCase().includes(kw.toLowerCase())
@@ -881,7 +904,12 @@ function scoreSkill(entry, queryTerms, profile, recentFiles, skillName) {
     });
     recencyBoost = hasRecentMatch ? 1 : 0;
   }
-  return 0.35 * keywordScore + 0.2 * nameScore + 0.1 * descScore + 0.2 * stackScore + 0.15 * recencyBoost;
+  let score = 0.35 * keywordScore + 0.2 * nameScore + 0.1 * descScore + 0.2 * stackScore + 0.15 * recencyBoost;
+  if (healthSnapshot) {
+    const healthScore = computeHealthScore(entry, healthSnapshot);
+    score = 0.7 * score + 0.3 * healthScore;
+  }
+  return score;
 }
 function suggest(index, taskDescription, profile, recentFiles, config) {
   const queryTerms = taskDescription.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
@@ -950,7 +978,9 @@ function parseSkillEntry(yamlPath, source, tierOverrides) {
     stackSignals: meta.stack_signals ?? [],
     cognitiveMode: meta.cognitive_mode,
     phases: (meta.phases ?? []).map((p) => p.name),
-    source
+    source,
+    addresses: meta.addresses ?? [],
+    dependsOn: meta.depends_on ?? []
   };
 }
 function scanDirectory(dir, source, index, tierOverrides) {
@@ -1174,7 +1204,7 @@ var createSkillDefinition = {
 };
 async function handleCreateSkill(input) {
   try {
-    const { generateSkillFiles } = await import("./create-skill-NDXQSTIK.js");
+    const { generateSkillFiles } = await import("./create-skill-U3XCFRZN.js");
     const result = generateSkillFiles({
       name: input.name,
       description: input.description,
@@ -1292,7 +1322,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-KV2ICL5X.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-LCR2IO7U.js");
     const raw = fs10.readFileSync(roadmapFile, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) return;
@@ -1319,7 +1349,7 @@ async function triggerExternalSync(projectPath, roadmapFile) {
     }
     const token = process.env.GITHUB_TOKEN;
     if (!token) return;
-    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-KV2ICL5X.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-LCR2IO7U.js");
     const adapter = new GitHubIssuesSyncAdapter({
       token,
       config: trackerConfig
@@ -1431,12 +1461,12 @@ var manageStateDefinition = {
   }
 };
 async function handleShow(projectPath, input) {
-  const { loadState } = await import("./dist-KV2ICL5X.js");
+  const { loadState } = await import("./dist-LCR2IO7U.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-KV2ICL5X.js");
+  const { appendLearning } = await import("./dist-LCR2IO7U.js");
   const result = await appendLearning(
     projectPath,
     input.learning,
@@ -1451,7 +1481,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-KV2ICL5X.js");
+  const { appendFailure } = await import("./dist-LCR2IO7U.js");
   const result = await appendFailure(
     projectPath,
     input.description,
@@ -1464,24 +1494,24 @@ async function handleFailure(projectPath, input) {
   return resultToMcpResponse(Ok({ recorded: true }));
 }
 async function handleArchive(projectPath, input) {
-  const { archiveFailures } = await import("./dist-KV2ICL5X.js");
+  const { archiveFailures } = await import("./dist-LCR2IO7U.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-KV2ICL5X.js");
+  const { saveState, DEFAULT_STATE } = await import("./dist-LCR2IO7U.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-KV2ICL5X.js");
+  const { runMechanicalGate } = await import("./dist-LCR2IO7U.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-KV2ICL5X.js");
+  const { saveHandoff } = await import("./dist-LCR2IO7U.js");
   const result = await saveHandoff(
     projectPath,
     input.handoff,
@@ -1493,7 +1523,7 @@ async function handleSaveHandoff(projectPath, input) {
   return resultToMcpResponse(Ok({ saved: true }));
 }
 async function handleLoadHandoff(projectPath, input) {
-  const { loadHandoff } = await import("./dist-KV2ICL5X.js");
+  const { loadHandoff } = await import("./dist-LCR2IO7U.js");
   return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
 }
 async function handleAppendEntry(projectPath, input) {
@@ -1501,7 +1531,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-KV2ICL5X.js");
+  const { appendSessionEntry } = await import("./dist-LCR2IO7U.js");
   const result = await appendSessionEntry(
     projectPath,
     input.session,
@@ -1517,7 +1547,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-KV2ICL5X.js");
+  const { updateSessionEntryStatus } = await import("./dist-LCR2IO7U.js");
   const result = await updateSessionEntryStatus(
     projectPath,
     input.session,
@@ -1530,7 +1560,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-KV2ICL5X.js");
+  const { readSessionSection } = await import("./dist-LCR2IO7U.js");
   const result = await readSessionSection(
     projectPath,
     input.session,
@@ -1540,13 +1570,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-KV2ICL5X.js");
+  const { readSessionSections } = await import("./dist-LCR2IO7U.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-KV2ICL5X.js");
+  const { archiveSession } = await import("./dist-LCR2IO7U.js");
   const result = await archiveSession(projectPath, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   await autoSyncRoadmap(projectPath);
@@ -1610,7 +1640,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-KV2ICL5X.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-LCR2IO7U.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -1648,7 +1678,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-I4NQOCSU.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-7JQ6EW5R.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -1704,7 +1734,7 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-PFRKABCS.js");
+    const { runCrossCheck } = await import("./validate-cross-check-VX2BAHQI.js");
     const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
@@ -2349,7 +2379,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-KV2ICL5X.js");
+    const { loadState, migrateToStreams } = await import("./dist-LCR2IO7U.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -2437,7 +2467,7 @@ async function handleQueryGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-U7EAO6T2.js");
+    const { ContextQL } = await import("./dist-IA6XYKNO.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -2528,7 +2558,7 @@ async function handleSearchSimilar(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer } = await import("./dist-U7EAO6T2.js");
+    const { FusionLayer } = await import("./dist-IA6XYKNO.js");
     const fusion = new FusionLayer(store);
     const results = fusion.search(input.query, input.topK ?? 10);
     if (input.mode === "summary") {
@@ -2583,7 +2613,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-U7EAO6T2.js");
+    const { FusionLayer, ContextQL } = await import("./dist-IA6XYKNO.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -2679,7 +2709,7 @@ async function handleGetRelationships(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-U7EAO6T2.js");
+    const { ContextQL } = await import("./dist-IA6XYKNO.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -2785,7 +2815,7 @@ async function handleGetImpact(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-U7EAO6T2.js");
+    const { ContextQL } = await import("./dist-IA6XYKNO.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -2917,9 +2947,9 @@ async function handleIngestSource(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const graphDir = path16.join(projectPath, ".harness", "graph");
-    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-U7EAO6T2.js");
-    const fs16 = await import("fs/promises");
-    await fs16.mkdir(graphDir, { recursive: true });
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-IA6XYKNO.js");
+    const fs17 = await import("fs/promises");
+    await fs17.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -2992,7 +3022,7 @@ async function handleDetectAnomalies(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { GraphAnomalyAdapter } = await import("./dist-U7EAO6T2.js");
+    const { GraphAnomalyAdapter } = await import("./dist-IA6XYKNO.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -3032,7 +3062,7 @@ async function handleAskGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { askGraph } = await import("./dist-U7EAO6T2.js");
+    const { askGraph } = await import("./dist-IA6XYKNO.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -3168,7 +3198,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-QICSCGXB.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-KU6X2UQN.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -3463,32 +3493,42 @@ function handleSync(projectPath, input, deps) {
   }
   return resultToMcpResponse(Ok2({ changes, applied: false }));
 }
+var readOnlyActions = /* @__PURE__ */ new Set(["show", "query"]);
+function dispatchAction(action, projectPath, input, deps) {
+  switch (action) {
+    case "show":
+      return handleShow2(projectPath, input, deps);
+    case "add":
+      return handleAdd(projectPath, input, deps);
+    case "update":
+      return handleUpdate(projectPath, input, deps);
+    case "remove":
+      return handleRemove(projectPath, input, deps);
+    case "query":
+      return handleQuery(projectPath, input, deps);
+    case "sync":
+      return handleSync(projectPath, input, deps);
+    default:
+      return { content: [{ type: "text", text: `Error: unknown action` }], isError: true };
+  }
+}
+function shouldTriggerExternalSync(input, response) {
+  if (response.isError || readOnlyActions.has(input.action)) return false;
+  if (input.action === "sync") return input.apply === true;
+  return true;
+}
 async function handleManageRoadmap(input) {
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-KV2ICL5X.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-LCR2IO7U.js");
     const { Ok: Ok2 } = await import("./dist-USY2C5JL.js");
     const projectPath = sanitizePath(input.path);
     const deps = { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, Ok: Ok2 };
-    switch (input.action) {
-      case "show":
-        return handleShow2(projectPath, input, deps);
-      case "add":
-        return handleAdd(projectPath, input, deps);
-      case "update":
-        return handleUpdate(projectPath, input, deps);
-      case "remove":
-        return handleRemove(projectPath, input, deps);
-      case "query":
-        return handleQuery(projectPath, input, deps);
-      case "sync":
-        return handleSync(projectPath, input, deps);
-      default: {
-        return {
-          content: [{ type: "text", text: `Error: unknown action` }],
-          isError: true
-        };
-      }
+    const response = dispatchAction(input.action, projectPath, input, deps);
+    if (shouldTriggerExternalSync(input, response)) {
+      await triggerExternalSync(projectPath, roadmapPath(projectPath)).catch(() => {
+      });
     }
+    return response;
   } catch (error) {
     return {
       content: [
@@ -3907,7 +3947,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-KV2ICL5X.js");
+    const { saveHandoff } = await import("./dist-LCR2IO7U.js");
     await saveHandoff(
       projectPath,
       {
@@ -3975,7 +4015,7 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-KV2ICL5X.js");
+    const { loadState, saveState } = await import("./dist-LCR2IO7U.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -4064,10 +4104,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-KV2ICL5X.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-LCR2IO7U.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-KV2ICL5X.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-LCR2IO7U.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -4076,14 +4116,14 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-KV2ICL5X.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-LCR2IO7U.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-KMHDQYDT.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-FJN4H7Y4.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return null;
-    const { FusionLayer, ContextQL } = await import("./dist-U7EAO6T2.js");
+    const { FusionLayer, ContextQL } = await import("./dist-IA6XYKNO.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -4120,11 +4160,11 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-KV2ICL5X.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-LCR2IO7U.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-KV2ICL5X.js").then(async (core) => {
+  const eventsPromise = shouldIncludeEvents ? import("./dist-LCR2IO7U.js").then(async (core) => {
     const result = await core.loadEvents(projectPath, {
       session: input.session
     });
@@ -4132,7 +4172,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-VHFE6J6O.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-4IA5RPEX.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -4226,7 +4266,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-KV2ICL5X.js");
+      const core = await import("./dist-LCR2IO7U.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -4248,291 +4288,6 @@ async function handleGatherContext(input) {
   };
 }
 
-// src/mcp/tools/assess-project.ts
-var assessProjectDefinition = {
-  name: "assess_project",
-  description: "Run all project health checks in parallel and return a unified report. Checks: validate, dependencies, docs, entropy, security, performance, lint.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      path: { type: "string", description: "Path to project root" },
-      checks: {
-        type: "array",
-        items: {
-          type: "string",
-          enum: ["validate", "deps", "docs", "entropy", "security", "perf", "lint"]
-        },
-        description: "Which checks to run (default: all)"
-      },
-      mode: {
-        type: "string",
-        enum: ["summary", "detailed"],
-        description: "Response density. Default: summary"
-      }
-    },
-    required: ["path"]
-  }
-};
-async function handleAssessProject(input) {
-  const start = Date.now();
-  let projectPath;
-  try {
-    projectPath = sanitizePath(input.path);
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
-  }
-  const checksToRun = new Set(
-    input.checks ?? ["validate", "deps", "docs", "entropy", "security", "perf", "lint"]
-  );
-  const mode = input.mode ?? "summary";
-  let validateResult = null;
-  if (checksToRun.has("validate")) {
-    try {
-      const { handleValidateProject: handleValidateProject2 } = await import("./validate-VHFE6J6O.js");
-      const result = await handleValidateProject2({ path: projectPath });
-      const first = result.content[0];
-      const parsed = first ? JSON.parse(first.text) : {};
-      validateResult = {
-        name: "validate",
-        passed: parsed.valid === true,
-        issueCount: parsed.errors?.length ?? 0,
-        ...parsed.errors?.length > 0 ? { topIssue: parsed.errors[0] } : {},
-        ...mode === "detailed" ? { detailed: parsed } : {}
-      };
-    } catch (error) {
-      validateResult = {
-        name: "validate",
-        passed: false,
-        issueCount: 1,
-        topIssue: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  const parallelChecks = [];
-  if (checksToRun.has("deps")) {
-    parallelChecks.push(
-      (async () => {
-        try {
-          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-NANP4XPE.js");
-          const result = await handleCheckDependencies2({ path: projectPath });
-          const first = result.content[0];
-          const parsed = first ? JSON.parse(first.text) : {};
-          const violations = parsed.violations ?? [];
-          return {
-            name: "deps",
-            passed: !result.isError && violations.length === 0,
-            issueCount: violations.length,
-            ...violations.length > 0 ? { topIssue: violations[0]?.message ?? String(violations[0]) } : {},
-            ...mode === "detailed" ? { detailed: parsed } : {}
-          };
-        } catch (error) {
-          return {
-            name: "deps",
-            passed: false,
-            issueCount: 1,
-            topIssue: error instanceof Error ? error.message : String(error)
-          };
-        }
-      })()
-    );
-  }
-  if (checksToRun.has("docs")) {
-    parallelChecks.push(
-      (async () => {
-        try {
-          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-2PCZVSGB.js");
-          const result = await handleCheckDocs2({ path: projectPath, scope: "coverage" });
-          const first = result.content[0];
-          const parsed = first ? JSON.parse(first.text) : {};
-          const undocumented = parsed.undocumented ?? parsed.files?.undocumented ?? [];
-          return {
-            name: "docs",
-            passed: !result.isError,
-            issueCount: Array.isArray(undocumented) ? undocumented.length : 0,
-            ...Array.isArray(undocumented) && undocumented.length > 0 ? { topIssue: `Undocumented: ${undocumented[0]}` } : {},
-            ...mode === "detailed" ? { detailed: parsed } : {}
-          };
-        } catch (error) {
-          return {
-            name: "docs",
-            passed: false,
-            issueCount: 1,
-            topIssue: error instanceof Error ? error.message : String(error)
-          };
-        }
-      })()
-    );
-  }
-  if (checksToRun.has("entropy")) {
-    parallelChecks.push(
-      (async () => {
-        try {
-          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-VGXXBIGX.js");
-          const result = await handleDetectEntropy2({ path: projectPath, type: "all" });
-          const first = result.content[0];
-          const parsed = first ? JSON.parse(first.text) : {};
-          const issues = (parsed.drift?.staleReferences?.length ?? 0) + (parsed.drift?.missingTargets?.length ?? 0) + (parsed.deadCode?.unusedImports?.length ?? 0) + (parsed.deadCode?.unusedExports?.length ?? 0) + (parsed.patterns?.violations?.length ?? 0);
-          return {
-            name: "entropy",
-            passed: !("isError" in result && result.isError) && issues === 0,
-            issueCount: issues,
-            ...issues > 0 ? { topIssue: "Entropy detected -- run detect_entropy for details" } : {},
-            ...mode === "detailed" ? { detailed: parsed } : {}
-          };
-        } catch (error) {
-          return {
-            name: "entropy",
-            passed: false,
-            issueCount: 1,
-            topIssue: error instanceof Error ? error.message : String(error)
-          };
-        }
-      })()
-    );
-  }
-  if (checksToRun.has("security")) {
-    parallelChecks.push(
-      (async () => {
-        try {
-          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-NLWTMK3G.js");
-          const result = await handleRunSecurityScan2({ path: projectPath });
-          const first = result.content[0];
-          const parsed = first ? JSON.parse(first.text) : {};
-          const findings = parsed.findings ?? [];
-          const errorCount = findings.filter(
-            (f) => f.severity === "error"
-          ).length;
-          return {
-            name: "security",
-            passed: !result.isError && errorCount === 0,
-            issueCount: findings.length,
-            ...findings.length > 0 ? {
-              topIssue: `${findings[0]?.rule ?? findings[0]?.type ?? "finding"}: ${findings[0]?.message ?? ""}`
-            } : {},
-            ...mode === "detailed" ? { detailed: parsed } : {}
-          };
-        } catch (error) {
-          return {
-            name: "security",
-            passed: false,
-            issueCount: 1,
-            topIssue: error instanceof Error ? error.message : String(error)
-          };
-        }
-      })()
-    );
-  }
-  if (checksToRun.has("perf")) {
-    parallelChecks.push(
-      (async () => {
-        try {
-          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-RV4DUMFI.js");
-          const result = await handleCheckPerformance2({ path: projectPath });
-          if ("isError" in result && result.isError) {
-            const msg = result.content[0]?.text ?? "Performance check failed";
-            return { name: "perf", passed: false, issueCount: 1, topIssue: msg };
-          }
-          const first = result.content[0];
-          let parsed = {};
-          try {
-            parsed = first ? JSON.parse(first.text) : {};
-          } catch {
-            return {
-              name: "perf",
-              passed: false,
-              issueCount: 1,
-              topIssue: first?.text ?? "Invalid perf output"
-            };
-          }
-          const issues = parsed.violations?.length ?? parsed.issues?.length ?? 0;
-          return {
-            name: "perf",
-            passed: issues === 0,
-            issueCount: issues,
-            ...issues > 0 ? { topIssue: "Performance issues detected" } : {},
-            ...mode === "detailed" ? { detailed: parsed } : {}
-          };
-        } catch (error) {
-          return {
-            name: "perf",
-            passed: false,
-            issueCount: 1,
-            topIssue: error instanceof Error ? error.message : String(error)
-          };
-        }
-      })()
-    );
-  }
-  if (checksToRun.has("lint")) {
-    parallelChecks.push(
-      (async () => {
-        try {
-          const { execFileSync } = await import("child_process");
-          const output = execFileSync("npx", ["turbo", "run", "lint", "--force"], {
-            cwd: projectPath,
-            encoding: "utf-8",
-            timeout: 6e4,
-            stdio: ["pipe", "pipe", "pipe"]
-          });
-          return {
-            name: "lint",
-            passed: true,
-            issueCount: 0,
-            ...mode === "detailed" ? { detailed: output } : {}
-          };
-        } catch (error) {
-          const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr) : "";
-          const stdout = error && typeof error === "object" && "stdout" in error ? String(error.stdout) : "";
-          const combined = (stderr + "\n" + stdout).trim();
-          const errorMatch = combined.match(/(\d+) error/);
-          const issueCount = errorMatch?.[1] ? parseInt(errorMatch[1], 10) : 1;
-          const firstError = combined.split("\n").find((line) => line.includes("error"));
-          return {
-            name: "lint",
-            passed: false,
-            issueCount,
-            topIssue: firstError?.trim() ?? (error instanceof Error ? error.message : String(error)),
-            ...mode === "detailed" ? { detailed: combined } : {}
-          };
-        }
-      })()
-    );
-  }
-  const parallelResults = await Promise.all(parallelChecks);
-  const allChecks = [];
-  if (validateResult) allChecks.push(validateResult);
-  allChecks.push(...parallelResults);
-  const healthy = allChecks.every((c) => c.passed);
-  const assessedIn = Date.now() - start;
-  if (mode === "summary") {
-    const summaryChecks = allChecks.map(({ detailed: _d, ...rest }) => rest);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ healthy, checks: summaryChecks, assessedIn })
-        }
-      ]
-    };
-  }
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({ healthy, checks: allChecks, assessedIn })
-      }
-    ]
-  };
-}
-
 // src/mcp/tools/review-changes.ts
 var SIZE_GATE_LINES = 1e4;
 var reviewChangesDefinition = {
@@ -4637,7 +4392,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-VTSPL3O7.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-QGCSW7SB.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -4668,7 +4423,7 @@ function extractFileCount(diffParsed) {
   return files?.length ?? 0;
 }
 async function runStandardReview(projectPath, diff, diffLines, downgraded) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-VTSPL3O7.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-QGCSW7SB.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -4700,7 +4455,7 @@ async function runStandardReview(projectPath, diff, diffLines, downgraded) {
   };
 }
 async function runDeepReview(projectPath, diff, diffLines, _downgraded) {
-  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-7KQJB4SI.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-3ZS3GJSP.js");
   const result = await handleRunCodeReview2({ path: projectPath, diff });
   const deepContent = result.content[0];
   if (!deepContent) throw new Error("Empty code review response");
@@ -4771,7 +4526,7 @@ async function handleCheckTaskIndependence(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { TaskIndependenceAnalyzer } = await import("./dist-U7EAO6T2.js");
+    const { TaskIndependenceAnalyzer } = await import("./dist-IA6XYKNO.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -4859,7 +4614,7 @@ async function handlePredictConflicts(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { ConflictPredictor } = await import("./dist-U7EAO6T2.js");
+    const { ConflictPredictor } = await import("./dist-IA6XYKNO.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -4965,7 +4720,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KMHDQYDT.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-FJN4H7Y4.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -4986,7 +4741,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-KV2ICL5X.js");
+    const { detectStaleConstraints } = await import("./dist-LCR2IO7U.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -5013,6 +4768,204 @@ async function handleDetectStaleConstraints(input) {
   }
 }
 
+// src/skill/health-snapshot.ts
+import { execSync } from "child_process";
+import * as fs16 from "fs";
+import * as path19 from "path";
+var CACHE_FILE = "health-snapshot.json";
+var STALENESS_MS = 36e5;
+function isSnapshotFresh(snapshot, projectPath) {
+  try {
+    const currentHead = execSync("git rev-parse HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (snapshot.gitHead === currentHead) return true;
+  } catch {
+  }
+  const age = Date.now() - new Date(snapshot.capturedAt).getTime();
+  return age < STALENESS_MS;
+}
+function loadCachedSnapshot(projectPath) {
+  const filePath = path19.join(projectPath, ".harness", CACHE_FILE);
+  try {
+    const raw = fs16.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveCachedSnapshot(snapshot, projectPath) {
+  const dir = path19.join(projectPath, ".harness");
+  fs16.mkdirSync(dir, { recursive: true });
+  const filePath = path19.join(dir, CACHE_FILE);
+  fs16.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
+}
+var SIGNAL_RULES = [
+  ["circular-deps", (c) => c.deps.circularDeps > 0],
+  ["layer-violations", (c) => c.deps.layerViolations > 0],
+  ["dead-code", (c) => c.entropy.deadExports > 0 || c.entropy.deadFiles > 0],
+  ["drift", (c) => c.entropy.driftCount > 0],
+  ["security-findings", (c) => c.security.findingCount > 0],
+  ["doc-gaps", (c) => c.docs.undocumentedCount > 0],
+  ["perf-regression", (c) => c.perf.violationCount > 0],
+  ["anomaly-outlier", (_c, m) => m.anomalyOutlierCount > 0],
+  ["articulation-point", (_c, m) => m.articulationPointCount > 0],
+  ["high-coupling", (_c, m) => m.avgCouplingRatio > 0.5 || m.maxFanOut > 20],
+  ["high-complexity", (_c, m) => m.maxCyclomaticComplexity > 20 || m.avgCyclomaticComplexity > 10],
+  ["low-coverage", (_c, m) => m.testCoverage !== null && m.testCoverage < 60]
+];
+function deriveSignals(checks, metrics) {
+  const signals = /* @__PURE__ */ new Set();
+  for (const [name, predicate] of SIGNAL_RULES) {
+    if (predicate(checks, metrics)) signals.add(name);
+  }
+  return [...signals];
+}
+var DEFAULT_CHECK = { passed: true, issueCount: 0 };
+function parseToolResult(result) {
+  return JSON.parse(result.content[0]?.text ?? "{}");
+}
+function buildCheckMap(assessData) {
+  const map = /* @__PURE__ */ new Map();
+  const checks = assessData.checks ?? [];
+  for (const c of checks) {
+    map.set(c.name, { passed: c.passed, issueCount: c.issueCount });
+  }
+  return map;
+}
+function countViolations(depsData) {
+  const violations = depsData.violations ?? [];
+  return {
+    circularDeps: violations.filter((v) => v.reason === "CIRCULAR_DEP").length,
+    layerViolations: violations.filter(
+      (v) => v.reason === "WRONG_LAYER" || v.reason === "FORBIDDEN_IMPORT"
+    ).length
+  };
+}
+function parseEntropyGranular(entropyData) {
+  const dc = entropyData.deadCode ?? {};
+  const dr = entropyData.drift ?? {};
+  return {
+    deadExports: dc.unusedExports?.length ?? 0,
+    deadFiles: dc.deadFiles?.length ?? 0,
+    driftCount: (dr.staleReferences?.length ?? 0) + (dr.missingTargets?.length ?? 0)
+  };
+}
+function countCriticalFindings(securityData) {
+  const findings = securityData.findings ?? [];
+  return findings.filter((f) => f.severity === "error").length;
+}
+async function runHealthChecks(projectPath) {
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-R2OZIDDS.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-OVOCDTI6.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-AKSZG7G5.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-LJCLZES6.js");
+  const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
+    handleAssessProject2({
+      path: projectPath,
+      checks: ["deps", "entropy", "security", "perf", "docs", "lint"]
+    }),
+    handleCheckDependencies2({ path: projectPath }),
+    handleDetectEntropy2({ path: projectPath, type: "all" }),
+    handleRunSecurityScan2({ path: projectPath })
+  ]);
+  const assessData = parseToolResult(assessResult);
+  const checkMap = buildCheckMap(assessData);
+  const { circularDeps, layerViolations } = countViolations(parseToolResult(depsResult));
+  const entropyGranular = parseEntropyGranular(parseToolResult(entropyResult));
+  const criticalCount = countCriticalFindings(parseToolResult(securityResult));
+  const deps = checkMap.get("deps") ?? DEFAULT_CHECK;
+  const entropy = checkMap.get("entropy") ?? DEFAULT_CHECK;
+  const security = checkMap.get("security") ?? DEFAULT_CHECK;
+  const perf = checkMap.get("perf") ?? DEFAULT_CHECK;
+  const docs = checkMap.get("docs") ?? DEFAULT_CHECK;
+  const lint = checkMap.get("lint") ?? DEFAULT_CHECK;
+  return {
+    deps: { passed: deps.passed, issueCount: deps.issueCount, circularDeps, layerViolations },
+    entropy: { passed: entropy.passed, ...entropyGranular },
+    security: { passed: security.passed, findingCount: security.issueCount, criticalCount },
+    perf: { passed: perf.passed, violationCount: perf.issueCount },
+    docs: { passed: docs.passed, undocumentedCount: docs.issueCount },
+    lint: { passed: lint.passed, issueCount: lint.issueCount }
+  };
+}
+var ZERO_METRICS = {
+  avgFanOut: 0,
+  maxFanOut: 0,
+  avgCyclomaticComplexity: 0,
+  maxCyclomaticComplexity: 0,
+  avgCouplingRatio: 0,
+  testCoverage: null,
+  anomalyOutlierCount: 0,
+  articulationPointCount: 0
+};
+function avg(values) {
+  if (values.length === 0) return 0;
+  return Math.round(values.reduce((s, v) => s + v, 0) / values.length * 1e3) / 1e3;
+}
+async function runGraphMetrics(projectPath) {
+  try {
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-FJN4H7Y4.js");
+    const store = await loadGraphStore2(projectPath);
+    if (!store) return ZERO_METRICS;
+    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-IA6XYKNO.js");
+    const couplingAdapter = new GraphCouplingAdapter(store);
+    const couplingData = couplingAdapter.computeCouplingData();
+    const files = couplingData.files;
+    const avgFanOut = avg(files.map((f) => f.fanOut));
+    const maxFanOut = files.length > 0 ? Math.max(...files.map((f) => f.fanOut)) : 0;
+    const avgCouplingRatio = avg(files.map((f) => f.couplingRatio));
+    const complexityAdapter = new GraphComplexityAdapter(store);
+    const complexityData = complexityAdapter.computeComplexityHotspots();
+    const hotspots = complexityData.hotspots;
+    const avgCyclomaticComplexity = avg(hotspots.map((h) => h.complexity));
+    const maxCyclomaticComplexity = hotspots.length > 0 ? Math.max(...hotspots.map((h) => h.complexity)) : 0;
+    const anomalyAdapter = new GraphAnomalyAdapter(store);
+    const anomalyReport = anomalyAdapter.detect();
+    return {
+      avgFanOut,
+      maxFanOut,
+      avgCyclomaticComplexity,
+      maxCyclomaticComplexity,
+      avgCouplingRatio,
+      testCoverage: null,
+      // Coverage integration deferred -- not available from graph
+      anomalyOutlierCount: anomalyReport.summary.outlierCount,
+      articulationPointCount: anomalyReport.summary.articulationPointCount
+    };
+  } catch {
+    return ZERO_METRICS;
+  }
+}
+async function captureHealthSnapshot(projectPath) {
+  let gitHead = "";
+  try {
+    gitHead = execSync("git rev-parse HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+  }
+  const [checks, metrics] = await Promise.all([
+    runHealthChecks(projectPath),
+    runGraphMetrics(projectPath)
+  ]);
+  const signals = deriveSignals(checks, metrics);
+  const snapshot = {
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    gitHead,
+    projectPath,
+    checks,
+    metrics,
+    signals
+  };
+  saveCachedSnapshot(snapshot, projectPath);
+  return snapshot;
+}
+
 // src/mcp/tools/search-skills.ts
 var searchSkillsDefinition = {
   name: "search_skills",
@@ -5045,10 +4998,12 @@ async function handleSearchSkills(input) {
   const tierOverrides = configResult.ok ? configResult.value.skills?.tierOverrides : void 0;
   const index = loadOrRebuildIndex(platform, projectRoot, tierOverrides);
   const profile = loadOrGenerateProfile(projectRoot);
+  const snapshot = loadCachedSnapshot(projectRoot);
+  const freshSnapshot = snapshot && isSnapshotFresh(snapshot, projectRoot) ? snapshot : void 0;
   const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
   const results = [];
   for (const [name, entry] of Object.entries(index.skills)) {
-    const score = scoreSkill(entry, queryTerms, profile, [], name);
+    const score = scoreSkill(entry, queryTerms, profile, [], name, freshSnapshot);
     if (score > 0 || queryTerms.length === 0) {
       results.push({
         name,
@@ -5072,6 +5027,125 @@ 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"]
+  }
+};
+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-LCR2IO7U.js");
+    const { TimelineManager } = core;
+    const manager = new TimelineManager(projectPath);
+    const timeline = manager.load();
+    if (timeline.snapshots.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No architecture snapshots found. Run `harness snapshot capture` to create the first snapshot."
+          }
+        ]
+      };
+    }
+    const trendOptions = {};
+    if (input.last !== void 0) trendOptions.last = input.last;
+    if (input.since !== void 0) trendOptions.since = input.since;
+    const trends = manager.trends(trendOptions);
+    if (input.category) {
+      const categoryTrend = trends.categories[input.category];
+      if (!categoryTrend) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No trend data for category "${input.category}".`
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                category: input.category,
+                trend: categoryTrend,
+                snapshotCount: trends.snapshotCount,
+                from: trends.from,
+                to: trends.to
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(trends, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error computing decay trends: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
 // src/mcp/tools/code-nav.ts
 var codeOutlineDefinition = {
   name: "code_outline",
@@ -5107,7 +5181,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-KV2ICL5X.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-LCR2IO7U.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -5187,7 +5261,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-KV2ICL5X.js");
+    const { searchSymbols } = await import("./dist-LCR2IO7U.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) {
@@ -5256,7 +5330,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-KV2ICL5X.js");
+      const { unfoldSymbol } = await import("./dist-LCR2IO7U.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}
@@ -5264,7 +5338,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-KV2ICL5X.js");
+      const { unfoldRange } = await import("./dist-LCR2IO7U.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -5292,6 +5366,501 @@ async function handleCodeUnfold(input) {
   }
 }
 
+// src/mcp/tools/traceability.ts
+var checkTraceabilityDefinition = {
+  name: "check_traceability",
+  description: "Check requirement-to-code-to-test traceability for a spec or all specs",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      spec: { type: "string", description: "Specific spec file path to check" },
+      feature: { type: "string", description: "Feature name filter" },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns coverage stats only, detailed returns full requirement list. Default: summary"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckTraceability(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No graph found. Run `harness scan` or use `ingest_source` tool first."
+          }
+        ],
+        isError: true
+      };
+    }
+    const { queryTraceability } = await import("./dist-IA6XYKNO.js");
+    const options = {};
+    if (input.spec) options.specPath = input.spec;
+    if (input.feature) options.featureName = input.feature;
+    const results = queryTraceability(store, options);
+    if (results.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              status: "no-requirements",
+              message: "No requirement nodes found in graph. Ingest specs with RequirementIngestor first."
+            })
+          }
+        ]
+      };
+    }
+    const mode = input.mode ?? "summary";
+    if (mode === "summary") {
+      const summaries = results.map((r) => ({
+        specPath: r.specPath,
+        featureName: r.featureName,
+        ...r.summary
+      }));
+      const totals = summaries.reduce(
+        (acc, s) => ({
+          total: acc.total + s.total,
+          withCode: acc.withCode + s.withCode,
+          withTests: acc.withTests + s.withTests,
+          fullyTraced: acc.fullyTraced + s.fullyTraced,
+          untraceable: acc.untraceable + s.untraceable
+        }),
+        { total: 0, withCode: 0, withTests: 0, fullyTraced: 0, untraceable: 0 }
+      );
+      const overallCoverage = totals.total > 0 ? Math.round(totals.fullyTraced / totals.total * 100) : 0;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "summary",
+              overallCoverage,
+              totals,
+              specs: summaries
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            mode: "detailed",
+            results
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/predict-failures.ts
+var predictFailuresDefinition = {
+  name: "predict_failures",
+  description: "Predict which architectural constraints will break and when, based on decay trends and planned roadmap features. Requires at least 3 timeline snapshots.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      horizon: {
+        type: "number",
+        description: "Forecast horizon in weeks (default: 12)"
+      },
+      category: {
+        type: "string",
+        description: "Filter to a single metric category",
+        enum: [
+          "circular-deps",
+          "layer-violations",
+          "complexity",
+          "coupling",
+          "forbidden-imports",
+          "module-size",
+          "dependency-depth"
+        ]
+      },
+      includeRoadmap: {
+        type: "boolean",
+        description: "Include roadmap spec impact in forecasts (default: true)"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handlePredictFailures(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-LCR2IO7U.js");
+    const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
+    const manager = new TimelineManager(projectPath);
+    const includeRoadmap = input.includeRoadmap !== false;
+    const estimator = includeRoadmap ? new SpecImpactEstimator(projectPath) : null;
+    const engine = new PredictionEngine(projectPath, manager, estimator);
+    const opts = {
+      includeRoadmap
+    };
+    if (input.horizon !== void 0) opts.horizon = input.horizon;
+    if (input.category) opts.categories = [input.category];
+    const result = engine.predict(opts);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// 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",
+  description: "Recommend skills based on codebase health. Returns sequenced workflow with urgency markers.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Project root path (defaults to cwd)"
+      },
+      noCache: {
+        type: "boolean",
+        description: "Force fresh health snapshot even if cache is fresh"
+      },
+      top: {
+        type: "number",
+        description: "Max recommendations to return (default 5)"
+      }
+    },
+    required: []
+  }
+};
+async function handleRecommendSkills(input) {
+  const projectRoot = input.path || process.cwd();
+  const noCache = input.noCache || false;
+  const top = input.top || 5;
+  let snapshot = null;
+  let usedCache = false;
+  if (!noCache) {
+    const cached = loadCachedSnapshot(projectRoot);
+    if (cached && isSnapshotFresh(cached, projectRoot)) {
+      snapshot = cached;
+      usedCache = true;
+    }
+  }
+  if (!snapshot) {
+    snapshot = await captureHealthSnapshot(projectRoot);
+  }
+  const configResult = resolveConfig();
+  const tierOverrides = configResult.ok ? configResult.value.skills?.tierOverrides : void 0;
+  const index = loadOrRebuildIndex("claude-code", projectRoot, tierOverrides);
+  const skills = {};
+  for (const [name, entry] of Object.entries(index.skills)) {
+    skills[name] = { addresses: entry.addresses, dependsOn: entry.dependsOn };
+  }
+  const result = recommend(snapshot, skills, { top });
+  const output = {
+    ...result,
+    snapshotAge: usedCache ? "cached" : "fresh"
+  };
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(output, null, 2)
+      }
+    ]
+  };
+}
+
 // src/mcp/server.ts
 var TOOL_DEFINITIONS = [
   validateToolDefinition,
@@ -5342,7 +5911,11 @@ var TOOL_DEFINITIONS = [
   searchSkillsDefinition,
   codeOutlineDefinition,
   codeSearchDefinition,
-  codeUnfoldDefinition
+  codeUnfoldDefinition,
+  getDecayTrendsDefinition,
+  checkTraceabilityDefinition,
+  predictFailuresDefinition,
+  recommendSkillsDefinition
 ].map((def) => ({ ...def, trustedOutput: true }));
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -5393,7 +5966,11 @@ var TOOL_HANDLERS = {
   search_skills: handleSearchSkills,
   code_outline: handleCodeOutline,
   code_search: handleCodeSearch,
-  code_unfold: handleCodeUnfold
+  code_unfold: handleCodeUnfold,
+  get_decay_trends: handleGetDecayTrends,
+  check_traceability: handleCheckTraceability,
+  predict_failures: handlePredictFailures,
+  recommend_skills: handleRecommendSkills
 };
 var RESOURCE_DEFINITIONS = [
   {
@@ -5479,7 +6056,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-KV2ICL5X.js");
+    } = await import("./dist-LCR2IO7U.js");
     const { CLI_VERSION } = await import("./version-KFFPOQAX.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;
@@ -5561,7 +6138,12 @@ export {
   generateSlashCommands,
   handleOrphanDeletion,
   createGenerateSlashCommandsCommand,
+  loadOrRebuildIndex,
   handleGetImpact,
+  isSnapshotFresh,
+  loadCachedSnapshot,
+  captureHealthSnapshot,
+  recommend,
   getToolDefinitions,
   createHarnessServer,
   startServer