@harness-engineering/cli 1.13.1 → 1.15.0

package/dist/{chunk-NERR4TAO.js → chunk-NNHDDXYT.js}

@@ -1,7 +1,7 @@
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-DZS7CJKL.js";
+} from "./chunk-VEPAJXBW.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -11,7 +11,7 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-TKJZKICB.js";
+} from "./chunk-EDXIVMAP.js";
 import {
   analyzeDiffDefinition,
   createSelfReviewDefinition,
@@ -19,15 +19,15 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-IM32EEDM.js";
+} from "./chunk-YLXFKVJE.js";
 import {
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-65FRIL4D.js";
+} from "./chunk-3ZZKVN62.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition
-} from "./chunk-4ZMOCPYO.js";
+} from "./chunk-ND2ENWDM.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_GEMINI,
@@ -38,24 +38,24 @@ import {
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-NOPU4RZ4.js";
+} from "./chunk-OFXQSFOW.js";
 import {
   loadGraphStore
-} from "./chunk-IMFVFNJE.js";
+} from "./chunk-FTMXDOR6.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-QY4T6YAZ.js";
+} from "./chunk-N25INEIX.js";
 import {
   resolveProjectConfig
-} from "./chunk-K6XAPGML.js";
+} from "./chunk-H7Y5CKTM.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-ND6PNADU.js";
+} from "./chunk-2BKLWLY6.js";
 import {
   resolveConfig
-} from "./chunk-Z77YQRQT.js";
+} from "./chunk-B2HKP423.js";
 import {
   resultToMcpResponse
 } from "./chunk-IDZNPTYD.js";
@@ -82,7 +82,7 @@ import {
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -109,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) }
@@ -143,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) }] };
@@ -163,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",
@@ -175,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-OL4T6NZS.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-3RB7MXPP.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-DPYFB6R6.js");
+  const { listPersonas } = await import("./loader-UUTVMQCC.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -246,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-DPYFB6R6.js");
-  const { generateRuntime } = await import("./runtime-X7U6SC7K.js");
-  const { generateAgentsMd } = await import("./agents-md-XU3BHE22.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-EHV65NQB.js");
+  const { loadPersona } = await import("./loader-UUTVMQCC.js");
+  const { generateRuntime } = await import("./runtime-BCK5RRZQ.js");
+  const { generateAgentsMd } = await import("./agents-md-ZGNIDWAF.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-765LSHRD.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}`)));
   }
@@ -304,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-DPYFB6R6.js");
+  const { loadPersona } = await import("./loader-UUTVMQCC.js");
   const { runPersona } = await import("./runner-VMYLHWOC.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}`)));
   }
@@ -470,8 +697,8 @@ async function handleRunAgentTask(input) {
 }
 
 // src/mcp/tools/skill.ts
-import * as fs3 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 
 // src/skill/dispatcher.ts
 var TIER_1_SKILLS = /* @__PURE__ */ new Set([
@@ -546,26 +773,26 @@ function formatSuggestions(suggestions) {
 }
 
 // src/skill/index-builder.ts
-import fs from "fs";
-import path3 from "path";
+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 (!fs.existsSync(dir)) continue;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!fs3.existsSync(dir)) continue;
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const yamlPath = path3.join(dir, entry.name, "skill.yaml");
-      if (!fs.existsSync(yamlPath)) continue;
-      const stat = fs.statSync(yamlPath);
+      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 = fs.readFileSync(yamlPath, "utf-8");
+  const raw = fs3.readFileSync(yamlPath, "utf-8");
   const parsed = parse(raw);
   const result = SkillMetadataSchema.safeParse(parsed);
   if (!result.success) return null;
@@ -584,12 +811,12 @@ function parseSkillEntry(yamlPath, source, tierOverrides) {
   };
 }
 function scanDirectory(dir, source, index, tierOverrides) {
-  if (!fs.existsSync(dir)) return;
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+  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 = path3.join(dir, entry.name, "skill.yaml");
-    if (!fs.existsSync(yamlPath)) 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;
@@ -613,25 +840,25 @@ function buildIndex(platform, _projectRoot, tierOverrides) {
   return index;
 }
 function loadOrRebuildIndex(platform, projectRoot, tierOverrides) {
-  const indexPath = path3.join(projectRoot, ".harness", "skills-index.json");
+  const indexPath = path4.join(projectRoot, ".harness", "skills-index.json");
   const skillsDirs = resolveAllSkillsDirs(platform);
   const currentHash = computeSkillsDirHash(skillsDirs);
-  if (fs.existsSync(indexPath)) {
+  if (fs3.existsSync(indexPath)) {
     try {
-      const existing = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+      const existing = JSON.parse(fs3.readFileSync(indexPath, "utf-8"));
       if (existing.hash === currentHash) return existing;
     } catch {
     }
   }
   const index = buildIndex(platform, projectRoot, tierOverrides);
-  fs.mkdirSync(path3.dirname(indexPath), { recursive: true });
-  fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+  fs3.mkdirSync(path4.dirname(indexPath), { recursive: true });
+  fs3.writeFileSync(indexPath, JSON.stringify(index, null, 2));
   return index;
 }
 
 // src/skill/stack-profile.ts
-import fs2 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var SIGNAL_DOMAIN_MAP = {
   "prisma/schema.prisma": ["database"],
   "drizzle.config.ts": ["database"],
@@ -679,8 +906,8 @@ function generateStackProfile(projectRoot) {
   const signals = {};
   const domainSet = /* @__PURE__ */ new Set();
   for (const [pattern, domains] of Object.entries(SIGNAL_DOMAIN_MAP)) {
-    const fullPath = path4.join(projectRoot, pattern);
-    const exists = fs2.existsSync(fullPath);
+    const fullPath = path5.join(projectRoot, pattern);
+    const exists = fs4.existsSync(fullPath);
     signals[pattern] = exists;
     if (exists) {
       for (const domain of domains) domainSet.add(domain);
@@ -693,16 +920,16 @@ function generateStackProfile(projectRoot) {
   };
 }
 function loadOrGenerateProfile(projectRoot) {
-  const profilePath = path4.join(projectRoot, ".harness", "stack-profile.json");
-  if (fs2.existsSync(profilePath)) {
+  const profilePath = path5.join(projectRoot, ".harness", "stack-profile.json");
+  if (fs4.existsSync(profilePath)) {
     try {
-      return JSON.parse(fs2.readFileSync(profilePath, "utf-8"));
+      return JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
     } catch {
     }
   }
   const profile = generateStackProfile(projectRoot);
-  fs2.mkdirSync(path4.dirname(profilePath), { recursive: true });
-  fs2.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+  fs4.mkdirSync(path5.dirname(profilePath), { recursive: true });
+  fs4.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
   return profile;
 }
 
@@ -731,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 = path5.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 (!fs3.existsSync(skillDir)) {
+  if (!fs5.existsSync(skillDir)) {
     return resultToMcpResponse(Err(new Error(`Skill not found: ${input.skill}`)));
   }
-  const skillMdPath = path5.join(skillDir, "SKILL.md");
-  if (!fs3.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 = fs3.readFileSync(skillMdPath, "utf-8");
+  let content = fs5.readFileSync(skillMdPath, "utf-8");
   if (input.path) {
     const projectPath = sanitizePath(input.path);
-    const stateFile = path5.join(projectPath, ".harness", "state.json");
-    if (fs3.existsSync(stateFile)) {
-      const stateContent = fs3.readFileSync(stateFile, "utf-8");
+    const stateFile = path6.join(projectPath, ".harness", "state.json");
+    if (fs5.existsSync(stateFile)) {
+      const stateContent = fs5.readFileSync(stateFile, "utf-8");
       content += `
 
 ---
@@ -826,22 +1053,22 @@ async function handleCreateSkill(input) {
 }
 
 // src/mcp/resources/skills.ts
-import * as fs4 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import * as yaml from "yaml";
 async function getSkillsResource(projectRoot) {
-  const skillsDir = path6.join(projectRoot, "agents", "skills", "claude-code");
+  const skillsDir = path7.join(projectRoot, "agents", "skills", "claude-code");
   const skills = [];
-  if (!fs4.existsSync(skillsDir)) {
+  if (!fs6.existsSync(skillsDir)) {
     return JSON.stringify(skills, null, 2);
   }
-  const entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillYamlPath = path6.join(skillsDir, entry.name, "skill.yaml");
-    if (!fs4.existsSync(skillYamlPath)) continue;
+    const skillYamlPath = path7.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs6.existsSync(skillYamlPath)) continue;
     try {
-      const content = fs4.readFileSync(skillYamlPath, "utf-8");
+      const content = fs6.readFileSync(skillYamlPath, "utf-8");
       const parsed = yaml.parse(content);
       skills.push({
         name: parsed.name,
@@ -857,14 +1084,14 @@ async function getSkillsResource(projectRoot) {
 }
 
 // src/mcp/resources/rules.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 async function getRulesResource(projectRoot) {
   const rules = [];
-  const configPath = path7.join(projectRoot, "harness.config.json");
-  if (fs5.existsSync(configPath)) {
+  const configPath = path8.join(projectRoot, "harness.config.json");
+  if (fs7.existsSync(configPath)) {
     try {
-      const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
       if (config.layers) {
         rules.push({ type: "layer-enforcement", config: config.layers });
       }
@@ -877,10 +1104,10 @@ async function getRulesResource(projectRoot) {
     } catch {
     }
   }
-  const linterPath = path7.join(projectRoot, ".harness", "linter.json");
-  if (fs5.existsSync(linterPath)) {
+  const linterPath = path8.join(projectRoot, ".harness", "linter.json");
+  if (fs7.existsSync(linterPath)) {
     try {
-      const linterConfig = JSON.parse(fs5.readFileSync(linterPath, "utf-8"));
+      const linterConfig = JSON.parse(fs7.readFileSync(linterPath, "utf-8"));
       rules.push({ type: "linter", config: linterConfig });
     } catch {
     }
@@ -889,32 +1116,57 @@ async function getRulesResource(projectRoot) {
 }
 
 // src/mcp/resources/project.ts
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 async function getProjectResource(projectRoot) {
-  const agentsPath = path8.join(projectRoot, "AGENTS.md");
-  if (fs6.existsSync(agentsPath)) {
-    return fs6.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 fs7 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 async function getLearningsResource(projectRoot) {
   const sections = [];
-  const reviewPath = path9.join(projectRoot, ".harness", "review-learnings.md");
-  if (fs7.existsSync(reviewPath)) {
-    sections.push("## Review Learnings\n\n" + fs7.readFileSync(reviewPath, "utf-8"));
+  const 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 = path9.join(projectRoot, ".harness", "anti-patterns.md");
-  if (fs7.existsSync(antiPath)) {
-    sections.push("## Anti-Pattern Log\n\n" + fs7.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/tools/roadmap-auto-sync.ts
+import * as fs10 from "fs";
+import * as path11 from "path";
+async function autoSyncRoadmap(projectPath) {
+  try {
+    const roadmapFile = path11.join(projectPath, "docs", "roadmap.md");
+    if (!fs10.existsSync(roadmapFile)) return;
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-ALQDD67R.js");
+    const raw = fs10.readFileSync(roadmapFile, "utf-8");
+    const parseResult = parseRoadmap(raw);
+    if (!parseResult.ok) return;
+    const roadmap = parseResult.value;
+    const syncResult = syncRoadmap({ projectPath, roadmap });
+    if (!syncResult.ok || syncResult.value.length === 0) return;
+    applySyncChanges(roadmap, syncResult.value);
+    fs10.writeFileSync(roadmapFile, serializeRoadmap(roadmap), "utf-8");
+  } catch {
+  }
+}
+
+// src/mcp/utils.ts
+function mcpError(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
 // src/mcp/tools/state.ts
 var manageStateDefinition = {
   name: "manage_state",
@@ -933,7 +1185,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"
       },
@@ -950,138 +1207,178 @@ 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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.js");
+  const result = await saveHandoff(
+    projectPath,
+    input.handoff,
+    input.stream,
+    input.session
+  );
+  if (!result.ok) return resultToMcpResponse(result);
+  await autoSyncRoadmap(projectPath);
+  return resultToMcpResponse(Ok({ saved: true }));
+}
+async function handleLoadHandoff(projectPath, input) {
+  const { loadHandoff } = await import("./dist-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.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-ALQDD67R.js");
+  const result = await archiveSession(projectPath, input.session);
+  if (!result.ok) return resultToMcpResponse(result);
+  await autoSyncRoadmap(projectPath);
+  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-2B363XUH.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-2B363XUH.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-2B363XUH.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 = {
@@ -1097,7 +1394,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-2B363XUH.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-ALQDD67R.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -1135,7 +1432,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-2OFZ7OWW.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-ZOXVBDCN.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -1155,7 +1452,7 @@ async function handleCheckPhaseGate(input) {
 }
 
 // src/mcp/tools/cross-check.ts
-import * as path10 from "path";
+import * as path12 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",
@@ -1191,15 +1488,15 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-STFHYMAZ.js");
-    const specsDir = path10.resolve(projectPath, input.specsDir ?? "docs/specs");
+    const { runCrossCheck } = await import("./validate-cross-check-OABMREW4.js");
+    const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: specsDir escapes project root" }],
         isError: true
       };
     }
-    const plansDir = path10.resolve(projectPath, input.plansDir ?? "docs/plans");
+    const plansDir = path12.resolve(projectPath, input.plansDir ?? "docs/plans");
     if (!plansDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: plansDir escapes project root" }],
@@ -1230,14 +1527,14 @@ async function handleValidateCrossCheck(input) {
 
 // src/commands/generate-slash-commands.ts
 import { Command } from "commander";
-import fs9 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import os from "os";
 import readline from "readline";
 
 // src/slash-commands/normalize.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { parse as parse3 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
@@ -1254,113 +1551,125 @@ function normalizeName(skillName) {
 }
 
 // src/slash-commands/normalize.ts
+function readSkillYaml(yamlPath) {
+  let raw;
+  try {
+    raw = fs11.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 = path13.join(skillsDir, entry.name, "SKILL.md");
+  const skillMdContent = fs11.existsSync(skillMdPath) ? fs11.readFileSync(skillMdPath, "utf-8") : "";
+  const skillMdRelative = path13.relative(process.cwd(), skillMdPath).replaceAll("\\", "/");
+  const skillYamlRelative = path13.relative(process.cwd(), path13.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
+  const 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 (!fs8.existsSync(skillsDir)) continue;
-    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    if (!fs11.existsSync(skillsDir)) continue;
+    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const entry of entries) {
-      const yamlPath = path11.join(skillsDir, entry.name, "skill.yaml");
-      if (!fs8.existsSync(yamlPath)) continue;
-      let raw;
-      try {
-        raw = fs8.readFileSync(yamlPath, "utf-8");
-      } catch {
-        continue;
-      }
-      const parsed = parse3(raw);
-      const result = SkillMetadataSchema.safeParse(parsed);
+      const yamlPath = path13.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs11.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;
-      const tier = meta.tier;
-      const isInternal = meta.internal;
-      if (tier === 3 || isInternal) 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 = path11.join(skillsDir, entry.name, "SKILL.md");
-      const skillMdContent = fs8.existsSync(skillMdPath) ? fs8.readFileSync(skillMdPath, "utf-8") : "";
-      const skillMdRelative = path11.relative(process.cwd(), path11.join(skillsDir, entry.name, "SKILL.md")).replaceAll("\\", "/");
-      const skillYamlRelative = path11.relative(process.cwd(), path11.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
-      const args = (meta.cli?.args ?? []).map((a) => ({
-        name: a.name,
-        description: a.description ?? "",
-        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;
@@ -1460,13 +1769,13 @@ function renderGemini(spec, skillMdContent, skillYamlContent) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path12.join(opts.output, "harness");
+    return path14.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os.homedir();
-    return platform === "claude-code" ? path12.join(home, ".claude", "commands", "harness") : path12.join(home, ".gemini", "commands", "harness");
+    return platform === "claude-code" ? path14.join(home, ".claude", "commands", "harness") : path14.join(home, ".gemini", "commands", "harness");
   }
-  return platform === "claude-code" ? path12.join("agents", "commands", "claude-code", "harness") : path12.join("agents", "commands", "gemini-cli", "harness");
+  return platform === "claude-code" ? path14.join("agents", "commands", "claude-code", "harness") : path14.join("agents", "commands", "gemini-cli", "harness");
 }
 function fileExtension(platform) {
   return platform === "claude-code" ? ".md" : ".toml";
@@ -1481,26 +1790,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 (fs9.existsSync(communityDir)) {
-      skillSources.push({ dir: communityDir, source: "community" });
-    }
-    if (opts.includeGlobal || skillSources.length === 0) {
-      const globalDir = resolveGlobalSkillsDir();
-      if (!projectDir || path12.resolve(globalDir) !== path12.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 (fs12.existsSync(communityDir)) {
+    sources.push({ dir: communityDir, source: "community" });
+  }
+  if (opts.includeGlobal || sources.length === 0) {
+    const globalDir = resolveGlobalSkillsDir();
+    if (!projectDir || path14.resolve(globalDir) !== path14.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) {
@@ -1518,7 +1830,7 @@ function generateSlashCommands(opts) {
             executionContext: spec.prompt.executionContext.split("\n").map((line) => {
               if (line.startsWith("@")) {
                 const relPath = line.slice(1);
-                return `@${path12.resolve(relPath)}`;
+                return `@${path14.resolve(relPath)}`;
               }
               return line;
             }).join("\n")
@@ -1526,10 +1838,10 @@ function generateSlashCommands(opts) {
         } : spec;
         rendered.set(filename, renderClaudeCode(renderSpec));
       } else {
-        const mdPath = path12.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-        const yamlPath = path12.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
-        const mdContent = fs9.existsSync(mdPath) ? fs9.readFileSync(mdPath, "utf-8") : "";
-        const yamlContent = fs9.existsSync(yamlPath) ? fs9.readFileSync(yamlPath, "utf-8") : "";
+        const mdPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs12.existsSync(mdPath) ? fs12.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs12.existsSync(yamlPath) ? fs12.readFileSync(yamlPath, "utf-8") : "";
         rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
       }
     }
@@ -1555,9 +1867,9 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (shouldDelete) {
       for (const filename of result.removed) {
-        const filePath = path12.join(result.outputDir, filename);
-        if (fs9.existsSync(filePath)) {
-          fs9.unlinkSync(filePath);
+        const filePath = path14.join(result.outputDir, filename);
+        if (fs12.existsSync(filePath)) {
+          fs12.unlinkSync(filePath);
         }
       }
     }
@@ -1683,7 +1995,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-2B363XUH.js");
+    const { loadState, migrateToStreams } = await import("./dist-ALQDD67R.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -1771,7 +2083,7 @@ async function handleQueryGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-HXHWB7SV.js");
+    const { ContextQL } = await import("./dist-B26DFXMP.js");
     const cql = new ContextQL(store);
     const result = cql.execute({
       rootNodeIds: input.rootNodeIds,
@@ -1862,7 +2174,7 @@ async function handleSearchSimilar(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { FusionLayer } = await import("./dist-HXHWB7SV.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") {
@@ -1917,7 +2229,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-HXHWB7SV.js");
+    const { FusionLayer, ContextQL } = await import("./dist-B26DFXMP.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -2013,7 +2325,7 @@ async function handleGetRelationships(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-HXHWB7SV.js");
+    const { ContextQL } = await import("./dist-B26DFXMP.js");
     const cql = new ContextQL(store);
     const direction = input.direction ?? "both";
     const bidirectional = direction === "both" || direction === "inbound";
@@ -2119,7 +2431,7 @@ async function handleGetImpact(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { ContextQL } = await import("./dist-HXHWB7SV.js");
+    const { ContextQL } = await import("./dist-B26DFXMP.js");
     let targetNodeId = input.nodeId;
     if (!targetNodeId && input.filePath) {
       const fileNodes = store.findNodes({ type: "file" });
@@ -2230,7 +2542,7 @@ async function handleGetImpact(input) {
 }
 
 // src/mcp/tools/graph/ingest-source.ts
-import * as path13 from "path";
+import * as path15 from "path";
 var ingestSourceDefinition = {
   name: "ingest_source",
   description: "Ingest sources into the project knowledge graph. Supports code analysis, knowledge documents, git history, or all at once.",
@@ -2250,10 +2562,10 @@ var ingestSourceDefinition = {
 async function handleIngestSource(input) {
   try {
     const projectPath = sanitizePath(input.path);
-    const graphDir = path13.join(projectPath, ".harness", "graph");
-    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-HXHWB7SV.js");
-    const fs12 = await import("fs/promises");
-    await fs12.mkdir(graphDir, { recursive: true });
+    const graphDir = path15.join(projectPath, ".harness", "graph");
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-B26DFXMP.js");
+    const fs15 = await import("fs/promises");
+    await fs15.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -2326,7 +2638,7 @@ async function handleDetectAnomalies(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { GraphAnomalyAdapter } = await import("./dist-HXHWB7SV.js");
+    const { GraphAnomalyAdapter } = await import("./dist-B26DFXMP.js");
     const adapter = new GraphAnomalyAdapter(store);
     const report = adapter.detect({
       ...input.threshold !== void 0 && { threshold: input.threshold },
@@ -2366,7 +2678,7 @@ async function handleAskGraph(input) {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
     if (!store) return graphNotFoundError();
-    const { askGraph } = await import("./dist-HXHWB7SV.js");
+    const { askGraph } = await import("./dist-B26DFXMP.js");
     const result = await askGraph(store, input.question);
     return {
       content: [{ type: "text", text: JSON.stringify(result) }]
@@ -2385,8 +2697,8 @@ async function handleAskGraph(input) {
 }
 
 // src/mcp/resources/graph.ts
-import * as fs10 from "fs/promises";
-import * as path14 from "path";
+import * as fs13 from "fs/promises";
+import * as path16 from "path";
 var MAX_ITEMS = 5e3;
 function formatStaleness(isoTimestamp) {
   const then = new Date(isoTimestamp).getTime();
@@ -2409,11 +2721,11 @@ async function getGraphResource(projectRoot) {
       message: "No knowledge graph found. Run harness scan to build one."
     });
   }
-  const graphDir = path14.join(projectRoot, ".harness", "graph");
-  const metadataPath = path14.join(graphDir, "metadata.json");
+  const graphDir = path16.join(projectRoot, ".harness", "graph");
+  const metadataPath = path16.join(graphDir, "metadata.json");
   let lastScanTimestamp = null;
   try {
-    const raw = JSON.parse(await fs10.readFile(metadataPath, "utf-8"));
+    const raw = JSON.parse(await fs13.readFile(metadataPath, "utf-8"));
     lastScanTimestamp = raw.lastScanTimestamp ?? null;
   } catch {
   }
@@ -2502,7 +2814,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-64S3CLEZ.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-ZAE726AU.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -2513,8 +2825,8 @@ async function handleGenerateAgentDefinitions(input) {
 }
 
 // src/mcp/tools/roadmap.ts
-import * as fs11 from "fs";
-import * as path15 from "path";
+import * as fs14 from "fs";
+import * as path17 from "path";
 var manageRoadmapDefinition = {
   name: "manage_roadmap",
   description: "Manage the project roadmap: show, add, update, remove, sync features, or query by filter. Reads and writes docs/roadmap.md.",
@@ -2569,21 +2881,21 @@ var manageRoadmapDefinition = {
   }
 };
 function roadmapPath(projectRoot) {
-  return path15.join(projectRoot, "docs", "roadmap.md");
+  return path17.join(projectRoot, "docs", "roadmap.md");
 }
 function readRoadmapFile(projectRoot) {
   const filePath = roadmapPath(projectRoot);
   try {
-    return fs11.readFileSync(filePath, "utf-8");
+    return fs14.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writeRoadmapFile(projectRoot, content) {
   const filePath = roadmapPath(projectRoot);
-  const dir = path15.dirname(filePath);
-  fs11.mkdirSync(dir, { recursive: true });
-  fs11.writeFileSync(filePath, content, "utf-8");
+  const dir = path17.dirname(filePath);
+  fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(filePath, content, "utf-8");
 }
 function roadmapNotFoundError() {
   return {
@@ -2596,7 +2908,7 @@ function roadmapNotFoundError() {
     isError: true
   };
 }
-function handleShow(projectPath, input, deps) {
+function handleShow2(projectPath, input, deps) {
   const { parseRoadmap, Ok: Ok2 } = deps;
   const raw = readRoadmapFile(projectPath);
   if (raw === null) return roadmapNotFoundError();
@@ -2788,18 +3100,7 @@ function handleSync(projectPath, input, deps) {
     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();
+    deps.applySyncChanges(roadmap, changes);
     writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
     return resultToMcpResponse(Ok2({ changes, applied: true, roadmap }));
   }
@@ -2807,13 +3108,13 @@ function handleSync(projectPath, input, deps) {
 }
 async function handleManageRoadmap(input) {
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap } = await import("./dist-2B363XUH.js");
-    const { Ok: Ok2 } = await import("./dist-D4RYGUZE.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-ALQDD67R.js");
+    const { Ok: Ok2 } = await import("./dist-USY2C5JL.js");
     const projectPath = sanitizePath(input.path);
-    const deps = { parseRoadmap, serializeRoadmap, syncRoadmap, Ok: Ok2 };
+    const deps = { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, Ok: Ok2 };
     switch (input.action) {
       case "show":
-        return handleShow(projectPath, input, deps);
+        return handleShow2(projectPath, input, deps);
       case "add":
         return handleAdd(projectPath, input, deps);
       case "update":
@@ -3193,226 +3494,119 @@ var emitInteractionDefinition = {
     required: ["path", "type"]
   }
 };
-async function handleEmitInteraction(input) {
+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 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
-      };
-    }
+    const { saveHandoff } = await import("./dist-ALQDD67R.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 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-2B363XUH.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-2B363XUH.js");
+    const { loadState, saveState } = await import("./dist-ALQDD67R.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -3430,7 +3624,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: {
@@ -3451,10 +3645,14 @@ var gatherContextDefinition = {
         type: "array",
         items: {
           type: "string",
-          enum: ["state", "learnings", "handoff", "graph", "validation"]
+          enum: ["state", "learnings", "handoff", "graph", "validation", "sessions", "events"]
         },
         description: "Which constituents to include (default: all)"
       },
+      includeEvents: {
+        type: "boolean",
+        description: "Include recent events timeline. Default: true when session is provided, false otherwise. Can also be controlled via include array."
+      },
       mode: {
         type: "string",
         enum: ["summary", "detailed"],
@@ -3467,6 +3665,11 @@ var gatherContextDefinition = {
       session: {
         type: "string",
         description: "Session slug for session-scoped state. When provided, state/learnings/handoff/failures are read from .harness/sessions/<session>/ instead of .harness/. Omit for global fallback."
+      },
+      depth: {
+        type: "string",
+        enum: ["index", "summary", "full"],
+        description: 'Retrieval depth for learnings. "index" returns one-line summaries, "summary" (default) returns full entries, "full" returns entries with linked context.'
       }
     },
     required: ["path", "intent"]
@@ -3492,25 +3695,26 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-2B363XUH.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-ALQDD67R.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-2B363XUH.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-ALQDD67R.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
       ...input.skill !== void 0 && { skill: input.skill },
-      ...input.session !== void 0 && { session: input.session }
+      ...input.session !== void 0 && { session: input.session },
+      ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-2B363XUH.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-ALQDD67R.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-GJZ4FN4Y.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-HXHWB7SV.js");
+    const { FusionLayer, ContextQL } = await import("./dist-B26DFXMP.js");
     const fusion = new FusionLayer(store);
     const cql = new ContextQL(store);
     const tokenBudget = input.tokenBudget ?? 4e3;
@@ -3547,18 +3751,39 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-ALQDD67R.js").then(
+    (core) => core.readSessionSections(projectPath, input.session)
+  ) : Promise.resolve(null);
+  const shouldIncludeEvents = input.includeEvents !== void 0 ? input.includeEvents : includeSet.has("events") || !!input.session && !input.include;
+  const eventsPromise = shouldIncludeEvents ? import("./dist-ALQDD67R.js").then(async (core) => {
+    const result = await core.loadEvents(projectPath, {
+      session: input.session
+    });
+    if (!result.ok) return null;
+    return core.formatEventTimeline(result.value);
+  }) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-GCHZJIL7.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-KBYQAEWE.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,
+    eventsResult
+  ] = await Promise.allSettled([
     statePromise,
     learningsPromise,
     handoffPromise,
     graphPromise,
-    validationPromise
+    validationPromise,
+    sessionsPromise,
+    eventsPromise
   ]);
   function extract(settled, name) {
     if (settled.status === "rejected") {
@@ -3572,6 +3797,8 @@ 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 eventsTimeline = extract(eventsResult, "events");
   const state = stateRaw && typeof stateRaw === "object" && "ok" in stateRaw ? stateRaw.ok ? stateRaw.value : (() => {
     errors.push(`state: ${stateRaw.error.message}`);
     return null;
@@ -3588,6 +3815,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;
@@ -3612,6 +3845,8 @@ async function handleGatherContext(input) {
     handoff: outputHandoff,
     graphContext: outputGraphContext,
     validation: outputValidation,
+    sessionSections: sessionSections ?? null,
+    events: eventsTimeline || null,
     meta: {
       assembledIn,
       graphAvailable: graphContext !== null,
@@ -3622,7 +3857,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-2B363XUH.js");
+      const core = await import("./dist-ALQDD67R.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -3692,7 +3927,7 @@ async function handleAssessProject(input) {
   let validateResult = null;
   if (checksToRun.has("validate")) {
     try {
-      const { handleValidateProject: handleValidateProject2 } = await import("./validate-GCHZJIL7.js");
+      const { handleValidateProject: handleValidateProject2 } = await import("./validate-KBYQAEWE.js");
       const result = await handleValidateProject2({ path: projectPath });
       const first = result.content[0];
       const parsed = first ? JSON.parse(first.text) : {};
@@ -3717,7 +3952,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-2R5Z4ZAF.js");
+          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-ZLIH5533.js");
           const result = await handleCheckDependencies2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3744,7 +3979,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-FZOPM4GK.js");
+          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-NRMQCOJ6.js");
           const result = await handleCheckDocs2({ path: projectPath, scope: "coverage" });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3771,14 +4006,14 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-LVHJMFGH.js");
+          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-6AGX2ZUN.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 } : {}
@@ -3798,7 +4033,7 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-FWQZF2IZ.js");
+          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-2RPQEN62.js");
           const result = await handleRunSecurityScan2({ path: projectPath });
           const first = result.content[0];
           const parsed = first ? JSON.parse(first.text) : {};
@@ -3830,14 +4065,14 @@ async function handleAssessProject(input) {
     parallelChecks.push(
       (async () => {
         try {
-          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-ZTVSUANN.js");
+          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-2D7G6NMJ.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 } : {}
@@ -4004,81 +4239,8 @@ async function handleReviewChanges(input) {
     downgraded = true;
   }
   try {
-    if (effectiveDepth === "quick") {
-      const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-IHLVLMRD.js");
-      const result2 = await handleAnalyzeDiff2({ diff, path: projectPath });
-      const firstContent = result2.content[0];
-      if (!firstContent) throw new Error("Empty analyze_diff response");
-      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-IHLVLMRD.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-76JHKGSV.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: [
@@ -4091,6 +4253,97 @@ async function handleReviewChanges(input) {
     };
   }
 }
+async function runQuickReview(projectPath, diff, diffLines, downgraded) {
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-MY4QZIFD.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-MY4QZIFD.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-RAQ55ISU.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 = {
@@ -4135,7 +4388,7 @@ async function handleCheckTaskIndependence(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { TaskIndependenceAnalyzer } = await import("./dist-HXHWB7SV.js");
+    const { TaskIndependenceAnalyzer } = await import("./dist-B26DFXMP.js");
     const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
     const result = analyzer.analyze({
       tasks: input.tasks,
@@ -4223,7 +4476,7 @@ async function handlePredictConflicts(input) {
   try {
     const projectPath = sanitizePath(input.path);
     const store = await loadGraphStore(projectPath);
-    const { ConflictPredictor } = await import("./dist-HXHWB7SV.js");
+    const { ConflictPredictor } = await import("./dist-B26DFXMP.js");
     const predictor = new ConflictPredictor(store ?? void 0);
     const result = predictor.predict({
       tasks: input.tasks,
@@ -4329,7 +4582,7 @@ async function handleDetectStaleConstraints(input) {
         isError: true
       };
     }
-    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-GJZ4FN4Y.js");
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-2M2HXDQI.js");
     const store = await loadGraphStore2(projectPath);
     if (!store) {
       return {
@@ -4350,7 +4603,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-2B363XUH.js");
+    const { detectStaleConstraints } = await import("./dist-ALQDD67R.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -4447,6 +4700,226 @@ async function handleSearchSkills(input) {
   };
 }
 
+// src/mcp/tools/code-nav.ts
+var codeOutlineDefinition = {
+  name: "code_outline",
+  description: "Get a structural skeleton of a file or files matching a glob: exports, classes, functions, types with signatures and line numbers. No implementation bodies. 4-8x token savings vs full file read.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute file path or directory path. When a directory, outlines all supported files within it."
+      },
+      glob: {
+        type: "string",
+        description: 'Optional glob pattern to filter files (e.g. "*.ts", "src/**/*.py"). Only used when path is a directory.'
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleCodeOutline(input) {
+  let targetPath;
+  try {
+    targetPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-ALQDD67R.js");
+    const { stat } = await import("fs/promises");
+    const stats = await stat(targetPath).catch(() => null);
+    if (stats?.isFile()) {
+      const outline = await getOutline(targetPath);
+      return { content: [{ type: "text", text: formatOutline(outline) }] };
+    }
+    if (stats?.isDirectory()) {
+      const { glob } = await import("glob");
+      const exts = Object.keys(EXTENSION_MAP).map((e) => e.slice(1));
+      const pattern = input.glob ?? `**/*.{${exts.join(",")}}`;
+      const files = await glob(pattern, { cwd: targetPath, absolute: true });
+      const results = [];
+      const MAX_FILES = 50;
+      for (const file of files.slice(0, MAX_FILES)) {
+        const outline = await getOutline(file);
+        results.push(formatOutline(outline));
+      }
+      if (files.length > MAX_FILES) {
+        results.push(
+          `
+... and ${files.length - MAX_FILES} more files (use a narrower glob to see them)`
+        );
+      }
+      return { content: [{ type: "text", text: results.join("\n\n") }] };
+    }
+    return {
+      content: [{ type: "text", text: `Error: Path not found: ${targetPath}` }],
+      isError: true
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var codeSearchDefinition = {
+  name: "code_search",
+  description: "Search for symbols (functions, classes, types, variables) by name or pattern across a directory. Returns matching locations with file, line, kind, and one-line context. 6-12x token savings vs grep + read.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Symbol name or substring to search for (case-insensitive)."
+      },
+      directory: {
+        type: "string",
+        description: "Absolute path to directory to search in."
+      },
+      glob: {
+        type: "string",
+        description: 'Optional glob pattern to filter files (e.g. "*.ts").'
+      }
+    },
+    required: ["query", "directory"]
+  }
+};
+async function handleCodeSearch(input) {
+  let directory;
+  try {
+    directory = sanitizePath(input.directory);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const { searchSymbols } = await import("./dist-ALQDD67R.js");
+    const result = await searchSymbols(input.query, directory, input.glob);
+    const lines = [`Search: "${result.query}" \u2014 ${result.matches.length} matches`];
+    for (const match of result.matches) {
+      const { symbol } = match;
+      lines.push(
+        `  ${symbol.file}:${symbol.line} [${symbol.kind}] ${symbol.name} \u2014 ${match.context}`
+      );
+    }
+    if (result.skipped.length > 0) {
+      lines.push(`
+Skipped ${result.skipped.length} files (unsupported or parse failed)`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var codeUnfoldDefinition = {
+  name: "code_unfold",
+  description: "Extract the complete implementation of a specific symbol (function, class, type) or a line range from a file. Uses AST boundaries for precise extraction. 2-4x token savings vs full file read.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute path to the file."
+      },
+      symbol: {
+        type: "string",
+        description: "Name of the symbol to extract (function, class, type, etc.). Mutually exclusive with startLine/endLine."
+      },
+      startLine: {
+        type: "number",
+        description: "Start line number (1-indexed). Used with endLine for range extraction. Mutually exclusive with symbol."
+      },
+      endLine: {
+        type: "number",
+        description: "End line number (1-indexed, inclusive). Used with startLine for range extraction."
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleCodeUnfold(input) {
+  let filePath;
+  try {
+    filePath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    if (input.symbol) {
+      const { unfoldSymbol } = await import("./dist-ALQDD67R.js");
+      const result = await unfoldSymbol(filePath, input.symbol);
+      const header = result.warning ? `${result.file}:${result.startLine}-${result.endLine} ${result.warning}
+` : `${result.file}:${result.startLine}-${result.endLine}
+`;
+      return { content: [{ type: "text", text: header + result.content }] };
+    }
+    if (input.startLine != null && input.endLine != null) {
+      const { unfoldRange } = await import("./dist-ALQDD67R.js");
+      const result = await unfoldRange(filePath, input.startLine, input.endLine);
+      const header = `${result.file}:${result.startLine}-${result.endLine}
+`;
+      return { content: [{ type: "text", text: header + result.content }] };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: 'Error: Provide either "symbol" or "startLine" + "endLine".'
+        }
+      ],
+      isError: true
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
 // src/mcp/server.ts
 var TOOL_DEFINITIONS = [
   validateToolDefinition,
@@ -4494,7 +4967,10 @@ var TOOL_DEFINITIONS = [
   checkTaskIndependenceDefinition,
   predictConflictsDefinition,
   detectStaleConstraintsDefinition,
-  searchSkillsDefinition
+  searchSkillsDefinition,
+  codeOutlineDefinition,
+  codeSearchDefinition,
+  codeUnfoldDefinition
 ];
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -4542,7 +5018,10 @@ var TOOL_HANDLERS = {
   check_task_independence: handleCheckTaskIndependence,
   predict_conflicts: handlePredictConflicts,
   detect_stale_constraints: handleDetectStaleConstraints,
-  search_skills: handleSearchSkills
+  search_skills: handleSearchSkills,
+  code_outline: handleCodeOutline,
+  code_search: handleCodeSearch,
+  code_unfold: handleCodeUnfold
 };
 var RESOURCE_DEFINITIONS = [
   {
@@ -4607,6 +5086,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-ALQDD67R.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;
@@ -4626,42 +5144,7 @@ function createHarnessServer(projectRoot) {
     const result = await handler(args ?? {});
     if (!sessionChecked) {
       sessionChecked = true;
-      try {
-        const {
-          getUpdateNotification,
-          isUpdateCheckEnabled,
-          shouldRunCheck,
-          readCheckState,
-          spawnBackgroundCheck
-        } = await import("./dist-2B363XUH.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;
   });
@@ -4690,6 +5173,8 @@ async function startServer() {
 }
 
 export {
+  persistToolingConfig,
+  appendFrameworkAgents,
   generateSlashCommands,
   handleOrphanDeletion,
   createGenerateSlashCommandsCommand,