@harness-engineering/cli 1.26.0 → 1.27.0

package/dist/{chunk-CAS3TS4Y.js → chunk-TCMVZ3B7.js}

@@ -1,10 +1,15 @@
+import {
+  handleRunCodeReview,
+  runCodeReviewDefinition,
+  sortFindingsBySeverity
+} from "./chunk-2FOLD76X.js";
 import {
   assessProjectDefinition,
   handleAssessProject
-} from "./chunk-RNAGPTKF.js";
+} from "./chunk-F3Y64VNF.js";
 import {
   getBusinessKnowledgeResource
-} from "./chunk-RC5ZY3EV.js";
+} from "./chunk-IOW3MW2K.js";
 import {
   analyzeDiffDefinition,
   createSelfReviewDefinition,
@@ -12,37 +17,35 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-UBRD5FH4.js";
+} from "./chunk-BZZNYHRY.js";
 import {
   getSecurityTrendsDefinition,
   handleGetSecurityTrends,
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-IFHAUFJX.js";
+} from "./chunk-3AJW7VQ3.js";
 import {
-  handleRunCodeReview,
-  runCodeReviewDefinition,
-  sortFindingsBySeverity
-} from "./chunk-G6SYTGOH.js";
+  loadGraphStore
+} from "./chunk-776JFSPK.js";
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-JBJ4AVE4.js";
+} from "./chunk-Q5DKIL46.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-KFE2X7LG.js";
+} from "./chunk-MGPVA2EM.js";
 import {
   resolveProjectConfig
-} from "./chunk-J3O64D2A.js";
+} from "./chunk-YZH4I4JO.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-FI3D6D7U.js";
+} from "./chunk-T7UZOJF4.js";
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-7JNZXJKY.js";
+} from "./chunk-EGRQHLDM.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -52,16 +55,19 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-NVGQO4VM.js";
+} from "./chunk-CJYNZMOP.js";
 import {
   resultToMcpResponse
 } from "./chunk-EPUKTTJZ.js";
 import {
   sanitizePath
 } from "./chunk-W6Y7ZW3Y.js";
+import {
+  loadOrRebuildIndex
+} from "./chunk-27AJKSQY.js";
 import {
   resolveConfig
-} from "./chunk-4KSKV5MK.js";
+} from "./chunk-A4ETL34H.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_CODEX,
@@ -72,7 +78,6 @@ import {
   computeSyncPlan
 } from "./chunk-3ISINLYT.js";
 import {
-  resolveAllSkillsDirs,
   resolveCommunitySkillsDir,
   resolveGlobalCommunitySkillsDir,
   resolveGlobalSkillsDir,
@@ -81,9 +86,6 @@ import {
   resolveSkillsDir,
   resolveTemplatesDir
 } from "./chunk-6B6UN6SG.js";
-import {
-  loadGraphStore
-} from "./chunk-Z2JORLRT.js";
 import {
   CompactionPipeline,
   DEFAULT_TOKEN_BUDGET,
@@ -101,7 +103,7 @@ import {
   scanForInjection,
   serializeEnvelope,
   writeTaint
-} from "./chunk-77EZGPSR.js";
+} from "./chunk-IBTHD2UA.js";
 import {
   Err,
   Ok
@@ -109,6 +111,9 @@ import {
 import {
   SkillMetadataSchema
 } from "./chunk-HIK6OEUF.js";
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
 import {
   CLIError,
   ExitCode,
@@ -701,7 +706,7 @@ ${skippedMsg}`
 async function handleInitProject(input) {
   const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-KQG5RVXX.js");
+    const { TemplateEngine } = await import("./engine-FB3HCNVT.js");
     const engine = new TemplateEngine(resolveTemplatesDir());
     const safePath = sanitizePath(i.path);
     const detected = tryDetectFramework(engine, safePath, i);
@@ -723,7 +728,7 @@ var listPersonasDefinition = {
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-CWAH6B4H.js");
+  const { listPersonas } = await import("./loader-HXUOBTYA.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -747,10 +752,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-CWAH6B4H.js");
-  const { generateRuntime } = await import("./runtime-SFEFRPLX.js");
-  const { generateAgentsMd } = await import("./agents-md-OPOZA5L7.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-H52EMCL6.js");
+  const { loadPersona } = await import("./loader-HXUOBTYA.js");
+  const { generateRuntime } = await import("./runtime-HQQNOARD.js");
+  const { generateAgentsMd } = await import("./agents-md-2RN666DE.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-JFOL4YWW.js");
   const personasDir = resolvePersonasDir();
   const filePath = path3.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -805,7 +810,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-CWAH6B4H.js");
+  const { loadPersona } = await import("./loader-HXUOBTYA.js");
   const { runPersona } = await import("./runner-AAEF2TXY.js");
   const { executeSkill } = await import("./skill-executor-MOCUIAYS.js");
   const personasDir = resolvePersonasDir();
@@ -972,8 +977,8 @@ async function handleRunAgentTask(input) {
 
 // src/mcp/tools/skill.ts
 init_dist();
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/skill/dispatcher.ts
@@ -1159,103 +1164,9 @@ function formatSuggestions(suggestions) {
   ].join("\n");
 }
 
-// src/skill/index-builder.ts
+// src/skill/stack-profile.ts
 import fs3 from "fs";
 import path4 from "path";
-import crypto from "crypto";
-import { parse } from "yaml";
-function computeSkillsDirHash(skillsDirs) {
-  const hash = crypto.createHash("sha256");
-  for (const dir of skillsDirs) {
-    if (!fs3.existsSync(dir)) continue;
-    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const yamlPath = path4.join(dir, entry.name, "skill.yaml");
-      if (!fs3.existsSync(yamlPath)) continue;
-      const stat = fs3.statSync(yamlPath);
-      hash.update(`${yamlPath}:${stat.mtimeMs}`);
-    }
-  }
-  return hash.digest("hex");
-}
-function parseSkillEntry(yamlPath, source, tierOverrides) {
-  const raw = fs3.readFileSync(yamlPath, "utf-8");
-  const parsed = parse(raw);
-  const result = SkillMetadataSchema.safeParse(parsed);
-  if (!result.success) return null;
-  const meta = result.data;
-  const effectiveTier = tierOverrides?.[meta.name] ?? meta.tier;
-  if (meta.internal) return null;
-  return {
-    tier: effectiveTier ?? 3,
-    type: meta.type,
-    description: meta.description,
-    keywords: meta.keywords ?? [],
-    stackSignals: meta.stack_signals ?? [],
-    cognitiveMode: meta.cognitive_mode,
-    phases: (meta.phases ?? []).map((p) => p.name),
-    paths: meta.paths ?? [],
-    relatedSkills: meta.related_skills ?? [],
-    source,
-    addresses: meta.addresses ?? [],
-    dependsOn: meta.depends_on ?? [],
-    ...meta.context_budget && {
-      contextBudget: {
-        maxTokens: meta.context_budget.max_tokens,
-        priority: meta.context_budget.priority
-      }
-    }
-  };
-}
-function scanDirectory(dir, source, index, tierOverrides) {
-  if (!fs3.existsSync(dir)) return;
-  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    if (index.skills[entry.name]) continue;
-    const yamlPath = path4.join(dir, entry.name, "skill.yaml");
-    if (!fs3.existsSync(yamlPath)) continue;
-    try {
-      const parsed = parseSkillEntry(yamlPath, source, tierOverrides);
-      if (parsed) index.skills[entry.name] = parsed;
-    } catch {
-      continue;
-    }
-  }
-}
-function buildIndex(platform, _projectRoot, tierOverrides) {
-  const skillsDirs = resolveAllSkillsDirs(platform);
-  const sourceMap = ["project", "community", "bundled"];
-  const index = {
-    version: 1,
-    hash: computeSkillsDirHash(skillsDirs),
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    skills: {}
-  };
-  for (let i = 0; i < skillsDirs.length; i++) {
-    scanDirectory(skillsDirs[i], sourceMap[i] ?? "bundled", index, tierOverrides);
-  }
-  return index;
-}
-function loadOrRebuildIndex(platform, projectRoot, tierOverrides) {
-  const indexPath = path4.join(projectRoot, ".harness", "skills-index.json");
-  const skillsDirs = resolveAllSkillsDirs(platform);
-  const currentHash = computeSkillsDirHash(skillsDirs);
-  if (fs3.existsSync(indexPath)) {
-    try {
-      const existing = JSON.parse(fs3.readFileSync(indexPath, "utf-8"));
-      if (existing.hash === currentHash) return existing;
-    } catch {
-    }
-  }
-  const index = buildIndex(platform, projectRoot, tierOverrides);
-  fs3.mkdirSync(path4.dirname(indexPath), { recursive: true });
-  fs3.writeFileSync(indexPath, JSON.stringify(index, null, 2));
-  return index;
-}
-
-// src/skill/stack-profile.ts
-import fs4 from "fs";
-import path5 from "path";
 var SIGNAL_DOMAIN_MAP = {
   "prisma/schema.prisma": ["database"],
   "drizzle.config.ts": ["database"],
@@ -1314,8 +1225,8 @@ function generateStackProfile(projectRoot) {
   const signals = {};
   const domainSet = /* @__PURE__ */ new Set();
   for (const [pattern, domains] of Object.entries(SIGNAL_DOMAIN_MAP)) {
-    const fullPath = path5.join(projectRoot, pattern);
-    const exists = fs4.existsSync(fullPath);
+    const fullPath = path4.join(projectRoot, pattern);
+    const exists = fs3.existsSync(fullPath);
     signals[pattern] = exists;
     if (exists) {
       for (const domain of domains) domainSet.add(domain);
@@ -1328,23 +1239,23 @@ function generateStackProfile(projectRoot) {
   };
 }
 function loadOrGenerateProfile(projectRoot) {
-  const profilePath = path5.join(projectRoot, ".harness", "stack-profile.json");
-  if (fs4.existsSync(profilePath)) {
+  const profilePath = path4.join(projectRoot, ".harness", "stack-profile.json");
+  if (fs3.existsSync(profilePath)) {
     try {
-      return JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
+      return JSON.parse(fs3.readFileSync(profilePath, "utf-8"));
     } catch {
     }
   }
   const profile = generateStackProfile(projectRoot);
-  fs4.mkdirSync(path5.dirname(profilePath), { recursive: true });
-  fs4.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+  fs3.mkdirSync(path4.dirname(profilePath), { recursive: true });
+  fs3.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
   return profile;
 }
 
 // src/mcp/tools/event-emitter.ts
 async function emitSkillEvent(projectPath, event) {
   try {
-    const { emitEvent } = await import("./dist-TG63OKA5.js");
+    const { emitEvent } = await import("./dist-CPKL5Y2R.js");
     await emitEvent(projectPath, event);
   } catch {
   }
@@ -1379,18 +1290,18 @@ async function handleRunSkill(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.skill)) {
     return resultToMcpResponse(Err(new Error(`Invalid skill name: ${input.skill}`)));
   }
-  const skillDir = path6.join(skillsDir, input.skill);
+  const skillDir = path5.join(skillsDir, input.skill);
   if (!skillDir.startsWith(skillsDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid skill path: ${input.skill}`)));
   }
-  if (!fs5.existsSync(skillDir)) {
+  if (!fs4.existsSync(skillDir)) {
     return resultToMcpResponse(Err(new Error(`Skill not found: ${input.skill}`)));
   }
-  const skillMdPath = path6.join(skillDir, "SKILL.md");
-  if (!fs5.existsSync(skillMdPath)) {
+  const skillMdPath = path5.join(skillDir, "SKILL.md");
+  if (!fs4.existsSync(skillMdPath)) {
     return resultToMcpResponse(Err(new Error(`SKILL.md not found for skill: ${input.skill}`)));
   }
-  let content = fs5.readFileSync(skillMdPath, "utf-8");
+  let content = fs4.readFileSync(skillMdPath, "utf-8");
   const projectRoot = input.path ? sanitizePath(input.path) : process.cwd();
   const configResult = resolveConfig();
   const skillsConfig = configResult.ok ? configResult.value.skills : void 0;
@@ -1417,9 +1328,9 @@ async function handleRunSkill(input) {
   }
   if (input.path) {
     const projectPath = sanitizePath(input.path);
-    const stateFile = path6.join(projectPath, ".harness", "state.json");
-    if (fs5.existsSync(stateFile)) {
-      const stateContent = fs5.readFileSync(stateFile, "utf-8");
+    const stateFile = path5.join(projectPath, ".harness", "state.json");
+    if (fs4.existsSync(stateFile)) {
+      const stateContent = fs4.readFileSync(stateFile, "utf-8");
       content += `
 
 ---
@@ -1430,10 +1341,10 @@ ${stateContent}
 `;
     }
   }
-  const skillYamlPath = path6.join(skillDir, "skill.yaml");
-  if (fs5.existsSync(skillYamlPath)) {
+  const skillYamlPath = path5.join(skillDir, "skill.yaml");
+  if (fs4.existsSync(skillYamlPath)) {
     try {
-      const rawYaml = fs5.readFileSync(skillYamlPath, "utf-8");
+      const rawYaml = fs4.readFileSync(skillYamlPath, "utf-8");
       const skillMeta = parseYaml(rawYaml);
       if (skillMeta.type === "knowledge") {
         const boundary = content.indexOf("\n## Details");
@@ -1494,7 +1405,7 @@ var createSkillDefinition = {
 };
 async function handleCreateSkill(input) {
   try {
-    const { generateSkillFiles } = await import("./create-skill-6QWJHQYS.js");
+    const { generateSkillFiles } = await import("./create-skill-4T5CBSJ2.js");
     const result = generateSkillFiles({
       name: input.name,
       description: input.description,
@@ -1516,22 +1427,22 @@ async function handleCreateSkill(input) {
 }
 
 // src/mcp/resources/skills.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 import * as yaml from "yaml";
 async function getSkillsResource(projectRoot) {
-  const skillsDir = path7.join(projectRoot, "agents", "skills", "claude-code");
+  const skillsDir = path6.join(projectRoot, "agents", "skills", "claude-code");
   const skills = [];
-  if (!fs6.existsSync(skillsDir)) {
+  if (!fs5.existsSync(skillsDir)) {
     return JSON.stringify(skills, null, 2);
   }
-  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs5.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillYamlPath = path7.join(skillsDir, entry.name, "skill.yaml");
-    if (!fs6.existsSync(skillYamlPath)) continue;
+    const skillYamlPath = path6.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs5.existsSync(skillYamlPath)) continue;
     try {
-      const content = fs6.readFileSync(skillYamlPath, "utf-8");
+      const content = fs5.readFileSync(skillYamlPath, "utf-8");
       const parsed = yaml.parse(content);
       skills.push({
         name: parsed.name,
@@ -1547,14 +1458,14 @@ async function getSkillsResource(projectRoot) {
 }
 
 // src/mcp/resources/rules.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 async function getRulesResource(projectRoot) {
   const rules = [];
-  const configPath = path8.join(projectRoot, "harness.config.json");
-  if (fs7.existsSync(configPath)) {
+  const configPath = path7.join(projectRoot, "harness.config.json");
+  if (fs6.existsSync(configPath)) {
     try {
-      const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
       if (config.layers) {
         rules.push({ type: "layer-enforcement", config: config.layers });
       }
@@ -1567,10 +1478,10 @@ async function getRulesResource(projectRoot) {
     } catch {
     }
   }
-  const linterPath = path8.join(projectRoot, ".harness", "linter.json");
-  if (fs7.existsSync(linterPath)) {
+  const linterPath = path7.join(projectRoot, ".harness", "linter.json");
+  if (fs6.existsSync(linterPath)) {
     try {
-      const linterConfig = JSON.parse(fs7.readFileSync(linterPath, "utf-8"));
+      const linterConfig = JSON.parse(fs6.readFileSync(linterPath, "utf-8"));
       rules.push({ type: "linter", config: linterConfig });
     } catch {
     }
@@ -1579,28 +1490,28 @@ async function getRulesResource(projectRoot) {
 }
 
 // src/mcp/resources/project.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 async function getProjectResource(projectRoot) {
-  const agentsPath = path9.join(projectRoot, "AGENTS.md");
-  if (fs8.existsSync(agentsPath)) {
-    return fs8.readFileSync(agentsPath, "utf-8");
+  const agentsPath = path8.join(projectRoot, "AGENTS.md");
+  if (fs7.existsSync(agentsPath)) {
+    return fs7.readFileSync(agentsPath, "utf-8");
   }
   return "# No AGENTS.md found";
 }
 
 // src/mcp/resources/learnings.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 async function getLearningsResource(projectRoot) {
   const sections = [];
-  const reviewPath = path10.join(projectRoot, ".harness", "review-learnings.md");
-  if (fs9.existsSync(reviewPath)) {
-    sections.push("## Review Learnings\n\n" + fs9.readFileSync(reviewPath, "utf-8"));
+  const reviewPath = path9.join(projectRoot, ".harness", "review-learnings.md");
+  if (fs8.existsSync(reviewPath)) {
+    sections.push("## Review Learnings\n\n" + fs8.readFileSync(reviewPath, "utf-8"));
   }
-  const antiPath = path10.join(projectRoot, ".harness", "anti-patterns.md");
-  if (fs9.existsSync(antiPath)) {
-    sections.push("## Anti-Pattern Log\n\n" + fs9.readFileSync(antiPath, "utf-8"));
+  const antiPath = path9.join(projectRoot, ".harness", "anti-patterns.md");
+  if (fs8.existsSync(antiPath)) {
+    sections.push("## Anti-Pattern Log\n\n" + fs8.readFileSync(antiPath, "utf-8"));
   }
   return sections.length > 0 ? sections.join("\n\n---\n\n") : "No learnings files found.";
 }
@@ -1610,14 +1521,14 @@ init_dist();
 
 // src/mcp/tools/roadmap-auto-sync.ts
 init_dist();
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 async function autoSyncRoadmap(projectPath) {
   try {
-    const roadmapFile = path11.join(projectPath, "docs", "roadmap.md");
-    if (!fs10.existsSync(roadmapFile)) return;
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-TG63OKA5.js");
-    const raw = fs10.readFileSync(roadmapFile, "utf-8");
+    const roadmapFile = path10.join(projectPath, "docs", "roadmap.md");
+    if (!fs9.existsSync(roadmapFile)) return;
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-CPKL5Y2R.js");
+    const raw = fs9.readFileSync(roadmapFile, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) return;
     const roadmap = parseResult.value;
@@ -1627,7 +1538,7 @@ async function autoSyncRoadmap(projectPath) {
       return;
     }
     applySyncChanges(roadmap, syncResult.value);
-    fs10.writeFileSync(roadmapFile, serializeRoadmap(roadmap), "utf-8");
+    fs9.writeFileSync(roadmapFile, serializeRoadmap(roadmap), "utf-8");
     await triggerExternalSync(projectPath, roadmapFile);
   } catch {
   }
@@ -1636,8 +1547,8 @@ async function triggerExternalSync(projectPath, roadmapFile) {
   try {
     const trackerConfig = loadTrackerSyncConfig(projectPath);
     if (!trackerConfig) return;
-    const projectEnvPath = path11.join(projectPath, ".env");
-    if (fs10.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+    const projectEnvPath = path10.join(projectPath, ".env");
+    if (fs9.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
       const { config: loadDotenv } = await import("dotenv");
       loadDotenv({ path: projectEnvPath });
     }
@@ -1646,7 +1557,7 @@ async function triggerExternalSync(projectPath, roadmapFile) {
       console.warn("[roadmap-sync] GITHUB_TOKEN not found \u2014 external sync skipped");
       return;
     }
-    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-TG63OKA5.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-CPKL5Y2R.js");
     const adapter = new GitHubIssuesSyncAdapter({
       token,
       config: trackerConfig
@@ -1743,12 +1654,12 @@ var manageStateDefinition = {
   }
 };
 async function handleShow(projectPath, input) {
-  const { loadState } = await import("./dist-TG63OKA5.js");
+  const { loadState } = await import("./dist-CPKL5Y2R.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-TG63OKA5.js");
+  const { appendLearning } = await import("./dist-CPKL5Y2R.js");
   const result = await appendLearning(
     projectPath,
     input.learning,
@@ -1763,7 +1674,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-TG63OKA5.js");
+  const { appendFailure } = await import("./dist-CPKL5Y2R.js");
   const result = await appendFailure(
     projectPath,
     input.description,
@@ -1782,19 +1693,19 @@ async function handleFailure(projectPath, input) {
   return resultToMcpResponse(Ok({ recorded: true }));
 }
 async function handleArchive(projectPath, input) {
-  const { archiveFailures } = await import("./dist-TG63OKA5.js");
+  const { archiveFailures } = await import("./dist-CPKL5Y2R.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-TG63OKA5.js");
+  const { saveState, DEFAULT_STATE } = await import("./dist-CPKL5Y2R.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-TG63OKA5.js");
+  const { runMechanicalGate } = await import("./dist-CPKL5Y2R.js");
   const result = await runMechanicalGate(projectPath);
   if (result.ok) {
     await emitSkillEvent(projectPath, {
@@ -1814,7 +1725,7 @@ async function handleGate(projectPath, input) {
 }
 async function handleSaveHandoff(projectPath, input) {
   if (!input.handoff) return mcpError("Error: handoff is required for save-handoff action");
-  const { saveHandoff } = await import("./dist-TG63OKA5.js");
+  const { saveHandoff } = await import("./dist-CPKL5Y2R.js");
   const result = await saveHandoff(
     projectPath,
     input.handoff,
@@ -1836,7 +1747,7 @@ async function handleSaveHandoff(projectPath, input) {
   return resultToMcpResponse(Ok({ saved: true }));
 }
 async function handleLoadHandoff(projectPath, input) {
-  const { loadHandoff } = await import("./dist-TG63OKA5.js");
+  const { loadHandoff } = await import("./dist-CPKL5Y2R.js");
   return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
 }
 async function handleAppendEntry(projectPath, input) {
@@ -1844,7 +1755,7 @@ async function handleAppendEntry(projectPath, input) {
   if (!input.authorSkill) return mcpError("Error: authorSkill is required for append_entry action");
   if (!input.content) return mcpError("Error: content is required for append_entry action");
   if (input.session) {
-    const { appendSessionEntry } = await import("./dist-TG63OKA5.js");
+    const { appendSessionEntry } = await import("./dist-CPKL5Y2R.js");
     const result = await appendSessionEntry(
       projectPath,
       input.session,
@@ -1857,7 +1768,7 @@ async function handleAppendEntry(projectPath, input) {
   if (input.section !== "decisions") {
     return mcpError("Error: session is required for non-decisions sections");
   }
-  const { loadState, saveState } = await import("./dist-TG63OKA5.js");
+  const { loadState, saveState } = await import("./dist-CPKL5Y2R.js");
   const lr = await loadState(projectPath, input.stream);
   if (!lr.ok) return resultToMcpResponse(lr);
   lr.value.decisions.push({
@@ -1875,7 +1786,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-TG63OKA5.js");
+  const { updateSessionEntryStatus } = await import("./dist-CPKL5Y2R.js");
   const result = await updateSessionEntryStatus(
     projectPath,
     input.session,
@@ -1888,7 +1799,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-TG63OKA5.js");
+  const { readSessionSection } = await import("./dist-CPKL5Y2R.js");
   const result = await readSessionSection(
     projectPath,
     input.session,
@@ -1898,13 +1809,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-TG63OKA5.js");
+  const { readSessionSections } = await import("./dist-CPKL5Y2R.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-TG63OKA5.js");
+  const { archiveSession } = await import("./dist-CPKL5Y2R.js");
   const result = await archiveSession(projectPath, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   await autoSyncRoadmap(projectPath);
@@ -1984,7 +1895,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-TG63OKA5.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-CPKL5Y2R.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -2022,7 +1933,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-NTLAU3LO.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-ZVG56NT2.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -2042,7 +1953,7 @@ async function handleCheckPhaseGate(input) {
 }
 
 // src/mcp/tools/cross-check.ts
-import * as path12 from "path";
+import * as path11 from "path";
 var validateCrossCheckDefinition = {
   name: "validate_cross_check",
   description: "Validate plan-to-implementation coverage: checks that specs have plans and plans have implementations, detects staleness",
@@ -2078,15 +1989,15 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-ULQLEOME.js");
-    const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
+    const { runCrossCheck } = await import("./validate-cross-check-SPL3H4O5.js");
+    const specsDir = path11.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: specsDir escapes project root" }],
         isError: true
       };
     }
-    const plansDir = path12.resolve(projectPath, input.plansDir ?? "docs/plans");
+    const plansDir = path11.resolve(projectPath, input.plansDir ?? "docs/plans");
     if (!plansDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: plansDir escapes project root" }],
@@ -2120,15 +2031,15 @@ init_dist();
 
 // src/commands/generate-slash-commands.ts
 import { Command } from "commander";
-import fs13 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import os from "os";
 import readline from "readline";
 
 // src/slash-commands/normalize.ts
-import fs11 from "fs";
-import path13 from "path";
-import { parse as parse3 } from "yaml";
+import fs10 from "fs";
+import path12 from "path";
+import { parse as parse2 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
 function normalizeName(skillName) {
@@ -2147,11 +2058,11 @@ function normalizeName(skillName) {
 function readSkillYaml(yamlPath) {
   let raw;
   try {
-    raw = fs11.readFileSync(yamlPath, "utf-8");
+    raw = fs10.readFileSync(yamlPath, "utf-8");
   } catch {
     return null;
   }
-  return SkillMetadataSchema.safeParse(parse3(raw));
+  return SkillMetadataSchema.safeParse(parse2(raw));
 }
 var DERIVED_FROM_CLAUDE_CODE = ["cursor", "codex"];
 function shouldSkipSkill(meta, platforms) {
@@ -2211,10 +2122,10 @@ function buildProcessLines(meta) {
   ];
 }
 function buildSpec(meta, normalized, entry, skillsDir, source) {
-  const skillMdPath = path13.join(skillsDir, entry.name, "SKILL.md");
-  const skillMdContent = fs11.existsSync(skillMdPath) ? fs11.readFileSync(skillMdPath, "utf-8") : "";
-  const skillMdRelative = path13.relative(process.cwd(), skillMdPath).replaceAll("\\", "/");
-  const skillYamlRelative = path13.relative(process.cwd(), path13.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
+  const skillMdPath = path12.join(skillsDir, entry.name, "SKILL.md");
+  const skillMdContent = fs10.existsSync(skillMdPath) ? fs10.readFileSync(skillMdPath, "utf-8") : "";
+  const skillMdRelative = path12.relative(process.cwd(), skillMdPath).replaceAll("\\", "/");
+  const skillYamlRelative = path12.relative(process.cwd(), path12.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
   const args = (meta.cli?.args ?? []).map((a) => ({
     name: a.name,
     description: a.description ?? "",
@@ -2269,11 +2180,11 @@ function normalizeSkills(skillSources, platforms) {
   const specs = [];
   const nameMap = /* @__PURE__ */ new Map();
   for (const { dir: skillsDir, source } of skillSources) {
-    if (!fs11.existsSync(skillsDir)) continue;
-    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    if (!fs10.existsSync(skillsDir)) continue;
+    const entries = fs10.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const entry of entries) {
-      const yamlPath = path13.join(skillsDir, entry.name, "skill.yaml");
-      if (!fs11.existsSync(yamlPath)) continue;
+      const yamlPath = path12.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs10.existsSync(yamlPath)) continue;
       const result = readSkillYaml(yamlPath);
       if (!result) continue;
       if (!result.success) {
@@ -2443,27 +2354,27 @@ function renderCodexAgentsMd(specs) {
 }
 
 // src/slash-commands/sync-codex.ts
-import fs12 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path13 from "path";
 function computeCodexSync(outputDir, specs, dryRun) {
   const added = [];
   const updated = [];
   const unchanged = [];
   const specSkillNames = /* @__PURE__ */ new Set();
   for (const spec of specs) {
-    const mdPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-    const skillMd = fs12.existsSync(mdPath) ? fs12.readFileSync(mdPath, "utf-8") : "";
-    const skillDir = path14.join(outputDir, spec.skillYamlName);
+    const mdPath = path13.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+    const skillMd = fs11.existsSync(mdPath) ? fs11.readFileSync(mdPath, "utf-8") : "";
+    const skillDir = path13.join(outputDir, spec.skillYamlName);
     specSkillNames.add(spec.skillYamlName);
     const renderedSkillMd = renderCodexSkill(skillMd);
     const renderedOpenaiYaml = renderCodexOpenaiYaml(spec);
-    const existingSkillMdPath = path14.join(skillDir, "SKILL.md");
-    const existingOpenaiYamlPath = path14.join(skillDir, "agents", "openai.yaml");
-    if (!fs12.existsSync(skillDir)) {
+    const existingSkillMdPath = path13.join(skillDir, "SKILL.md");
+    const existingOpenaiYamlPath = path13.join(skillDir, "agents", "openai.yaml");
+    if (!fs11.existsSync(skillDir)) {
       added.push(spec.skillYamlName);
     } else {
-      const existingSkillMd = fs12.existsSync(existingSkillMdPath) ? fs12.readFileSync(existingSkillMdPath, "utf-8") : "";
-      const existingOpenaiYaml = fs12.existsSync(existingOpenaiYamlPath) ? fs12.readFileSync(existingOpenaiYamlPath, "utf-8") : "";
+      const existingSkillMd = fs11.existsSync(existingSkillMdPath) ? fs11.readFileSync(existingSkillMdPath, "utf-8") : "";
+      const existingOpenaiYaml = fs11.existsSync(existingOpenaiYamlPath) ? fs11.readFileSync(existingOpenaiYamlPath, "utf-8") : "";
       if (existingSkillMd === renderedSkillMd && existingOpenaiYaml === renderedOpenaiYaml) {
         unchanged.push(spec.skillYamlName);
       } else {
@@ -2471,10 +2382,10 @@ function computeCodexSync(outputDir, specs, dryRun) {
       }
     }
     if (!dryRun && !unchanged.includes(spec.skillYamlName)) {
-      const agentsSubDir = path14.join(skillDir, "agents");
-      fs12.mkdirSync(agentsSubDir, { recursive: true });
-      fs12.writeFileSync(existingSkillMdPath, renderedSkillMd, "utf-8");
-      fs12.writeFileSync(existingOpenaiYamlPath, renderedOpenaiYaml, "utf-8");
+      const agentsSubDir = path13.join(skillDir, "agents");
+      fs11.mkdirSync(agentsSubDir, { recursive: true });
+      fs11.writeFileSync(existingSkillMdPath, renderedSkillMd, "utf-8");
+      fs11.writeFileSync(existingOpenaiYamlPath, renderedOpenaiYaml, "utf-8");
     }
   }
   const removed = detectCodexOrphans(outputDir, specSkillNames);
@@ -2482,13 +2393,13 @@ function computeCodexSync(outputDir, specs, dryRun) {
 }
 function detectCodexOrphans(outputDir, specSkillNames) {
   const removed = [];
-  if (!fs12.existsSync(outputDir)) return removed;
-  const existingDirs = fs12.readdirSync(outputDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs11.existsSync(outputDir)) return removed;
+  const existingDirs = fs11.readdirSync(outputDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   for (const dirName of existingDirs) {
     if (specSkillNames.has(dirName)) continue;
-    const skillMdPath = path14.join(outputDir, dirName, "SKILL.md");
-    if (fs12.existsSync(skillMdPath)) {
-      const content = fs12.readFileSync(skillMdPath, "utf-8");
+    const skillMdPath = path13.join(outputDir, dirName, "SKILL.md");
+    if (fs11.existsSync(skillMdPath)) {
+      const content = fs11.readFileSync(skillMdPath, "utf-8");
       if (content.includes(GENERATED_HEADER_CODEX)) {
         removed.push(dirName);
       }
@@ -2500,19 +2411,19 @@ function detectCodexOrphans(outputDir, specSkillNames) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path15.join(opts.output, "harness");
+    return path14.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os.homedir();
-    if (platform === "claude-code") return path15.join(home, ".claude", "commands", "harness");
-    if (platform === "gemini-cli") return path15.join(home, ".gemini", "commands", "harness");
-    if (platform === "cursor") return path15.join(home, ".cursor", "rules", "harness");
-    return path15.join(home, ".codex", "harness");
+    if (platform === "claude-code") return path14.join(home, ".claude", "commands", "harness");
+    if (platform === "gemini-cli") return path14.join(home, ".gemini", "commands", "harness");
+    if (platform === "cursor") return path14.join(home, ".cursor", "rules", "harness");
+    return path14.join(home, ".codex", "harness");
   }
-  if (platform === "claude-code") return path15.join("agents", "commands", "claude-code", "harness");
-  if (platform === "gemini-cli") return path15.join("agents", "commands", "gemini-cli", "harness");
-  if (platform === "cursor") return path15.join("agents", "commands", "cursor", "harness");
-  return path15.join("agents", "commands", "codex", "harness");
+  if (platform === "claude-code") return path14.join("agents", "commands", "claude-code", "harness");
+  if (platform === "gemini-cli") return path14.join("agents", "commands", "gemini-cli", "harness");
+  if (platform === "cursor") return path14.join("agents", "commands", "cursor", "harness");
+  return path14.join("agents", "commands", "codex", "harness");
 }
 async function confirmDeletion(files) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -2528,8 +2439,8 @@ function resolveSkillSources(opts) {
   const sources = [];
   const seenPaths = /* @__PURE__ */ new Set();
   function addSource(dir, source) {
-    const resolved = path15.resolve(dir);
-    if (!seenPaths.has(resolved) && fs13.existsSync(dir)) {
+    const resolved = path14.resolve(dir);
+    if (!seenPaths.has(resolved) && fs12.existsSync(dir)) {
       seenPaths.add(resolved);
       sources.push({ dir, source });
     }
@@ -2556,32 +2467,32 @@ function resolveAbsoluteExecutionContext(spec) {
     ...spec,
     prompt: {
       ...spec.prompt,
-      executionContext: spec.prompt.executionContext.split("\n").map((line) => line.startsWith("@") ? `@${path15.resolve(line.slice(1))}` : line).join("\n")
+      executionContext: spec.prompt.executionContext.split("\n").map((line) => line.startsWith("@") ? `@${path14.resolve(line.slice(1))}` : line).join("\n")
     }
   };
 }
 function renderSpec(platform, spec, useAbsolutePaths) {
   if (platform === "cursor") {
-    const mdPath2 = path15.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-    const skillMd = fs13.existsSync(mdPath2) ? fs13.readFileSync(mdPath2, "utf-8") : "";
+    const mdPath2 = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+    const skillMd = fs12.existsSync(mdPath2) ? fs12.readFileSync(mdPath2, "utf-8") : "";
     return [`${spec.skillYamlName}.mdc`, renderCursor(spec, skillMd, spec.cursor)];
   }
   if (platform === "claude-code") {
     const renderSpecValue = useAbsolutePaths ? resolveAbsoluteExecutionContext(spec) : spec;
     return [`${spec.name}.md`, renderClaudeCode(renderSpecValue)];
   }
-  const mdPath = path15.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-  const yamlPath = path15.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
-  const mdContent = fs13.existsSync(mdPath) ? fs13.readFileSync(mdPath, "utf-8") : "";
-  const yamlContent = fs13.existsSync(yamlPath) ? fs13.readFileSync(yamlPath, "utf-8") : "";
+  const mdPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+  const yamlPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+  const mdContent = fs12.existsSync(mdPath) ? fs12.readFileSync(mdPath, "utf-8") : "";
+  const yamlContent = fs12.existsSync(yamlPath) ? fs12.readFileSync(yamlPath, "utf-8") : "";
   return [`${spec.name}.toml`, renderGemini(spec, mdContent, yamlContent)];
 }
 function generateForCodex(platform, outputDir, specs, dryRun) {
   const codexSync = computeCodexSync(outputDir, specs, dryRun);
-  const codexRoot = path15.dirname(outputDir);
+  const codexRoot = path14.dirname(outputDir);
   if (!dryRun) {
-    fs13.mkdirSync(codexRoot, { recursive: true });
-    fs13.writeFileSync(path15.join(codexRoot, "AGENTS.md"), renderCodexAgentsMd(specs), "utf-8");
+    fs12.mkdirSync(codexRoot, { recursive: true });
+    fs12.writeFileSync(path14.join(codexRoot, "AGENTS.md"), renderCodexAgentsMd(specs), "utf-8");
   }
   return { platform, ...codexSync, outputDir };
 }
@@ -2612,9 +2523,9 @@ function generateForPlatform(platform, outputDir, specs, opts) {
   const allUpdated = [...plan.updated];
   const allRemoved = [...plan.removed];
   const allUnchanged = [...plan.unchanged];
-  const parentDir = path15.dirname(outputDir);
+  const parentDir = path14.dirname(outputDir);
   for (const [ns, nsRendered] of customNamespaceRendered) {
-    const nsDir = path15.join(parentDir, ns);
+    const nsDir = path14.join(parentDir, ns);
     const nsPlan = computeSyncPlan(nsDir, nsRendered);
     if (!opts.dryRun) {
       applySyncPlan(nsDir, nsRendered, nsPlan, false);
@@ -2664,13 +2575,13 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (!shouldDelete) continue;
     for (const filename of result.removed) {
-      const filePath = path15.join(result.outputDir, filename);
-      if (!fs13.existsSync(filePath)) continue;
-      const stat = fs13.statSync(filePath);
+      const filePath = path14.join(result.outputDir, filename);
+      if (!fs12.existsSync(filePath)) continue;
+      const stat = fs12.statSync(filePath);
       if (stat.isDirectory()) {
-        fs13.rmSync(filePath, { recursive: true, force: true });
+        fs12.rmSync(filePath, { recursive: true, force: true });
       } else {
-        fs13.unlinkSync(filePath);
+        fs12.unlinkSync(filePath);
       }
     }
   }
@@ -2801,7 +2712,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-TG63OKA5.js");
+    const { loadState, migrateToStreams } = await import("./dist-CPKL5Y2R.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -2919,7 +2830,7 @@ async function handleQueryGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-PGQ32ZI7.js");
+    const { ContextQL } = await import("./dist-BZS2XRLG.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -3001,7 +2912,7 @@ async function handleSearchSimilar(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer } = await import("./dist-PGQ32ZI7.js");
+    const { FusionLayer } = await import("./dist-BZS2XRLG.js");
     const fusion = new FusionLayer(store);
     const results = fusion.search(input.query, input.topK ?? 10);
     if (input.mode === "summary") {
@@ -3056,7 +2967,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-PGQ32ZI7.js");
+    const { FusionLayer, ContextQL } = await import("./dist-BZS2XRLG.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -3161,7 +3072,7 @@ async function handleGetRelationships(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-PGQ32ZI7.js");
+    const { ContextQL } = await import("./dist-BZS2XRLG.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -3279,7 +3190,7 @@ async function handleGetImpact(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-PGQ32ZI7.js");
+    const { ContextQL } = await import("./dist-BZS2XRLG.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -3390,7 +3301,7 @@ async function handleGetImpact(input) {
 }
 
 // src/mcp/tools/graph/ingest-source.ts
-import * as path16 from "path";
+import * as path15 from "path";
 var ingestSourceDefinition = {
   name: "ingest_source",
   description: "Ingest sources into the project knowledge graph. Supports code analysis, knowledge documents, git history, or all at once.",
@@ -3410,8 +3321,8 @@ var ingestSourceDefinition = {
 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-PGQ32ZI7.js");
+    const graphDir = path15.join(projectPath, ".harness", "graph");
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-BZS2XRLG.js");
     const fs17 = await import("fs/promises");
     await fs17.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
@@ -3435,13 +3346,13 @@ async function handleIngestSource(input) {
       results.push(gitResult);
     }
     if (input.source === "business-signals" || input.source === "all") {
-      const { createExtractionRunner } = await import("./dist-PGQ32ZI7.js");
-      const extractedDir = path16.join(projectPath, ".harness", "knowledge", "extracted");
+      const { createExtractionRunner } = await import("./dist-BZS2XRLG.js");
+      const extractedDir = path15.join(projectPath, ".harness", "knowledge", "extracted");
       const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
       results.push(signalsResult);
     }
     if (input.source === "diagrams" || input.source === "all") {
-      const { DiagramParser } = await import("./dist-PGQ32ZI7.js");
+      const { DiagramParser } = await import("./dist-BZS2XRLG.js");
       const diagramParser = new DiagramParser(store);
       const diagramResult = await diagramParser.ingest(projectPath);
       results.push(diagramResult);
@@ -3507,7 +3418,7 @@ async function handleDetectAnomalies(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { GraphAnomalyAdapter } = await import("./dist-PGQ32ZI7.js");
+    const { GraphAnomalyAdapter } = await import("./dist-BZS2XRLG.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -3556,7 +3467,7 @@ async function handleAskGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { askGraph } = await import("./dist-PGQ32ZI7.js");
+    const { askGraph } = await import("./dist-BZS2XRLG.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -3620,7 +3531,7 @@ async function handleComputeBlastRadius(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { CascadeSimulator } = await import("./dist-PGQ32ZI7.js");
+    const { CascadeSimulator } = await import("./dist-BZS2XRLG.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.file) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -3707,8 +3618,8 @@ async function handleComputeBlastRadius(input) {
 }
 
 // src/mcp/resources/graph.ts
-import * as fs14 from "fs/promises";
-import * as path17 from "path";
+import * as fs13 from "fs/promises";
+import * as path16 from "path";
 var MAX_ITEMS = 5e3;
 function formatStaleness(isoTimestamp) {
   const then = new Date(isoTimestamp).getTime();
@@ -3731,9 +3642,9 @@ function countByType(items) {
   return counts;
 }
 async function readLastScanTimestamp(projectRoot) {
-  const metadataPath = path17.join(projectRoot, ".harness", "graph", "metadata.json");
+  const metadataPath = path16.join(projectRoot, ".harness", "graph", "metadata.json");
   try {
-    const raw = JSON.parse(await fs14.readFile(metadataPath, "utf-8"));
+    const raw = JSON.parse(await fs13.readFile(metadataPath, "utf-8"));
     return raw.lastScanTimestamp ?? null;
   } catch {
     return null;
@@ -3821,7 +3732,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-I4B7CVOB.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-FOSFADNR.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -3832,8 +3743,8 @@ async function handleGenerateAgentDefinitions(input) {
 }
 
 // src/mcp/tools/roadmap.ts
-import * as fs15 from "fs";
-import * as path18 from "path";
+import * as fs14 from "fs";
+import * as path17 from "path";
 var manageRoadmapDefinition = {
   name: "manage_roadmap",
   description: "Manage the project roadmap: show, add, update, remove, sync features, or query by filter. Reads and writes docs/roadmap.md.",
@@ -3892,21 +3803,21 @@ var manageRoadmapDefinition = {
   }
 };
 function roadmapPath(projectRoot) {
-  return path18.join(projectRoot, "docs", "roadmap.md");
+  return path17.join(projectRoot, "docs", "roadmap.md");
 }
 function readRoadmapFile(projectRoot) {
   const filePath = roadmapPath(projectRoot);
   try {
-    return fs15.readFileSync(filePath, "utf-8");
+    return fs14.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writeRoadmapFile(projectRoot, content) {
   const filePath = roadmapPath(projectRoot);
-  const dir = path18.dirname(filePath);
-  fs15.mkdirSync(dir, { recursive: true });
-  fs15.writeFileSync(filePath, content, "utf-8");
+  const dir = path17.dirname(filePath);
+  fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(filePath, content, "utf-8");
 }
 function roadmapNotFoundError() {
   return {
@@ -4149,7 +4060,7 @@ function shouldTriggerExternalSync(input, response) {
 }
 async function handleManageRoadmap(input) {
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-TG63OKA5.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-CPKL5Y2R.js");
     const { Ok: Ok2 } = await import("./dist-3EWNRFFQ.js");
     const projectPath = sanitizePath(input.path);
     const deps = {
@@ -4588,7 +4499,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-TG63OKA5.js");
+    const { saveHandoff } = await import("./dist-CPKL5Y2R.js");
     await saveHandoff(
       projectPath,
       {
@@ -4669,7 +4580,7 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-TG63OKA5.js");
+    const { loadState, saveState } = await import("./dist-CPKL5Y2R.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -4827,13 +4738,13 @@ async function handleGatherContext(input) {
     };
   }
   const includeSet = new Set(
-    input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
+    input.include ?? ["state", "learnings", "handoff", "graph", "validation", "businessKnowledge"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-TG63OKA5.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-CPKL5Y2R.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-TG63OKA5.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-CPKL5Y2R.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -4842,14 +4753,14 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-TG63OKA5.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-CPKL5Y2R.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-TIVI6NQ7.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-QEI7SYOQ.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return null;
-    const { FusionLayer, ContextQL } = await import("./dist-PGQ32ZI7.js");
+    const { FusionLayer, ContextQL } = await import("./dist-BZS2XRLG.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -4886,11 +4797,11 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-TG63OKA5.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-CPKL5Y2R.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-TG63OKA5.js").then(async (core) => {
+  const eventsPromise = shouldIncludeEvents ? import("./dist-CPKL5Y2R.js").then(async (core) => {
     const result = await core.loadEvents(projectPath, {
       session: input.session
     });
@@ -4898,13 +4809,13 @@ async function handleGatherContext(input) {
     return core.formatEventTimeline(result.value);
   }) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-HXM6DXRZ.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-EAVGKZQB.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
   })() : Promise.resolve(null);
   const businessKnowledgePromise = includeSet.has("businessKnowledge") ? (async () => {
-    const { getBusinessKnowledgeResource: getBusinessKnowledgeResource2 } = await import("./business-knowledge-6RHYJOB3.js");
+    const { getBusinessKnowledgeResource: getBusinessKnowledgeResource2 } = await import("./business-knowledge-EISPR7FU.js");
     const raw = await getBusinessKnowledgeResource2(projectPath);
     return JSON.parse(raw);
   })() : Promise.resolve(null);
@@ -5001,7 +4912,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-TG63OKA5.js");
+      const core = await import("./dist-CPKL5Y2R.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -5153,7 +5064,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-HS7ZYXOU.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-7EC4T6XG.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -5188,7 +5099,7 @@ function extractFileCount(diffParsed) {
   return files?.length ?? 0;
 }
 async function runStandardReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-HS7ZYXOU.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-7EC4T6XG.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -5223,7 +5134,7 @@ async function runStandardReview(projectPath, diff, diffLines, downgraded, offse
   };
 }
 async function runDeepReview(projectPath, diff, diffLines, _downgraded, offset, limit) {
-  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-QOZGWCTY.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-B4WPU6BQ.js");
   const result = await handleRunCodeReview2({
     path: projectPath,
     diff,
@@ -5302,7 +5213,7 @@ async function handleCheckTaskIndependence(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { TaskIndependenceAnalyzer } = await import("./dist-PGQ32ZI7.js");
+    const { TaskIndependenceAnalyzer } = await import("./dist-BZS2XRLG.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -5390,7 +5301,7 @@ async function handlePredictConflicts(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { ConflictPredictor } = await import("./dist-PGQ32ZI7.js");
+    const { ConflictPredictor } = await import("./dist-BZS2XRLG.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -5496,7 +5407,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-TIVI6NQ7.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-QEI7SYOQ.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -5517,7 +5428,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-TG63OKA5.js");
+    const { detectStaleConstraints } = await import("./dist-CPKL5Y2R.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -5549,8 +5460,8 @@ init_dist();
 
 // src/skill/health-snapshot.ts
 import { execSync } from "child_process";
-import * as fs16 from "fs";
-import * as path19 from "path";
+import * as fs15 from "fs";
+import * as path18 from "path";
 var CACHE_FILE = "health-snapshot.json";
 var STALENESS_MS = 36e5;
 function isSnapshotFresh(snapshot, projectPath) {
@@ -5567,19 +5478,19 @@ function isSnapshotFresh(snapshot, projectPath) {
   return age < STALENESS_MS;
 }
 function loadCachedSnapshot(projectPath) {
-  const filePath = path19.join(projectPath, ".harness", CACHE_FILE);
+  const filePath = path18.join(projectPath, ".harness", CACHE_FILE);
   try {
-    const raw = fs16.readFileSync(filePath, "utf-8");
+    const raw = fs15.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));
+  const dir = path18.join(projectPath, ".harness");
+  fs15.mkdirSync(dir, { recursive: true });
+  const filePath = path18.join(dir, CACHE_FILE);
+  fs15.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
 }
 var SIGNAL_RULES = [
   ["circular-deps", (c) => c.deps.circularDeps > 0],
@@ -5637,10 +5548,10 @@ function countCriticalFindings(securityData) {
   return findings.filter((f) => f.severity === "error").length;
 }
 async function runHealthChecks(projectPath) {
-  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-ZW7EKNIT.js");
-  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-PMVMO6SF.js");
-  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-RXESIYKC.js");
-  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-2K7UUK6T.js");
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-LLWWEQEV.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-ZR33YKJB.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-FIEE4YDA.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-25VFLIAO.js");
   const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
     handleAssessProject2({
       path: projectPath,
@@ -5695,10 +5606,10 @@ function avg(values) {
 }
 async function runGraphMetrics(projectPath) {
   try {
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-TIVI6NQ7.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-QEI7SYOQ.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return ZERO_METRICS;
-    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-PGQ32ZI7.js");
+    const { GraphCouplingAdapter, GraphComplexityAdapter, GraphAnomalyAdapter } = await import("./dist-BZS2XRLG.js");
     const couplingAdapter = new GraphCouplingAdapter(store);
     const couplingData = couplingAdapter.computeCouplingData();
     const files = couplingData.files;
@@ -5927,7 +5838,8 @@ function resolveMetricValue(metrics, metricName) {
 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] ?? [];
+    const canonicalName = name.replace(/^harness-/, "");
+    const addresses = entry.addresses.length > 0 ? entry.addresses : FALLBACK_RULES[name] ?? FALLBACK_RULES[canonicalName] ?? [];
     index.set(name, { addresses, dependsOn: entry.dependsOn });
   }
   for (const [name, addresses] of Object.entries(FALLBACK_RULES)) {
@@ -6087,7 +5999,14 @@ function recommend(snapshot, skills, options = {}) {
   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))];
+  let merged = [...hardRecs, ...softRecs.filter((r) => !hardSkills.has(r.skillName))];
+  const { trigger, skillTriggers } = options;
+  if (trigger && skillTriggers) {
+    merged = merged.filter((r) => {
+      const triggers = skillTriggers.get(r.skillName);
+      return triggers ? triggers.includes(trigger) : true;
+    });
+  }
   merged.sort((a, b) => b.score - a.score);
   const limited = merged.slice(0, top);
   const depMap = /* @__PURE__ */ new Map();
@@ -6252,7 +6171,12 @@ 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 recOpts = {
+    top: limit
+  };
+  if (options.trigger) recOpts.trigger = options.trigger;
+  if (options.skillTriggers) recOpts.skillTriggers = options.skillTriggers;
+  const recResult = recommend(enrichedSnapshot, {}, recOpts);
   const addressIndex = buildSkillAddressIndex({});
   const skills = recResult.recommendations.map((rec, i) => {
     const prevRec = i > 0 ? recResult.recommendations[i - 1] : null;
@@ -6303,6 +6227,8 @@ async function dispatchSkillsFromGit(projectPath, options = {}) {
   const ctx = await enrichSnapshotForDispatch(projectPath, enrichOpts);
   const dispatchOpts = {};
   if (options.limit !== void 0) dispatchOpts.limit = options.limit;
+  if (options.trigger) dispatchOpts.trigger = options.trigger;
+  if (options.skillTriggers) dispatchOpts.skillTriggers = options.skillTriggers;
   return dispatchSkills(ctx, dispatchOpts);
 }
 
@@ -6333,6 +6259,10 @@ var dispatchSkillsDefinition = {
       limit: {
         type: "number",
         description: "Maximum number of skills to return (default: 5)"
+      },
+      trigger: {
+        type: "string",
+        description: "Filter to skills declaring this trigger (e.g. on_pr, on_commit, on_milestone, on_task_complete, on_refactor, on_review). Only skills whose triggers array includes this value are returned."
       }
     },
     required: []
@@ -6345,19 +6275,23 @@ function buildEnrichOpts(files, commitMessage, fresh) {
   if (fresh) opts.fresh = fresh;
   return opts;
 }
-async function dispatchWithExplicitInput(projectRoot, files, commitMessage, fresh, limit) {
+async function dispatchWithExplicitInput(projectRoot, files, commitMessage, fresh, limit, trigger, skillTriggers) {
   const ctx = await enrichSnapshotForDispatch(
     projectRoot,
     buildEnrichOpts(files, commitMessage, fresh)
   );
   const dispatchOpts = {};
   if (limit !== 5) dispatchOpts.limit = limit;
+  if (trigger) dispatchOpts.trigger = trigger;
+  if (skillTriggers) dispatchOpts.skillTriggers = skillTriggers;
   return dispatchSkills(ctx, dispatchOpts);
 }
-async function dispatchFromGit(projectRoot, fresh, limit) {
+async function dispatchFromGit(projectRoot, fresh, limit, trigger, skillTriggers) {
   const opts = {};
   if (fresh) opts.fresh = fresh;
   if (limit !== 5) opts.limit = limit;
+  if (trigger) opts.trigger = trigger;
+  if (skillTriggers) opts.skillTriggers = skillTriggers;
   return dispatchSkillsFromGit(projectRoot, opts);
 }
 async function handleDispatchSkills(input) {
@@ -6366,9 +6300,30 @@ async function handleDispatchSkills(input) {
   const commitMessage = input.commitMessage;
   const fresh = input.fresh ?? false;
   const limit = input.limit ?? 5;
+  const trigger = input.trigger;
   try {
+    let skillTriggers;
+    if (trigger) {
+      try {
+        const { loadOrRebuildIndex: loadOrRebuildIndex2 } = await import("./index-builder-3AOQ3ZII.js");
+        const index = loadOrRebuildIndex2("claude-code", projectRoot);
+        skillTriggers = /* @__PURE__ */ new Map();
+        for (const [name, entry] of Object.entries(index.skills)) {
+          skillTriggers.set(name, entry.triggers ?? ["manual"]);
+        }
+      } catch {
+      }
+    }
     const hasExplicitInput = files !== void 0 || commitMessage !== void 0;
-    const result = hasExplicitInput ? await dispatchWithExplicitInput(projectRoot, files, commitMessage, fresh, limit) : await dispatchFromGit(projectRoot, fresh, limit);
+    const result = hasExplicitInput ? await dispatchWithExplicitInput(
+      projectRoot,
+      files,
+      commitMessage,
+      fresh,
+      limit,
+      trigger,
+      skillTriggers
+    ) : await dispatchFromGit(projectRoot, fresh, limit, trigger, skillTriggers);
     if (result.skills.length > limit) {
       result.skills = result.skills.slice(0, limit);
     }
@@ -6437,7 +6392,7 @@ async function handleGetDecayTrends(input) {
     };
   }
   try {
-    const core = await import("./dist-TG63OKA5.js");
+    const core = await import("./dist-CPKL5Y2R.js");
     const { TimelineManager } = core;
     const manager = new TimelineManager(projectPath);
     const timeline = manager.load();
@@ -6572,7 +6527,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-TG63OKA5.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-CPKL5Y2R.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -6591,7 +6546,7 @@ async function handleCodeOutline(input) {
         })
       );
       fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      const { paginate: paginate2 } = await import("./dist-TG63OKA5.js");
+      const { paginate: paginate2 } = await import("./dist-CPKL5Y2R.js");
       const paged = paginate2(fileStats, input.offset ?? 0, input.limit ?? 30);
       const results = [];
       for (const entry of paged.items) {
@@ -6664,7 +6619,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-TG63OKA5.js");
+    const { searchSymbols } = await import("./dist-CPKL5Y2R.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) {
@@ -6733,7 +6688,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-TG63OKA5.js");
+      const { unfoldSymbol } = await import("./dist-CPKL5Y2R.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}
@@ -6741,7 +6696,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-TG63OKA5.js");
+      const { unfoldRange } = await import("./dist-CPKL5Y2R.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -6803,7 +6758,7 @@ async function handleCheckTraceability(input) {
         isError: true
       };
     }
-    const { queryTraceability } = await import("./dist-PGQ32ZI7.js");
+    const { queryTraceability } = await import("./dist-BZS2XRLG.js");
     const options = {};
     if (input.spec) options.specPath = input.spec;
     if (input.feature) options.featureName = input.feature;
@@ -6926,7 +6881,7 @@ async function handlePredictFailures(input) {
     };
   }
   try {
-    const core = await import("./dist-TG63OKA5.js");
+    const core = await import("./dist-CPKL5Y2R.js");
     const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
     const manager = new TimelineManager(projectPath);
     const includeRoadmap = input.includeRoadmap !== false;
@@ -7028,6 +6983,699 @@ async function handleRecommendSkills(input) {
   };
 }
 
+// src/mcp/tools/advise-skills.ts
+import path20 from "path";
+
+// src/commands/advise-skills.ts
+import { Command as Command2 } from "commander";
+import fs16 from "fs";
+import path19 from "path";
+import chalk from "chalk";
+
+// src/skill/content-matcher-types.ts
+var TIER_THRESHOLDS = {
+  apply: 0.6,
+  reference: 0.35,
+  consider: 0.15
+};
+var SCORING_WEIGHTS = {
+  keyword: 0.35,
+  stack: 0.25,
+  termOverlap: 0.25,
+  domain: 0.15
+};
+var DOMAIN_KEYWORD_MAP = {
+  design: [
+    "layout",
+    "responsive",
+    "typography",
+    "color",
+    "theme",
+    "dark mode",
+    "ui",
+    "ux",
+    "component",
+    "palette",
+    "breakpoint",
+    "grid",
+    "elevation",
+    "shadow",
+    "motion",
+    "animation",
+    "css"
+  ],
+  auth: [
+    "authentication",
+    "authorization",
+    "oauth",
+    "session",
+    "token",
+    "jwt",
+    "login",
+    "signup",
+    "password",
+    "credential",
+    "rbac",
+    "permission",
+    "identity"
+  ],
+  data: [
+    "database",
+    "schema",
+    "migration",
+    "query",
+    "sql",
+    "nosql",
+    "orm",
+    "model",
+    "table",
+    "transaction",
+    "prisma",
+    "drizzle"
+  ],
+  security: [
+    "security",
+    "vulnerability",
+    "xss",
+    "csrf",
+    "injection",
+    "sanitiz",
+    "encrypt",
+    "hash",
+    "owasp",
+    "cve",
+    "audit"
+  ],
+  a11y: [
+    "accessibility",
+    "a11y",
+    "aria",
+    "screen reader",
+    "screen-reader",
+    "wcag",
+    "contrast",
+    "keyboard navigation",
+    "focus management"
+  ],
+  perf: [
+    "performance",
+    "latency",
+    "throughput",
+    "cache",
+    "lazy load",
+    "bundle size",
+    "tree shaking",
+    "code splitting",
+    "lighthouse",
+    "optimization",
+    "bundle"
+  ],
+  testing: [
+    "test",
+    "coverage",
+    "mock",
+    "stub",
+    "fixture",
+    "assertion",
+    "snapshot",
+    "e2e",
+    "integration test",
+    "unit test",
+    "tdd"
+  ],
+  api: [
+    "api",
+    "endpoint",
+    "rest",
+    "graphql",
+    "openapi",
+    "swagger",
+    "route",
+    "middleware",
+    "webhook",
+    "grpc"
+  ],
+  infra: [
+    "docker",
+    "kubernetes",
+    "ci/cd",
+    "ci",
+    "cd",
+    "deploy",
+    "terraform",
+    "aws",
+    "gcp",
+    "azure",
+    "cloud",
+    "container",
+    "helm"
+  ],
+  mobile: [
+    "mobile",
+    "ios",
+    "android",
+    "react native",
+    "react-native",
+    "flutter",
+    "app store",
+    "push notification"
+  ]
+};
+
+// src/skill/signal-extractor.ts
+var STEM_SUFFIXES = [
+  "ation",
+  "tion",
+  "sion",
+  "ment",
+  "ness",
+  "ible",
+  "able",
+  "ive",
+  "ous",
+  "ful",
+  "ing",
+  "ity",
+  "ly",
+  "ed",
+  "er",
+  "es",
+  "s"
+];
+function simpleStem(word) {
+  const w = word.toLowerCase();
+  if (w.length <= 4) return w;
+  for (const suffix of STEM_SUFFIXES) {
+    if (w.endsWith(suffix) && w.length - suffix.length >= 3) {
+      return w.slice(0, -suffix.length);
+    }
+  }
+  return w;
+}
+function extractSpecKeywords(specText) {
+  const match = specText.match(/\*\*Keywords?:\*\*\s*(.+)/i);
+  if (!match?.[1]) return [];
+  return match[1].split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+}
+var STACK_SIGNAL_MAP = {
+  react: "react",
+  "react-dom": "react",
+  "react-native": "react-native",
+  next: "next",
+  vue: "vue",
+  nuxt: "nuxt",
+  angular: "angular",
+  svelte: "svelte",
+  express: "express",
+  fastify: "fastify",
+  nestjs: "nest",
+  "@nestjs/core": "nest",
+  typescript: "typescript",
+  tailwindcss: "tailwind",
+  prisma: "prisma",
+  "@prisma/client": "prisma",
+  "drizzle-orm": "drizzle",
+  graphql: "graphql",
+  "@trpc/server": "trpc",
+  trpc: "trpc",
+  vitest: "vitest",
+  jest: "jest",
+  playwright: "playwright",
+  cypress: "cypress",
+  vite: "vite",
+  webpack: "webpack",
+  zod: "zod",
+  mongoose: "mongoose",
+  redis: "redis",
+  ioredis: "redis",
+  "socket.io": "websocket",
+  ws: "websocket"
+};
+function detectStackFromDeps(dependencies, devDependencies) {
+  const signals = /* @__PURE__ */ new Set();
+  const allDeps = { ...dependencies, ...devDependencies };
+  for (const pkgName of Object.keys(allDeps)) {
+    const signal = STACK_SIGNAL_MAP[pkgName];
+    if (signal) {
+      signals.add(signal);
+    }
+  }
+  return [...signals].sort();
+}
+function inferDomain(specText) {
+  const lower = specText.toLowerCase();
+  const domains = [];
+  for (const [domain, markers] of Object.entries(DOMAIN_KEYWORD_MAP)) {
+    const hits = markers.filter((m) => lower.includes(m)).length;
+    if (hits >= 2) {
+      domains.push(domain);
+    }
+  }
+  return domains.sort();
+}
+function extractSignals(specText, dependencies, devDependencies, contextKeywords, taskText) {
+  const specKeywords = extractSpecKeywords(specText);
+  if (contextKeywords) {
+    const existing = new Set(specKeywords);
+    for (const kw of contextKeywords) {
+      if (!existing.has(kw)) {
+        specKeywords.push(kw);
+        existing.add(kw);
+      }
+    }
+  }
+  const stackSignals = detectStackFromDeps(dependencies, devDependencies);
+  const featureDomain = inferDomain(specText);
+  return {
+    specKeywords,
+    specText,
+    stackSignals,
+    featureDomain,
+    ...taskText !== void 0 && { taskText }
+  };
+}
+
+// src/skill/content-matcher.ts
+function computeKeywordOverlap(skillKeywords, specKeywords) {
+  if (skillKeywords.length === 0 || specKeywords.length === 0) return 0;
+  const stemTokens = (keywords) => {
+    const tokens = /* @__PURE__ */ new Set();
+    for (const kw of keywords) {
+      const parts = kw.toLowerCase().split(/[-_\s]+/);
+      for (const part of parts) {
+        if (part.length > 0) {
+          tokens.add(simpleStem(part));
+        }
+      }
+    }
+    return tokens;
+  };
+  const skillStems = stemTokens(skillKeywords);
+  const specStems = stemTokens(specKeywords);
+  let intersectionCount = 0;
+  for (const stem of skillStems) {
+    if (specStems.has(stem)) intersectionCount++;
+  }
+  const unionSize = (/* @__PURE__ */ new Set([...skillStems, ...specStems])).size;
+  return unionSize > 0 ? intersectionCount / unionSize : 0;
+}
+function computeStackMatch(skillSignals, projectSignals) {
+  if (skillSignals.length === 0) return 0;
+  const projectSet = new Set(projectSignals.map((s) => s.toLowerCase()));
+  const matched = skillSignals.filter((s) => projectSet.has(s.toLowerCase())).length;
+  return matched / skillSignals.length;
+}
+function computeTermOverlap(skillDescription, specText) {
+  if (!skillDescription || !specText) return 0;
+  const tokenize = (text) => text.toLowerCase().split(/[\s\-_,.;:!?()[\]{}"'`]+/).filter((t) => t.length > 3).map(simpleStem);
+  const descTokens = tokenize(skillDescription);
+  if (descTokens.length === 0) return 0;
+  const specTokenSet = new Set(tokenize(specText));
+  const matched = descTokens.filter((t) => specTokenSet.has(t)).length;
+  return matched / descTokens.length;
+}
+function computeDomainMatch(entry, featureDomains) {
+  if (featureDomains.length === 0 || entry.keywords.length === 0) return 0;
+  const skillKeywordsLower = entry.keywords.map((k) => k.toLowerCase());
+  for (const domain of featureDomains) {
+    const domainKeywords = DOMAIN_KEYWORD_MAP[domain];
+    if (!domainKeywords) continue;
+    const hasMatch = skillKeywordsLower.some(
+      (kw) => domainKeywords.some((dk) => kw.includes(dk) || dk.includes(kw))
+    );
+    if (hasMatch) return 1;
+  }
+  return 0;
+}
+function classifyTier(score) {
+  if (score >= TIER_THRESHOLDS.apply) return "apply";
+  if (score >= TIER_THRESHOLDS.reference) return "reference";
+  if (score >= TIER_THRESHOLDS.consider) return "consider";
+  return null;
+}
+var WHEN_RULES = [
+  { name: /scan|audit|i18n|lint/, when: "End of phase" },
+  { name: /test/, keywords: /test|tdd|coverage|mock|e2e|snapshot/, when: "Testing" },
+  {
+    name: /a11y|contrast|wcag|color.accessib/,
+    keywords: /contrast|wcag/,
+    when: "After styling"
+  },
+  { keywords: /css|tailwind|typography|font|color|palette/, when: "During styling" },
+  { keywords: /alignment|whitespace|spacing|grid/, when: "Layout review" },
+  { keywords: /motion|animation|transition|parallax/, when: "During polish" },
+  { keywords: /architect|pattern|api|schema|data.model/, when: "Architecture decisions" },
+  { name: /^(gof-|js-)/, when: "Architecture decisions" }
+];
+function matchesWhenRule(rule, nameLower, keywordsLower) {
+  const nameHit = rule.name ? rule.name.test(nameLower) : false;
+  const kwHit = rule.keywords ? rule.keywords.test(keywordsLower) : false;
+  if (rule.name && rule.keywords) return nameHit || kwHit;
+  return nameHit || kwHit;
+}
+function inferWhen(name, entry) {
+  const nameLower = name.toLowerCase();
+  const keywordsLower = entry.keywords.map((k) => k.toLowerCase()).join(" ");
+  for (const rule of WHEN_RULES) {
+    if (matchesWhenRule(rule, nameLower, keywordsLower)) return rule.when;
+  }
+  return "During implementation";
+}
+function scoreSkillByContent(entry, signals) {
+  const keywordScore = computeKeywordOverlap(entry.keywords, signals.specKeywords);
+  const stackScore = computeStackMatch(entry.stackSignals, signals.stackSignals);
+  const textToMatch = signals.taskText ?? signals.specText;
+  const descScore = computeTermOverlap(entry.description, textToMatch);
+  const domainScore = computeDomainMatch(entry, signals.featureDomain);
+  return SCORING_WEIGHTS.keyword * keywordScore + SCORING_WEIGHTS.stack * stackScore + SCORING_WEIGHTS.termOverlap * descScore + SCORING_WEIGHTS.domain * domainScore;
+}
+function buildMatchReasons(entry, signals) {
+  const reasons = [];
+  const matchedKeywords = entry.keywords.filter(
+    (kw) => signals.specKeywords.some(
+      (sk) => kw.toLowerCase().includes(sk.toLowerCase()) || sk.toLowerCase().includes(kw.toLowerCase())
+    )
+  );
+  if (matchedKeywords.length > 0) {
+    reasons.push(`Keywords: ${matchedKeywords.join(", ")}`);
+  }
+  const projectSignalSet = new Set(signals.stackSignals.map((s) => s.toLowerCase()));
+  const matchedStack = entry.stackSignals.filter((s) => projectSignalSet.has(s.toLowerCase()));
+  if (matchedStack.length > 0) {
+    reasons.push(`Stack: ${matchedStack.join(", ")}`);
+  }
+  if (signals.featureDomain.length > 0) {
+    reasons.push(`Domain: ${signals.featureDomain.join(", ")}`);
+  }
+  return reasons;
+}
+function inferCategory(entry) {
+  const keywordsLower = entry.keywords.map((k) => k.toLowerCase()).join(" ");
+  if (/design|layout|responsive|css|ui|ux|theme|color/.test(keywordsLower)) return "design";
+  if (/auth|oauth|session|token|jwt|login/.test(keywordsLower)) return "security";
+  if (/a11y|accessibility|aria|wcag/.test(keywordsLower)) return "a11y";
+  if (/perf|performance|cache|optimization|lighthouse/.test(keywordsLower)) return "perf";
+  if (/test|tdd|coverage|mock|e2e/.test(keywordsLower)) return "testing";
+  if (/database|sql|orm|migration|schema/.test(keywordsLower)) return "data";
+  if (/api|rest|graphql|endpoint/.test(keywordsLower)) return "api";
+  if (/docker|kubernetes|deploy|ci|terraform/.test(keywordsLower)) return "infra";
+  if (/react|vue|angular|svelte|next/.test(keywordsLower)) return "framework";
+  return "patterns";
+}
+function scoreAllSkills(index, signals) {
+  const scored = [];
+  for (const [name, entry] of Object.entries(index.skills)) {
+    const score = scoreSkillByContent(entry, signals);
+    if (score >= TIER_THRESHOLDS.consider) {
+      scored.push({ name, entry, score });
+    }
+  }
+  return scored;
+}
+function expandRelatedSkills(scored, index) {
+  const matchedNames = new Set(scored.map((s) => s.name));
+  const expansions = [];
+  for (const match of scored) {
+    if (match.score < TIER_THRESHOLDS.reference) continue;
+    for (const relatedName of match.entry.relatedSkills) {
+      if (matchedNames.has(relatedName)) continue;
+      const relatedEntry = index.skills[relatedName];
+      if (!relatedEntry) continue;
+      const boostedScore = match.score * 0.6;
+      if (boostedScore >= TIER_THRESHOLDS.consider) {
+        matchedNames.add(relatedName);
+        expansions.push({
+          name: relatedName,
+          entry: relatedEntry,
+          score: boostedScore,
+          parentName: match.name
+        });
+      }
+    }
+  }
+  return expansions;
+}
+function buildMatchList(scored, expansions, signals) {
+  const matches = [];
+  for (const { name, entry, score } of scored) {
+    const tier = classifyTier(score);
+    if (!tier) continue;
+    matches.push({
+      skillName: name,
+      score: Math.round(score * 100) / 100,
+      tier,
+      matchReasons: buildMatchReasons(entry, signals),
+      category: inferCategory(entry),
+      when: inferWhen(name, entry)
+    });
+  }
+  for (const { name, entry, score, parentName } of expansions) {
+    const tier = classifyTier(score);
+    if (!tier) continue;
+    matches.push({
+      skillName: name,
+      score: Math.round(score * 100) / 100,
+      tier,
+      matchReasons: [`Related to: ${parentName}`, ...buildMatchReasons(entry, signals)],
+      category: inferCategory(entry),
+      when: inferWhen(name, entry)
+    });
+  }
+  matches.sort((a, b) => b.score - a.score);
+  return matches;
+}
+function matchContent(index, signals) {
+  const startTime = performance.now();
+  const scored = scoreAllSkills(index, signals);
+  const expansions = expandRelatedSkills(scored, index);
+  const matches = buildMatchList(scored, expansions, signals);
+  return {
+    matches,
+    signalsUsed: signals,
+    scanDuration: Math.round(performance.now() - startTime)
+  };
+}
+
+// src/skill/skills-md-writer.ts
+function generateSkillsMd(featureName, result, totalSkillCount) {
+  const lines = [];
+  lines.push(`# Recommended Skills: ${featureName}`);
+  lines.push("");
+  lines.push("> Auto-generated by Pipeline Skill Advisor. Review and adjust as needed.");
+  const apply = result.matches.filter((m) => m.tier === "apply");
+  const reference = result.matches.filter((m) => m.tier === "reference");
+  const consider = result.matches.filter((m) => m.tier === "consider");
+  if (apply.length > 0) {
+    lines.push("");
+    lines.push("## Apply (invoke during execution)");
+    lines.push("");
+    lines.push(...renderTable(apply));
+  }
+  if (reference.length > 0) {
+    lines.push("");
+    lines.push("## Reference (load as context)");
+    lines.push("");
+    lines.push(...renderTable(reference));
+  }
+  if (consider.length > 0) {
+    lines.push("");
+    lines.push("## Consider");
+    lines.push("");
+    lines.push(...renderTable(consider));
+  }
+  lines.push("");
+  lines.push("---");
+  const skillsScanned = totalSkillCount ?? result.matches.length;
+  const keywords = result.signalsUsed.specKeywords.length;
+  const stack = result.signalsUsed.stackSignals.length;
+  const domains = result.signalsUsed.featureDomain.length;
+  lines.push(
+    `*Scanned ${skillsScanned} skills in ${result.scanDuration}ms. Signals: ${keywords} keywords, ${stack} stack markers, ${domains} domains.*`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function renderTable(matches) {
+  const lines = [];
+  lines.push("| Skill | Purpose | When | Relevance |");
+  lines.push("|-------|---------|------|-----------|");
+  for (const match of matches) {
+    const purpose = match.matchReasons.join("; ");
+    lines.push(`| \`${match.skillName}\` | ${purpose} | ${match.when} | ${match.score} |`);
+  }
+  return lines;
+}
+
+// src/commands/advise-skills.ts
+function readPackageDeps(cwd) {
+  const pkgPath = path19.join(cwd, "package.json");
+  if (!fs16.existsSync(pkgPath)) return { deps: {}, devDeps: {} };
+  try {
+    const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
+    const deps = typeof pkg.dependencies === "object" && pkg.dependencies !== null ? pkg.dependencies : {};
+    const devDeps = typeof pkg.devDependencies === "object" && pkg.devDependencies !== null ? pkg.devDependencies : {};
+    return { deps, devDeps };
+  } catch {
+    return { deps: {}, devDeps: {} };
+  }
+}
+function readSpecText(specPath) {
+  if (!fs16.existsSync(specPath)) {
+    throw new Error(`Spec not found: ${specPath}`);
+  }
+  return fs16.readFileSync(specPath, "utf-8");
+}
+function filterMatchesByTier(result, top, thorough) {
+  const applySkills = result.matches.filter((m) => m.tier === "apply").slice(0, top);
+  const refSkills = result.matches.filter((m) => m.tier === "reference").slice(0, top * 2);
+  const considerSkills = thorough ? result.matches.filter((m) => m.tier === "consider").slice(0, top) : [];
+  return { ...result, matches: [...applySkills, ...refSkills, ...considerSkills] };
+}
+function extractFeatureName(specText, specPath) {
+  const titleMatch = specText.match(/^#\s+(.+)/m);
+  return titleMatch?.[1] ?? path19.basename(path19.dirname(specPath));
+}
+async function runAdviseSkills(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const specPath = path19.resolve(cwd, options.specPath);
+  const specText = readSpecText(specPath);
+  const { deps, devDeps } = readPackageDeps(cwd);
+  const signals = extractSignals(specText, deps, devDeps);
+  const configResult = resolveConfig();
+  const tierOverrides = configResult.ok ? configResult.value.skills?.tierOverrides : void 0;
+  const index = loadOrRebuildIndex("claude-code", cwd, tierOverrides);
+  const totalSkills = Object.keys(index.skills).length;
+  const result = matchContent(index, signals);
+  const filteredResult = filterMatchesByTier(result, options.top ?? 5, !!options.thorough);
+  const featureName = extractFeatureName(specText, specPath);
+  const skillsMdPath = path19.join(path19.dirname(specPath), "SKILLS.md");
+  const md = generateSkillsMd(featureName, filteredResult, totalSkills);
+  fs16.writeFileSync(skillsMdPath, md, "utf-8");
+  return { result: filteredResult, skillsMdPath, featureName, totalSkills };
+}
+function formatOutput(featureName, result, skillsMdPath, totalSkills) {
+  const apply = result.matches.filter((m) => m.tier === "apply");
+  const ref = result.matches.filter((m) => m.tier === "reference");
+  const consider = result.matches.filter((m) => m.tier === "consider");
+  const lines = [];
+  lines.push(`Skill Advisor: Found ${result.matches.length} relevant skills for "${featureName}"`);
+  lines.push("");
+  if (apply.length > 0) {
+    lines.push(chalk.green(`  Apply (${apply.length}):`));
+    for (const m of apply) {
+      lines.push(`    ${m.skillName}  (${m.score}) \u2014 ${m.when}`);
+    }
+  }
+  if (ref.length > 0) {
+    lines.push(chalk.blue(`  Reference (${ref.length}):`));
+    for (const m of ref) {
+      lines.push(`    ${m.skillName}  (${m.score}) \u2014 ${m.when}`);
+    }
+  }
+  if (consider.length > 0) {
+    lines.push(chalk.dim(`  Consider (${consider.length}):`));
+    for (const m of consider) {
+      lines.push(`    ${m.skillName}  (${m.score}) \u2014 ${m.when}`);
+    }
+  }
+  lines.push("");
+  lines.push(`Scanned ${totalSkills} skills in ${result.scanDuration}ms`);
+  lines.push(`Written to ${skillsMdPath}`);
+  return lines.join("\n");
+}
+function createAdviseSkillsCommand() {
+  return new Command2("advise-skills").description("Content-based skill recommendations for a spec").requiredOption("--spec-path <path>", "Path to the spec (proposal.md)").option("--thorough", "Include Consider tier in output").option("--top <n>", "Max skills per tier (default 5)", parseInt).option("--json", "Output as JSON").action(async (opts) => {
+    try {
+      const { result, skillsMdPath, featureName, totalSkills } = await runAdviseSkills({
+        specPath: opts.specPath,
+        thorough: opts.thorough,
+        top: opts.top
+      });
+      if (opts.json) {
+        logger.info(JSON.stringify(result, null, 2));
+      } else {
+        logger.info(formatOutput(featureName, result, skillsMdPath, totalSkills));
+      }
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/mcp/tools/advise-skills.ts
+var adviseSkillsDefinition = {
+  name: "advise_skills",
+  description: "Content-based skill recommendations for a spec or feature description. Returns tiered matches with purpose and timing guidance.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Project root path (defaults to cwd)"
+      },
+      specPath: {
+        type: "string",
+        description: "Path to the spec file (proposal.md), relative to project root"
+      },
+      thorough: {
+        type: "boolean",
+        description: "Include Consider tier in output"
+      },
+      top: {
+        type: "number",
+        description: "Max skills per tier (default 5 apply, 10 reference)"
+      }
+    },
+    required: ["specPath"]
+  }
+};
+async function handleAdviseSkills(input) {
+  const projectRoot = input.path || process.cwd();
+  const specRelPath = input.specPath;
+  const thorough = input.thorough || false;
+  const top = input.top || 5;
+  try {
+    const { result, skillsMdPath, featureName, totalSkills } = await runAdviseSkills({
+      specPath: specRelPath,
+      cwd: projectRoot,
+      thorough,
+      top
+    });
+    const response = {
+      featureName,
+      skillsPath: path20.relative(projectRoot, skillsMdPath).replaceAll("\\", "/"),
+      totalScanned: totalSkills,
+      scanDuration: result.scanDuration,
+      apply: result.matches.filter((m) => m.tier === "apply").map((m) => ({
+        skill: m.skillName,
+        score: m.score,
+        when: m.when,
+        reasons: m.matchReasons
+      })),
+      reference: result.matches.filter((m) => m.tier === "reference").map((m) => ({
+        skill: m.skillName,
+        score: m.score,
+        when: m.when,
+        reasons: m.matchReasons
+      })),
+      consider: result.matches.filter((m) => m.tier === "consider").map((m) => ({
+        skill: m.skillName,
+        score: m.score,
+        when: m.when,
+        reasons: m.matchReasons
+      }))
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+    };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+    };
+  }
+}
+
 // src/mcp/tools/compact.ts
 init_dist();
 var COMPACT_TOOL_DEFAULT_BUDGET = 2e3;
@@ -7116,7 +7764,7 @@ function handleContentMode(content, pipeline, budget, source) {
   };
 }
 async function handleIntentMode(projectPath, intent, pipeline, budget, filterContent) {
-  const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-TIVI6NQ7.js");
+  const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-QEI7SYOQ.js");
   const store = await loadGraphStore2(projectPath);
   if (!store) {
     return {
@@ -7129,7 +7777,7 @@ async function handleIntentMode(projectPath, intent, pipeline, budget, filterCon
       isError: true
     };
   }
-  const { PackedSummaryCache, FusionLayer, ContextQL } = await import("./dist-PGQ32ZI7.js");
+  const { PackedSummaryCache, FusionLayer, ContextQL } = await import("./dist-BZS2XRLG.js");
   const cache = new PackedSummaryCache(store);
   const cachedEnvelope = cache.get(intent);
   if (cachedEnvelope) {
@@ -7342,7 +7990,7 @@ async function handleDetectConstraintEmergence(input) {
     }
     const nodePath = await import("path");
     const historyPath = nodePath.resolve(projectPath, ".harness/arch/violation-history.json");
-    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-TG63OKA5.js");
+    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-CPKL5Y2R.js");
     const manager = new ViolationHistoryManager(historyPath);
     const history = manager.load();
     const options = { windowWeeks, minOccurrences };
@@ -7371,6 +8019,146 @@ async function handleDetectConstraintEmergence(input) {
   }
 }
 
+// src/mcp/tools/ci.ts
+var VALID_CHECKS = [
+  "validate",
+  "deps",
+  "docs",
+  "entropy",
+  "security",
+  "perf",
+  "phase-gate",
+  "arch",
+  "traceability"
+];
+var runCIChecksDefinition = {
+  name: "run_ci_checks",
+  description: "Run CI/CD validation checks on a harness project. Returns pass/fail results per check with issues. Checks: validate, deps, docs, entropy, security, perf, phase-gate, arch, traceability.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" },
+      checks: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: VALID_CHECKS
+        },
+        description: "Subset of checks to run (default: all)"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleRunCIChecks(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
+    };
+  }
+  const configResult = resolveProjectConfig(projectPath);
+  if (!configResult.ok) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${configResult.error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const { runCIChecks } = await import("./dist-CPKL5Y2R.js");
+    const skip = input.checks ? VALID_CHECKS.filter((c) => !input.checks.includes(c)) : [];
+    const result = await runCIChecks({
+      projectRoot: projectPath,
+      config: configResult.value,
+      ...skip.length > 0 ? { skip } : {}
+    });
+    if (!result.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${result.error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result.value) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error running CI checks: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/blueprint.ts
+var generateBlueprintDefinition = {
+  name: "generate_blueprint",
+  description: "Scan a project and return its blueprint data (modules, hotspots, dependencies). Returns the scan results as JSON without writing files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" }
+    },
+    required: ["path"]
+  }
+};
+async function handleGenerateBlueprint(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 { ProjectScanner } = await import("./dist-CPKL5Y2R.js");
+    const scanner = new ProjectScanner(projectPath);
+    const data = await scanner.scan();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error generating blueprint: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
 // src/mcp/server.ts
 var TOOL_DEFINITIONS = [
   validateToolDefinition,
@@ -7427,10 +8215,13 @@ var TOOL_DEFINITIONS = [
   checkTraceabilityDefinition,
   predictFailuresDefinition,
   recommendSkillsDefinition,
+  adviseSkillsDefinition,
   computeBlastRadiusDefinition,
   dispatchSkillsDefinition,
   compactToolDefinition,
-  detectConstraintEmergenceDefinition
+  detectConstraintEmergenceDefinition,
+  runCIChecksDefinition,
+  generateBlueprintDefinition
 ].map((def) => ({ ...def, trustedOutput: true }));
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -7487,10 +8278,13 @@ var TOOL_HANDLERS = {
   check_traceability: handleCheckTraceability,
   predict_failures: handlePredictFailures,
   recommend_skills: handleRecommendSkills,
+  advise_skills: handleAdviseSkills,
   compute_blast_radius: handleComputeBlastRadius,
   dispatch_skills: handleDispatchSkills,
   compact: handleCompact,
-  detect_constraint_emergence: handleDetectConstraintEmergence
+  detect_constraint_emergence: handleDetectConstraintEmergence,
+  run_ci_checks: handleRunCIChecks,
+  generate_blueprint: handleGenerateBlueprint
 };
 var RESOURCE_DEFINITIONS = [
   {
@@ -7592,7 +8386,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-TG63OKA5.js");
+    } = await import("./dist-CPKL5Y2R.js");
     const { CLI_VERSION } = await import("./version-CUI434OP.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;
@@ -7686,6 +8480,7 @@ async function startServer(toolFilter) {
 }
 
 export {
+  createAdviseSkillsCommand,
   generateSlashCommands,
   handleOrphanDeletion,
   createGenerateSlashCommandsCommand,
@@ -7693,7 +8488,6 @@ export {
   persistToolingConfig,
   ensureHarnessGitignore,
   appendFrameworkAgents,
-  loadOrRebuildIndex,
   isSnapshotFresh,
   loadCachedSnapshot,
   captureHealthSnapshot,