@harness-engineering/cli 1.12.0 → 1.13.1

package/dist/{chunk-747VBPA4.js → chunk-NERR4TAO.js}

@@ -1,7 +1,7 @@
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-JLXOEO5C.js";
+} from "./chunk-DZS7CJKL.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -11,7 +11,7 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-2SWJ4VO7.js";
+} from "./chunk-TKJZKICB.js";
 import {
   analyzeDiffDefinition,
   createSelfReviewDefinition,
@@ -19,15 +19,15 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-FLOEMHDF.js";
+} from "./chunk-IM32EEDM.js";
 import {
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-EAURF4LH.js";
+} from "./chunk-65FRIL4D.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition
-} from "./chunk-TJVVU3HB.js";
+} from "./chunk-4ZMOCPYO.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_GEMINI,
@@ -38,21 +38,24 @@ import {
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-YXOG2277.js";
+} from "./chunk-NOPU4RZ4.js";
 import {
   loadGraphStore
-} from "./chunk-2YPZKGAG.js";
+} from "./chunk-IMFVFNJE.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-OIGVQF5V.js";
+} from "./chunk-QY4T6YAZ.js";
 import {
   resolveProjectConfig
 } from "./chunk-K6XAPGML.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-CTTFXXKJ.js";
+} from "./chunk-ND6PNADU.js";
+import {
+  resolveConfig
+} from "./chunk-Z77YQRQT.js";
 import {
   resultToMcpResponse
 } from "./chunk-IDZNPTYD.js";
@@ -60,13 +63,14 @@ import {
   sanitizePath
 } from "./chunk-W6Y7ZW3Y.js";
 import {
+  resolveAllSkillsDirs,
   resolveCommunitySkillsDir,
   resolveGlobalSkillsDir,
   resolvePersonasDir,
   resolveProjectSkillsDir,
   resolveSkillsDir,
   resolveTemplatesDir
-} from "./chunk-HD4IBGLA.js";
+} from "./chunk-N5G5QMS3.js";
 import {
   CLIError,
   ExitCode,
@@ -74,7 +78,7 @@ import {
 } from "./chunk-3WGJMBKH.js";
 import {
   SkillMetadataSchema
-} from "./chunk-VRFZWGMS.js";
+} from "./chunk-XYLGHKG6.js";
 import {
   Err,
   Ok
@@ -180,7 +184,7 @@ var initProjectDefinition = {
 };
 async function handleInitProject(input) {
   try {
-    const { TemplateEngine } = await import("./engine-BUWPAAGD.js");
+    const { TemplateEngine } = await import("./engine-OL4T6NZS.js");
     const templatesDir = resolveTemplatesDir();
     const engine = new TemplateEngine(templatesDir);
     const level = input.level ?? "basic";
@@ -218,7 +222,7 @@ var listPersonasDefinition = {
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-PCU5YWRH.js");
+  const { listPersonas } = await import("./loader-DPYFB6R6.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -242,10 +246,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-PCU5YWRH.js");
-  const { generateRuntime } = await import("./runtime-F6R27LD6.js");
-  const { generateAgentsMd } = await import("./agents-md-KIS2RSMG.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-NBL4OT4A.js");
+  const { loadPersona } = await import("./loader-DPYFB6R6.js");
+  const { generateRuntime } = await import("./runtime-X7U6SC7K.js");
+  const { generateAgentsMd } = await import("./agents-md-XU3BHE22.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-EHV65NQB.js");
   const personasDir = resolvePersonasDir();
   const filePath = path2.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -300,9 +304,9 @@ async function handleRunPersona(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.persona)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.persona}`)));
   }
-  const { loadPersona } = await import("./loader-PCU5YWRH.js");
+  const { loadPersona } = await import("./loader-DPYFB6R6.js");
   const { runPersona } = await import("./runner-VMYLHWOC.js");
-  const { executeSkill } = await import("./skill-executor-RG45LUO5.js");
+  const { executeSkill } = await import("./skill-executor-XZLYZYAK.js");
   const personasDir = resolvePersonasDir();
   const filePath = path2.join(personasDir, `${input.persona}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -466,8 +470,243 @@ async function handleRunAgentTask(input) {
 }
 
 // src/mcp/tools/skill.ts
-import * as fs from "fs";
-import * as path3 from "path";
+import * as fs3 from "fs";
+import * as path5 from "path";
+
+// src/skill/dispatcher.ts
+var TIER_1_SKILLS = /* @__PURE__ */ new Set([
+  "harness-brainstorming",
+  "harness-planning",
+  "harness-execution",
+  "harness-autopilot",
+  "harness-tdd",
+  "harness-debugging",
+  "harness-refactoring"
+]);
+function isTier1Skill(skillName) {
+  return TIER_1_SKILLS.has(skillName);
+}
+function scoreSkill(entry, queryTerms, profile, recentFiles) {
+  const matchedKeywords = entry.keywords.filter(
+    (kw) => queryTerms.some(
+      (term) => kw.toLowerCase().includes(term.toLowerCase()) || term.toLowerCase().includes(kw.toLowerCase())
+    )
+  );
+  const keywordScore = queryTerms.length > 0 ? matchedKeywords.length / queryTerms.length : 0;
+  let stackScore = 0;
+  if (profile && entry.stackSignals.length > 0) {
+    const matchedSignals = entry.stackSignals.filter((signal) => {
+      if (profile.signals[signal]) return true;
+      return profile.detectedDomains.some(
+        (domain) => entry.keywords.some((kw) => kw.toLowerCase() === domain.toLowerCase())
+      );
+    });
+    stackScore = matchedSignals.length / entry.stackSignals.length;
+  }
+  let recencyBoost = 0;
+  if (recentFiles.length > 0) {
+    const hasRecentMatch = entry.stackSignals.some((signal) => {
+      const cleanSignal = signal.replace(/\*/g, "").replace(/\*\*/g, "");
+      return recentFiles.some((f) => f.includes(cleanSignal));
+    });
+    recencyBoost = hasRecentMatch ? 1 : 0;
+  }
+  return 0.5 * keywordScore + 0.3 * stackScore + 0.2 * recencyBoost;
+}
+function suggest(index, taskDescription, profile, recentFiles, config) {
+  const queryTerms = taskDescription.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const scored = [];
+  for (const [name, entry] of Object.entries(index.skills)) {
+    if (config?.neverSuggest?.includes(name)) continue;
+    const score = scoreSkill(entry, queryTerms, profile, recentFiles);
+    const isForced = config?.alwaysSuggest?.includes(name);
+    if (score >= 0.4 || isForced) {
+      scored.push({
+        name,
+        description: entry.description,
+        score: isForced ? Math.max(score, 1) : score
+      });
+    }
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, 3);
+}
+function formatSuggestions(suggestions) {
+  if (suggestions.length === 0) return "";
+  const lines = suggestions.map((s) => `- **${s.name}** \u2014 ${s.description}`);
+  return [
+    "",
+    "---",
+    "## Suggested Domain Skills",
+    "Based on your task and project stack, these catalog skills may be relevant:",
+    ...lines,
+    "",
+    'To load a skill: call search_skills("<skill-name>") for full details.',
+    "---"
+  ].join("\n");
+}
+
+// src/skill/index-builder.ts
+import fs from "fs";
+import path3 from "path";
+import crypto from "crypto";
+import { parse } from "yaml";
+function computeSkillsDirHash(skillsDirs) {
+  const hash = crypto.createHash("sha256");
+  for (const dir of skillsDirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const yamlPath = path3.join(dir, entry.name, "skill.yaml");
+      if (!fs.existsSync(yamlPath)) continue;
+      const stat = fs.statSync(yamlPath);
+      hash.update(`${yamlPath}:${stat.mtimeMs}`);
+    }
+  }
+  return hash.digest("hex");
+}
+function parseSkillEntry(yamlPath, source, tierOverrides) {
+  const raw = fs.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;
+  if (effectiveTier !== 3 && source !== "community") return null;
+  return {
+    tier: effectiveTier ?? 3,
+    description: meta.description,
+    keywords: meta.keywords ?? [],
+    stackSignals: meta.stack_signals ?? [],
+    cognitiveMode: meta.cognitive_mode,
+    phases: (meta.phases ?? []).map((p) => p.name),
+    source
+  };
+}
+function scanDirectory(dir, source, index, tierOverrides) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (index.skills[entry.name]) continue;
+    const yamlPath = path3.join(dir, entry.name, "skill.yaml");
+    if (!fs.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 = path3.join(projectRoot, ".harness", "skills-index.json");
+  const skillsDirs = resolveAllSkillsDirs(platform);
+  const currentHash = computeSkillsDirHash(skillsDirs);
+  if (fs.existsSync(indexPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+      if (existing.hash === currentHash) return existing;
+    } catch {
+    }
+  }
+  const index = buildIndex(platform, projectRoot, tierOverrides);
+  fs.mkdirSync(path3.dirname(indexPath), { recursive: true });
+  fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+  return index;
+}
+
+// src/skill/stack-profile.ts
+import fs2 from "fs";
+import path4 from "path";
+var SIGNAL_DOMAIN_MAP = {
+  "prisma/schema.prisma": ["database"],
+  "drizzle.config.ts": ["database"],
+  "knexfile.js": ["database"],
+  "knexfile.ts": ["database"],
+  migrations: ["database"],
+  Dockerfile: ["containerization"],
+  "docker-compose.yml": ["containerization"],
+  "docker-compose.yaml": ["containerization"],
+  k8s: ["containerization"],
+  kubernetes: ["containerization"],
+  helm: ["containerization"],
+  ".github/workflows": ["deployment"],
+  ".gitlab-ci.yml": ["deployment"],
+  Jenkinsfile: ["deployment"],
+  terraform: ["infrastructure-as-code"],
+  "Pulumi.yaml": ["infrastructure-as-code"],
+  "cdk.json": ["infrastructure-as-code"],
+  "openapi.yaml": ["api-design"],
+  "openapi.json": ["api-design"],
+  "swagger.yaml": ["api-design"],
+  "swagger.json": ["api-design"],
+  "schema.graphql": ["api-design"],
+  ".env": ["secrets"],
+  ".env.example": ["secrets"],
+  "vault.hcl": ["secrets"],
+  e2e: ["e2e"],
+  cypress: ["e2e"],
+  "playwright.config.ts": ["e2e"],
+  "playwright.config.js": ["e2e"],
+  "stryker.conf.js": ["mutation-test"],
+  "stryker.conf.mjs": ["mutation-test"],
+  k6: ["load-testing"],
+  "artillery.yml": ["load-testing"],
+  "dbt_project.yml": ["data-pipeline"],
+  airflow: ["data-pipeline"],
+  ios: ["mobile-patterns"],
+  android: ["mobile-patterns"],
+  "pubspec.yaml": ["mobile-patterns"],
+  "App.tsx": ["mobile-patterns"],
+  runbooks: ["incident-response"],
+  "docs/runbooks": ["incident-response"]
+};
+function generateStackProfile(projectRoot) {
+  const signals = {};
+  const domainSet = /* @__PURE__ */ new Set();
+  for (const [pattern, domains] of Object.entries(SIGNAL_DOMAIN_MAP)) {
+    const fullPath = path4.join(projectRoot, pattern);
+    const exists = fs2.existsSync(fullPath);
+    signals[pattern] = exists;
+    if (exists) {
+      for (const domain of domains) domainSet.add(domain);
+    }
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    signals,
+    detectedDomains: [...domainSet].sort()
+  };
+}
+function loadOrGenerateProfile(projectRoot) {
+  const profilePath = path4.join(projectRoot, ".harness", "stack-profile.json");
+  if (fs2.existsSync(profilePath)) {
+    try {
+      return JSON.parse(fs2.readFileSync(profilePath, "utf-8"));
+    } catch {
+    }
+  }
+  const profile = generateStackProfile(projectRoot);
+  fs2.mkdirSync(path4.dirname(profilePath), { recursive: true });
+  fs2.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+  return profile;
+}
+
+// src/mcp/tools/skill.ts
 var runSkillDefinition = {
   name: "run_skill",
   description: "Load and return the content of a skill (SKILL.md), optionally with project state context",
@@ -492,23 +731,23 @@ 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 = path3.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 (!fs.existsSync(skillDir)) {
+  if (!fs3.existsSync(skillDir)) {
     return resultToMcpResponse(Err(new Error(`Skill not found: ${input.skill}`)));
   }
-  const skillMdPath = path3.join(skillDir, "SKILL.md");
-  if (!fs.existsSync(skillMdPath)) {
+  const skillMdPath = path5.join(skillDir, "SKILL.md");
+  if (!fs3.existsSync(skillMdPath)) {
     return resultToMcpResponse(Err(new Error(`SKILL.md not found for skill: ${input.skill}`)));
   }
-  let content = fs.readFileSync(skillMdPath, "utf-8");
+  let content = fs3.readFileSync(skillMdPath, "utf-8");
   if (input.path) {
     const projectPath = sanitizePath(input.path);
-    const stateFile = path3.join(projectPath, ".harness", "state.json");
-    if (fs.existsSync(stateFile)) {
-      const stateContent = fs.readFileSync(stateFile, "utf-8");
+    const stateFile = path5.join(projectPath, ".harness", "state.json");
+    if (fs3.existsSync(stateFile)) {
+      const stateContent = fs3.readFileSync(stateFile, "utf-8");
       content += `
 
 ---
@@ -519,6 +758,23 @@ ${stateContent}
 `;
     }
   }
+  if (isTier1Skill(input.skill)) {
+    try {
+      const projectRoot = input.path ? sanitizePath(input.path) : process.cwd();
+      const platform = "claude-code";
+      const configResult = resolveConfig();
+      const skillsConfig = configResult.ok ? configResult.value.skills : void 0;
+      const index = loadOrRebuildIndex(platform, projectRoot, skillsConfig?.tierOverrides);
+      const profile = loadOrGenerateProfile(projectRoot);
+      const taskDesc = [input.skill, input.phase].filter(Boolean).join(" ");
+      const suggestions = suggest(index, taskDesc, profile, [], skillsConfig);
+      const suggestionText = formatSuggestions(suggestions);
+      if (suggestionText) {
+        content += suggestionText;
+      }
+    } catch {
+    }
+  }
   return resultToMcpResponse(Ok(content));
 }
 var createSkillDefinition = {
@@ -548,7 +804,7 @@ var createSkillDefinition = {
 };
 async function handleCreateSkill(input) {
   try {
-    const { generateSkillFiles } = await import("./create-skill-WPXHSLX2.js");
+    const { generateSkillFiles } = await import("./create-skill-XSWHMSM5.js");
     const result = generateSkillFiles({
       name: input.name,
       description: input.description,
@@ -570,22 +826,22 @@ async function handleCreateSkill(input) {
 }
 
 // src/mcp/resources/skills.ts
-import * as fs2 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path6 from "path";
 import * as yaml from "yaml";
 async function getSkillsResource(projectRoot) {
-  const skillsDir = path4.join(projectRoot, "agents", "skills", "claude-code");
+  const skillsDir = path6.join(projectRoot, "agents", "skills", "claude-code");
   const skills = [];
-  if (!fs2.existsSync(skillsDir)) {
+  if (!fs4.existsSync(skillsDir)) {
     return JSON.stringify(skills, null, 2);
   }
-  const entries = fs2.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillYamlPath = path4.join(skillsDir, entry.name, "skill.yaml");
-    if (!fs2.existsSync(skillYamlPath)) continue;
+    const skillYamlPath = path6.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs4.existsSync(skillYamlPath)) continue;
     try {
-      const content = fs2.readFileSync(skillYamlPath, "utf-8");
+      const content = fs4.readFileSync(skillYamlPath, "utf-8");
       const parsed = yaml.parse(content);
       skills.push({
         name: parsed.name,
@@ -601,14 +857,14 @@ async function getSkillsResource(projectRoot) {
 }
 
 // src/mcp/resources/rules.ts
-import * as fs3 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path7 from "path";
 async function getRulesResource(projectRoot) {
   const rules = [];
-  const configPath = path5.join(projectRoot, "harness.config.json");
-  if (fs3.existsSync(configPath)) {
+  const configPath = path7.join(projectRoot, "harness.config.json");
+  if (fs5.existsSync(configPath)) {
     try {
-      const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
       if (config.layers) {
         rules.push({ type: "layer-enforcement", config: config.layers });
       }
@@ -621,10 +877,10 @@ async function getRulesResource(projectRoot) {
     } catch {
     }
   }
-  const linterPath = path5.join(projectRoot, ".harness", "linter.json");
-  if (fs3.existsSync(linterPath)) {
+  const linterPath = path7.join(projectRoot, ".harness", "linter.json");
+  if (fs5.existsSync(linterPath)) {
     try {
-      const linterConfig = JSON.parse(fs3.readFileSync(linterPath, "utf-8"));
+      const linterConfig = JSON.parse(fs5.readFileSync(linterPath, "utf-8"));
       rules.push({ type: "linter", config: linterConfig });
     } catch {
     }
@@ -633,28 +889,28 @@ async function getRulesResource(projectRoot) {
 }
 
 // src/mcp/resources/project.ts
-import * as fs4 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
 async function getProjectResource(projectRoot) {
-  const agentsPath = path6.join(projectRoot, "AGENTS.md");
-  if (fs4.existsSync(agentsPath)) {
-    return fs4.readFileSync(agentsPath, "utf-8");
+  const agentsPath = path8.join(projectRoot, "AGENTS.md");
+  if (fs6.existsSync(agentsPath)) {
+    return fs6.readFileSync(agentsPath, "utf-8");
   }
   return "# No AGENTS.md found";
 }
 
 // src/mcp/resources/learnings.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 async function getLearningsResource(projectRoot) {
   const sections = [];
-  const reviewPath = path7.join(projectRoot, ".harness", "review-learnings.md");
-  if (fs5.existsSync(reviewPath)) {
-    sections.push("## Review Learnings\n\n" + fs5.readFileSync(reviewPath, "utf-8"));
+  const reviewPath = path9.join(projectRoot, ".harness", "review-learnings.md");
+  if (fs7.existsSync(reviewPath)) {
+    sections.push("## Review Learnings\n\n" + fs7.readFileSync(reviewPath, "utf-8"));
   }
-  const antiPath = path7.join(projectRoot, ".harness", "anti-patterns.md");
-  if (fs5.existsSync(antiPath)) {
-    sections.push("## Anti-Pattern Log\n\n" + fs5.readFileSync(antiPath, "utf-8"));
+  const antiPath = path9.join(projectRoot, ".harness", "anti-patterns.md");
+  if (fs7.existsSync(antiPath)) {
+    sections.push("## Anti-Pattern Log\n\n" + fs7.readFileSync(antiPath, "utf-8"));
   }
   return sections.length > 0 ? sections.join("\n\n---\n\n") : "No learnings files found.";
 }
@@ -690,6 +946,10 @@ var manageStateDefinition = {
       stream: {
         type: "string",
         description: "Stream name to target (auto-resolves from branch if omitted)"
+      },
+      session: {
+        type: "string",
+        description: "Session slug for session-scoped state (takes priority over stream when provided)"
       }
     },
     required: ["path", "action"]
@@ -705,11 +965,11 @@ async function handleManageState(input) {
       archiveFailures,
       runMechanicalGate,
       DEFAULT_STATE
-    } = await import("./dist-IJ4J4C5G.js");
+    } = await import("./dist-2B363XUH.js");
     const projectPath = sanitizePath(input.path);
     switch (input.action) {
       case "show": {
-        const result = await loadState(projectPath, input.stream);
+        const result = await loadState(projectPath, input.stream, input.session);
         return resultToMcpResponse(result);
       }
       case "learn": {
@@ -726,7 +986,8 @@ async function handleManageState(input) {
           input.learning,
           input.skillName,
           input.outcome,
-          input.stream
+          input.stream,
+          input.session
         );
         if (!result.ok) return resultToMcpResponse(result);
         return resultToMcpResponse(Ok({ recorded: true }));
@@ -756,18 +1017,24 @@ async function handleManageState(input) {
           input.description,
           input.skillName ?? "unknown",
           input.failureType,
-          input.stream
+          input.stream,
+          input.session
         );
         if (!result.ok) return resultToMcpResponse(result);
         return resultToMcpResponse(Ok({ recorded: true }));
       }
       case "archive": {
-        const result = await archiveFailures(projectPath, input.stream);
+        const result = await archiveFailures(projectPath, input.stream, input.session);
         if (!result.ok) return resultToMcpResponse(result);
         return resultToMcpResponse(Ok({ archived: true }));
       }
       case "reset": {
-        const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream);
+        const result = await saveState(
+          projectPath,
+          { ...DEFAULT_STATE },
+          input.stream,
+          input.session
+        );
         if (!result.ok) return resultToMcpResponse(result);
         return resultToMcpResponse(Ok({ reset: true }));
       }
@@ -784,17 +1051,18 @@ async function handleManageState(input) {
             isError: true
           };
         }
-        const { saveHandoff } = await import("./dist-IJ4J4C5G.js");
+        const { saveHandoff } = await import("./dist-2B363XUH.js");
         const result = await saveHandoff(
           projectPath,
           input.handoff,
-          input.stream
+          input.stream,
+          input.session
         );
         return resultToMcpResponse(result.ok ? Ok({ saved: true }) : result);
       }
       case "load-handoff": {
-        const { loadHandoff } = await import("./dist-IJ4J4C5G.js");
-        const result = await loadHandoff(projectPath, input.stream);
+        const { loadHandoff } = await import("./dist-2B363XUH.js");
+        const result = await loadHandoff(projectPath, input.stream, input.session);
         return resultToMcpResponse(result);
       }
       default: {
@@ -829,7 +1097,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-IJ4J4C5G.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-2B363XUH.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -867,7 +1135,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-K7QCSYRJ.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-2OFZ7OWW.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -887,7 +1155,7 @@ async function handleCheckPhaseGate(input) {
 }
 
 // src/mcp/tools/cross-check.ts
-import * as path8 from "path";
+import * as path10 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",
@@ -923,15 +1191,15 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-LJX65SBS.js");
-    const specsDir = path8.resolve(projectPath, input.specsDir ?? "docs/specs");
+    const { runCrossCheck } = await import("./validate-cross-check-STFHYMAZ.js");
+    const specsDir = path10.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: specsDir escapes project root" }],
         isError: true
       };
     }
-    const plansDir = path8.resolve(projectPath, input.plansDir ?? "docs/plans");
+    const plansDir = path10.resolve(projectPath, input.plansDir ?? "docs/plans");
     if (!plansDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: plansDir escapes project root" }],
@@ -962,15 +1230,15 @@ async function handleValidateCrossCheck(input) {
 
 // src/commands/generate-slash-commands.ts
 import { Command } from "commander";
-import fs7 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path12 from "path";
 import os from "os";
 import readline from "readline";
 
 // src/slash-commands/normalize.ts
-import fs6 from "fs";
-import path9 from "path";
-import { parse as parse2 } from "yaml";
+import fs8 from "fs";
+import path11 from "path";
+import { parse as parse3 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
 function normalizeName(skillName) {
@@ -990,18 +1258,18 @@ function normalizeSkills(skillSources, platforms) {
   const specs = [];
   const nameMap = /* @__PURE__ */ new Map();
   for (const { dir: skillsDir, source } of skillSources) {
-    if (!fs6.existsSync(skillsDir)) continue;
-    const entries = fs6.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    if (!fs8.existsSync(skillsDir)) continue;
+    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const entry of entries) {
-      const yamlPath = path9.join(skillsDir, entry.name, "skill.yaml");
-      if (!fs6.existsSync(yamlPath)) continue;
+      const yamlPath = path11.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs8.existsSync(yamlPath)) continue;
       let raw;
       try {
-        raw = fs6.readFileSync(yamlPath, "utf-8");
+        raw = fs8.readFileSync(yamlPath, "utf-8");
       } catch {
         continue;
       }
-      const parsed = parse2(raw);
+      const parsed = parse3(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
         console.warn(`Skipping ${entry.name}: invalid skill.yaml`);
@@ -1010,6 +1278,9 @@ function normalizeSkills(skillSources, platforms) {
       const meta = result.data;
       const matchesPlatform = platforms.some((p) => meta.platforms.includes(p));
       if (!matchesPlatform) continue;
+      const tier = meta.tier;
+      const isInternal = meta.internal;
+      if (tier === 3 || isInternal) continue;
       const normalized = normalizeName(meta.name);
       const existing = nameMap.get(normalized);
       if (existing) {
@@ -1021,16 +1292,10 @@ function normalizeSkills(skillSources, platforms) {
         continue;
       }
       nameMap.set(normalized, { skillName: meta.name, source });
-      const skillMdPath = path9.join(skillsDir, entry.name, "SKILL.md");
-      const skillMdContent = fs6.existsSync(skillMdPath) ? fs6.readFileSync(skillMdPath, "utf-8") : "";
-      const skillMdRelative = path9.relative(
-        process.cwd(),
-        path9.join(skillsDir, entry.name, "SKILL.md")
-      );
-      const skillYamlRelative = path9.relative(
-        process.cwd(),
-        path9.join(skillsDir, entry.name, "skill.yaml")
-      );
+      const skillMdPath = path11.join(skillsDir, entry.name, "SKILL.md");
+      const skillMdContent = fs8.existsSync(skillMdPath) ? fs8.readFileSync(skillMdPath, "utf-8") : "";
+      const skillMdRelative = path11.relative(process.cwd(), path11.join(skillsDir, entry.name, "SKILL.md")).replaceAll("\\", "/");
+      const skillYamlRelative = path11.relative(process.cwd(), path11.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
       const args = (meta.cli?.args ?? []).map((a) => ({
         name: a.name,
         description: a.description ?? "",
@@ -1195,13 +1460,13 @@ function renderGemini(spec, skillMdContent, skillYamlContent) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path10.join(opts.output, "harness");
+    return path12.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os.homedir();
-    return platform === "claude-code" ? path10.join(home, ".claude", "commands", "harness") : path10.join(home, ".gemini", "commands", "harness");
+    return platform === "claude-code" ? path12.join(home, ".claude", "commands", "harness") : path12.join(home, ".gemini", "commands", "harness");
   }
-  return platform === "claude-code" ? path10.join("agents", "commands", "claude-code", "harness") : path10.join("agents", "commands", "gemini-cli", "harness");
+  return platform === "claude-code" ? path12.join("agents", "commands", "claude-code", "harness") : path12.join("agents", "commands", "gemini-cli", "harness");
 }
 function fileExtension(platform) {
   return platform === "claude-code" ? ".md" : ".toml";
@@ -1226,12 +1491,12 @@ function generateSlashCommands(opts) {
       skillSources.push({ dir: projectDir, source: "project" });
     }
     const communityDir = resolveCommunitySkillsDir();
-    if (fs7.existsSync(communityDir)) {
+    if (fs9.existsSync(communityDir)) {
       skillSources.push({ dir: communityDir, source: "community" });
     }
     if (opts.includeGlobal || skillSources.length === 0) {
       const globalDir = resolveGlobalSkillsDir();
-      if (!projectDir || path10.resolve(globalDir) !== path10.resolve(projectDir)) {
+      if (!projectDir || path12.resolve(globalDir) !== path12.resolve(projectDir)) {
         skillSources.push({ dir: globalDir, source: "global" });
       }
     }
@@ -1253,7 +1518,7 @@ function generateSlashCommands(opts) {
             executionContext: spec.prompt.executionContext.split("\n").map((line) => {
               if (line.startsWith("@")) {
                 const relPath = line.slice(1);
-                return `@${path10.resolve(relPath)}`;
+                return `@${path12.resolve(relPath)}`;
               }
               return line;
             }).join("\n")
@@ -1261,10 +1526,10 @@ function generateSlashCommands(opts) {
         } : spec;
         rendered.set(filename, renderClaudeCode(renderSpec));
       } else {
-        const mdPath = path10.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-        const yamlPath = path10.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
-        const mdContent = fs7.existsSync(mdPath) ? fs7.readFileSync(mdPath, "utf-8") : "";
-        const yamlContent = fs7.existsSync(yamlPath) ? fs7.readFileSync(yamlPath, "utf-8") : "";
+        const mdPath = path12.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path12.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs9.existsSync(mdPath) ? fs9.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs9.existsSync(yamlPath) ? fs9.readFileSync(yamlPath, "utf-8") : "";
         rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
       }
     }
@@ -1290,9 +1555,9 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (shouldDelete) {
       for (const filename of result.removed) {
-        const filePath = path10.join(result.outputDir, filename);
-        if (fs7.existsSync(filePath)) {
-          fs7.unlinkSync(filePath);
+        const filePath = path12.join(result.outputDir, filename);
+        if (fs9.existsSync(filePath)) {
+          fs9.unlinkSync(filePath);
         }
       }
     }
@@ -1418,7 +1683,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-IJ4J4C5G.js");
+    const { loadState, migrateToStreams } = await import("./dist-2B363XUH.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -1442,8 +1707,7 @@ async function getStateResource(projectRoot) {
   }
 }
 
-// src/mcp/tools/graph.ts
-import * as path11 from "path";
+// src/mcp/tools/graph/shared.ts
 function graphNotFoundError() {
   return {
     content: [
@@ -1455,6 +1719,8 @@ function graphNotFoundError() {
     isError: true
   };
 }
+
+// src/mcp/tools/graph/query-graph.ts
 var queryGraphDefinition = {
   name: "query_graph",
   description: "Query the project knowledge graph using ContextQL. Traverses from root nodes outward, filtering by node/edge types.",
@@ -1505,7 +1771,7 @@ async function handleQueryGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-M6BQODWC.js");
+    const { ContextQL } = await import("./dist-HXHWB7SV.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -1571,6 +1837,8 @@ async function handleQueryGraph(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/search-similar.ts
 var searchSimilarDefinition = {
   name: "search_similar",
   description: "Search the knowledge graph for nodes similar to a query string using keyword and semantic fusion.",
@@ -1594,7 +1862,7 @@ async function handleSearchSimilar(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer } = await import("./dist-M6BQODWC.js");
+    const { FusionLayer } = await import("./dist-HXHWB7SV.js");
     const fusion = new FusionLayer(store);
     const results = fusion.search(input.query, input.topK ?? 10);
     if (input.mode === "summary") {
@@ -1626,6 +1894,8 @@ async function handleSearchSimilar(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/find-context-for.ts
 var findContextForDefinition = {
   name: "find_context_for",
   description: "Find relevant context for a given intent by searching the graph and expanding around top results. Returns assembled context within a token budget.",
@@ -1647,7 +1917,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-M6BQODWC.js");
+    const { FusionLayer, ContextQL } = await import("./dist-HXHWB7SV.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -1713,6 +1983,8 @@ async function handleFindContextFor(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/get-relationships.ts
 var getRelationshipsDefinition = {
   name: "get_relationships",
   description: "Get relationships for a specific node in the knowledge graph, with configurable direction and depth.",
@@ -1741,7 +2013,7 @@ async function handleGetRelationships(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-M6BQODWC.js");
+    const { ContextQL } = await import("./dist-HXHWB7SV.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -1808,6 +2080,8 @@ async function handleGetRelationships(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/get-impact.ts
 var getImpactDefinition = {
   name: "get_impact",
   description: "Analyze the impact of changing a node or file. Returns affected tests, docs, code, and other nodes grouped by type.",
@@ -1845,7 +2119,7 @@ async function handleGetImpact(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-M6BQODWC.js");
+    const { ContextQL } = await import("./dist-HXHWB7SV.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -1954,6 +2228,9 @@ async function handleGetImpact(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/ingest-source.ts
+import * as path13 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.",
@@ -1973,10 +2250,10 @@ var ingestSourceDefinition = {
 async function handleIngestSource(input) {
   try {
     const projectPath = sanitizePath(input.path);
-    const graphDir = path11.join(projectPath, ".harness", "graph");
-    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-M6BQODWC.js");
-    const fs10 = await import("fs/promises");
-    await fs10.mkdir(graphDir, { recursive: true });
+    const graphDir = path13.join(projectPath, ".harness", "graph");
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-HXHWB7SV.js");
+    const fs12 = await import("fs/promises");
+    await fs12.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -2025,6 +2302,8 @@ async function handleIngestSource(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/detect-anomalies.ts
 var detectAnomaliesDefinition = {
   name: "detect_anomalies",
   description: "Detect structural anomalies \u2014 statistical outliers across code metrics and topological single points of failure in the import graph",
@@ -2047,7 +2326,7 @@ async function handleDetectAnomalies(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { GraphAnomalyAdapter } = await import("./dist-M6BQODWC.js");
+    const { GraphAnomalyAdapter } = await import("./dist-HXHWB7SV.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -2068,6 +2347,8 @@ async function handleDetectAnomalies(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/ask-graph.ts
 var askGraphDefinition = {
   name: "ask_graph",
   description: 'Ask a natural language question about the codebase knowledge graph. Supports questions about impact ("what breaks if I change X?"), finding entities ("where is the auth middleware?"), relationships ("what calls UserService?"), explanations ("what is GraphStore?"), and anomalies ("what looks wrong?"). Returns a human-readable summary and raw graph data.',
@@ -2085,7 +2366,7 @@ async function handleAskGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { askGraph } = await import("./dist-M6BQODWC.js");
+    const { askGraph } = await import("./dist-HXHWB7SV.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -2104,8 +2385,8 @@ async function handleAskGraph(input) {
 }
 
 // src/mcp/resources/graph.ts
-import * as fs8 from "fs/promises";
-import * as path12 from "path";
+import * as fs10 from "fs/promises";
+import * as path14 from "path";
 var MAX_ITEMS = 5e3;
 function formatStaleness(isoTimestamp) {
   const then = new Date(isoTimestamp).getTime();
@@ -2128,11 +2409,11 @@ async function getGraphResource(projectRoot) {
       message: "No knowledge graph found. Run harness scan to build one."
     });
   }
-  const graphDir = path12.join(projectRoot, ".harness", "graph");
-  const metadataPath = path12.join(graphDir, "metadata.json");
+  const graphDir = path14.join(projectRoot, ".harness", "graph");
+  const metadataPath = path14.join(graphDir, "metadata.json");
   let lastScanTimestamp = null;
   try {
-    const raw = JSON.parse(await fs8.readFile(metadataPath, "utf-8"));
+    const raw = JSON.parse(await fs10.readFile(metadataPath, "utf-8"));
     lastScanTimestamp = raw.lastScanTimestamp ?? null;
   } catch {
   }
@@ -2221,7 +2502,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-J5HANRNR.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-64S3CLEZ.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -2232,8 +2513,8 @@ async function handleGenerateAgentDefinitions(input) {
 }
 
 // src/mcp/tools/roadmap.ts
-import * as fs9 from "fs";
-import * as path13 from "path";
+import * as fs11 from "fs";
+import * as path15 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.",
@@ -2288,309 +2569,261 @@ var manageRoadmapDefinition = {
   }
 };
 function roadmapPath(projectRoot) {
-  return path13.join(projectRoot, "docs", "roadmap.md");
+  return path15.join(projectRoot, "docs", "roadmap.md");
 }
 function readRoadmapFile(projectRoot) {
   const filePath = roadmapPath(projectRoot);
   try {
-    return fs9.readFileSync(filePath, "utf-8");
+    return fs11.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writeRoadmapFile(projectRoot, content) {
   const filePath = roadmapPath(projectRoot);
-  const dir = path13.dirname(filePath);
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(filePath, content, "utf-8");
+  const dir = path15.dirname(filePath);
+  fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(filePath, content, "utf-8");
+}
+function roadmapNotFoundError() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "Error: docs/roadmap.md not found. Create a roadmap first."
+      }
+    ],
+    isError: true
+  };
+}
+function handleShow(projectPath, input, deps) {
+  const { parseRoadmap, Ok: Ok2 } = deps;
+  const raw = readRoadmapFile(projectPath);
+  if (raw === null) return roadmapNotFoundError();
+  const result = parseRoadmap(raw);
+  if (!result.ok) return resultToMcpResponse(result);
+  let roadmap = result.value;
+  if (input.milestone) {
+    const milestoneFilter = input.milestone;
+    roadmap = {
+      ...roadmap,
+      milestones: roadmap.milestones.filter(
+        (m) => m.name.toLowerCase() === milestoneFilter.toLowerCase()
+      )
+    };
+  }
+  if (input.status) {
+    const statusFilter = input.status;
+    roadmap = {
+      ...roadmap,
+      milestones: roadmap.milestones.map((m) => ({
+        ...m,
+        features: m.features.filter((f) => f.status === statusFilter)
+      })).filter((m) => m.features.length > 0)
+    };
+  }
+  return resultToMcpResponse(Ok2(roadmap));
+}
+function handleAdd(projectPath, input, deps) {
+  const { parseRoadmap, serializeRoadmap, Ok: Ok2 } = deps;
+  if (!input.feature) {
+    return {
+      content: [{ type: "text", text: "Error: feature is required for add action" }],
+      isError: true
+    };
+  }
+  if (!input.milestone) {
+    return {
+      content: [{ type: "text", text: "Error: milestone is required for add action" }],
+      isError: true
+    };
+  }
+  if (!input.status) {
+    return {
+      content: [{ type: "text", text: "Error: status is required for add action" }],
+      isError: true
+    };
+  }
+  if (!input.summary) {
+    return {
+      content: [{ type: "text", text: "Error: summary is required for add action" }],
+      isError: true
+    };
+  }
+  const raw = readRoadmapFile(projectPath);
+  if (raw === null) return roadmapNotFoundError();
+  const result = parseRoadmap(raw);
+  if (!result.ok) return resultToMcpResponse(result);
+  const roadmap = result.value;
+  const milestone = roadmap.milestones.find(
+    (m) => m.name.toLowerCase() === input.milestone.toLowerCase()
+  );
+  if (!milestone) {
+    return {
+      content: [{ type: "text", text: `Error: milestone "${input.milestone}" not found` }],
+      isError: true
+    };
+  }
+  milestone.features.push({
+    name: input.feature,
+    status: input.status,
+    spec: input.spec ?? null,
+    plans: input.plans ?? [],
+    blockedBy: input.blocked_by ?? [],
+    summary: input.summary
+  });
+  roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
+  writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+  return resultToMcpResponse(Ok2(roadmap));
+}
+function handleUpdate(projectPath, input, deps) {
+  const { parseRoadmap, serializeRoadmap, Ok: Ok2 } = deps;
+  if (!input.feature) {
+    return {
+      content: [{ type: "text", text: "Error: feature is required for update action" }],
+      isError: true
+    };
+  }
+  const raw = readRoadmapFile(projectPath);
+  if (raw === null) return roadmapNotFoundError();
+  const result = parseRoadmap(raw);
+  if (!result.ok) return resultToMcpResponse(result);
+  const roadmap = result.value;
+  let found = false;
+  for (const m of roadmap.milestones) {
+    const feature = m.features.find((f) => f.name.toLowerCase() === input.feature.toLowerCase());
+    if (feature) {
+      if (input.status) feature.status = input.status;
+      if (input.summary !== void 0) feature.summary = input.summary;
+      if (input.spec !== void 0) feature.spec = input.spec || null;
+      if (input.plans !== void 0) feature.plans = input.plans;
+      if (input.blocked_by !== void 0) feature.blockedBy = input.blocked_by;
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    return {
+      content: [{ type: "text", text: `Error: feature "${input.feature}" not found` }],
+      isError: true
+    };
+  }
+  roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
+  writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+  return resultToMcpResponse(Ok2(roadmap));
+}
+function handleRemove(projectPath, input, deps) {
+  const { parseRoadmap, serializeRoadmap, Ok: Ok2 } = deps;
+  if (!input.feature) {
+    return {
+      content: [{ type: "text", text: "Error: feature is required for remove action" }],
+      isError: true
+    };
+  }
+  const raw = readRoadmapFile(projectPath);
+  if (raw === null) return roadmapNotFoundError();
+  const result = parseRoadmap(raw);
+  if (!result.ok) return resultToMcpResponse(result);
+  const roadmap = result.value;
+  let found = false;
+  for (const m of roadmap.milestones) {
+    const idx = m.features.findIndex((f) => f.name.toLowerCase() === input.feature.toLowerCase());
+    if (idx !== -1) {
+      m.features.splice(idx, 1);
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    return {
+      content: [{ type: "text", text: `Error: feature "${input.feature}" not found` }],
+      isError: true
+    };
+  }
+  roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
+  writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+  return resultToMcpResponse(Ok2(roadmap));
+}
+function handleQuery(projectPath, input, deps) {
+  const { parseRoadmap, Ok: Ok2 } = deps;
+  if (!input.filter) {
+    return {
+      content: [{ type: "text", text: "Error: filter is required for query action" }],
+      isError: true
+    };
+  }
+  const raw = readRoadmapFile(projectPath);
+  if (raw === null) return roadmapNotFoundError();
+  const result = parseRoadmap(raw);
+  if (!result.ok) return resultToMcpResponse(result);
+  const roadmap = result.value;
+  const allFeatures = roadmap.milestones.flatMap(
+    (m) => m.features.map((f) => ({ ...f, milestone: m.name }))
+  );
+  const filter = input.filter.toLowerCase();
+  let filtered;
+  if (filter.startsWith("milestone:")) {
+    const milestoneName = filter.slice("milestone:".length).trim();
+    filtered = allFeatures.filter((f) => f.milestone.toLowerCase().includes(milestoneName));
+  } else {
+    filtered = allFeatures.filter((f) => f.status === filter);
+  }
+  return resultToMcpResponse(Ok2(filtered));
+}
+function handleSync(projectPath, input, deps) {
+  const { parseRoadmap, serializeRoadmap, syncRoadmap, Ok: Ok2 } = deps;
+  const raw = readRoadmapFile(projectPath);
+  if (raw === null) return roadmapNotFoundError();
+  const result = parseRoadmap(raw);
+  if (!result.ok) return resultToMcpResponse(result);
+  const roadmap = result.value;
+  const syncResult = syncRoadmap({
+    projectPath,
+    roadmap,
+    forceSync: input.force_sync ?? false
+  });
+  if (!syncResult.ok) return resultToMcpResponse(syncResult);
+  const changes = syncResult.value;
+  if (changes.length === 0) {
+    return resultToMcpResponse(Ok2({ changes: [], message: "Roadmap is up to date." }));
+  }
+  if (input.apply) {
+    for (const change of changes) {
+      for (const m of roadmap.milestones) {
+        const feature = m.features.find(
+          (f) => f.name.toLowerCase() === change.feature.toLowerCase()
+        );
+        if (feature) {
+          feature.status = change.to;
+          break;
+        }
+      }
+    }
+    roadmap.frontmatter.lastSynced = (/* @__PURE__ */ new Date()).toISOString();
+    writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+    return resultToMcpResponse(Ok2({ changes, applied: true, roadmap }));
+  }
+  return resultToMcpResponse(Ok2({ changes, applied: false }));
 }
 async function handleManageRoadmap(input) {
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap } = await import("./dist-IJ4J4C5G.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap } = await import("./dist-2B363XUH.js");
     const { Ok: Ok2 } = await import("./dist-D4RYGUZE.js");
     const projectPath = sanitizePath(input.path);
+    const deps = { parseRoadmap, serializeRoadmap, syncRoadmap, Ok: Ok2 };
     switch (input.action) {
-      case "show": {
-        const raw = readRoadmapFile(projectPath);
-        if (raw === null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: docs/roadmap.md not found. Create a roadmap first."
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = parseRoadmap(raw);
-        if (!result.ok) return resultToMcpResponse(result);
-        let roadmap = result.value;
-        if (input.milestone) {
-          const milestoneFilter = input.milestone;
-          roadmap = {
-            ...roadmap,
-            milestones: roadmap.milestones.filter(
-              (m) => m.name.toLowerCase() === milestoneFilter.toLowerCase()
-            )
-          };
-        }
-        if (input.status) {
-          const statusFilter = input.status;
-          roadmap = {
-            ...roadmap,
-            milestones: roadmap.milestones.map((m) => ({
-              ...m,
-              features: m.features.filter((f) => f.status === statusFilter)
-            })).filter((m) => m.features.length > 0)
-          };
-        }
-        return resultToMcpResponse(Ok2(roadmap));
-      }
-      case "add": {
-        if (!input.feature) {
-          return {
-            content: [{ type: "text", text: "Error: feature is required for add action" }],
-            isError: true
-          };
-        }
-        if (!input.milestone) {
-          return {
-            content: [
-              { type: "text", text: "Error: milestone is required for add action" }
-            ],
-            isError: true
-          };
-        }
-        if (!input.status) {
-          return {
-            content: [{ type: "text", text: "Error: status is required for add action" }],
-            isError: true
-          };
-        }
-        if (!input.summary) {
-          return {
-            content: [{ type: "text", text: "Error: summary is required for add action" }],
-            isError: true
-          };
-        }
-        const raw = readRoadmapFile(projectPath);
-        if (raw === null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: docs/roadmap.md not found. Create a roadmap first."
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = parseRoadmap(raw);
-        if (!result.ok) return resultToMcpResponse(result);
-        const roadmap = result.value;
-        const milestone = roadmap.milestones.find(
-          (m) => m.name.toLowerCase() === input.milestone.toLowerCase()
-        );
-        if (!milestone) {
-          return {
-            content: [
-              { type: "text", text: `Error: milestone "${input.milestone}" not found` }
-            ],
-            isError: true
-          };
-        }
-        milestone.features.push({
-          name: input.feature,
-          status: input.status,
-          spec: input.spec ?? null,
-          plans: input.plans ?? [],
-          blockedBy: input.blocked_by ?? [],
-          summary: input.summary
-        });
-        roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-        writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
-        return resultToMcpResponse(Ok2(roadmap));
-      }
-      case "update": {
-        if (!input.feature) {
-          return {
-            content: [
-              { type: "text", text: "Error: feature is required for update action" }
-            ],
-            isError: true
-          };
-        }
-        const raw = readRoadmapFile(projectPath);
-        if (raw === null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: docs/roadmap.md not found. Create a roadmap first."
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = parseRoadmap(raw);
-        if (!result.ok) return resultToMcpResponse(result);
-        const roadmap = result.value;
-        let found = false;
-        for (const m of roadmap.milestones) {
-          const feature = m.features.find(
-            (f) => f.name.toLowerCase() === input.feature.toLowerCase()
-          );
-          if (feature) {
-            if (input.status) feature.status = input.status;
-            if (input.summary !== void 0) feature.summary = input.summary;
-            if (input.spec !== void 0) feature.spec = input.spec || null;
-            if (input.plans !== void 0) feature.plans = input.plans;
-            if (input.blocked_by !== void 0) feature.blockedBy = input.blocked_by;
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          return {
-            content: [
-              { type: "text", text: `Error: feature "${input.feature}" not found` }
-            ],
-            isError: true
-          };
-        }
-        roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-        writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
-        return resultToMcpResponse(Ok2(roadmap));
-      }
-      case "remove": {
-        if (!input.feature) {
-          return {
-            content: [
-              { type: "text", text: "Error: feature is required for remove action" }
-            ],
-            isError: true
-          };
-        }
-        const raw = readRoadmapFile(projectPath);
-        if (raw === null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: docs/roadmap.md not found. Create a roadmap first."
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = parseRoadmap(raw);
-        if (!result.ok) return resultToMcpResponse(result);
-        const roadmap = result.value;
-        let found = false;
-        for (const m of roadmap.milestones) {
-          const idx = m.features.findIndex(
-            (f) => f.name.toLowerCase() === input.feature.toLowerCase()
-          );
-          if (idx !== -1) {
-            m.features.splice(idx, 1);
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          return {
-            content: [
-              { type: "text", text: `Error: feature "${input.feature}" not found` }
-            ],
-            isError: true
-          };
-        }
-        roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-        writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
-        return resultToMcpResponse(Ok2(roadmap));
-      }
-      case "query": {
-        if (!input.filter) {
-          return {
-            content: [
-              { type: "text", text: "Error: filter is required for query action" }
-            ],
-            isError: true
-          };
-        }
-        const raw = readRoadmapFile(projectPath);
-        if (raw === null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: docs/roadmap.md not found. Create a roadmap first."
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = parseRoadmap(raw);
-        if (!result.ok) return resultToMcpResponse(result);
-        const roadmap = result.value;
-        const allFeatures = roadmap.milestones.flatMap(
-          (m) => m.features.map((f) => ({ ...f, milestone: m.name }))
-        );
-        const filter = input.filter.toLowerCase();
-        let filtered;
-        if (filter.startsWith("milestone:")) {
-          const milestoneName = filter.slice("milestone:".length).trim();
-          filtered = allFeatures.filter((f) => f.milestone.toLowerCase().includes(milestoneName));
-        } else {
-          filtered = allFeatures.filter((f) => f.status === filter);
-        }
-        return resultToMcpResponse(Ok2(filtered));
-      }
-      case "sync": {
-        const raw = readRoadmapFile(projectPath);
-        if (raw === null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: docs/roadmap.md not found. Create a roadmap first."
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = parseRoadmap(raw);
-        if (!result.ok) return resultToMcpResponse(result);
-        const roadmap = result.value;
-        const syncResult = syncRoadmap({
-          projectPath,
-          roadmap,
-          forceSync: input.force_sync ?? false
-        });
-        if (!syncResult.ok) return resultToMcpResponse(syncResult);
-        const changes = syncResult.value;
-        if (changes.length === 0) {
-          return resultToMcpResponse(Ok2({ changes: [], message: "Roadmap is up to date." }));
-        }
-        if (input.apply) {
-          for (const change of changes) {
-            for (const m of roadmap.milestones) {
-              const feature = m.features.find(
-                (f) => f.name.toLowerCase() === change.feature.toLowerCase()
-              );
-              if (feature) {
-                feature.status = change.to;
-                break;
-              }
-            }
-          }
-          roadmap.frontmatter.lastSynced = (/* @__PURE__ */ new Date()).toISOString();
-          writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
-          return resultToMcpResponse(Ok2({ changes, applied: true, roadmap }));
-        }
-        return resultToMcpResponse(Ok2({ changes, applied: false }));
-      }
+      case "show":
+        return handleShow(projectPath, input, deps);
+      case "add":
+        return handleAdd(projectPath, input, deps);
+      case "update":
+        return handleUpdate(projectPath, input, deps);
+      case "remove":
+        return handleRemove(projectPath, input, deps);
+      case "query":
+        return handleQuery(projectPath, input, deps);
+      case "sync":
+        return handleSync(projectPath, input, deps);
       default: {
         return {
           content: [{ type: "text", text: `Error: unknown action` }],
@@ -2699,6 +2932,7 @@ var EmitInteractionInputSchema = z.object({
   path: z.string().min(1),
   type: InteractionTypeSchema,
   stream: z.string().optional(),
+  session: z.string().optional(),
   // Uses base schema here; refined validation (recommendation required with options)
   // is applied in the handler's question branch via InteractionQuestionWithOptionsSchema.
   // Refined schemas with .refine() cannot be nested inside z.object().optional() reliably.
@@ -2823,6 +3057,10 @@ var emitInteractionDefinition = {
         type: "string",
         description: "State stream for recording (auto-resolves from branch if omitted)"
       },
+      session: {
+        type: "string",
+        description: "Session slug for session-scoped handoff (takes priority over stream when provided)"
+      },
       question: {
         type: "object",
         description: "Question payload (required when type is question)",
@@ -3072,7 +3310,7 @@ async function handleEmitInteraction(input) {
         const transition = transitionResult.data;
         const prompt = renderTransition(transition);
         try {
-          const { saveHandoff } = await import("./dist-IJ4J4C5G.js");
+          const { saveHandoff } = await import("./dist-2B363XUH.js");
           await saveHandoff(
             projectPath,
             {
@@ -3087,7 +3325,8 @@ async function handleEmitInteraction(input) {
               blockers: [],
               contextKeywords: []
             },
-            validInput.stream
+            validInput.stream,
+            validInput.session
           );
         } catch {
         }
@@ -3173,7 +3412,7 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-IJ4J4C5G.js");
+    const { loadState, saveState } = await import("./dist-2B363XUH.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -3220,6 +3459,14 @@ var gatherContextDefinition = {
         type: "string",
         enum: ["summary", "detailed"],
         description: "Response density. Default: summary"
+      },
+      learningsBudget: {
+        type: "number",
+        description: "Token budget for learnings slice (default 1000). Separate from graph tokenBudget."
+      },
+      session: {
+        type: "string",
+        description: "Session slug for session-scoped state. When provided, state/learnings/handoff/failures are read from .harness/sessions/<session>/ instead of .harness/. Omit for global fallback."
       }
     },
     required: ["path", "intent"]
@@ -3245,16 +3492,25 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-IJ4J4C5G.js").then((core) => core.loadState(projectPath)) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-IJ4J4C5G.js").then(
-    (core) => core.loadRelevantLearnings(projectPath, input.skill)
+  const statePromise = includeSet.has("state") ? import("./dist-2B363XUH.js").then(
+    (core) => core.loadState(projectPath, void 0, input.session)
+  ) : Promise.resolve(null);
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-2B363XUH.js").then(
+    (core) => core.loadBudgetedLearnings(projectPath, {
+      intent: input.intent,
+      tokenBudget: input.learningsBudget ?? 1e3,
+      ...input.skill !== void 0 && { skill: input.skill },
+      ...input.session !== void 0 && { session: input.session }
+    })
+  ) : Promise.resolve(null);
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-2B363XUH.js").then(
+    (core) => core.loadHandoff(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-IJ4J4C5G.js").then((core) => core.loadHandoff(projectPath)) : Promise.resolve(null);
   const graphPromise = includeSet.has("graph") ? (async () => {
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-GJZ4FN4Y.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return null;
-    const { FusionLayer, ContextQL } = await import("./dist-M6BQODWC.js");
+    const { FusionLayer, ContextQL } = await import("./dist-HXHWB7SV.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -3292,7 +3548,7 @@ async function handleGatherContext(input) {
     };
   })() : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-EFNMSFKD.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-GCHZJIL7.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -3364,6 +3620,17 @@ async function handleGatherContext(input) {
       errors
     }
   };
+  if (input.session) {
+    try {
+      const core = await import("./dist-2B363XUH.js");
+      core.updateSessionIndex(
+        projectPath,
+        input.session,
+        `${input.skill ?? "unknown"} \u2014 ${input.intent}`
+      );
+    } catch {
+    }
+  }
   const outputText = JSON.stringify(output);
   const tokenEstimate = Math.ceil(outputText.length / 4);
   output.meta.tokenEstimate = tokenEstimate;
@@ -3425,7 +3692,7 @@ async function handleAssessProject(input) {
   let validateResult = null;
   if (checksToRun.has("validate")) {
     try {
-      const { handleValidateProject: handleValidateProject2 } = await import("./validate-EFNMSFKD.js");
+      const { handleValidateProject: handleValidateProject2 } = await import("./validate-GCHZJIL7.js");
       const result = await handleValidateProject2({ path: projectPath });
       const first = result.content[0];
       const parsed = first ? JSON.parse(first.text) : {};
@@ -3450,7 +3717,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-AJAUDRQQ.js");
+          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-2R5Z4ZAF.js");
           const result = await handleCheckDependencies2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3477,7 +3744,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-CPTMH3VY.js");
+          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-FZOPM4GK.js");
           const result = await handleCheckDocs2({ path: projectPath, scope: "coverage" });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3504,7 +3771,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-Z4FYVQ7L.js");
+          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-LVHJMFGH.js");
           const result = await handleDetectEntropy2({ path: projectPath, type: "all" });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3531,7 +3798,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-MX5VVXBC.js");
+          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-FWQZF2IZ.js");
           const result = await handleRunSecurityScan2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3563,7 +3830,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-YJVXOKIB.js");
+          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-ZTVSUANN.js");
           const result = await handleCheckPerformance2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3738,7 +4005,7 @@ async function handleReviewChanges(input) {
   }
   try {
     if (effectiveDepth === "quick") {
-      const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-TT6WF5YX.js");
+      const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-IHLVLMRD.js");
       const result2 = await handleAnalyzeDiff2({ diff, path: projectPath });
       const firstContent = result2.content[0];
       if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -3760,7 +4027,7 @@ async function handleReviewChanges(input) {
       };
     }
     if (effectiveDepth === "standard") {
-      const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-TT6WF5YX.js");
+      const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-IHLVLMRD.js");
       const [diffResult, reviewResult] = await Promise.all([
         handleAnalyzeDiff2({ diff, path: projectPath }),
         handleCreateSelfReview2({ path: projectPath, diff })
@@ -3791,7 +4058,7 @@ async function handleReviewChanges(input) {
         ]
       };
     }
-    const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-KGMIMLIE.js");
+    const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-76JHKGSV.js");
     const result = await handleRunCodeReview2({ path: projectPath, diff });
     const deepContent = result.content[0];
     if (!deepContent) throw new Error("Empty code review response");
@@ -3868,7 +4135,7 @@ async function handleCheckTaskIndependence(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { TaskIndependenceAnalyzer } = await import("./dist-M6BQODWC.js");
+    const { TaskIndependenceAnalyzer } = await import("./dist-HXHWB7SV.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -3956,7 +4223,7 @@ async function handlePredictConflicts(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { ConflictPredictor } = await import("./dist-M6BQODWC.js");
+    const { ConflictPredictor } = await import("./dist-HXHWB7SV.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -4062,7 +4329,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-GJZ4FN4Y.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -4083,7 +4350,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-IJ4J4C5G.js");
+    const { detectStaleConstraints } = await import("./dist-2B363XUH.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -4110,6 +4377,76 @@ async function handleDetectStaleConstraints(input) {
   }
 }
 
+// src/mcp/tools/search-skills.ts
+var searchSkillsDefinition = {
+  name: "search_skills",
+  description: "Search the skill catalog for domain-specific skills. Returns ranked results based on keyword and stack-signal matching. Use this to discover catalog skills that are not loaded as slash commands.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural language or keyword query to search for skills"
+      },
+      path: {
+        type: "string",
+        description: "Project root path (defaults to cwd)"
+      },
+      platform: {
+        type: "string",
+        enum: ["claude-code", "gemini-cli"],
+        description: "Target platform (defaults to claude-code)"
+      }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchSkills(input) {
+  const query = input.query;
+  const projectRoot = input.path || process.cwd();
+  const platform = input.platform || "claude-code";
+  const configResult = resolveConfig();
+  const tierOverrides = configResult.ok ? configResult.value.skills?.tierOverrides : void 0;
+  const index = loadOrRebuildIndex(platform, projectRoot, tierOverrides);
+  const profile = loadOrGenerateProfile(projectRoot);
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const results = [];
+  for (const [name, entry] of Object.entries(index.skills)) {
+    const matchedKeywords = entry.keywords.filter(
+      (kw) => queryTerms.some(
+        (term) => kw.toLowerCase().includes(term.toLowerCase()) || term.toLowerCase().includes(kw.toLowerCase())
+      )
+    );
+    const keywordScore = queryTerms.length > 0 ? matchedKeywords.length / queryTerms.length : 0;
+    let stackScore = 0;
+    if (entry.stackSignals.length > 0) {
+      const matchedSignals = entry.stackSignals.filter((signal) => profile.signals[signal]);
+      stackScore = matchedSignals.length / entry.stackSignals.length;
+    }
+    const score = 0.6 * keywordScore + 0.4 * stackScore;
+    if (score > 0 || queryTerms.length === 0) {
+      results.push({
+        name,
+        description: entry.description,
+        keywords: entry.keywords,
+        phases: entry.phases,
+        score: Math.round(score * 100) / 100,
+        source: entry.source
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  const top5 = results.slice(0, 5);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ results: top5 }, null, 2)
+      }
+    ]
+  };
+}
+
 // src/mcp/server.ts
 var TOOL_DEFINITIONS = [
   validateToolDefinition,
@@ -4156,7 +4493,8 @@ var TOOL_DEFINITIONS = [
   askGraphDefinition,
   checkTaskIndependenceDefinition,
   predictConflictsDefinition,
-  detectStaleConstraintsDefinition
+  detectStaleConstraintsDefinition,
+  searchSkillsDefinition
 ];
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -4203,7 +4541,8 @@ var TOOL_HANDLERS = {
   ask_graph: handleAskGraph,
   check_task_independence: handleCheckTaskIndependence,
   predict_conflicts: handlePredictConflicts,
-  detect_stale_constraints: handleDetectStaleConstraints
+  detect_stale_constraints: handleDetectStaleConstraints,
+  search_skills: handleSearchSkills
 };
 var RESOURCE_DEFINITIONS = [
   {
@@ -4294,7 +4633,7 @@ function createHarnessServer(projectRoot) {
           shouldRunCheck,
           readCheckState,
           spawnBackgroundCheck
-        } = await import("./dist-IJ4J4C5G.js");
+        } = await import("./dist-2B363XUH.js");
         const { CLI_VERSION: version } = await import("./version-KFFPOQAX.js");
         let CLI_VERSION = version;
         let configInterval;