@harness-engineering/cli 1.13.0 → 1.14.0

package/dist/{chunk-7KQSUZVG.js → chunk-YZD2MRNQ.js}

@@ -1,7 +1,7 @@
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-MACVXDZK.js";
+} from "./chunk-OXLLOSSR.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -11,7 +11,7 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-2VU4MFM3.js";
+} from "./chunk-YPYGXRDR.js";
 import {
   analyzeDiffDefinition,
   createSelfReviewDefinition,
@@ -19,15 +19,15 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-7PZWR4LI.js";
+} from "./chunk-TPOTOBR7.js";
 import {
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-5VY23YK3.js";
+} from "./chunk-OSXBPAMK.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition
-} from "./chunk-LD3DKUK5.js";
+} from "./chunk-NLVUVUGD.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_GEMINI,
@@ -38,21 +38,24 @@ import {
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-PSNN4LWX.js";
+} from "./chunk-S2FXOWOR.js";
 import {
   loadGraphStore
-} from "./chunk-2YPZKGAG.js";
+} from "./chunk-FTMXDOR6.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-WPPDRIJL.js";
+} from "./chunk-3C2MLBPJ.js";
 import {
   resolveProjectConfig
-} from "./chunk-K6XAPGML.js";
+} from "./chunk-H7Y5CKTM.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-MI5XJQDY.js";
+} from "./chunk-7IP4JIFL.js";
+import {
+  resolveConfig
+} from "./chunk-O5OJVPL6.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,11 +78,11 @@ import {
 } from "./chunk-3WGJMBKH.js";
 import {
   SkillMetadataSchema
-} from "./chunk-VRFZWGMS.js";
+} from "./chunk-XYLGHKG6.js";
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -105,7 +109,7 @@ var generateLinterDefinition = {
 };
 async function handleGenerateLinter(input) {
   try {
-    const { generate } = await import("./dist-L7LAAQAS.js");
+    const { generate } = await import("./dist-DZ63LLUD.js");
     const result = await generate({
       configPath: sanitizePath(input.configPath),
       ...input.outputDir !== void 0 && { outputDir: sanitizePath(input.outputDir) }
@@ -139,7 +143,7 @@ var validateLinterConfigDefinition = {
 };
 async function handleValidateLinterConfig(input) {
   try {
-    const { validate } = await import("./dist-L7LAAQAS.js");
+    const { validate } = await import("./dist-DZ63LLUD.js");
     const result = await validate({ configPath: sanitizePath(input.configPath) });
     if ("success" in result && result.success) {
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
@@ -159,7 +163,179 @@ async function handleValidateLinterConfig(input) {
 }
 
 // src/mcp/tools/init.ts
+import * as path2 from "path";
+import * as fs2 from "fs";
+
+// src/templates/post-write.ts
+import * as fs from "fs";
 import * as path from "path";
+
+// src/templates/agents-append.ts
+var FRAMEWORK_SECTIONS = {
+  nextjs: {
+    title: "Next.js Conventions",
+    content: [
+      "- Use the App Router (`src/app/`) for all routes",
+      '- Server Components by default; add `"use client"` only when needed',
+      "- Use `next/image` for images and `next/link` for navigation",
+      "- API routes go in `src/app/api/`",
+      "- Run `next dev` for development, `next build` for production"
+    ].join("\n")
+  },
+  "react-vite": {
+    title: "React + Vite Conventions",
+    content: [
+      "- Component files use `.tsx` extension in `src/`",
+      "- Use Vite for dev server and bundling (`npm run dev`)",
+      "- Prefer function components with hooks",
+      "- CSS modules or styled-components for styling",
+      "- Tests use Vitest (`npm test`)"
+    ].join("\n")
+  },
+  vue: {
+    title: "Vue Conventions",
+    content: [
+      "- Single File Components (`.vue`) in `src/`",
+      "- Use `<script setup>` with Composition API",
+      "- Vite for dev server and bundling (`npm run dev`)",
+      "- Vue Router for routing, Pinia for state management",
+      "- Tests use Vitest (`npm test`)"
+    ].join("\n")
+  },
+  express: {
+    title: "Express Conventions",
+    content: [
+      "- Entry point at `src/app.ts`",
+      "- Routes in `src/routes/`, middleware in `src/middleware/`",
+      "- Use `express.json()` for body parsing",
+      "- Error handling via centralized error middleware",
+      "- Tests use Vitest with supertest (`npm test`)"
+    ].join("\n")
+  },
+  nestjs: {
+    title: "NestJS Conventions",
+    content: [
+      "- Module-based architecture: each feature in its own module",
+      "- Use decorators (`@Controller`, `@Injectable`, `@Module`)",
+      "- Entry point at `src/main.ts`, root module at `src/app.module.ts`",
+      "- Use Nest CLI for generating components (`nest g`)",
+      "- Tests use Vitest (`npm test`)"
+    ].join("\n")
+  },
+  fastapi: {
+    title: "FastAPI Conventions",
+    content: [
+      "- Entry point at `src/main.py` with FastAPI app instance",
+      "- Use Pydantic models for request/response validation",
+      "- Async endpoints preferred; sync is acceptable for CPU-bound work",
+      "- Run with `uvicorn src.main:app --reload` for development",
+      "- Tests use pytest (`pytest`)"
+    ].join("\n")
+  },
+  django: {
+    title: "Django Conventions",
+    content: [
+      "- Settings at `src/settings.py`, URLs at `src/urls.py`",
+      "- Use `manage.py` for management commands",
+      "- Apps in `src/` directory; each app has models, views, urls",
+      "- Run with `python manage.py runserver` for development",
+      "- Tests use pytest with pytest-django (`pytest`)"
+    ].join("\n")
+  },
+  gin: {
+    title: "Gin Conventions",
+    content: [
+      "- Entry point at `main.go` with Gin router setup",
+      "- Group routes by feature using `router.Group()`",
+      "- Use middleware for logging, auth, error recovery",
+      "- Run with `go run main.go` for development",
+      "- Tests use `go test ./...`"
+    ].join("\n")
+  },
+  axum: {
+    title: "Axum Conventions",
+    content: [
+      "- Entry point at `src/main.rs` with Axum router",
+      "- Use extractors for request parsing (`Path`, `Query`, `Json`)",
+      "- Shared state via `Extension` or `State`",
+      "- Run with `cargo run` for development",
+      "- Tests use `cargo test`"
+    ].join("\n")
+  },
+  "spring-boot": {
+    title: "Spring Boot Conventions",
+    content: [
+      "- Entry point annotated with `@SpringBootApplication`",
+      "- Controllers in `controller/` package, services in `service/`",
+      "- Use constructor injection for dependencies",
+      "- Run with `mvn spring-boot:run` for development",
+      "- Tests use JUnit 5 with Spring Boot Test (`mvn test`)"
+    ].join("\n")
+  }
+};
+function buildFrameworkSection(framework) {
+  const entry = FRAMEWORK_SECTIONS[framework];
+  if (!entry) return "";
+  return `## ${entry.title}
+
+<!-- framework: ${framework} -->
+${entry.content}
+`;
+}
+function appendFrameworkSection(existingContent, framework, _language) {
+  if (!framework) return existingContent;
+  const startMarker = `<!-- harness:framework-conventions:${framework} -->`;
+  const endMarker = `<!-- /harness:framework-conventions:${framework} -->`;
+  if (existingContent.includes(startMarker)) return existingContent;
+  const section = buildFrameworkSection(framework);
+  if (!section) return existingContent;
+  const block = `
+${startMarker}
+${section}${endMarker}
+`;
+  return existingContent.trimEnd() + "\n" + block;
+}
+
+// src/templates/post-write.ts
+function persistToolingConfig(targetDir, resolveResult, framework) {
+  const configPath = path.join(targetDir, "harness.config.json");
+  if (!fs.existsSync(configPath)) return;
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const overlayMeta = resolveResult.overlayMetadata;
+    if (framework) {
+      config.template = config.template || {};
+      config.template.framework = framework;
+    }
+    if (overlayMeta?.tooling) {
+      config.tooling = { ...config.tooling, ...overlayMeta.tooling };
+      delete config.tooling.lockFile;
+    } else if (resolveResult.metadata.tooling && !config.tooling) {
+      config.tooling = { ...resolveResult.metadata.tooling };
+      delete config.tooling.lockFile;
+    }
+    if (config.template?.level === null || config.template?.level === void 0) {
+      delete config.template.level;
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  } catch {
+  }
+}
+function appendFrameworkAgents(targetDir, framework, language) {
+  if (!framework) return;
+  const agentsPath = path.join(targetDir, "AGENTS.md");
+  if (!fs.existsSync(agentsPath)) return;
+  try {
+    const existing = fs.readFileSync(agentsPath, "utf-8");
+    const updated = appendFrameworkSection(existing, framework, language);
+    if (updated !== existing) {
+      fs.writeFileSync(agentsPath, updated);
+    }
+  } catch {
+  }
+}
+
+// src/mcp/tools/init.ts
 var initProjectDefinition = {
   name: "init_project",
   description: "Scaffold a new harness engineering project from a template",
@@ -171,54 +347,109 @@ var initProjectDefinition = {
       level: {
         type: "string",
         enum: ["basic", "intermediate", "advanced"],
-        description: "Adoption level"
+        description: "Adoption level (JS/TS only)"
       },
-      framework: { type: "string", description: "Framework overlay (e.g., nextjs)" }
+      framework: { type: "string", description: "Framework overlay (e.g., nextjs, fastapi, gin)" },
+      language: {
+        type: "string",
+        enum: ["typescript", "python", "go", "rust", "java"],
+        description: "Target language"
+      }
     },
     required: ["path"]
   }
 };
+function mcpText(text, isError = false) {
+  return { content: [{ type: "text", text }], isError };
+}
+function findFrameworkLanguage(engine, framework) {
+  const templates = engine.listTemplates();
+  if (!templates.ok || !templates.value) return void 0;
+  return templates.value.find((t) => t.framework === framework)?.language;
+}
+function tryDetectFramework(engine, safePath, input) {
+  if (input.framework || input.language || !fs2.existsSync(safePath)) return null;
+  const result = engine.detectFramework(safePath);
+  if (!result.ok || !result.value || result.value.length === 0) return null;
+  const candidates = result.value.map((c) => `${c.framework} (${c.language}, score: ${c.score})`).join(", ");
+  return mcpText(
+    `Detected frameworks: ${candidates}
+
+Re-invoke with --framework <name> to scaffold, or specify --language for a bare scaffold.`
+  );
+}
+function checkFrameworkLanguageConflict(engine, input) {
+  if (!input.framework || !input.language) return null;
+  const fwLang = findFrameworkLanguage(engine, input.framework);
+  if (fwLang && fwLang !== input.language) {
+    return mcpText(
+      `Framework "${input.framework}" is a ${fwLang} framework, but language "${input.language}" was specified. Use language "${fwLang}" instead.`,
+      true
+    );
+  }
+  return null;
+}
+function inferLanguage(engine, input) {
+  if (input.language) return input.language;
+  if (!input.framework) return void 0;
+  return findFrameworkLanguage(engine, input.framework);
+}
+function scaffoldMcp(engine, safePath, i, language) {
+  const isNonJs = language && language !== "typescript";
+  const level = isNonJs ? void 0 : i.level ?? "basic";
+  const resolveResult = engine.resolveTemplate(level, i.framework, language);
+  if (!resolveResult.ok) return resultToMcpResponse(resolveResult);
+  const renderResult = engine.render(resolveResult.value, {
+    projectName: i.name ?? path2.basename(safePath),
+    level: level ?? "",
+    ...i.framework !== void 0 && { framework: i.framework },
+    ...language !== void 0 && { language }
+  });
+  if (!renderResult.ok) return resultToMcpResponse(renderResult);
+  const writeResult = engine.write(renderResult.value, safePath, {
+    overwrite: false,
+    ...language !== void 0 && { language }
+  });
+  if (writeResult.ok) {
+    persistToolingConfig(safePath, resolveResult.value, i.framework);
+    appendFrameworkAgents(safePath, i.framework, language);
+  }
+  if (writeResult.ok && writeResult.value.skippedConfigs.length > 0) {
+    const skippedMsg = writeResult.value.skippedConfigs.map((f) => `  - ${f}`).join("\n");
+    return mcpText(
+      `Files written: ${writeResult.value.written.join(", ")}
+
+Skipped existing config files (add harness dependencies manually):
+${skippedMsg}`
+    );
+  }
+  return resultToMcpResponse(writeResult);
+}
 async function handleInitProject(input) {
+  const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-LXLIWQQ3.js");
-    const templatesDir = resolveTemplatesDir();
-    const engine = new TemplateEngine(templatesDir);
-    const level = input.level ?? "basic";
-    const resolveResult = engine.resolveTemplate(level, input.framework);
-    if (!resolveResult.ok) return resultToMcpResponse(resolveResult);
-    const safePath = sanitizePath(input.path);
-    const renderResult = engine.render(resolveResult.value, {
-      projectName: input.name ?? path.basename(safePath),
-      level,
-      ...input.framework !== void 0 && { framework: input.framework }
-    });
-    if (!renderResult.ok) return resultToMcpResponse(renderResult);
-    const writeResult = engine.write(renderResult.value, safePath, {
-      overwrite: false
-    });
-    return resultToMcpResponse(writeResult);
+    const { TemplateEngine } = await import("./engine-EG4EH4IX.js");
+    const engine = new TemplateEngine(resolveTemplatesDir());
+    const safePath = sanitizePath(i.path);
+    const detected = tryDetectFramework(engine, safePath, i);
+    if (detected) return detected;
+    const conflict = checkFrameworkLanguageConflict(engine, i);
+    if (conflict) return conflict;
+    return scaffoldMcp(engine, safePath, i, inferLanguage(engine, i));
   } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Init failed: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
+    return mcpText(`Init failed: ${error instanceof Error ? error.message : String(error)}`, true);
   }
 }
 
 // src/mcp/tools/persona.ts
-import * as path2 from "path";
+import * as path3 from "path";
 var listPersonasDefinition = {
   name: "list_personas",
   description: "List available agent personas",
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-Z2IT7QX3.js");
+  const { listPersonas } = await import("./loader-ZPALXIVR.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -242,12 +473,12 @@ 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-Z2IT7QX3.js");
-  const { generateRuntime } = await import("./runtime-PDWD7UIK.js");
-  const { generateAgentsMd } = await import("./agents-md-P2RHSUV7.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-4NYBUG6R.js");
+  const { loadPersona } = await import("./loader-ZPALXIVR.js");
+  const { generateRuntime } = await import("./runtime-7YLVK453.js");
+  const { generateAgentsMd } = await import("./agents-md-YTYQDA3P.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-EQZFVX3P.js");
   const personasDir = resolvePersonasDir();
-  const filePath = path2.join(personasDir, `${input.name}.yaml`);
+  const filePath = path3.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona path: ${input.name}`)));
   }
@@ -300,11 +531,11 @@ 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-Z2IT7QX3.js");
+  const { loadPersona } = await import("./loader-ZPALXIVR.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`);
+  const filePath = path3.join(personasDir, `${input.persona}.yaml`);
   if (!filePath.startsWith(personasDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona path: ${input.persona}`)));
   }
@@ -466,8 +697,243 @@ async function handleRunAgentTask(input) {
 }
 
 // src/mcp/tools/skill.ts
-import * as fs from "fs";
-import * as path3 from "path";
+import * as fs5 from "fs";
+import * as path6 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 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;
+  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 (!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"],
+  "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 = path5.join(projectRoot, pattern);
+    const exists = fs4.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 = path5.join(projectRoot, ".harness", "stack-profile.json");
+  if (fs4.existsSync(profilePath)) {
+    try {
+      return JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
+    } catch {
+    }
+  }
+  const profile = generateStackProfile(projectRoot);
+  fs4.mkdirSync(path5.dirname(profilePath), { recursive: true });
+  fs4.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 +958,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 = path6.join(skillsDir, input.skill);
   if (!skillDir.startsWith(skillsDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid skill path: ${input.skill}`)));
   }
-  if (!fs.existsSync(skillDir)) {
+  if (!fs5.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 = path6.join(skillDir, "SKILL.md");
+  if (!fs5.existsSync(skillMdPath)) {
     return resultToMcpResponse(Err(new Error(`SKILL.md not found for skill: ${input.skill}`)));
   }
-  let content = fs.readFileSync(skillMdPath, "utf-8");
+  let content = fs5.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 = path6.join(projectPath, ".harness", "state.json");
+    if (fs5.existsSync(stateFile)) {
+      const stateContent = fs5.readFileSync(stateFile, "utf-8");
       content += `
 
 ---
@@ -519,6 +985,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 +1031,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 +1053,22 @@ async function handleCreateSkill(input) {
 }
 
 // src/mcp/resources/skills.ts
-import * as fs2 from "fs";
-import * as path4 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import * as yaml from "yaml";
 async function getSkillsResource(projectRoot) {
-  const skillsDir = path4.join(projectRoot, "agents", "skills", "claude-code");
+  const skillsDir = path7.join(projectRoot, "agents", "skills", "claude-code");
   const skills = [];
-  if (!fs2.existsSync(skillsDir)) {
+  if (!fs6.existsSync(skillsDir)) {
     return JSON.stringify(skills, null, 2);
   }
-  const entries = fs2.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs6.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 = path7.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs6.existsSync(skillYamlPath)) continue;
     try {
-      const content = fs2.readFileSync(skillYamlPath, "utf-8");
+      const content = fs6.readFileSync(skillYamlPath, "utf-8");
       const parsed = yaml.parse(content);
       skills.push({
         name: parsed.name,
@@ -601,14 +1084,14 @@ async function getSkillsResource(projectRoot) {
 }
 
 // src/mcp/resources/rules.ts
-import * as fs3 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 async function getRulesResource(projectRoot) {
   const rules = [];
-  const configPath = path5.join(projectRoot, "harness.config.json");
-  if (fs3.existsSync(configPath)) {
+  const configPath = path8.join(projectRoot, "harness.config.json");
+  if (fs7.existsSync(configPath)) {
     try {
-      const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
       if (config.layers) {
         rules.push({ type: "layer-enforcement", config: config.layers });
       }
@@ -621,10 +1104,10 @@ async function getRulesResource(projectRoot) {
     } catch {
     }
   }
-  const linterPath = path5.join(projectRoot, ".harness", "linter.json");
-  if (fs3.existsSync(linterPath)) {
+  const linterPath = path8.join(projectRoot, ".harness", "linter.json");
+  if (fs7.existsSync(linterPath)) {
     try {
-      const linterConfig = JSON.parse(fs3.readFileSync(linterPath, "utf-8"));
+      const linterConfig = JSON.parse(fs7.readFileSync(linterPath, "utf-8"));
       rules.push({ type: "linter", config: linterConfig });
     } catch {
     }
@@ -633,32 +1116,37 @@ async function getRulesResource(projectRoot) {
 }
 
 // src/mcp/resources/project.ts
-import * as fs4 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path9 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 = path9.join(projectRoot, "AGENTS.md");
+  if (fs8.existsSync(agentsPath)) {
+    return fs8.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 fs9 from "fs";
+import * as path10 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 = path10.join(projectRoot, ".harness", "review-learnings.md");
+  if (fs9.existsSync(reviewPath)) {
+    sections.push("## Review Learnings\n\n" + fs9.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 = path10.join(projectRoot, ".harness", "anti-patterns.md");
+  if (fs9.existsSync(antiPath)) {
+    sections.push("## Anti-Pattern Log\n\n" + fs9.readFileSync(antiPath, "utf-8"));
   }
   return sections.length > 0 ? sections.join("\n\n---\n\n") : "No learnings files found.";
 }
 
+// src/mcp/utils.ts
+function mcpError(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
 // src/mcp/tools/state.ts
 var manageStateDefinition = {
   name: "manage_state",
@@ -677,7 +1165,12 @@ var manageStateDefinition = {
           "reset",
           "gate",
           "save-handoff",
-          "load-handoff"
+          "load-handoff",
+          "append_entry",
+          "update_entry_status",
+          "read_section",
+          "read_sections",
+          "archive_session"
         ],
         description: "Action to perform"
       },
@@ -694,138 +1187,175 @@ var manageStateDefinition = {
       session: {
         type: "string",
         description: "Session slug for session-scoped state (takes priority over stream when provided)"
+      },
+      section: {
+        type: "string",
+        enum: ["terminology", "decisions", "constraints", "risks", "openQuestions", "evidence"],
+        description: "Session section name (terminology, decisions, constraints, risks, openQuestions, evidence)"
+      },
+      authorSkill: {
+        type: "string",
+        description: "Name of the skill authoring the entry (required for append_entry)"
+      },
+      content: {
+        type: "string",
+        description: "Entry content text (required for append_entry)"
+      },
+      entryId: {
+        type: "string",
+        description: "ID of the entry to update (required for update_entry_status)"
+      },
+      newStatus: {
+        type: "string",
+        enum: ["active", "resolved", "superseded"],
+        description: "New status for the entry: active, resolved, or superseded (required for update_entry_status)"
       }
     },
     required: ["path", "action"]
   }
 };
+async function handleShow(projectPath, input) {
+  const { loadState } = await import("./dist-HWXF2C3R.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-HWXF2C3R.js");
+  const result = await appendLearning(
+    projectPath,
+    input.learning,
+    input.skillName,
+    input.outcome,
+    input.stream,
+    input.session
+  );
+  if (!result.ok) return resultToMcpResponse(result);
+  return resultToMcpResponse(Ok({ recorded: true }));
+}
+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-HWXF2C3R.js");
+  const result = await appendFailure(
+    projectPath,
+    input.description,
+    input.skillName ?? "unknown",
+    input.failureType,
+    input.stream,
+    input.session
+  );
+  if (!result.ok) return resultToMcpResponse(result);
+  return resultToMcpResponse(Ok({ recorded: true }));
+}
+async function handleArchive(projectPath, input) {
+  const { archiveFailures } = await import("./dist-HWXF2C3R.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-HWXF2C3R.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-HWXF2C3R.js");
+  return resultToMcpResponse(await runMechanicalGate(projectPath));
+}
+async function handleSaveHandoff(projectPath, input) {
+  if (!input.handoff) return mcpError("Error: handoff is required for save-handoff action");
+  const { saveHandoff } = await import("./dist-HWXF2C3R.js");
+  const result = await saveHandoff(
+    projectPath,
+    input.handoff,
+    input.stream,
+    input.session
+  );
+  return resultToMcpResponse(result.ok ? Ok({ saved: true }) : result);
+}
+async function handleLoadHandoff(projectPath, input) {
+  const { loadHandoff } = await import("./dist-HWXF2C3R.js");
+  return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
+}
+async function handleAppendEntry(projectPath, input) {
+  if (!input.session) return mcpError("Error: session is required for append_entry action");
+  if (!input.section) return mcpError("Error: section is required for append_entry action");
+  if (!input.authorSkill) return mcpError("Error: authorSkill is required for append_entry action");
+  if (!input.content) return mcpError("Error: content is required for append_entry action");
+  const { appendSessionEntry } = await import("./dist-HWXF2C3R.js");
+  const result = await appendSessionEntry(
+    projectPath,
+    input.session,
+    input.section,
+    input.authorSkill,
+    input.content
+  );
+  return resultToMcpResponse(result);
+}
+async function handleUpdateEntryStatus(projectPath, input) {
+  if (!input.session) return mcpError("Error: session is required for update_entry_status action");
+  if (!input.section) return mcpError("Error: section is required for update_entry_status action");
+  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-HWXF2C3R.js");
+  const result = await updateSessionEntryStatus(
+    projectPath,
+    input.session,
+    input.section,
+    input.entryId,
+    input.newStatus
+  );
+  return resultToMcpResponse(result);
+}
+async function handleReadSection(projectPath, input) {
+  if (!input.session) return mcpError("Error: session is required for read_section action");
+  if (!input.section) return mcpError("Error: section is required for read_section action");
+  const { readSessionSection } = await import("./dist-HWXF2C3R.js");
+  const result = await readSessionSection(
+    projectPath,
+    input.session,
+    input.section
+  );
+  return resultToMcpResponse(result);
+}
+async function handleReadSections(projectPath, input) {
+  if (!input.session) return mcpError("Error: session is required for read_sections action");
+  const { readSessionSections } = await import("./dist-HWXF2C3R.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-HWXF2C3R.js");
+  const result = await archiveSession(projectPath, input.session);
+  if (!result.ok) return resultToMcpResponse(result);
+  return resultToMcpResponse(Ok({ archived: true }));
+}
+var ACTION_HANDLERS = {
+  show: handleShow,
+  learn: handleLearn,
+  failure: handleFailure,
+  archive: handleArchive,
+  reset: handleReset,
+  gate: handleGate,
+  "save-handoff": handleSaveHandoff,
+  "load-handoff": handleLoadHandoff,
+  append_entry: handleAppendEntry,
+  update_entry_status: handleUpdateEntryStatus,
+  read_section: handleReadSection,
+  read_sections: handleReadSections,
+  archive_session: handleArchiveSession
+};
 async function handleManageState(input) {
   try {
-    const {
-      loadState,
-      saveState,
-      appendLearning,
-      appendFailure,
-      archiveFailures,
-      runMechanicalGate,
-      DEFAULT_STATE
-    } = await import("./dist-WF4C7A4A.js");
     const projectPath = sanitizePath(input.path);
-    switch (input.action) {
-      case "show": {
-        const result = await loadState(projectPath, input.stream, input.session);
-        return resultToMcpResponse(result);
-      }
-      case "learn": {
-        if (!input.learning) {
-          return {
-            content: [
-              { type: "text", text: "Error: learning is required for learn action" }
-            ],
-            isError: true
-          };
-        }
-        const result = await appendLearning(
-          projectPath,
-          input.learning,
-          input.skillName,
-          input.outcome,
-          input.stream,
-          input.session
-        );
-        if (!result.ok) return resultToMcpResponse(result);
-        return resultToMcpResponse(Ok({ recorded: true }));
-      }
-      case "failure": {
-        if (!input.description) {
-          return {
-            content: [
-              { type: "text", text: "Error: description is required for failure action" }
-            ],
-            isError: true
-          };
-        }
-        if (!input.failureType) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: failureType is required for failure action"
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = await appendFailure(
-          projectPath,
-          input.description,
-          input.skillName ?? "unknown",
-          input.failureType,
-          input.stream,
-          input.session
-        );
-        if (!result.ok) return resultToMcpResponse(result);
-        return resultToMcpResponse(Ok({ recorded: true }));
-      }
-      case "archive": {
-        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,
-          input.session
-        );
-        if (!result.ok) return resultToMcpResponse(result);
-        return resultToMcpResponse(Ok({ reset: true }));
-      }
-      case "gate": {
-        const result = await runMechanicalGate(projectPath);
-        return resultToMcpResponse(result);
-      }
-      case "save-handoff": {
-        if (!input.handoff) {
-          return {
-            content: [
-              { type: "text", text: "Error: handoff is required for save-handoff action" }
-            ],
-            isError: true
-          };
-        }
-        const { saveHandoff } = await import("./dist-WF4C7A4A.js");
-        const result = await saveHandoff(
-          projectPath,
-          input.handoff,
-          input.stream,
-          input.session
-        );
-        return resultToMcpResponse(result.ok ? Ok({ saved: true }) : result);
-      }
-      case "load-handoff": {
-        const { loadHandoff } = await import("./dist-WF4C7A4A.js");
-        const result = await loadHandoff(projectPath, input.stream, input.session);
-        return resultToMcpResponse(result);
-      }
-      default: {
-        return {
-          content: [{ type: "text", text: `Error: unknown action` }],
-          isError: true
-        };
-      }
-    }
+    const handler = ACTION_HANDLERS[input.action];
+    if (!handler) return mcpError("Error: unknown action");
+    return await handler(projectPath, input);
   } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
+    return mcpError(`Error: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 var listStreamsDefinition = {
@@ -841,7 +1371,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-WF4C7A4A.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-HWXF2C3R.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -879,7 +1409,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-S2MZKLFQ.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-L3RADYWO.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -899,7 +1429,7 @@ async function handleCheckPhaseGate(input) {
 }
 
 // src/mcp/tools/cross-check.ts
-import * as path8 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",
@@ -935,15 +1465,15 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-EDQ5QGTM.js");
-    const specsDir = path8.resolve(projectPath, input.specsDir ?? "docs/specs");
+    const { runCrossCheck } = await import("./validate-cross-check-WNJM6H2D.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 = path8.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" }],
@@ -974,15 +1504,15 @@ async function handleValidateCrossCheck(input) {
 
 // src/commands/generate-slash-commands.ts
 import { Command } from "commander";
-import fs7 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path13 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 fs10 from "fs";
+import path12 from "path";
+import { parse as parse3 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
 function normalizeName(skillName) {
@@ -998,116 +1528,125 @@ function normalizeName(skillName) {
 }
 
 // src/slash-commands/normalize.ts
+function readSkillYaml(yamlPath) {
+  let raw;
+  try {
+    raw = fs10.readFileSync(yamlPath, "utf-8");
+  } catch {
+    return null;
+  }
+  return SkillMetadataSchema.safeParse(parse3(raw));
+}
+function shouldSkipSkill(meta, platforms) {
+  const matchesPlatform = platforms.some((p) => meta.platforms.includes(p));
+  if (!matchesPlatform) return true;
+  if (meta.tier === 3 || meta.internal) return true;
+  return false;
+}
+function checkNameCollision(normalized, metaName, source, nameMap) {
+  const existing = nameMap.get(normalized);
+  if (!existing) {
+    nameMap.set(normalized, { skillName: metaName, source });
+    return "ok";
+  }
+  if (existing.source === source) {
+    throw new Error(
+      `Name collision: skills "${existing.skillName}" and "${metaName}" both normalize to "${normalized}"`
+    );
+  }
+  return "skip";
+}
+function buildContextLines(meta) {
+  const lines = [];
+  if (meta.cognitive_mode) lines.push(`Cognitive mode: ${meta.cognitive_mode}`);
+  if (meta.type) lines.push(`Type: ${meta.type}`);
+  if (meta.state?.persistent) {
+    const files = meta.state.files?.join(", ") ?? "";
+    lines.push(`State: persistent${files ? ` (files: ${files})` : ""}`);
+  }
+  return lines;
+}
+function buildObjectiveLines(meta) {
+  const lines = [meta.description];
+  if (meta.phases && meta.phases.length > 0) {
+    lines.push("", "Phases:");
+    for (const phase of meta.phases) {
+      const req = phase.required !== false ? "" : " (optional)";
+      lines.push(`- ${phase.name}: ${phase.description}${req}`);
+    }
+  }
+  return lines;
+}
+function buildProcessLines(meta) {
+  if (meta.mcp?.tool) {
+    return [
+      `1. Try: invoke mcp__harness__${meta.mcp.tool} with skill: "${meta.name}"`,
+      `2. If MCP unavailable: read SKILL.md and follow its workflow directly`,
+      `3. Pass through any arguments provided by the user`
+    ];
+  }
+  return [
+    `1. Read SKILL.md and follow its workflow directly`,
+    `2. Pass through any arguments provided by the user`
+  ];
+}
+function buildSpec(meta, normalized, entry, skillsDir, source) {
+  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 ?? "",
+    required: a.required ?? false
+  }));
+  const tools = [...meta.tools ?? []];
+  if (!tools.includes("Read")) tools.push("Read");
+  const executionContextLines = [];
+  if (skillMdContent) {
+    executionContextLines.push(`@${skillMdRelative}`, `@${skillYamlRelative}`);
+  }
+  return {
+    name: normalized,
+    namespace: "harness",
+    fullName: `harness:${normalized}`,
+    description: meta.description,
+    version: meta.version,
+    ...meta.cognitive_mode ? { cognitiveMode: meta.cognitive_mode } : {},
+    tools,
+    args,
+    skillYamlName: meta.name,
+    sourceDir: entry.name,
+    skillsBaseDir: skillsDir,
+    source,
+    prompt: {
+      context: buildContextLines(meta).join("\n"),
+      objective: buildObjectiveLines(meta).join("\n"),
+      executionContext: executionContextLines.join("\n"),
+      process: buildProcessLines(meta).join("\n")
+    }
+  };
+}
 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 (!fs10.existsSync(skillsDir)) continue;
+    const entries = fs10.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;
-      let raw;
-      try {
-        raw = fs6.readFileSync(yamlPath, "utf-8");
-      } catch {
-        continue;
-      }
-      const parsed = parse2(raw);
-      const result = SkillMetadataSchema.safeParse(parsed);
+      const yamlPath = path12.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs10.existsSync(yamlPath)) continue;
+      const result = readSkillYaml(yamlPath);
+      if (!result) continue;
       if (!result.success) {
         console.warn(`Skipping ${entry.name}: invalid skill.yaml`);
         continue;
       }
       const meta = result.data;
-      const matchesPlatform = platforms.some((p) => meta.platforms.includes(p));
-      if (!matchesPlatform) continue;
+      if (shouldSkipSkill(meta, platforms)) continue;
       const normalized = normalizeName(meta.name);
-      const existing = nameMap.get(normalized);
-      if (existing) {
-        if (existing.source === source) {
-          throw new Error(
-            `Name collision: skills "${existing.skillName}" and "${meta.name}" both normalize to "${normalized}"`
-          );
-        }
-        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 args = (meta.cli?.args ?? []).map((a) => ({
-        name: a.name,
-        description: a.description ?? "",
-        required: a.required ?? false
-      }));
-      const tools = [...meta.tools ?? []];
-      if (!tools.includes("Read")) {
-        tools.push("Read");
-      }
-      const contextLines = [];
-      if (meta.cognitive_mode) {
-        contextLines.push(`Cognitive mode: ${meta.cognitive_mode}`);
-      }
-      if (meta.type) {
-        contextLines.push(`Type: ${meta.type}`);
-      }
-      if (meta.state?.persistent) {
-        const files = meta.state.files?.join(", ") ?? "";
-        contextLines.push(`State: persistent${files ? ` (files: ${files})` : ""}`);
-      }
-      const objectiveLines = [meta.description];
-      if (meta.phases && meta.phases.length > 0) {
-        objectiveLines.push("");
-        objectiveLines.push("Phases:");
-        for (const phase of meta.phases) {
-          const req = phase.required !== false ? "" : " (optional)";
-          objectiveLines.push(`- ${phase.name}: ${phase.description}${req}`);
-        }
-      }
-      const executionContextLines = [];
-      if (skillMdContent) {
-        executionContextLines.push(`@${skillMdRelative}`);
-        executionContextLines.push(`@${skillYamlRelative}`);
-      }
-      const processLines = [];
-      if (meta.mcp?.tool) {
-        processLines.push(
-          `1. Try: invoke mcp__harness__${meta.mcp.tool} with skill: "${meta.name}"`
-        );
-        processLines.push(`2. If MCP unavailable: read SKILL.md and follow its workflow directly`);
-        processLines.push(`3. Pass through any arguments provided by the user`);
-      } else {
-        processLines.push(`1. Read SKILL.md and follow its workflow directly`);
-        processLines.push(`2. Pass through any arguments provided by the user`);
-      }
-      specs.push({
-        name: normalized,
-        namespace: "harness",
-        fullName: `harness:${normalized}`,
-        description: meta.description,
-        version: meta.version,
-        ...meta.cognitive_mode ? { cognitiveMode: meta.cognitive_mode } : {},
-        tools,
-        args,
-        skillYamlName: meta.name,
-        sourceDir: entry.name,
-        skillsBaseDir: skillsDir,
-        source,
-        prompt: {
-          context: contextLines.join("\n"),
-          objective: objectiveLines.join("\n"),
-          executionContext: executionContextLines.join("\n"),
-          process: processLines.join("\n")
-        }
-      });
+      if (checkNameCollision(normalized, meta.name, source, nameMap) === "skip") continue;
+      specs.push(buildSpec(meta, normalized, entry, skillsDir, source));
     }
   }
   return specs;
@@ -1207,13 +1746,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 path13.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" ? path13.join(home, ".claude", "commands", "harness") : path13.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" ? path13.join("agents", "commands", "claude-code", "harness") : path13.join("agents", "commands", "gemini-cli", "harness");
 }
 function fileExtension(platform) {
   return platform === "claude-code" ? ".md" : ".toml";
@@ -1228,26 +1767,29 @@ Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
     });
   });
 }
-function generateSlashCommands(opts) {
-  const skillSources = [];
+function resolveSkillSources(opts) {
   if (opts.skillsDir) {
-    skillSources.push({ dir: opts.skillsDir, source: "project" });
-  } else {
-    const projectDir = resolveProjectSkillsDir();
-    if (projectDir) {
-      skillSources.push({ dir: projectDir, source: "project" });
-    }
-    const communityDir = resolveCommunitySkillsDir();
-    if (fs7.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)) {
-        skillSources.push({ dir: globalDir, source: "global" });
-      }
+    return [{ dir: opts.skillsDir, source: "project" }];
+  }
+  const sources = [];
+  const projectDir = resolveProjectSkillsDir();
+  if (projectDir) {
+    sources.push({ dir: projectDir, source: "project" });
+  }
+  const communityDir = resolveCommunitySkillsDir();
+  if (fs11.existsSync(communityDir)) {
+    sources.push({ dir: communityDir, source: "community" });
+  }
+  if (opts.includeGlobal || sources.length === 0) {
+    const globalDir = resolveGlobalSkillsDir();
+    if (!projectDir || path13.resolve(globalDir) !== path13.resolve(projectDir)) {
+      sources.push({ dir: globalDir, source: "global" });
     }
   }
+  return sources;
+}
+function generateSlashCommands(opts) {
+  const skillSources = resolveSkillSources(opts);
   const specs = normalizeSkills(skillSources, opts.platforms);
   const results = [];
   for (const platform of opts.platforms) {
@@ -1265,7 +1807,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 `@${path13.resolve(relPath)}`;
               }
               return line;
             }).join("\n")
@@ -1273,10 +1815,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 = path13.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path13.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs11.existsSync(mdPath) ? fs11.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs11.existsSync(yamlPath) ? fs11.readFileSync(yamlPath, "utf-8") : "";
         rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
       }
     }
@@ -1302,9 +1844,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 = path13.join(result.outputDir, filename);
+        if (fs11.existsSync(filePath)) {
+          fs11.unlinkSync(filePath);
         }
       }
     }
@@ -1430,7 +1972,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-WF4C7A4A.js");
+    const { loadState, migrateToStreams } = await import("./dist-HWXF2C3R.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -1454,8 +1996,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: [
@@ -1467,6 +2008,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.",
@@ -1517,7 +2060,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-B26DFXMP.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -1583,6 +2126,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.",
@@ -1606,7 +2151,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-B26DFXMP.js");
     const fusion = new FusionLayer(store);
     const results = fusion.search(input.query, input.topK ?? 10);
     if (input.mode === "summary") {
@@ -1638,6 +2183,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.",
@@ -1659,7 +2206,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-B26DFXMP.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -1725,6 +2272,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.",
@@ -1753,7 +2302,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-B26DFXMP.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -1820,6 +2369,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.",
@@ -1857,7 +2408,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-B26DFXMP.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -1966,6 +2517,9 @@ async function handleGetImpact(input) {
     };
   }
 }
+
+// src/mcp/tools/graph/ingest-source.ts
+import * as path14 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.",
@@ -1985,10 +2539,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 = path14.join(projectPath, ".harness", "graph");
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-B26DFXMP.js");
+    const fs14 = await import("fs/promises");
+    await fs14.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -2037,6 +2591,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",
@@ -2059,7 +2615,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-B26DFXMP.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -2080,6 +2636,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.',
@@ -2097,7 +2655,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-B26DFXMP.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -2116,8 +2674,8 @@ async function handleAskGraph(input) {
 }
 
 // src/mcp/resources/graph.ts
-import * as fs8 from "fs/promises";
-import * as path12 from "path";
+import * as fs12 from "fs/promises";
+import * as path15 from "path";
 var MAX_ITEMS = 5e3;
 function formatStaleness(isoTimestamp) {
   const then = new Date(isoTimestamp).getTime();
@@ -2140,11 +2698,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 = path15.join(projectRoot, ".harness", "graph");
+  const metadataPath = path15.join(graphDir, "metadata.json");
   let lastScanTimestamp = null;
   try {
-    const raw = JSON.parse(await fs8.readFile(metadataPath, "utf-8"));
+    const raw = JSON.parse(await fs12.readFile(metadataPath, "utf-8"));
     lastScanTimestamp = raw.lastScanTimestamp ?? null;
   } catch {
   }
@@ -2233,7 +2791,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-QABOJG56.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-3PM5EU7V.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -2244,8 +2802,8 @@ async function handleGenerateAgentDefinitions(input) {
 }
 
 // src/mcp/tools/roadmap.ts
-import * as fs9 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path16 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.",
@@ -2300,309 +2858,261 @@ var manageRoadmapDefinition = {
   }
 };
 function roadmapPath(projectRoot) {
-  return path13.join(projectRoot, "docs", "roadmap.md");
+  return path16.join(projectRoot, "docs", "roadmap.md");
 }
 function readRoadmapFile(projectRoot) {
   const filePath = roadmapPath(projectRoot);
   try {
-    return fs9.readFileSync(filePath, "utf-8");
+    return fs13.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 = path16.dirname(filePath);
+  fs13.mkdirSync(dir, { recursive: true });
+  fs13.writeFileSync(filePath, content, "utf-8");
 }
-async function handleManageRoadmap(input) {
-  try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap } = await import("./dist-WF4C7A4A.js");
-    const { Ok: Ok2 } = await import("./dist-D4RYGUZE.js");
-    const projectPath = sanitizePath(input.path);
-    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));
+function roadmapNotFoundError() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "Error: docs/roadmap.md not found. Create a roadmap first."
       }
-      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 }))
+    ],
+    isError: true
+  };
+}
+function handleShow2(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()
         );
-        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 }));
+        if (feature) {
+          feature.status = change.to;
+          break;
         }
-        return resultToMcpResponse(Ok2({ changes, applied: false }));
       }
+    }
+    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-HWXF2C3R.js");
+    const { Ok: Ok2 } = await import("./dist-USY2C5JL.js");
+    const projectPath = sanitizePath(input.path);
+    const deps = { parseRoadmap, serializeRoadmap, syncRoadmap, Ok: Ok2 };
+    switch (input.action) {
+      case "show":
+        return handleShow2(projectPath, input, deps);
+      case "add":
+        return handleAdd(projectPath, input, deps);
+      case "update":
+        return handleUpdate(projectPath, input, deps);
+      case "remove":
+        return handleRemove(projectPath, input, deps);
+      case "query":
+        return handleQuery(projectPath, input, deps);
+      case "sync":
+        return handleSync(projectPath, input, deps);
       default: {
         return {
           content: [{ type: "text", text: `Error: unknown action` }],
@@ -2972,226 +3482,119 @@ var emitInteractionDefinition = {
     required: ["path", "type"]
   }
 };
+function formatZodErrors(issues) {
+  return issues.map((i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message).join("; ");
+}
+async function handleQuestion(validInput, projectPath, id) {
+  if (!validInput.question)
+    return mcpError("Error: question payload is required when type is question");
+  const questionResult = InteractionQuestionWithOptionsSchema.safeParse(validInput.question);
+  if (!questionResult.success)
+    return mcpError(`Error: ${formatZodErrors(questionResult.error.issues)}`);
+  const prompt = renderQuestion(questionResult.data);
+  await recordInteraction(projectPath, id, "question", questionResult.data.text, validInput.stream);
+  return { content: [{ type: "text", text: JSON.stringify({ id, prompt }) }] };
+}
+async function handleConfirmation(validInput, projectPath, id) {
+  if (!validInput.confirmation)
+    return mcpError("Error: confirmation payload is required when type is confirmation");
+  const confirmResult = InteractionConfirmationSchema.safeParse(validInput.confirmation);
+  if (!confirmResult.success)
+    return mcpError(
+      `Error: ${confirmResult.error.issues.map((i) => i.message).join("; ")}`
+    );
+  const prompt = renderConfirmation(confirmResult.data);
+  await recordInteraction(
+    projectPath,
+    id,
+    "confirmation",
+    confirmResult.data.text,
+    validInput.stream
+  );
+  return { content: [{ type: "text", text: JSON.stringify({ id, prompt }) }] };
+}
+async function handleTransition(validInput, projectPath, id) {
+  if (!validInput.transition)
+    return mcpError("Error: transition payload is required when type is transition");
+  const transitionResult = InteractionTransitionSchema.safeParse(validInput.transition);
+  if (!transitionResult.success)
+    return mcpError(
+      `Error: ${transitionResult.error.issues.map((i) => i.message).join("; ")}`
+    );
+  const transition = transitionResult.data;
+  const prompt = renderTransition(transition);
+  try {
+    const { saveHandoff } = await import("./dist-HWXF2C3R.js");
+    await saveHandoff(
+      projectPath,
+      {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        fromSkill: "emit_interaction",
+        phase: transition.completedPhase,
+        summary: transition.reason,
+        completed: [transition.completedPhase],
+        pending: [transition.suggestedNext],
+        concerns: [],
+        decisions: [],
+        blockers: [],
+        contextKeywords: []
+      },
+      validInput.stream,
+      validInput.session
+    );
+  } catch {
+  }
+  await recordInteraction(
+    projectPath,
+    id,
+    "transition",
+    `${transition.completedPhase} -> ${transition.suggestedNext}`,
+    validInput.stream
+  );
+  const responsePayload = { id, prompt, handoffWritten: true };
+  if (!transition.requiresConfirmation) {
+    responsePayload.autoTransition = true;
+    responsePayload.nextAction = `Invoke harness-${transition.suggestedNext} skill now`;
+  }
+  return { content: [{ type: "text", text: JSON.stringify(responsePayload) }] };
+}
+async function handleBatch(validInput, projectPath, id) {
+  if (!validInput.batch) return mcpError("Error: batch payload is required when type is batch");
+  const batchResult = InteractionBatchSchema.safeParse(validInput.batch);
+  if (!batchResult.success)
+    return mcpError(
+      `Error: ${batchResult.error.issues.map((i) => i.message).join("; ")}`
+    );
+  const prompt = renderBatch(batchResult.data);
+  await recordInteraction(projectPath, id, "batch", batchResult.data.text, validInput.stream);
+  return {
+    content: [{ type: "text", text: JSON.stringify({ id, prompt, batchMode: true }) }]
+  };
+}
+var INTERACTION_HANDLERS = {
+  question: handleQuestion,
+  confirmation: handleConfirmation,
+  transition: handleTransition,
+  batch: handleBatch
+};
 async function handleEmitInteraction(input) {
   try {
     const parseResult = EmitInteractionInputSchema.safeParse(input);
-    if (!parseResult.success) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${parseResult.error.issues.map((i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message).join("; ")}`
-          }
-        ],
-        isError: true
-      };
-    }
+    if (!parseResult.success)
+      return mcpError(`Error: ${formatZodErrors(parseResult.error.issues)}`);
     const validInput = parseResult.data;
     const projectPath = sanitizePath(validInput.path);
     const id = randomUUID();
-    switch (validInput.type) {
-      case "question": {
-        if (!validInput.question) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: question payload is required when type is question"
-              }
-            ],
-            isError: true
-          };
-        }
-        const questionResult = InteractionQuestionWithOptionsSchema.safeParse(validInput.question);
-        if (!questionResult.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${questionResult.error.issues.map((i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message).join("; ")}`
-              }
-            ],
-            isError: true
-          };
-        }
-        const prompt = renderQuestion(questionResult.data);
-        await recordInteraction(
-          projectPath,
-          id,
-          "question",
-          questionResult.data.text,
-          validInput.stream
-        );
-        return {
-          content: [{ type: "text", text: JSON.stringify({ id, prompt }) }]
-        };
-      }
-      case "confirmation": {
-        if (!validInput.confirmation) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: confirmation payload is required when type is confirmation"
-              }
-            ],
-            isError: true
-          };
-        }
-        const confirmResult = InteractionConfirmationSchema.safeParse(validInput.confirmation);
-        if (!confirmResult.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${confirmResult.error.issues.map((i) => i.message).join("; ")}`
-              }
-            ],
-            isError: true
-          };
-        }
-        const prompt = renderConfirmation(confirmResult.data);
-        await recordInteraction(
-          projectPath,
-          id,
-          "confirmation",
-          confirmResult.data.text,
-          validInput.stream
-        );
-        return {
-          content: [{ type: "text", text: JSON.stringify({ id, prompt }) }]
-        };
-      }
-      case "transition": {
-        if (!validInput.transition) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: transition payload is required when type is transition"
-              }
-            ],
-            isError: true
-          };
-        }
-        const transitionResult = InteractionTransitionSchema.safeParse(validInput.transition);
-        if (!transitionResult.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${transitionResult.error.issues.map((i) => i.message).join("; ")}`
-              }
-            ],
-            isError: true
-          };
-        }
-        const transition = transitionResult.data;
-        const prompt = renderTransition(transition);
-        try {
-          const { saveHandoff } = await import("./dist-WF4C7A4A.js");
-          await saveHandoff(
-            projectPath,
-            {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              fromSkill: "emit_interaction",
-              phase: transition.completedPhase,
-              summary: transition.reason,
-              completed: [transition.completedPhase],
-              pending: [transition.suggestedNext],
-              concerns: [],
-              decisions: [],
-              blockers: [],
-              contextKeywords: []
-            },
-            validInput.stream,
-            validInput.session
-          );
-        } catch {
-        }
-        await recordInteraction(
-          projectPath,
-          id,
-          "transition",
-          `${transition.completedPhase} -> ${transition.suggestedNext}`,
-          validInput.stream
-        );
-        const responsePayload = { id, prompt, handoffWritten: true };
-        if (!transition.requiresConfirmation) {
-          responsePayload.autoTransition = true;
-          responsePayload.nextAction = `Invoke harness-${transition.suggestedNext} skill now`;
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(responsePayload)
-            }
-          ]
-        };
-      }
-      case "batch": {
-        if (!validInput.batch) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: batch payload is required when type is batch"
-              }
-            ],
-            isError: true
-          };
-        }
-        const batchResult = InteractionBatchSchema.safeParse(validInput.batch);
-        if (!batchResult.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${batchResult.error.issues.map((i) => i.message).join("; ")}`
-              }
-            ],
-            isError: true
-          };
-        }
-        const prompt = renderBatch(batchResult.data);
-        await recordInteraction(projectPath, id, "batch", batchResult.data.text, validInput.stream);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ id, prompt, batchMode: true })
-            }
-          ]
-        };
-      }
-      default: {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: unknown interaction type: ${String(validInput.type)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+    const handler = INTERACTION_HANDLERS[validInput.type];
+    if (!handler) return mcpError(`Error: unknown interaction type: ${String(validInput.type)}`);
+    return await handler(validInput, projectPath, id);
   } catch (error) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ],
-      isError: true
-    };
+    return mcpError(`Error: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-WF4C7A4A.js");
+    const { loadState, saveState } = await import("./dist-HWXF2C3R.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -3209,7 +3612,7 @@ async function recordInteraction(projectPath, id, type, decision, stream) {
 // src/mcp/tools/gather-context.ts
 var gatherContextDefinition = {
   name: "gather_context",
-  description: "Assemble all working context an agent needs in a single call: state, learnings, handoff, graph context, and project validation. Runs constituents in parallel.",
+  description: "Assemble all working context an agent needs in a single call: state, learnings, handoff, graph context, project validation, and session sections. Runs constituents in parallel.",
   inputSchema: {
     type: "object",
     properties: {
@@ -3230,7 +3633,7 @@ var gatherContextDefinition = {
         type: "array",
         items: {
           type: "string",
-          enum: ["state", "learnings", "handoff", "graph", "validation"]
+          enum: ["state", "learnings", "handoff", "graph", "validation", "sessions"]
         },
         description: "Which constituents to include (default: all)"
       },
@@ -3271,10 +3674,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-WF4C7A4A.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-HWXF2C3R.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-WF4C7A4A.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-HWXF2C3R.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -3282,14 +3685,14 @@ async function handleGatherContext(input) {
       ...input.session !== void 0 && { session: input.session }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-WF4C7A4A.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-HWXF2C3R.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-KO4GJ5N2.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-2M2HXDQI.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) return null;
-    const { FusionLayer, ContextQL } = await import("./dist-M6BQODWC.js");
+    const { FusionLayer, ContextQL } = await import("./dist-B26DFXMP.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -3326,18 +3729,29 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-HWXF2C3R.js").then(
+    (core) => core.readSessionSections(projectPath, input.session)
+  ) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-N7QJOKFZ.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-FD3Z6VJD.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
   })() : Promise.resolve(null);
-  const [stateResult, learningsResult, handoffResult, graphResult, validationResult] = await Promise.allSettled([
+  const [
+    stateResult,
+    learningsResult,
+    handoffResult,
+    graphResult,
+    validationResult,
+    sessionsResult
+  ] = await Promise.allSettled([
     statePromise,
     learningsPromise,
     handoffPromise,
     graphPromise,
-    validationPromise
+    validationPromise,
+    sessionsPromise
   ]);
   function extract(settled, name) {
     if (settled.status === "rejected") {
@@ -3351,6 +3765,7 @@ async function handleGatherContext(input) {
   const handoffRaw = extract(handoffResult, "handoff");
   const graphContextRaw = extract(graphResult, "graph");
   const validationRaw = extract(validationResult, "validation");
+  const sessionsRaw = extract(sessionsResult, "sessions");
   const state = stateRaw && typeof stateRaw === "object" && "ok" in stateRaw ? stateRaw.ok ? stateRaw.value : (() => {
     errors.push(`state: ${stateRaw.error.message}`);
     return null;
@@ -3367,6 +3782,12 @@ async function handleGatherContext(input) {
   })() : handoffRaw;
   const graphContext = graphContextRaw;
   const validation = validationRaw;
+  const sessionSections = sessionsRaw && typeof sessionsRaw === "object" && "ok" in sessionsRaw ? sessionsRaw.ok ? sessionsRaw.value : (() => {
+    errors.push(
+      `sessions: ${sessionsRaw.error.message}`
+    );
+    return null;
+  })() : sessionsRaw;
   const assembledIn = Date.now() - start;
   const mode = input.mode ?? "summary";
   const outputState = state ?? null;
@@ -3391,6 +3812,7 @@ async function handleGatherContext(input) {
     handoff: outputHandoff,
     graphContext: outputGraphContext,
     validation: outputValidation,
+    sessionSections: sessionSections ?? null,
     meta: {
       assembledIn,
       graphAvailable: graphContext !== null,
@@ -3401,7 +3823,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-WF4C7A4A.js");
+      const core = await import("./dist-HWXF2C3R.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -3471,7 +3893,7 @@ async function handleAssessProject(input) {
   let validateResult = null;
   if (checksToRun.has("validate")) {
     try {
-      const { handleValidateProject: handleValidateProject2 } = await import("./validate-N7QJOKFZ.js");
+      const { handleValidateProject: handleValidateProject2 } = await import("./validate-FD3Z6VJD.js");
       const result = await handleValidateProject2({ path: projectPath });
       const first = result.content[0];
       const parsed = first ? JSON.parse(first.text) : {};
@@ -3496,7 +3918,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-ESOOE26S.js");
+          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-JQZYM4US.js");
           const result = await handleCheckDependencies2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3523,7 +3945,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-BPYCN2DR.js");
+          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-7ECGYMAV.js");
           const result = await handleCheckDocs2({ path: projectPath, scope: "coverage" });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3550,14 +3972,14 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-4VDVV5CR.js");
+          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-5USWKLVS.js");
           const result = await handleDetectEntropy2({ path: projectPath, type: "all" });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
           const issues = (parsed.drift?.staleReferences?.length ?? 0) + (parsed.drift?.missingTargets?.length ?? 0) + (parsed.deadCode?.unusedImports?.length ?? 0) + (parsed.deadCode?.unusedExports?.length ?? 0) + (parsed.patterns?.violations?.length ?? 0);
           return {
             name: "entropy",
-            passed: !result.isError && issues === 0,
+            passed: !("isError" in result && result.isError) && issues === 0,
             issueCount: issues,
             ...issues > 0 ? { topIssue: "Entropy detected -- run detect_entropy for details" } : {},
             ...mode === "detailed" ? { detailed: parsed } : {}
@@ -3577,7 +3999,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-UQFUZXEN.js");
+          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-PZOX7AQS.js");
           const result = await handleRunSecurityScan2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3609,14 +4031,14 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-26BH47O4.js");
+          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-OQAFMJUD.js");
           const result = await handleCheckPerformance2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
           const issues = parsed.violations?.length ?? parsed.issues?.length ?? 0;
           return {
             name: "perf",
-            passed: !result.isError && issues === 0,
+            passed: !("isError" in result && result.isError) && issues === 0,
             issueCount: issues,
             ...issues > 0 ? { topIssue: "Performance issues detected" } : {},
             ...mode === "detailed" ? { detailed: parsed } : {}
@@ -3783,81 +4205,8 @@ async function handleReviewChanges(input) {
     downgraded = true;
   }
   try {
-    if (effectiveDepth === "quick") {
-      const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-63QB5RCA.js");
-      const result2 = await handleAnalyzeDiff2({ diff, path: projectPath });
-      const firstContent = result2.content[0];
-      if (!firstContent) throw new Error("Empty analyze_diff response");
-      const parsed2 = JSON.parse(firstContent.text);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              depth: "quick",
-              downgraded,
-              findings: parsed2.findings ?? parsed2.warnings ?? [],
-              fileCount: parsed2.summary?.filesChanged ?? parsed2.files?.length ?? 0,
-              lineCount: diffLines,
-              ...result2.isError ? { error: parsed2 } : {}
-            })
-          }
-        ]
-      };
-    }
-    if (effectiveDepth === "standard") {
-      const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-63QB5RCA.js");
-      const [diffResult, reviewResult] = await Promise.all([
-        handleAnalyzeDiff2({ diff, path: projectPath }),
-        handleCreateSelfReview2({ path: projectPath, diff })
-      ]);
-      const diffContent = diffResult.content[0];
-      const reviewContent = reviewResult.content[0];
-      if (!diffContent || !reviewContent) throw new Error("Empty review response");
-      const diffParsed = JSON.parse(diffContent.text);
-      const reviewParsed = JSON.parse(reviewContent.text);
-      const findings = [
-        ...diffParsed.findings ?? diffParsed.warnings ?? [],
-        ...reviewParsed.findings ?? reviewParsed.items ?? []
-      ];
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              depth: "standard",
-              downgraded,
-              findings,
-              diffAnalysis: diffParsed,
-              selfReview: reviewParsed,
-              fileCount: diffParsed.summary?.filesChanged ?? diffParsed.files?.length ?? 0,
-              lineCount: diffLines
-            })
-          }
-        ]
-      };
-    }
-    const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-GHR3WFBI.js");
-    const result = await handleRunCodeReview2({ path: projectPath, diff });
-    const deepContent = result.content[0];
-    if (!deepContent) throw new Error("Empty code review response");
-    const parsed = JSON.parse(deepContent.text);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            depth: "deep",
-            downgraded: false,
-            findings: parsed.findings ?? [],
-            assessment: parsed.assessment,
-            findingCount: parsed.findingCount,
-            lineCount: diffLines,
-            pipeline: parsed
-          })
-        }
-      ]
-    };
+    const reviewFn = DEPTH_HANDLERS[effectiveDepth];
+    return await reviewFn(projectPath, diff, diffLines, downgraded);
   } catch (error) {
     return {
       content: [
@@ -3870,6 +4219,97 @@ async function handleReviewChanges(input) {
     };
   }
 }
+async function runQuickReview(projectPath, diff, diffLines, downgraded) {
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-UTBXZZHF.js");
+  const result = await handleAnalyzeDiff2({ diff, path: projectPath });
+  const firstContent = result.content[0];
+  if (!firstContent) throw new Error("Empty analyze_diff response");
+  const parsed = JSON.parse(firstContent.text);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          depth: "quick",
+          downgraded,
+          findings: parsed.findings ?? parsed.warnings ?? [],
+          fileCount: parsed.summary?.filesChanged ?? parsed.files?.length ?? 0,
+          lineCount: diffLines,
+          ...result.isError ? { error: parsed } : {}
+        })
+      }
+    ]
+  };
+}
+function extractFindings(parsed, primaryKey, fallbackKey) {
+  return parsed[primaryKey] ?? parsed[fallbackKey] ?? [];
+}
+function extractFileCount(diffParsed) {
+  const summary = diffParsed.summary;
+  if (summary?.filesChanged !== void 0) return summary.filesChanged;
+  const files = diffParsed.files;
+  return files?.length ?? 0;
+}
+async function runStandardReview(projectPath, diff, diffLines, downgraded) {
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-UTBXZZHF.js");
+  const [diffResult, reviewResult] = await Promise.all([
+    handleAnalyzeDiff2({ diff, path: projectPath }),
+    handleCreateSelfReview2({ path: projectPath, diff })
+  ]);
+  const diffContent = diffResult.content[0];
+  const reviewContent = reviewResult.content[0];
+  if (!diffContent || !reviewContent) throw new Error("Empty review response");
+  const diffParsed = JSON.parse(diffContent.text);
+  const reviewParsed = JSON.parse(reviewContent.text);
+  const findings = [
+    ...extractFindings(diffParsed, "findings", "warnings"),
+    ...extractFindings(reviewParsed, "findings", "items")
+  ];
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          depth: "standard",
+          downgraded,
+          findings,
+          diffAnalysis: diffParsed,
+          selfReview: reviewParsed,
+          fileCount: extractFileCount(diffParsed),
+          lineCount: diffLines
+        })
+      }
+    ]
+  };
+}
+async function runDeepReview(projectPath, diff, diffLines, _downgraded) {
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-C4GCFVGP.js");
+  const result = await handleRunCodeReview2({ path: projectPath, diff });
+  const deepContent = result.content[0];
+  if (!deepContent) throw new Error("Empty code review response");
+  const parsed = JSON.parse(deepContent.text);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          depth: "deep",
+          downgraded: false,
+          findings: parsed.findings ?? [],
+          assessment: parsed.assessment,
+          findingCount: parsed.findingCount,
+          lineCount: diffLines,
+          pipeline: parsed
+        })
+      }
+    ]
+  };
+}
+var DEPTH_HANDLERS = {
+  quick: runQuickReview,
+  standard: runStandardReview,
+  deep: runDeepReview
+};
 
 // src/mcp/tools/task-independence.ts
 var checkTaskIndependenceDefinition = {
@@ -3914,7 +4354,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-B26DFXMP.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -4002,7 +4442,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-B26DFXMP.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -4108,7 +4548,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-2M2HXDQI.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -4129,7 +4569,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-WF4C7A4A.js");
+    const { detectStaleConstraints } = await import("./dist-HWXF2C3R.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -4156,6 +4596,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,
@@ -4202,7 +4712,8 @@ var TOOL_DEFINITIONS = [
   askGraphDefinition,
   checkTaskIndependenceDefinition,
   predictConflictsDefinition,
-  detectStaleConstraintsDefinition
+  detectStaleConstraintsDefinition,
+  searchSkillsDefinition
 ];
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -4249,7 +4760,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 = [
   {
@@ -4314,6 +4826,45 @@ var RESOURCE_HANDLERS = {
 function getToolDefinitions() {
   return TOOL_DEFINITIONS;
 }
+function readConfigInterval(resolvedRoot) {
+  try {
+    const configResult = resolveProjectConfig(resolvedRoot);
+    if (configResult.ok) {
+      const raw = configResult.value.updateCheckInterval;
+      if (typeof raw === "number" && Number.isInteger(raw) && raw >= 0) {
+        return raw;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function appendUpdateNotification(result, resolvedRoot) {
+  try {
+    const {
+      getUpdateNotification,
+      isUpdateCheckEnabled,
+      shouldRunCheck,
+      readCheckState,
+      spawnBackgroundCheck
+    } = await import("./dist-HWXF2C3R.js");
+    const { CLI_VERSION } = await import("./version-KFFPOQAX.js");
+    const configInterval = readConfigInterval(resolvedRoot);
+    const DEFAULT_INTERVAL = 864e5;
+    if (!isUpdateCheckEnabled(configInterval)) return;
+    const state = readCheckState();
+    if (shouldRunCheck(state, configInterval ?? DEFAULT_INTERVAL)) {
+      spawnBackgroundCheck(CLI_VERSION);
+    }
+    const notification = getUpdateNotification(CLI_VERSION);
+    if (notification) {
+      result.content.push({ type: "text", text: `
+---
+${notification}` });
+    }
+  } catch {
+  }
+}
 function createHarnessServer(projectRoot) {
   const resolvedRoot = projectRoot ?? process.cwd();
   let sessionChecked = false;
@@ -4333,42 +4884,7 @@ function createHarnessServer(projectRoot) {
     const result = await handler(args ?? {});
     if (!sessionChecked) {
       sessionChecked = true;
-      try {
-        const {
-          getUpdateNotification,
-          isUpdateCheckEnabled,
-          shouldRunCheck,
-          readCheckState,
-          spawnBackgroundCheck
-        } = await import("./dist-WF4C7A4A.js");
-        const { CLI_VERSION: version } = await import("./version-KFFPOQAX.js");
-        let CLI_VERSION = version;
-        let configInterval;
-        try {
-          const configResult = resolveProjectConfig(resolvedRoot);
-          if (configResult.ok) {
-            const raw = configResult.value.updateCheckInterval;
-            if (typeof raw === "number" && Number.isInteger(raw) && raw >= 0) {
-              configInterval = raw;
-            }
-          }
-        } catch {
-        }
-        const DEFAULT_INTERVAL = 864e5;
-        if (isUpdateCheckEnabled(configInterval)) {
-          const state = readCheckState();
-          if (shouldRunCheck(state, configInterval ?? DEFAULT_INTERVAL)) {
-            spawnBackgroundCheck(CLI_VERSION);
-          }
-          const notification = getUpdateNotification(CLI_VERSION);
-          if (notification) {
-            result.content.push({ type: "text", text: `
----
-${notification}` });
-          }
-        }
-      } catch {
-      }
+      await appendUpdateNotification(result, resolvedRoot);
     }
     return result;
   });
@@ -4397,6 +4913,8 @@ async function startServer() {
 }
 
 export {
+  persistToolingConfig,
+  appendFrameworkAgents,
   generateSlashCommands,
   handleOrphanDeletion,
   createGenerateSlashCommandsCommand,