@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/chunk-I6JZYEGT.js

@@ -0,0 +1,4361 @@
+import {
+  detectEntropyDefinition,
+  handleDetectEntropy
+} from "./chunk-Z75JC6I2.js";
+import {
+  checkPerformanceDefinition,
+  getCriticalPathsDefinition,
+  getPerfBaselinesDefinition,
+  handleCheckPerformance,
+  handleGetCriticalPaths,
+  handleGetPerfBaselines,
+  handleUpdatePerfBaselines,
+  updatePerfBaselinesDefinition
+} from "./chunk-GSIVNYVJ.js";
+import {
+  analyzeDiffDefinition,
+  createSelfReviewDefinition,
+  handleAnalyzeDiff,
+  handleCreateSelfReview,
+  handleRequestPeerReview,
+  requestPeerReviewDefinition
+} from "./chunk-PA2XHK75.js";
+import {
+  handleRunSecurityScan,
+  runSecurityScanDefinition
+} from "./chunk-X3MN5UQJ.js";
+import {
+  handleRunCodeReview,
+  runCodeReviewDefinition
+} from "./chunk-WUJTCNOU.js";
+import {
+  GENERATED_HEADER_CLAUDE,
+  GENERATED_HEADER_GEMINI,
+  VALID_PLATFORMS,
+  applySyncPlan,
+  computeSyncPlan
+} from "./chunk-ZOAWBDWU.js";
+import {
+  handleValidateProject,
+  validateToolDefinition
+} from "./chunk-WJZDO6OY.js";
+import {
+  loadGraphStore
+} from "./chunk-2YPZKGAG.js";
+import {
+  checkDependenciesDefinition,
+  handleCheckDependencies
+} from "./chunk-TI4TGEX6.js";
+import {
+  resolveProjectConfig
+} from "./chunk-K6XAPGML.js";
+import {
+  checkDocsDefinition,
+  handleCheckDocs
+} from "./chunk-NC6PXVWT.js";
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+import {
+  resolveCommunitySkillsDir,
+  resolveGlobalSkillsDir,
+  resolvePersonasDir,
+  resolveProjectSkillsDir,
+  resolveSkillsDir,
+  resolveTemplatesDir
+} from "./chunk-HD4IBGLA.js";
+import {
+  CLIError,
+  ExitCode,
+  handleError
+} from "./chunk-3WGJMBKH.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-VRFZWGMS.js";
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/tools/linter.ts
+var generateLinterDefinition = {
+  name: "generate_linter",
+  description: "Generate an ESLint rule from YAML configuration",
+  inputSchema: {
+    type: "object",
+    properties: {
+      configPath: { type: "string", description: "Path to harness-linter.yml" },
+      outputDir: { type: "string", description: "Output directory for generated rule" }
+    },
+    required: ["configPath"]
+  }
+};
+async function handleGenerateLinter(input) {
+  try {
+    const { generate } = await import("./dist-L7LAAQAS.js");
+    const result = await generate({
+      configPath: sanitizePath(input.configPath),
+      ...input.outputDir !== void 0 && { outputDir: sanitizePath(input.outputDir) }
+    });
+    if ("success" in result && result.success) {
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result) }], isError: true };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var validateLinterConfigDefinition = {
+  name: "validate_linter_config",
+  description: "Validate a harness-linter.yml configuration file",
+  inputSchema: {
+    type: "object",
+    properties: {
+      configPath: { type: "string", description: "Path to harness-linter.yml" }
+    },
+    required: ["configPath"]
+  }
+};
+async function handleValidateLinterConfig(input) {
+  try {
+    const { validate } = await import("./dist-L7LAAQAS.js");
+    const result = await validate({ configPath: sanitizePath(input.configPath) });
+    if ("success" in result && result.success) {
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result) }], isError: true };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/init.ts
+import * as path from "path";
+var initProjectDefinition = {
+  name: "init_project",
+  description: "Scaffold a new harness engineering project from a template",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Target directory" },
+      name: { type: "string", description: "Project name" },
+      level: {
+        type: "string",
+        enum: ["basic", "intermediate", "advanced"],
+        description: "Adoption level"
+      },
+      framework: { type: "string", description: "Framework overlay (e.g., nextjs)" }
+    },
+    required: ["path"]
+  }
+};
+async function handleInitProject(input) {
+  try {
+    const { TemplateEngine } = await import("./engine-6XUP6GAK.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);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Init failed: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/persona.ts
+import * as path2 from "path";
+var listPersonasDefinition = {
+  name: "list_personas",
+  description: "List available agent personas",
+  inputSchema: { type: "object", properties: {} }
+};
+async function handleListPersonas() {
+  const { listPersonas } = await import("./loader-4FIPIFII.js");
+  const result = listPersonas(resolvePersonasDir());
+  return resultToMcpResponse(result);
+}
+var generatePersonaArtifactsDefinition = {
+  name: "generate_persona_artifacts",
+  description: "Generate runtime config, AGENTS.md fragment, and CI workflow from a persona",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Persona name (e.g., architecture-enforcer)" },
+      only: {
+        type: "string",
+        enum: ["runtime", "agents-md", "ci"],
+        description: "Generate only a specific artifact type"
+      }
+    },
+    required: ["name"]
+  }
+};
+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-4FIPIFII.js");
+  const { generateRuntime } = await import("./runtime-GO7K2PJE.js");
+  const { generateAgentsMd } = await import("./agents-md-ZFV6RR5J.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-K5RCRNYR.js");
+  const personasDir = resolvePersonasDir();
+  const filePath = path2.join(personasDir, `${input.name}.yaml`);
+  if (!filePath.startsWith(personasDir)) {
+    return resultToMcpResponse(Err(new Error(`Invalid persona path: ${input.name}`)));
+  }
+  const personaResult = loadPersona(filePath);
+  if (!personaResult.ok) return resultToMcpResponse(personaResult);
+  const persona = personaResult.value;
+  const artifacts = {};
+  if (!input.only || input.only === "runtime") {
+    const r = generateRuntime(persona);
+    if (r.ok) artifacts.runtime = r.value;
+  }
+  if (!input.only || input.only === "agents-md") {
+    const r = generateAgentsMd(persona);
+    if (r.ok) artifacts.agentsMd = r.value;
+  }
+  if (!input.only || input.only === "ci") {
+    const r = generateCIWorkflow(persona, "github");
+    if (r.ok) artifacts.ciWorkflow = r.value;
+  }
+  return resultToMcpResponse(Ok(artifacts));
+}
+var runPersonaDefinition = {
+  name: "run_persona",
+  description: "Execute all steps defined in a persona and return aggregated results",
+  inputSchema: {
+    type: "object",
+    properties: {
+      persona: { type: "string", description: "Persona name (e.g., architecture-enforcer)" },
+      path: { type: "string", description: "Path to project root" },
+      trigger: {
+        type: "string",
+        enum: [
+          "always",
+          "on_pr",
+          "on_commit",
+          "on_review",
+          "scheduled",
+          "manual",
+          "on_plan_approved",
+          "auto"
+        ],
+        description: "Trigger context for step filtering (default: auto)"
+      },
+      dryRun: { type: "boolean", description: "Preview without side effects" }
+    },
+    required: ["persona"]
+  }
+};
+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-4FIPIFII.js");
+  const { runPersona } = await import("./runner-VMYLHWOC.js");
+  const { executeSkill } = await import("./skill-executor-RG45LUO5.js");
+  const personasDir = resolvePersonasDir();
+  const filePath = path2.join(personasDir, `${input.persona}.yaml`);
+  if (!filePath.startsWith(personasDir)) {
+    return resultToMcpResponse(Err(new Error(`Invalid persona path: ${input.persona}`)));
+  }
+  const personaResult = loadPersona(filePath);
+  if (!personaResult.ok) return resultToMcpResponse(personaResult);
+  const projectPath = input.path ? sanitizePath(input.path) : process.cwd();
+  const trigger = input.trigger ?? "auto";
+  const { ALLOWED_PERSONA_COMMANDS } = await import("./constants-5JGUXPEK.js");
+  const commandExecutor = async (command) => {
+    if (!ALLOWED_PERSONA_COMMANDS.has(command)) {
+      return Err(new Error(`Unknown harness command: ${command}`));
+    }
+    try {
+      const { execFileSync } = await import("child_process");
+      const args = ["harness", command];
+      if (input.dryRun) args.push("--dry-run");
+      const output = execFileSync("npx", args, {
+        cwd: projectPath,
+        stdio: "pipe",
+        timeout: personaResult.value.config.timeout
+      });
+      return Ok(output.toString());
+    } catch (error) {
+      return Err(
+        new Error(`${command} failed: ${error instanceof Error ? error.message : String(error)}`)
+      );
+    }
+  };
+  const report = await runPersona(personaResult.value, {
+    trigger,
+    commandExecutor,
+    skillExecutor: executeSkill,
+    projectPath
+  });
+  return resultToMcpResponse(Ok(report));
+}
+
+// src/mcp/tools/agent.ts
+var addComponentDefinition = {
+  name: "add_component",
+  description: "Add a component (layer, doc, or component type) to the project using the harness CLI",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" },
+      type: {
+        type: "string",
+        enum: ["layer", "doc", "component"],
+        description: "Type of component to add"
+      },
+      name: { type: "string", description: "Name of the component to add" }
+    },
+    required: ["path", "type", "name"]
+  }
+};
+var COMPONENT_NAME_REGEX = /^[a-z0-9][a-z0-9._-]{0,64}$/i;
+async function handleAddComponent(input) {
+  const projectPath = sanitizePath(input.path);
+  const ALLOWED_TYPES = /* @__PURE__ */ new Set(["layer", "doc", "component"]);
+  if (!ALLOWED_TYPES.has(input.type)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: `Invalid component type: ${input.type}` })
+        }
+      ],
+      isError: true
+    };
+  }
+  if (!COMPONENT_NAME_REGEX.test(input.name)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Invalid component name: must match ${COMPONENT_NAME_REGEX} (lowercase alphanumeric, dots, hyphens, underscores, max 65 chars)`
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const { execFileSync } = await import("child_process");
+    const output = execFileSync("npx", ["harness", "add", input.type, input.name], {
+      cwd: projectPath,
+      stdio: "pipe"
+    });
+    return {
+      content: [{ type: "text", text: output.toString() }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `add_component failed: ${error instanceof Error ? error.message : String(error)}`
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var runAgentTaskDefinition = {
+  name: "run_agent_task",
+  description: "Run an agent task using the harness CLI",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task: { type: "string", description: "Task to run" },
+      path: { type: "string", description: "Path to project root directory" },
+      timeout: { type: "number", description: "Timeout in milliseconds" }
+    },
+    required: ["task"]
+  }
+};
+var ALLOWED_AGENT_TASKS = /* @__PURE__ */ new Set(["review", "doc-review", "test-review"]);
+async function handleRunAgentTask(input) {
+  if (!ALLOWED_AGENT_TASKS.has(input.task)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Invalid task: "${input.task}". Allowed tasks: ${[...ALLOWED_AGENT_TASKS].join(", ")}`
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+  const projectPath = input.path ? sanitizePath(input.path) : process.cwd();
+  try {
+    const { execFileSync } = await import("child_process");
+    const output = execFileSync("npx", ["harness", "agent", "run", input.task], {
+      cwd: projectPath,
+      stdio: "pipe",
+      timeout: input.timeout
+    });
+    return {
+      content: [{ type: "text", text: output.toString() }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `run_agent_task failed: ${error instanceof Error ? error.message : String(error)}`
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/skill.ts
+import * as fs from "fs";
+import * as path3 from "path";
+var runSkillDefinition = {
+  name: "run_skill",
+  description: "Load and return the content of a skill (SKILL.md), optionally with project state context",
+  inputSchema: {
+    type: "object",
+    properties: {
+      skill: { type: "string", description: "Skill name (e.g., harness-tdd)" },
+      path: { type: "string", description: "Path to project root for state context injection" },
+      complexity: {
+        type: "string",
+        enum: ["auto", "light", "full"],
+        description: "Complexity level for scale-adaptive rigor"
+      },
+      phase: { type: "string", description: "Start at a specific phase (re-entry)" },
+      party: { type: "boolean", description: "Enable multi-perspective evaluation" }
+    },
+    required: ["skill"]
+  }
+};
+async function handleRunSkill(input) {
+  const skillsDir = resolveSkillsDir();
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.skill)) {
+    return resultToMcpResponse(Err(new Error(`Invalid skill name: ${input.skill}`)));
+  }
+  const skillDir = path3.join(skillsDir, input.skill);
+  if (!skillDir.startsWith(skillsDir)) {
+    return resultToMcpResponse(Err(new Error(`Invalid skill path: ${input.skill}`)));
+  }
+  if (!fs.existsSync(skillDir)) {
+    return resultToMcpResponse(Err(new Error(`Skill not found: ${input.skill}`)));
+  }
+  const skillMdPath = path3.join(skillDir, "SKILL.md");
+  if (!fs.existsSync(skillMdPath)) {
+    return resultToMcpResponse(Err(new Error(`SKILL.md not found for skill: ${input.skill}`)));
+  }
+  let content = fs.readFileSync(skillMdPath, "utf-8");
+  if (input.path) {
+    const projectPath = sanitizePath(input.path);
+    const stateFile = path3.join(projectPath, ".harness", "state.json");
+    if (fs.existsSync(stateFile)) {
+      const stateContent = fs.readFileSync(stateFile, "utf-8");
+      content += `
+
+---
+## Project State
+\`\`\`json
+${stateContent}
+\`\`\`
+`;
+    }
+  }
+  return resultToMcpResponse(Ok(content));
+}
+var createSkillDefinition = {
+  name: "create_skill",
+  description: "Scaffold a new harness skill with skill.yaml and SKILL.md",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" },
+      name: { type: "string", description: "Skill name in kebab-case (e.g., my-new-skill)" },
+      description: { type: "string", description: "Skill description" },
+      cognitiveMode: {
+        type: "string",
+        enum: [
+          "adversarial-reviewer",
+          "constructive-architect",
+          "meticulous-implementer",
+          "diagnostic-investigator",
+          "advisory-guide",
+          "meticulous-verifier"
+        ],
+        description: "Cognitive mode (default: constructive-architect)"
+      }
+    },
+    required: ["path", "name", "description"]
+  }
+};
+async function handleCreateSkill(input) {
+  try {
+    const { generateSkillFiles } = await import("./create-skill-WPXHSLX2.js");
+    const result = generateSkillFiles({
+      name: input.name,
+      description: input.description,
+      cognitiveMode: input.cognitiveMode ?? "constructive-architect",
+      outputDir: sanitizePath(input.path)
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/resources/skills.ts
+import * as fs2 from "fs";
+import * as path4 from "path";
+import * as yaml from "yaml";
+async function getSkillsResource(projectRoot) {
+  const skillsDir = path4.join(projectRoot, "agents", "skills", "claude-code");
+  const skills = [];
+  if (!fs2.existsSync(skillsDir)) {
+    return JSON.stringify(skills, null, 2);
+  }
+  const entries = fs2.readdirSync(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillYamlPath = path4.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs2.existsSync(skillYamlPath)) continue;
+    try {
+      const content = fs2.readFileSync(skillYamlPath, "utf-8");
+      const parsed = yaml.parse(content);
+      skills.push({
+        name: parsed.name,
+        description: parsed.description,
+        cognitive_mode: parsed.cognitive_mode,
+        type: parsed.type,
+        triggers: parsed.triggers
+      });
+    } catch {
+    }
+  }
+  return JSON.stringify(skills, null, 2);
+}
+
+// src/mcp/resources/rules.ts
+import * as fs3 from "fs";
+import * as path5 from "path";
+async function getRulesResource(projectRoot) {
+  const rules = [];
+  const configPath = path5.join(projectRoot, "harness.config.json");
+  if (fs3.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      if (config.layers) {
+        rules.push({ type: "layer-enforcement", config: config.layers });
+      }
+      if (config.phaseGates) {
+        rules.push({ type: "phase-gates", config: config.phaseGates });
+      }
+      if (config.rules) {
+        rules.push({ type: "custom-rules", config: config.rules });
+      }
+    } catch {
+    }
+  }
+  const linterPath = path5.join(projectRoot, ".harness", "linter.json");
+  if (fs3.existsSync(linterPath)) {
+    try {
+      const linterConfig = JSON.parse(fs3.readFileSync(linterPath, "utf-8"));
+      rules.push({ type: "linter", config: linterConfig });
+    } catch {
+    }
+  }
+  return JSON.stringify(rules, null, 2);
+}
+
+// src/mcp/resources/project.ts
+import * as fs4 from "fs";
+import * as path6 from "path";
+async function getProjectResource(projectRoot) {
+  const agentsPath = path6.join(projectRoot, "AGENTS.md");
+  if (fs4.existsSync(agentsPath)) {
+    return fs4.readFileSync(agentsPath, "utf-8");
+  }
+  return "# No AGENTS.md found";
+}
+
+// src/mcp/resources/learnings.ts
+import * as fs5 from "fs";
+import * as path7 from "path";
+async function getLearningsResource(projectRoot) {
+  const sections = [];
+  const reviewPath = path7.join(projectRoot, ".harness", "review-learnings.md");
+  if (fs5.existsSync(reviewPath)) {
+    sections.push("## Review Learnings\n\n" + fs5.readFileSync(reviewPath, "utf-8"));
+  }
+  const antiPath = path7.join(projectRoot, ".harness", "anti-patterns.md");
+  if (fs5.existsSync(antiPath)) {
+    sections.push("## Anti-Pattern Log\n\n" + fs5.readFileSync(antiPath, "utf-8"));
+  }
+  return sections.length > 0 ? sections.join("\n\n---\n\n") : "No learnings files found.";
+}
+
+// src/mcp/tools/state.ts
+var manageStateDefinition = {
+  name: "manage_state",
+  description: "Manage harness project state: show current state, record learnings/failures, archive failures, reset state, run mechanical gate checks, or save/load session handoff",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      action: {
+        type: "string",
+        enum: [
+          "show",
+          "learn",
+          "failure",
+          "archive",
+          "reset",
+          "gate",
+          "save-handoff",
+          "load-handoff"
+        ],
+        description: "Action to perform"
+      },
+      learning: { type: "string", description: "Learning text to record (required for learn)" },
+      skillName: { type: "string", description: "Skill name associated with the entry" },
+      outcome: { type: "string", description: "Outcome associated with the learning" },
+      description: { type: "string", description: "Failure description (required for failure)" },
+      failureType: { type: "string", description: "Type of failure (required for failure)" },
+      handoff: { type: "object", description: "Handoff data to save (required for save-handoff)" },
+      stream: {
+        type: "string",
+        description: "Stream name to target (auto-resolves from branch if omitted)"
+      }
+    },
+    required: ["path", "action"]
+  }
+};
+async function handleManageState(input) {
+  try {
+    const {
+      loadState,
+      saveState,
+      appendLearning,
+      appendFailure,
+      archiveFailures,
+      runMechanicalGate,
+      DEFAULT_STATE
+    } = await import("./dist-JVZ2MKBC.js");
+    const projectPath = sanitizePath(input.path);
+    switch (input.action) {
+      case "show": {
+        const result = await loadState(projectPath, input.stream);
+        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
+        );
+        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
+        );
+        if (!result.ok) return resultToMcpResponse(result);
+        return resultToMcpResponse(Ok({ recorded: true }));
+      }
+      case "archive": {
+        const result = await archiveFailures(projectPath, input.stream);
+        if (!result.ok) return resultToMcpResponse(result);
+        return resultToMcpResponse(Ok({ archived: true }));
+      }
+      case "reset": {
+        const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream);
+        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-JVZ2MKBC.js");
+        const result = await saveHandoff(
+          projectPath,
+          input.handoff,
+          input.stream
+        );
+        return resultToMcpResponse(result.ok ? Ok({ saved: true }) : result);
+      }
+      case "load-handoff": {
+        const { loadHandoff } = await import("./dist-JVZ2MKBC.js");
+        const result = await loadHandoff(projectPath, input.stream);
+        return resultToMcpResponse(result);
+      }
+      default: {
+        return {
+          content: [{ type: "text", text: `Error: unknown action` }],
+          isError: true
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var listStreamsDefinition = {
+  name: "list_streams",
+  description: "List known state streams with branch associations and last-active timestamps",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" }
+    },
+    required: ["path"]
+  }
+};
+async function handleListStreams(input) {
+  try {
+    const { listStreams, loadStreamIndex } = await import("./dist-JVZ2MKBC.js");
+    const projectPath = sanitizePath(input.path);
+    const indexResult = await loadStreamIndex(projectPath);
+    const streamsResult = await listStreams(projectPath);
+    if (!streamsResult.ok) return resultToMcpResponse(streamsResult);
+    return resultToMcpResponse(
+      Ok({
+        activeStream: indexResult.ok ? indexResult.value.activeStream : null,
+        streams: streamsResult.value
+      })
+    );
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/phase-gate.ts
+var checkPhaseGateDefinition = {
+  name: "check_phase_gate",
+  description: "Verify implementation-to-spec mappings: checks that each implementation file has a corresponding spec document",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckPhaseGate(input) {
+  try {
+    const { runCheckPhaseGate } = await import("./check-phase-gate-VZFOY2PO.js");
+    const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
+    if (result.ok) {
+      return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
+    }
+    return { content: [{ type: "text", text: result.error.message }], isError: true };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/cross-check.ts
+import * as path8 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",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root directory" },
+      specsDir: {
+        type: "string",
+        description: "Specs directory relative to project root (default: docs/specs)"
+      },
+      plansDir: {
+        type: "string",
+        description: "Plans directory relative to project root (default: docs/plans)"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleValidateCrossCheck(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const { runCrossCheck } = await import("./validate-cross-check-DB7RIFFF.js");
+    const specsDir = path8.resolve(projectPath, input.specsDir ?? "docs/specs");
+    if (!specsDir.startsWith(projectPath)) {
+      return {
+        content: [{ type: "text", text: "Error: specsDir escapes project root" }],
+        isError: true
+      };
+    }
+    const plansDir = path8.resolve(projectPath, input.plansDir ?? "docs/plans");
+    if (!plansDir.startsWith(projectPath)) {
+      return {
+        content: [{ type: "text", text: "Error: plansDir escapes project root" }],
+        isError: true
+      };
+    }
+    const result = await runCrossCheck({
+      projectPath,
+      specsDir,
+      plansDir
+    });
+    if (result.ok) {
+      return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
+    }
+    return { content: [{ type: "text", text: result.error.message }], isError: true };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/commands/generate-slash-commands.ts
+import { Command } from "commander";
+import fs7 from "fs";
+import path10 from "path";
+import os from "os";
+import readline from "readline";
+
+// src/slash-commands/normalize.ts
+import fs6 from "fs";
+import path9 from "path";
+import { parse as parse2 } from "yaml";
+
+// src/slash-commands/normalize-name.ts
+function normalizeName(skillName) {
+  let name = skillName;
+  if (name.startsWith("harness-")) {
+    name = name.slice("harness-".length);
+  }
+  name = name.replace(/-harness-/g, "-");
+  if (name.endsWith("-harness")) {
+    name = name.slice(0, -"-harness".length);
+  }
+  return name;
+}
+
+// src/slash-commands/normalize.ts
+function normalizeSkills(skillSources, platforms) {
+  const specs = [];
+  const nameMap = /* @__PURE__ */ new Map();
+  for (const { dir: skillsDir, source } of skillSources) {
+    if (!fs6.existsSync(skillsDir)) continue;
+    const entries = fs6.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const entry of entries) {
+      const yamlPath = path9.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs6.existsSync(yamlPath)) continue;
+      let raw;
+      try {
+        raw = fs6.readFileSync(yamlPath, "utf-8");
+      } catch {
+        continue;
+      }
+      const parsed = parse2(raw);
+      const result = SkillMetadataSchema.safeParse(parsed);
+      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 normalized = normalizeName(meta.name);
+      const existing = nameMap.get(normalized);
+      if (existing) {
+        if (existing.source === source) {
+          throw new Error(
+            `Name collision: skills "${existing.skillName}" and "${meta.name}" both normalize to "${normalized}"`
+          );
+        }
+        continue;
+      }
+      nameMap.set(normalized, { skillName: meta.name, source });
+      const skillMdPath = path9.join(skillsDir, entry.name, "SKILL.md");
+      const skillMdContent = fs6.existsSync(skillMdPath) ? fs6.readFileSync(skillMdPath, "utf-8") : "";
+      const skillMdRelative = path9.relative(
+        process.cwd(),
+        path9.join(skillsDir, entry.name, "SKILL.md")
+      );
+      const skillYamlRelative = path9.relative(
+        process.cwd(),
+        path9.join(skillsDir, entry.name, "skill.yaml")
+      );
+      const args = (meta.cli?.args ?? []).map((a) => ({
+        name: a.name,
+        description: a.description ?? "",
+        required: a.required ?? false
+      }));
+      const tools = [...meta.tools ?? []];
+      if (!tools.includes("Read")) {
+        tools.push("Read");
+      }
+      const contextLines = [];
+      if (meta.cognitive_mode) {
+        contextLines.push(`Cognitive mode: ${meta.cognitive_mode}`);
+      }
+      if (meta.type) {
+        contextLines.push(`Type: ${meta.type}`);
+      }
+      if (meta.state?.persistent) {
+        const files = meta.state.files?.join(", ") ?? "";
+        contextLines.push(`State: persistent${files ? ` (files: ${files})` : ""}`);
+      }
+      const objectiveLines = [meta.description];
+      if (meta.phases && meta.phases.length > 0) {
+        objectiveLines.push("");
+        objectiveLines.push("Phases:");
+        for (const phase of meta.phases) {
+          const req = phase.required !== false ? "" : " (optional)";
+          objectiveLines.push(`- ${phase.name}: ${phase.description}${req}`);
+        }
+      }
+      const executionContextLines = [];
+      if (skillMdContent) {
+        executionContextLines.push(`@${skillMdRelative}`);
+        executionContextLines.push(`@${skillYamlRelative}`);
+      }
+      const processLines = [];
+      if (meta.mcp?.tool) {
+        processLines.push(
+          `1. Try: invoke mcp__harness__${meta.mcp.tool} with skill: "${meta.name}"`
+        );
+        processLines.push(`2. If MCP unavailable: read SKILL.md and follow its workflow directly`);
+        processLines.push(`3. Pass through any arguments provided by the user`);
+      } else {
+        processLines.push(`1. Read SKILL.md and follow its workflow directly`);
+        processLines.push(`2. Pass through any arguments provided by the user`);
+      }
+      specs.push({
+        name: normalized,
+        namespace: "harness",
+        fullName: `harness:${normalized}`,
+        description: meta.description,
+        version: meta.version,
+        ...meta.cognitive_mode ? { cognitiveMode: meta.cognitive_mode } : {},
+        tools,
+        args,
+        skillYamlName: meta.name,
+        sourceDir: entry.name,
+        skillsBaseDir: skillsDir,
+        source,
+        prompt: {
+          context: contextLines.join("\n"),
+          objective: objectiveLines.join("\n"),
+          executionContext: executionContextLines.join("\n"),
+          process: processLines.join("\n")
+        }
+      });
+    }
+  }
+  return specs;
+}
+
+// src/slash-commands/argument-hint.ts
+function buildArgumentHint(args) {
+  return args.map((arg) => arg.required ? `--${arg.name} <${arg.name}>` : `[--${arg.name} <${arg.name}>]`).join(" ");
+}
+
+// src/slash-commands/render-claude-code.ts
+function renderClaudeCode(spec) {
+  const lines = ["---"];
+  lines.push(`name: ${spec.fullName}`);
+  lines.push(`description: ${spec.description}`);
+  const hint = buildArgumentHint(spec.args);
+  if (hint) {
+    lines.push(`argument-hint: "${hint}"`);
+  }
+  if (spec.tools.length > 0) {
+    lines.push("allowed-tools:");
+    for (const tool of spec.tools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(GENERATED_HEADER_CLAUDE);
+  lines.push("");
+  lines.push("<context>");
+  lines.push(spec.prompt.context);
+  lines.push("</context>");
+  lines.push("");
+  lines.push("<objective>");
+  lines.push(spec.prompt.objective);
+  lines.push("</objective>");
+  lines.push("");
+  if (spec.prompt.executionContext) {
+    lines.push("<execution_context>");
+    lines.push(spec.prompt.executionContext);
+    lines.push("</execution_context>");
+    lines.push("");
+  }
+  lines.push("<process>");
+  lines.push(spec.prompt.process);
+  lines.push("</process>");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/slash-commands/render-gemini.ts
+function escapeTomlLiteral(content) {
+  return content.replace(/'''/g, "''\\'''");
+}
+function renderGemini(spec, skillMdContent, skillYamlContent) {
+  const lines = [GENERATED_HEADER_GEMINI];
+  const safeDesc = spec.description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  lines.push(`description = "${safeDesc}"`);
+  lines.push("prompt = '''");
+  lines.push("<context>");
+  lines.push(spec.prompt.context);
+  lines.push("</context>");
+  lines.push("");
+  lines.push("<objective>");
+  lines.push(spec.prompt.objective);
+  lines.push("</objective>");
+  lines.push("");
+  if (skillMdContent || skillYamlContent) {
+    lines.push("<execution_context>");
+    if (skillMdContent) {
+      const mdPath = spec.prompt.executionContext.split("\n")[0]?.replace(/^@/, "") ?? "";
+      lines.push(`--- SKILL.md (${mdPath}) ---`);
+      lines.push(escapeTomlLiteral(skillMdContent));
+      lines.push("");
+    }
+    if (skillYamlContent) {
+      const refs = spec.prompt.executionContext.split("\n");
+      const yamlPath = (refs[1] ?? refs[0] ?? "").replace(/^@/, "");
+      lines.push(`--- skill.yaml (${yamlPath}) ---`);
+      lines.push(escapeTomlLiteral(skillYamlContent));
+    }
+    lines.push("</execution_context>");
+    lines.push("");
+  }
+  const geminiProcess = spec.prompt.process.replace(
+    "read SKILL.md and follow its workflow directly",
+    "follow the SKILL.md workflow provided above directly"
+  );
+  lines.push("<process>");
+  lines.push(geminiProcess);
+  lines.push("</process>");
+  lines.push("'''");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/generate-slash-commands.ts
+function resolveOutputDir(platform, opts) {
+  if (opts.output) {
+    return path10.join(opts.output, "harness");
+  }
+  if (opts.global) {
+    const home = os.homedir();
+    return platform === "claude-code" ? path10.join(home, ".claude", "commands", "harness") : path10.join(home, ".gemini", "commands", "harness");
+  }
+  return platform === "claude-code" ? path10.join("agents", "commands", "claude-code", "harness") : path10.join("agents", "commands", "gemini-cli", "harness");
+}
+function fileExtension(platform) {
+  return platform === "claude-code" ? ".md" : ".toml";
+}
+async function confirmDeletion(files) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(`
+Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
+      rl.close();
+      resolve2(answer.toLowerCase() === "y");
+    });
+  });
+}
+function generateSlashCommands(opts) {
+  const skillSources = [];
+  if (opts.skillsDir) {
+    skillSources.push({ dir: opts.skillsDir, source: "project" });
+  } else {
+    const projectDir = resolveProjectSkillsDir();
+    if (projectDir) {
+      skillSources.push({ dir: projectDir, source: "project" });
+    }
+    const communityDir = resolveCommunitySkillsDir();
+    if (fs7.existsSync(communityDir)) {
+      skillSources.push({ dir: communityDir, source: "community" });
+    }
+    if (opts.includeGlobal || skillSources.length === 0) {
+      const globalDir = resolveGlobalSkillsDir();
+      if (!projectDir || path10.resolve(globalDir) !== path10.resolve(projectDir)) {
+        skillSources.push({ dir: globalDir, source: "global" });
+      }
+    }
+  }
+  const specs = normalizeSkills(skillSources, opts.platforms);
+  const results = [];
+  for (const platform of opts.platforms) {
+    const outputDir = resolveOutputDir(platform, opts);
+    const ext = fileExtension(platform);
+    const useAbsolutePaths = opts.global;
+    const rendered = /* @__PURE__ */ new Map();
+    for (const spec of specs) {
+      const filename = `${spec.name}${ext}`;
+      if (platform === "claude-code") {
+        const renderSpec = useAbsolutePaths ? {
+          ...spec,
+          prompt: {
+            ...spec.prompt,
+            executionContext: spec.prompt.executionContext.split("\n").map((line) => {
+              if (line.startsWith("@")) {
+                const relPath = line.slice(1);
+                return `@${path10.resolve(relPath)}`;
+              }
+              return line;
+            }).join("\n")
+          }
+        } : spec;
+        rendered.set(filename, renderClaudeCode(renderSpec));
+      } else {
+        const mdPath = path10.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path10.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs7.existsSync(mdPath) ? fs7.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs7.existsSync(yamlPath) ? fs7.readFileSync(yamlPath, "utf-8") : "";
+        rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
+      }
+    }
+    const plan = computeSyncPlan(outputDir, rendered);
+    if (!opts.dryRun) {
+      applySyncPlan(outputDir, rendered, plan, false);
+    }
+    results.push({
+      platform,
+      added: plan.added,
+      updated: plan.updated,
+      removed: plan.removed,
+      unchanged: plan.unchanged,
+      outputDir
+    });
+  }
+  return results;
+}
+async function handleOrphanDeletion(results, opts) {
+  if (opts.dryRun) return;
+  for (const result of results) {
+    if (result.removed.length === 0) continue;
+    const shouldDelete = opts.yes || await confirmDeletion(result.removed);
+    if (shouldDelete) {
+      for (const filename of result.removed) {
+        const filePath = path10.join(result.outputDir, filename);
+        if (fs7.existsSync(filePath)) {
+          fs7.unlinkSync(filePath);
+        }
+      }
+    }
+  }
+}
+function createGenerateSlashCommandsCommand() {
+  return new Command("generate-slash-commands").description(
+    "Generate native slash commands for Claude Code and Gemini CLI from skill metadata"
+  ).option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global config directories", false).option("--include-global", "Include built-in global skills alongside project skills", false).option("--output <dir>", "Custom output directory").option("--skills-dir <path>", "Skills directory to scan").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const platforms = opts.platforms.split(",").map((p) => p.trim());
+    for (const p of platforms) {
+      if (!VALID_PLATFORMS.includes(p)) {
+        throw new CLIError(
+          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
+          ExitCode.VALIDATION_FAILED
+        );
+      }
+    }
+    const generateOpts = {
+      platforms,
+      global: opts.global,
+      includeGlobal: opts.includeGlobal,
+      output: opts.output,
+      skillsDir: opts.skillsDir ?? "",
+      dryRun: opts.dryRun,
+      yes: opts.yes
+    };
+    try {
+      const results = generateSlashCommands(generateOpts);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      const totalCommands = results.reduce(
+        (sum, r) => sum + r.added.length + r.updated.length + r.unchanged.length,
+        0
+      );
+      if (totalCommands === 0) {
+        console.log(
+          "\nNo skills found. Use --include-global to include built-in skills, or create a skill with: harness create-skill"
+        );
+        return;
+      }
+      for (const result of results) {
+        console.log(`
+${result.platform} \u2192 ${result.outputDir}`);
+        if (result.added.length > 0) {
+          console.log(`  + ${result.added.length} new: ${result.added.join(", ")}`);
+        }
+        if (result.updated.length > 0) {
+          console.log(`  ~ ${result.updated.length} updated: ${result.updated.join(", ")}`);
+        }
+        if (result.removed.length > 0) {
+          console.log(`  - ${result.removed.length} removed: ${result.removed.join(", ")}`);
+        }
+        if (result.unchanged.length > 0) {
+          console.log(`  = ${result.unchanged.length} unchanged`);
+        }
+        if (opts.dryRun) {
+          console.log("  (dry run \u2014 no files written)");
+        }
+      }
+      await handleOrphanDeletion(results, { yes: opts.yes, dryRun: opts.dryRun });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/mcp/tools/generate-slash-commands.ts
+var generateSlashCommandsDefinition = {
+  name: "generate_slash_commands",
+  description: "Generate native slash commands for Claude Code and Gemini CLI from harness skill metadata",
+  inputSchema: {
+    type: "object",
+    properties: {
+      platforms: {
+        type: "string",
+        description: "Comma-separated platforms: claude-code,gemini-cli (default: both)"
+      },
+      global: {
+        type: "boolean",
+        description: "Write to global config directories (~/.claude/commands/, ~/.gemini/commands/)"
+      },
+      output: {
+        type: "string",
+        description: "Custom output directory"
+      },
+      skillsDir: {
+        type: "string",
+        description: "Skills directory to scan"
+      },
+      includeGlobal: {
+        type: "boolean",
+        description: "Include built-in global skills alongside project skills"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Show what would change without writing files"
+      }
+    }
+  }
+};
+async function handleGenerateSlashCommands(input) {
+  try {
+    const platforms = (input.platforms ?? "claude-code,gemini-cli").split(",").map((p) => p.trim());
+    const results = generateSlashCommands({
+      platforms,
+      global: input.global ?? false,
+      includeGlobal: input.includeGlobal ?? false,
+      ...input.output !== void 0 && { output: sanitizePath(input.output) },
+      skillsDir: input.skillsDir ? sanitizePath(input.skillsDir) : "",
+      dryRun: input.dryRun ?? false,
+      yes: true
+    });
+    return resultToMcpResponse(Ok(JSON.stringify(results, null, 2)));
+  } catch (error) {
+    return resultToMcpResponse(Err(error instanceof Error ? error : new Error(String(error))));
+  }
+}
+
+// src/mcp/resources/state.ts
+async function getStateResource(projectRoot) {
+  try {
+    const { loadState, migrateToStreams } = await import("./dist-JVZ2MKBC.js");
+    await migrateToStreams(projectRoot);
+    const result = await loadState(projectRoot);
+    if (result.ok) {
+      return JSON.stringify(result.value, null, 2);
+    }
+    return JSON.stringify({
+      schemaVersion: 1,
+      position: {},
+      decisions: [],
+      blockers: [],
+      progress: {}
+    });
+  } catch {
+    return JSON.stringify({
+      schemaVersion: 1,
+      position: {},
+      decisions: [],
+      blockers: [],
+      progress: {}
+    });
+  }
+}
+
+// src/mcp/tools/graph.ts
+import * as path11 from "path";
+function graphNotFoundError() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "No graph found. Run `harness scan` or use `ingest_source` tool first."
+      }
+    ],
+    isError: true
+  };
+}
+var queryGraphDefinition = {
+  name: "query_graph",
+  description: "Query the project knowledge graph using ContextQL. Traverses from root nodes outward, filtering by node/edge types.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      rootNodeIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Node IDs to start traversal from"
+      },
+      maxDepth: { type: "number", description: "Maximum traversal depth (default 3)" },
+      includeTypes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Only include nodes of these types"
+      },
+      excludeTypes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Exclude nodes of these types"
+      },
+      includeEdges: {
+        type: "array",
+        items: { type: "string" },
+        description: "Only traverse edges of these types"
+      },
+      bidirectional: {
+        type: "boolean",
+        description: "Traverse edges in both directions (default false)"
+      },
+      pruneObservability: {
+        type: "boolean",
+        description: "Prune observability nodes like spans/metrics/logs (default true)"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns node/edge counts by type + top 10 nodes by connectivity, detailed returns full arrays. Default: detailed"
+      }
+    },
+    required: ["path", "rootNodeIds"]
+  }
+};
+async function handleQueryGraph(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { ContextQL } = await import("./dist-M6BQODWC.js");
+    const cql = new ContextQL(store);
+    const result = cql.execute({
+      rootNodeIds: input.rootNodeIds,
+      ...input.maxDepth !== void 0 && { maxDepth: input.maxDepth },
+      ...input.includeTypes !== void 0 && {
+        includeTypes: input.includeTypes
+      },
+      ...input.excludeTypes !== void 0 && {
+        excludeTypes: input.excludeTypes
+      },
+      ...input.includeEdges !== void 0 && {
+        includeEdges: input.includeEdges
+      },
+      ...input.bidirectional !== void 0 && { bidirectional: input.bidirectional },
+      ...input.pruneObservability !== void 0 && {
+        pruneObservability: input.pruneObservability
+      }
+    });
+    if (input.mode === "summary") {
+      const nodesByType = {};
+      for (const node of result.nodes) {
+        nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+      }
+      const edgesByType = {};
+      for (const edge of result.edges) {
+        edgesByType[edge.type] = (edgesByType[edge.type] ?? 0) + 1;
+      }
+      const edgeCounts = /* @__PURE__ */ new Map();
+      for (const edge of result.edges) {
+        edgeCounts.set(edge.from, (edgeCounts.get(edge.from) ?? 0) + 1);
+        edgeCounts.set(edge.to, (edgeCounts.get(edge.to) ?? 0) + 1);
+      }
+      const topNodes = [...edgeCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([id, connections]) => ({ id, connections }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "summary",
+              totalNodes: result.nodes.length,
+              totalEdges: result.edges.length,
+              nodesByType,
+              edgesByType,
+              topNodes,
+              stats: result.stats
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var searchSimilarDefinition = {
+  name: "search_similar",
+  description: "Search the knowledge graph for nodes similar to a query string using keyword and semantic fusion.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      query: { type: "string", description: "Search query string" },
+      topK: { type: "number", description: "Maximum number of results to return (default 10)" },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns top 5 results with scores only, detailed returns top 10+ with full metadata. Default: detailed"
+      }
+    },
+    required: ["path", "query"]
+  }
+};
+async function handleSearchSimilar(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { FusionLayer } = await import("./dist-M6BQODWC.js");
+    const fusion = new FusionLayer(store);
+    const results = fusion.search(input.query, input.topK ?? 10);
+    if (input.mode === "summary") {
+      const summaryResults = results.slice(0, 5).map((r) => ({
+        nodeId: r.nodeId,
+        score: r.score
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ mode: "summary", results: summaryResults })
+          }
+        ]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(results) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var findContextForDefinition = {
+  name: "find_context_for",
+  description: "Find relevant context for a given intent by searching the graph and expanding around top results. Returns assembled context within a token budget.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      intent: { type: "string", description: "Description of what context is needed for" },
+      tokenBudget: {
+        type: "number",
+        description: "Approximate token budget for results (default 4000)"
+      }
+    },
+    required: ["path", "intent"]
+  }
+};
+async function handleFindContextFor(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { FusionLayer, ContextQL } = await import("./dist-M6BQODWC.js");
+    const fusion = new FusionLayer(store);
+    const cql = new ContextQL(store);
+    const tokenBudget = input.tokenBudget ?? 4e3;
+    const charBudget = tokenBudget * 4;
+    const searchResults = fusion.search(input.intent, 10);
+    if (searchResults.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ context: [], message: "No relevant nodes found." })
+          }
+        ]
+      };
+    }
+    const contextBlocks = [];
+    let totalChars = 0;
+    for (const result of searchResults) {
+      if (totalChars >= charBudget) break;
+      const expanded = cql.execute({
+        rootNodeIds: [result.nodeId],
+        maxDepth: 2
+      });
+      const blockJson = JSON.stringify({
+        rootNode: result.nodeId,
+        score: result.score,
+        nodes: expanded.nodes,
+        edges: expanded.edges
+      });
+      if (totalChars + blockJson.length > charBudget && contextBlocks.length > 0) {
+        break;
+      }
+      contextBlocks.push({
+        rootNode: result.nodeId,
+        score: result.score,
+        nodes: expanded.nodes,
+        edges: expanded.edges
+      });
+      totalChars += blockJson.length;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            intent: input.intent,
+            tokenBudget,
+            blocksReturned: contextBlocks.length,
+            context: contextBlocks
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var getRelationshipsDefinition = {
+  name: "get_relationships",
+  description: "Get relationships for a specific node in the knowledge graph, with configurable direction and depth.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      nodeId: { type: "string", description: "ID of the node to get relationships for" },
+      direction: {
+        type: "string",
+        enum: ["outbound", "inbound", "both"],
+        description: "Direction of relationships to include (default both)"
+      },
+      depth: { type: "number", description: "Traversal depth (default 1)" },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns neighbor counts by type + direct neighbors only, detailed returns full traversal. Default: detailed"
+      }
+    },
+    required: ["path", "nodeId"]
+  }
+};
+async function handleGetRelationships(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { ContextQL } = await import("./dist-M6BQODWC.js");
+    const cql = new ContextQL(store);
+    const direction = input.direction ?? "both";
+    const bidirectional = direction === "both" || direction === "inbound";
+    const result = cql.execute({
+      rootNodeIds: [input.nodeId],
+      maxDepth: input.depth ?? 1,
+      bidirectional
+    });
+    let filteredNodes = result.nodes;
+    let filteredEdges = result.edges;
+    if (direction === "inbound") {
+      filteredEdges = result.edges.filter((e) => e.from !== input.nodeId);
+      const reachableNodeIds = new Set(filteredEdges.map((e) => e.from));
+      reachableNodeIds.add(input.nodeId);
+      filteredNodes = result.nodes.filter((n) => reachableNodeIds.has(n.id));
+    }
+    if (input.mode === "summary") {
+      const neighborsByType = {};
+      for (const node of filteredNodes) {
+        if (node.id === input.nodeId) continue;
+        neighborsByType[node.type] = (neighborsByType[node.type] ?? 0) + 1;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "summary",
+              nodeId: input.nodeId,
+              direction,
+              totalNeighbors: filteredNodes.length - 1,
+              neighborsByType,
+              totalEdges: filteredEdges.length,
+              stats: result.stats
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            nodeId: input.nodeId,
+            direction,
+            depth: input.depth ?? 1,
+            nodes: filteredNodes,
+            edges: filteredEdges,
+            stats: result.stats
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var getImpactDefinition = {
+  name: "get_impact",
+  description: "Analyze the impact of changing a node or file. Returns affected tests, docs, code, and other nodes grouped by type.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      nodeId: { type: "string", description: "ID of the node to analyze impact for" },
+      filePath: {
+        type: "string",
+        description: "File path (relative to project root) to analyze impact for"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density: summary returns impacted file count by category + highest-risk items, detailed returns full impact tree. Default: detailed"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleGetImpact(input) {
+  try {
+    if (!input.nodeId && !input.filePath) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: either nodeId or filePath is required"
+          }
+        ],
+        isError: true
+      };
+    }
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { ContextQL } = await import("./dist-M6BQODWC.js");
+    let targetNodeId = input.nodeId;
+    if (!targetNodeId && input.filePath) {
+      const fileNodes = store.findNodes({ type: "file" });
+      const match = fileNodes.find(
+        (n) => n.path === input.filePath || n.id === `file:${input.filePath}`
+      );
+      if (!match) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: no file node found matching path "${input.filePath}"`
+            }
+          ],
+          isError: true
+        };
+      }
+      targetNodeId = match.id;
+    }
+    const cql = new ContextQL(store);
+    const result = cql.execute({
+      rootNodeIds: [targetNodeId],
+      bidirectional: true,
+      maxDepth: 3
+    });
+    const groups = {
+      tests: [],
+      docs: [],
+      code: [],
+      other: []
+    };
+    const testTypes = /* @__PURE__ */ new Set(["test_result"]);
+    const docTypes = /* @__PURE__ */ new Set(["adr", "decision", "document", "learning"]);
+    const codeTypes = /* @__PURE__ */ new Set([
+      "file",
+      "module",
+      "class",
+      "interface",
+      "function",
+      "method",
+      "variable"
+    ]);
+    for (const node of result.nodes) {
+      if (node.id === targetNodeId) continue;
+      if (testTypes.has(node.type)) {
+        groups["tests"].push(node);
+      } else if (docTypes.has(node.type)) {
+        groups["docs"].push(node);
+      } else if (codeTypes.has(node.type)) {
+        groups["code"].push(node);
+      } else {
+        groups["other"].push(node);
+      }
+    }
+    if (input.mode === "summary") {
+      const highestRiskItems = [
+        ...groups["tests"].slice(0, 2),
+        ...groups["code"].slice(0, 2),
+        ...groups["docs"].slice(0, 2)
+      ].map((n) => {
+        const node = n;
+        return { id: node.id, type: node.type };
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "summary",
+              targetNodeId,
+              impactCounts: {
+                tests: groups["tests"].length,
+                docs: groups["docs"].length,
+                code: groups["code"].length,
+                other: groups["other"].length
+              },
+              highestRiskItems,
+              stats: result.stats
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            targetNodeId,
+            impact: groups,
+            stats: result.stats,
+            edges: result.edges
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var ingestSourceDefinition = {
+  name: "ingest_source",
+  description: "Ingest sources into the project knowledge graph. Supports code analysis, knowledge documents, git history, or all at once.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      source: {
+        type: "string",
+        enum: ["code", "knowledge", "git", "all"],
+        description: "Type of source to ingest"
+      }
+    },
+    required: ["path", "source"]
+  }
+};
+async function handleIngestSource(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const graphDir = path11.join(projectPath, ".harness", "graph");
+    const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-M6BQODWC.js");
+    const fs10 = await import("fs/promises");
+    await fs10.mkdir(graphDir, { recursive: true });
+    const store = new GraphStore();
+    await store.load(graphDir);
+    const results = [];
+    if (input.source === "code" || input.source === "all") {
+      const codeIngestor = new CodeIngestor(store);
+      const codeResult = await codeIngestor.ingest(projectPath);
+      results.push(codeResult);
+      const linker = new TopologicalLinker(store);
+      linker.link();
+    }
+    if (input.source === "knowledge" || input.source === "all") {
+      const knowledgeIngestor = new KnowledgeIngestor(store);
+      const knowledgeResult = await knowledgeIngestor.ingestAll(projectPath);
+      results.push(knowledgeResult);
+    }
+    if (input.source === "git" || input.source === "all") {
+      const gitIngestor = new GitIngestor(store);
+      const gitResult = await gitIngestor.ingest(projectPath);
+      results.push(gitResult);
+    }
+    await store.save(graphDir);
+    const combined = {
+      nodesAdded: results.reduce((s, r) => s + r.nodesAdded, 0),
+      nodesUpdated: results.reduce((s, r) => s + r.nodesUpdated, 0),
+      edgesAdded: results.reduce((s, r) => s + r.edgesAdded, 0),
+      edgesUpdated: results.reduce((s, r) => s + r.edgesUpdated, 0),
+      errors: results.flatMap((r) => r.errors),
+      durationMs: results.reduce((s, r) => s + r.durationMs, 0),
+      graphStats: {
+        totalNodes: store.nodeCount,
+        totalEdges: store.edgeCount
+      }
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(combined) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var detectAnomaliesDefinition = {
+  name: "detect_anomalies",
+  description: "Detect structural anomalies \u2014 statistical outliers across code metrics and topological single points of failure in the import graph",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      threshold: { type: "number", description: "Z-score threshold (default 2.0)" },
+      metrics: {
+        type: "array",
+        items: { type: "string" },
+        description: "Metrics to analyze (default: cyclomaticComplexity, fanIn, fanOut, hotspotScore, transitiveDepth)"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleDetectAnomalies(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { GraphAnomalyAdapter } = await import("./dist-M6BQODWC.js");
+    const adapter = new GraphAnomalyAdapter(store);
+    const report = adapter.detect({
+      ...input.threshold !== void 0 && { threshold: input.threshold },
+      ...input.metrics !== void 0 && { metrics: input.metrics }
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(report) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var askGraphDefinition = {
+  name: "ask_graph",
+  description: 'Ask a natural language question about the codebase knowledge graph. Supports questions about impact ("what breaks if I change X?"), finding entities ("where is the auth middleware?"), relationships ("what calls UserService?"), explanations ("what is GraphStore?"), and anomalies ("what looks wrong?"). Returns a human-readable summary and raw graph data.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      question: { type: "string", description: "Natural language question about the codebase" }
+    },
+    required: ["path", "question"]
+  }
+};
+async function handleAskGraph(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    if (!store) return graphNotFoundError();
+    const { askGraph } = await import("./dist-M6BQODWC.js");
+    const result = await askGraph(store, input.question);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/resources/graph.ts
+import * as fs8 from "fs/promises";
+import * as path12 from "path";
+var MAX_ITEMS = 5e3;
+function formatStaleness(isoTimestamp) {
+  const then = new Date(isoTimestamp).getTime();
+  const now = Date.now();
+  const diffMs = now - then;
+  const seconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days} day${days === 1 ? "" : "s"} ago`;
+  if (hours > 0) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  if (minutes > 0) return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+  return "just now";
+}
+async function getGraphResource(projectRoot) {
+  const store = await loadGraphStore(projectRoot);
+  if (!store) {
+    return JSON.stringify({
+      status: "no_graph",
+      message: "No knowledge graph found. Run harness scan to build one."
+    });
+  }
+  const graphDir = path12.join(projectRoot, ".harness", "graph");
+  const metadataPath = path12.join(graphDir, "metadata.json");
+  let lastScanTimestamp = null;
+  try {
+    const raw = JSON.parse(await fs8.readFile(metadataPath, "utf-8"));
+    lastScanTimestamp = raw.lastScanTimestamp ?? null;
+  } catch {
+  }
+  const allNodes = store.findNodes({});
+  const allEdges = store.getEdges({});
+  const nodesByType = {};
+  for (const node of allNodes) {
+    nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+  }
+  const edgesByType = {};
+  for (const edge of allEdges) {
+    edgesByType[edge.type] = (edgesByType[edge.type] ?? 0) + 1;
+  }
+  let status = "ok";
+  let staleness = "unknown";
+  if (lastScanTimestamp) {
+    const ageMs = Date.now() - new Date(lastScanTimestamp).getTime();
+    const twentyFourHoursMs = 24 * 60 * 60 * 1e3;
+    if (ageMs > twentyFourHoursMs) {
+      status = "stale";
+    }
+    staleness = formatStaleness(lastScanTimestamp);
+  }
+  return JSON.stringify({
+    status,
+    nodeCount: store.nodeCount,
+    edgeCount: store.edgeCount,
+    nodesByType,
+    edgesByType,
+    lastScanTimestamp,
+    staleness
+  });
+}
+async function getEntitiesResource(projectRoot) {
+  const store = await loadGraphStore(projectRoot);
+  if (!store) {
+    return "[]";
+  }
+  const nodes = store.findNodes({});
+  const entities = nodes.slice(0, MAX_ITEMS).map((n) => ({
+    id: n.id,
+    type: n.type,
+    name: n.name,
+    path: n.path,
+    metadata: n.metadata
+  }));
+  if (nodes.length > MAX_ITEMS) {
+    return JSON.stringify({ entities, _truncated: true, _total: nodes.length }, null, 2);
+  }
+  return JSON.stringify(entities);
+}
+async function getRelationshipsResource(projectRoot) {
+  const store = await loadGraphStore(projectRoot);
+  if (!store) {
+    return "[]";
+  }
+  const edges = store.getEdges({});
+  const relationships = edges.slice(0, MAX_ITEMS).map((e) => ({
+    from: e.from,
+    to: e.to,
+    type: e.type,
+    confidence: e.confidence,
+    metadata: e.metadata
+  }));
+  if (edges.length > MAX_ITEMS) {
+    return JSON.stringify({ relationships, _truncated: true, _total: edges.length }, null, 2);
+  }
+  return JSON.stringify(relationships);
+}
+
+// src/mcp/tools/agent-definitions.ts
+var generateAgentDefinitionsDefinition = {
+  name: "generate_agent_definitions",
+  description: "Generate agent definition files from personas for Claude Code and Gemini CLI",
+  inputSchema: {
+    type: "object",
+    properties: {
+      global: { type: "boolean", description: "Write to global agent directory" },
+      platform: {
+        type: "string",
+        enum: ["claude-code", "gemini-cli", "all"],
+        description: "Target platform (default: all)"
+      },
+      dryRun: { type: "boolean", description: "Preview without writing" }
+    }
+  }
+};
+async function handleGenerateAgentDefinitions(input) {
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-MWKEA5NU.js");
+  const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
+  const results = generateAgentDefinitions({
+    platforms: [...platforms],
+    global: input.global ?? false,
+    dryRun: input.dryRun ?? false
+  });
+  return resultToMcpResponse(Ok(results));
+}
+
+// src/mcp/tools/roadmap.ts
+import * as fs9 from "fs";
+import * as path13 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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      action: {
+        type: "string",
+        enum: ["show", "add", "update", "remove", "query", "sync"],
+        description: "Action to perform"
+      },
+      feature: { type: "string", description: "Feature name (required for add, update, remove)" },
+      milestone: {
+        type: "string",
+        description: "Milestone name (required for add; optional filter for show)"
+      },
+      status: {
+        type: "string",
+        enum: ["backlog", "planned", "in-progress", "done", "blocked"],
+        description: "Feature status (required for add; optional for update; optional filter for show)"
+      },
+      summary: {
+        type: "string",
+        description: "Feature summary (required for add; optional for update)"
+      },
+      spec: { type: "string", description: "Spec file path (optional for add/update)" },
+      plans: {
+        type: "array",
+        items: { type: "string" },
+        description: "Plan file paths (optional for add/update)"
+      },
+      blocked_by: {
+        type: "array",
+        items: { type: "string" },
+        description: "Blocking feature names (optional for add/update)"
+      },
+      filter: {
+        type: "string",
+        description: 'Query filter: "blocked", "in-progress", "done", "planned", "backlog", or "milestone:<name>" (required for query)'
+      },
+      apply: {
+        type: "boolean",
+        description: "For sync action: apply proposed changes (default: false, preview only)"
+      },
+      force_sync: {
+        type: "boolean",
+        description: "For sync action: override human-always-wins rule"
+      }
+    },
+    required: ["path", "action"]
+  }
+};
+function roadmapPath(projectRoot) {
+  return path13.join(projectRoot, "docs", "roadmap.md");
+}
+function readRoadmapFile(projectRoot) {
+  const filePath = roadmapPath(projectRoot);
+  try {
+    return fs9.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function writeRoadmapFile(projectRoot, content) {
+  const filePath = roadmapPath(projectRoot);
+  const dir = path13.dirname(filePath);
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(filePath, content, "utf-8");
+}
+async function handleManageRoadmap(input) {
+  try {
+    const { parseRoadmap, serializeRoadmap, syncRoadmap } = await import("./dist-JVZ2MKBC.js");
+    const { Ok: Ok2 } = await import("./dist-D4RYGUZE.js");
+    const projectPath = sanitizePath(input.path);
+    switch (input.action) {
+      case "show": {
+        const raw = readRoadmapFile(projectPath);
+        if (raw === null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: docs/roadmap.md not found. Create a roadmap first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = parseRoadmap(raw);
+        if (!result.ok) return resultToMcpResponse(result);
+        let roadmap = result.value;
+        if (input.milestone) {
+          const milestoneFilter = input.milestone;
+          roadmap = {
+            ...roadmap,
+            milestones: roadmap.milestones.filter(
+              (m) => m.name.toLowerCase() === milestoneFilter.toLowerCase()
+            )
+          };
+        }
+        if (input.status) {
+          const statusFilter = input.status;
+          roadmap = {
+            ...roadmap,
+            milestones: roadmap.milestones.map((m) => ({
+              ...m,
+              features: m.features.filter((f) => f.status === statusFilter)
+            })).filter((m) => m.features.length > 0)
+          };
+        }
+        return resultToMcpResponse(Ok2(roadmap));
+      }
+      case "add": {
+        if (!input.feature) {
+          return {
+            content: [{ type: "text", text: "Error: feature is required for add action" }],
+            isError: true
+          };
+        }
+        if (!input.milestone) {
+          return {
+            content: [
+              { type: "text", text: "Error: milestone is required for add action" }
+            ],
+            isError: true
+          };
+        }
+        if (!input.status) {
+          return {
+            content: [{ type: "text", text: "Error: status is required for add action" }],
+            isError: true
+          };
+        }
+        if (!input.summary) {
+          return {
+            content: [{ type: "text", text: "Error: summary is required for add action" }],
+            isError: true
+          };
+        }
+        const raw = readRoadmapFile(projectPath);
+        if (raw === null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: docs/roadmap.md not found. Create a roadmap first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = parseRoadmap(raw);
+        if (!result.ok) return resultToMcpResponse(result);
+        const roadmap = result.value;
+        const milestone = roadmap.milestones.find(
+          (m) => m.name.toLowerCase() === input.milestone.toLowerCase()
+        );
+        if (!milestone) {
+          return {
+            content: [
+              { type: "text", text: `Error: milestone "${input.milestone}" not found` }
+            ],
+            isError: true
+          };
+        }
+        milestone.features.push({
+          name: input.feature,
+          status: input.status,
+          spec: input.spec ?? null,
+          plans: input.plans ?? [],
+          blockedBy: input.blocked_by ?? [],
+          summary: input.summary
+        });
+        roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
+        writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+        return resultToMcpResponse(Ok2(roadmap));
+      }
+      case "update": {
+        if (!input.feature) {
+          return {
+            content: [
+              { type: "text", text: "Error: feature is required for update action" }
+            ],
+            isError: true
+          };
+        }
+        const raw = readRoadmapFile(projectPath);
+        if (raw === null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: docs/roadmap.md not found. Create a roadmap first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = parseRoadmap(raw);
+        if (!result.ok) return resultToMcpResponse(result);
+        const roadmap = result.value;
+        let found = false;
+        for (const m of roadmap.milestones) {
+          const feature = m.features.find(
+            (f) => f.name.toLowerCase() === input.feature.toLowerCase()
+          );
+          if (feature) {
+            if (input.status) feature.status = input.status;
+            if (input.summary !== void 0) feature.summary = input.summary;
+            if (input.spec !== void 0) feature.spec = input.spec || null;
+            if (input.plans !== void 0) feature.plans = input.plans;
+            if (input.blocked_by !== void 0) feature.blockedBy = input.blocked_by;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return {
+            content: [
+              { type: "text", text: `Error: feature "${input.feature}" not found` }
+            ],
+            isError: true
+          };
+        }
+        roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
+        writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+        return resultToMcpResponse(Ok2(roadmap));
+      }
+      case "remove": {
+        if (!input.feature) {
+          return {
+            content: [
+              { type: "text", text: "Error: feature is required for remove action" }
+            ],
+            isError: true
+          };
+        }
+        const raw = readRoadmapFile(projectPath);
+        if (raw === null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: docs/roadmap.md not found. Create a roadmap first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = parseRoadmap(raw);
+        if (!result.ok) return resultToMcpResponse(result);
+        const roadmap = result.value;
+        let found = false;
+        for (const m of roadmap.milestones) {
+          const idx = m.features.findIndex(
+            (f) => f.name.toLowerCase() === input.feature.toLowerCase()
+          );
+          if (idx !== -1) {
+            m.features.splice(idx, 1);
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return {
+            content: [
+              { type: "text", text: `Error: feature "${input.feature}" not found` }
+            ],
+            isError: true
+          };
+        }
+        roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
+        writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+        return resultToMcpResponse(Ok2(roadmap));
+      }
+      case "query": {
+        if (!input.filter) {
+          return {
+            content: [
+              { type: "text", text: "Error: filter is required for query action" }
+            ],
+            isError: true
+          };
+        }
+        const raw = readRoadmapFile(projectPath);
+        if (raw === null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: docs/roadmap.md not found. Create a roadmap first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = parseRoadmap(raw);
+        if (!result.ok) return resultToMcpResponse(result);
+        const roadmap = result.value;
+        const allFeatures = roadmap.milestones.flatMap(
+          (m) => m.features.map((f) => ({ ...f, milestone: m.name }))
+        );
+        const filter = input.filter.toLowerCase();
+        let filtered;
+        if (filter.startsWith("milestone:")) {
+          const milestoneName = filter.slice("milestone:".length).trim();
+          filtered = allFeatures.filter((f) => f.milestone.toLowerCase().includes(milestoneName));
+        } else {
+          filtered = allFeatures.filter((f) => f.status === filter);
+        }
+        return resultToMcpResponse(Ok2(filtered));
+      }
+      case "sync": {
+        const raw = readRoadmapFile(projectPath);
+        if (raw === null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: docs/roadmap.md not found. Create a roadmap first."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = parseRoadmap(raw);
+        if (!result.ok) return resultToMcpResponse(result);
+        const roadmap = result.value;
+        const syncResult = syncRoadmap({
+          projectPath,
+          roadmap,
+          forceSync: input.force_sync ?? false
+        });
+        if (!syncResult.ok) return resultToMcpResponse(syncResult);
+        const changes = syncResult.value;
+        if (changes.length === 0) {
+          return resultToMcpResponse(Ok2({ changes: [], message: "Roadmap is up to date." }));
+        }
+        if (input.apply) {
+          for (const change of changes) {
+            for (const m of roadmap.milestones) {
+              const feature = m.features.find(
+                (f) => f.name.toLowerCase() === change.feature.toLowerCase()
+              );
+              if (feature) {
+                feature.status = change.to;
+                break;
+              }
+            }
+          }
+          roadmap.frontmatter.lastSynced = (/* @__PURE__ */ new Date()).toISOString();
+          writeRoadmapFile(projectPath, serializeRoadmap(roadmap));
+          return resultToMcpResponse(Ok2({ changes, applied: true, roadmap }));
+        }
+        return resultToMcpResponse(Ok2({ changes, applied: false }));
+      }
+      default: {
+        return {
+          content: [{ type: "text", text: `Error: unknown action` }],
+          isError: true
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/interaction.ts
+import { randomUUID } from "crypto";
+
+// src/mcp/tools/interaction-schemas.ts
+import { z } from "zod";
+var RiskLevel = z.enum(["low", "medium", "high"]);
+var EffortLevel = z.enum(["low", "medium", "high"]);
+var ConfidenceLevel = z.enum(["low", "medium", "high"]);
+var InteractionOptionSchema = z.object({
+  label: z.string().min(1),
+  pros: z.array(z.string().min(1)).min(1),
+  cons: z.array(z.string().min(1)).min(1),
+  risk: RiskLevel.optional(),
+  effort: EffortLevel.optional()
+});
+var InteractionQuestionSchema = z.object({
+  text: z.string().min(1),
+  options: z.array(InteractionOptionSchema).min(2).max(10).optional(),
+  recommendation: z.object({
+    optionIndex: z.number().int().min(0),
+    reason: z.string().min(1),
+    confidence: ConfidenceLevel
+  }).optional(),
+  default: z.number().int().min(0).optional()
+});
+var InteractionQuestionWithOptionsSchema = InteractionQuestionSchema.refine(
+  (data) => {
+    if (data.options && data.options.length > 0) {
+      return data.recommendation !== void 0;
+    }
+    return true;
+  },
+  { message: "recommendation is required when options are provided" }
+).refine(
+  (data) => {
+    if (data.recommendation && data.options) {
+      return data.recommendation.optionIndex < data.options.length;
+    }
+    return true;
+  },
+  { message: "recommendation.optionIndex must reference a valid option" }
+).refine(
+  (data) => {
+    if (data.default !== void 0 && data.options) {
+      return data.default < data.options.length;
+    }
+    return true;
+  },
+  { message: "default must reference a valid option index" }
+);
+var InteractionConfirmationSchema = z.object({
+  text: z.string().min(1),
+  context: z.string().min(1),
+  impact: z.string().optional(),
+  risk: RiskLevel.optional()
+});
+var QualityGateCheckSchema = z.object({
+  name: z.string().min(1),
+  passed: z.boolean(),
+  detail: z.string().optional()
+});
+var QualityGateSchema = z.object({
+  checks: z.array(QualityGateCheckSchema).min(1),
+  allPassed: z.boolean()
+});
+var InteractionTransitionSchema = z.object({
+  completedPhase: z.string().min(1),
+  suggestedNext: z.string().min(1),
+  reason: z.string().min(1),
+  artifacts: z.array(z.string()),
+  requiresConfirmation: z.boolean(),
+  summary: z.string().min(1),
+  qualityGate: QualityGateSchema.optional()
+});
+var BatchDecisionSchema = z.object({
+  label: z.string().min(1),
+  recommendation: z.string().min(1),
+  risk: z.literal("low")
+});
+var InteractionBatchSchema = z.object({
+  text: z.string().min(1),
+  decisions: z.array(BatchDecisionSchema).min(1)
+});
+var InteractionTypeSchema = z.enum(["question", "confirmation", "transition", "batch"]);
+var EmitInteractionInputSchema = z.object({
+  path: z.string().min(1),
+  type: InteractionTypeSchema,
+  stream: z.string().optional(),
+  // Uses base schema here; refined validation (recommendation required with options)
+  // is applied in the handler's question branch via InteractionQuestionWithOptionsSchema.
+  // Refined schemas with .refine() cannot be nested inside z.object().optional() reliably.
+  question: InteractionQuestionSchema.optional(),
+  confirmation: InteractionConfirmationSchema.optional(),
+  transition: InteractionTransitionSchema.optional(),
+  batch: InteractionBatchSchema.optional()
+});
+
+// src/mcp/tools/interaction-renderer.ts
+function columnLabel(index) {
+  return String.fromCharCode(65 + index);
+}
+function renderQuestion(question) {
+  const { text, options, recommendation } = question;
+  if (!options || options.length === 0) {
+    return text;
+  }
+  const headers = options.map(
+    (opt, i) => `${columnLabel(i)}) ${escapeCell(opt.label)}`
+  );
+  const headerRow = `| | ${headers.join(" | ")} |`;
+  const separatorRow = `|---|${options.map(() => "---").join("|")}|`;
+  const prosRow = `| **Pros** | ${options.map((opt) => opt.pros.map(escapeCell).join("; ")).join(" | ")} |`;
+  const consRow = `| **Cons** | ${options.map((opt) => opt.cons.map(escapeCell).join("; ")).join(" | ")} |`;
+  const rows = [headerRow, separatorRow, prosRow, consRow];
+  if (options.some((opt) => opt.risk)) {
+    const riskRow = `| **Risk** | ${options.map((opt) => opt.risk ? capitalize(opt.risk) : "-").join(" | ")} |`;
+    rows.push(riskRow);
+  }
+  if (options.some((opt) => opt.effort)) {
+    const effortRow = `| **Effort** | ${options.map((opt) => opt.effort ? capitalize(opt.effort) : "-").join(" | ")} |`;
+    rows.push(effortRow);
+  }
+  let prompt = `### Decision needed: ${text}
+
+${rows.join("\n")}`;
+  if (recommendation) {
+    const opt = options[recommendation.optionIndex];
+    if (opt) {
+      const recLabel = `${columnLabel(recommendation.optionIndex)}) ${opt.label}`;
+      prompt += `
+
+**Recommendation:** ${recLabel} (confidence: ${recommendation.confidence})`;
+      prompt += `
+> ${recommendation.reason}`;
+    }
+  }
+  return prompt;
+}
+function renderConfirmation(confirmation) {
+  let prompt = `${confirmation.text}
+
+Context: ${confirmation.context}`;
+  if (confirmation.impact) {
+    prompt += `
+
+Impact: ${confirmation.impact}`;
+  }
+  if (confirmation.risk) {
+    prompt += `
+Risk: ${capitalize(confirmation.risk)}`;
+  }
+  prompt += "\n\nProceed? (yes/no)";
+  return prompt;
+}
+function renderTransition(transition) {
+  let prompt = `Phase "${transition.completedPhase}" complete. ${transition.reason}
+
+${transition.summary}
+
+Artifacts produced:
+${transition.artifacts.map((a) => `  - ${a}`).join("\n")}`;
+  if (transition.qualityGate) {
+    prompt += "\n\n**Quality Gate:**\n";
+    for (const check of transition.qualityGate.checks) {
+      const icon = check.passed ? "PASS" : "FAIL";
+      prompt += `  - [${icon}] ${check.name}`;
+      if (check.detail) {
+        prompt += ` -- ${check.detail}`;
+      }
+      prompt += "\n";
+    }
+    prompt += transition.qualityGate.allPassed ? "  All checks passed." : "  **Some checks failed.**";
+  }
+  prompt += "\n\n";
+  prompt += transition.requiresConfirmation ? `Suggested next: "${transition.suggestedNext}". Proceed?` : `Proceeding to ${transition.suggestedNext}...`;
+  return prompt;
+}
+function renderBatch(batch) {
+  let prompt = `${batch.text}
+
+`;
+  batch.decisions.forEach((d, i) => {
+    prompt += `${i + 1}. **${d.label}** -- Recommendation: ${d.recommendation} (risk: low)
+`;
+  });
+  prompt += "\nApprove all? (yes/no)";
+  return prompt;
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function escapeCell(s) {
+  return s.replace(/\|/g, "\\|");
+}
+
+// src/mcp/tools/interaction.ts
+var emitInteractionDefinition = {
+  name: "emit_interaction",
+  description: "Emit a structured interaction (question, confirmation, phase transition, or batch decision) for round-trip communication with the user",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      type: {
+        type: "string",
+        enum: ["question", "confirmation", "transition", "batch"],
+        description: "Type of interaction"
+      },
+      stream: {
+        type: "string",
+        description: "State stream for recording (auto-resolves from branch if omitted)"
+      },
+      question: {
+        type: "object",
+        description: "Question payload (required when type is question)",
+        properties: {
+          text: { type: "string", description: "The question text" },
+          options: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                label: { type: "string" },
+                pros: { type: "array", items: { type: "string" } },
+                cons: { type: "array", items: { type: "string" } },
+                risk: { type: "string", enum: ["low", "medium", "high"] },
+                effort: { type: "string", enum: ["low", "medium", "high"] }
+              },
+              required: ["label", "pros", "cons"]
+            },
+            description: "Structured options with pros/cons (omit for free-form)"
+          },
+          recommendation: {
+            type: "object",
+            properties: {
+              optionIndex: { type: "number", description: "Index of recommended option" },
+              reason: { type: "string", description: "Why this option is recommended" },
+              confidence: { type: "string", enum: ["low", "medium", "high"] }
+            },
+            required: ["optionIndex", "reason", "confidence"],
+            description: "Required when options are provided"
+          },
+          default: { type: "number", description: "Default option index" }
+        },
+        required: ["text"]
+      },
+      confirmation: {
+        type: "object",
+        description: "Confirmation payload (required when type is confirmation)",
+        properties: {
+          text: { type: "string", description: "What to confirm" },
+          context: {
+            type: "string",
+            description: "Why confirmation is needed"
+          },
+          impact: { type: "string", description: "Impact description" },
+          risk: { type: "string", enum: ["low", "medium", "high"], description: "Risk level" }
+        },
+        required: ["text", "context"]
+      },
+      transition: {
+        type: "object",
+        description: "Transition payload (required when type is transition)",
+        properties: {
+          completedPhase: {
+            type: "string",
+            description: "Phase that was completed"
+          },
+          suggestedNext: {
+            type: "string",
+            description: "Suggested next phase"
+          },
+          reason: {
+            type: "string",
+            description: "Why the transition is happening"
+          },
+          artifacts: {
+            type: "array",
+            items: { type: "string" },
+            description: "File paths produced during the completed phase"
+          },
+          requiresConfirmation: {
+            type: "boolean",
+            description: "true = wait for user confirmation, false = proceed immediately"
+          },
+          summary: {
+            type: "string",
+            description: "1-2 sentence rich summary with key metrics"
+          },
+          qualityGate: {
+            type: "object",
+            properties: {
+              checks: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    passed: { type: "boolean" },
+                    detail: { type: "string" }
+                  },
+                  required: ["name", "passed"]
+                }
+              },
+              allPassed: { type: "boolean" }
+            },
+            required: ["checks", "allPassed"],
+            description: "Quality gate results for the completed phase"
+          }
+        },
+        required: [
+          "completedPhase",
+          "suggestedNext",
+          "reason",
+          "artifacts",
+          "requiresConfirmation",
+          "summary"
+        ]
+      },
+      batch: {
+        type: "object",
+        description: "Batch decision payload (required when type is batch)",
+        properties: {
+          text: { type: "string", description: "Batch description" },
+          decisions: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                label: { type: "string" },
+                recommendation: { type: "string" },
+                risk: { type: "string", enum: ["low"] }
+              },
+              required: ["label", "recommendation", "risk"]
+            },
+            description: "Low-risk decisions to approve in batch"
+          }
+        },
+        required: ["text", "decisions"]
+      }
+    },
+    required: ["path", "type"]
+  }
+};
+async function handleEmitInteraction(input) {
+  try {
+    const parseResult = EmitInteractionInputSchema.safeParse(input);
+    if (!parseResult.success) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${parseResult.error.issues.map((i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message).join("; ")}`
+          }
+        ],
+        isError: true
+      };
+    }
+    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-JVZ2MKBC.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
+          );
+        } 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
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function recordInteraction(projectPath, id, type, decision, stream) {
+  try {
+    const { loadState, saveState } = await import("./dist-JVZ2MKBC.js");
+    const stateResult = await loadState(projectPath, stream);
+    if (stateResult.ok) {
+      const state = stateResult.value;
+      state.decisions.push({
+        date: (/* @__PURE__ */ new Date()).toISOString(),
+        decision: `[${type}:${id}] ${decision}`,
+        context: "pending user response"
+      });
+      await saveState(projectPath, state, stream);
+    }
+  } catch {
+  }
+}
+
+// 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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      intent: {
+        type: "string",
+        description: "What the agent is about to do (used for graph context search)"
+      },
+      skill: {
+        type: "string",
+        description: "Current skill name (filters learnings by skill)"
+      },
+      tokenBudget: {
+        type: "number",
+        description: "Approximate token budget for graph context (default 4000)"
+      },
+      include: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: ["state", "learnings", "handoff", "graph", "validation"]
+        },
+        description: "Which constituents to include (default: all)"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density. Default: summary"
+      }
+    },
+    required: ["path", "intent"]
+  }
+};
+async function handleGatherContext(input) {
+  const start = Date.now();
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const includeSet = new Set(
+    input.include ?? ["state", "learnings", "handoff", "graph", "validation"]
+  );
+  const errors = [];
+  const statePromise = includeSet.has("state") ? import("./dist-JVZ2MKBC.js").then((core) => core.loadState(projectPath)) : Promise.resolve(null);
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-JVZ2MKBC.js").then(
+    (core) => core.loadRelevantLearnings(projectPath, input.skill)
+  ) : Promise.resolve(null);
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-JVZ2MKBC.js").then((core) => core.loadHandoff(projectPath)) : Promise.resolve(null);
+  const graphPromise = includeSet.has("graph") ? (async () => {
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+    const store = await loadGraphStore2(projectPath);
+    if (!store) return null;
+    const { FusionLayer, ContextQL } = await import("./dist-M6BQODWC.js");
+    const fusion = new FusionLayer(store);
+    const cql = new ContextQL(store);
+    const tokenBudget = input.tokenBudget ?? 4e3;
+    const charBudget = tokenBudget * 4;
+    const searchResults = fusion.search(input.intent, 10);
+    if (searchResults.length === 0) return { context: [], tokenBudget };
+    const contextBlocks = [];
+    let totalChars = 0;
+    for (const result of searchResults) {
+      if (totalChars >= charBudget) break;
+      const expanded = cql.execute({
+        rootNodeIds: [result.nodeId],
+        maxDepth: 2
+      });
+      const blockJson = JSON.stringify({
+        rootNode: result.nodeId,
+        score: result.score,
+        nodes: expanded.nodes,
+        edges: expanded.edges
+      });
+      if (totalChars + blockJson.length > charBudget && contextBlocks.length > 0) break;
+      contextBlocks.push({
+        rootNode: result.nodeId,
+        score: result.score,
+        nodes: expanded.nodes,
+        edges: expanded.edges
+      });
+      totalChars += blockJson.length;
+    }
+    return {
+      intent: input.intent,
+      tokenBudget,
+      blocksReturned: contextBlocks.length,
+      context: contextBlocks
+    };
+  })() : Promise.resolve(null);
+  const validationPromise = includeSet.has("validation") ? (async () => {
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-JN44D2Q7.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([
+    statePromise,
+    learningsPromise,
+    handoffPromise,
+    graphPromise,
+    validationPromise
+  ]);
+  function extract(settled, name) {
+    if (settled.status === "rejected") {
+      errors.push(`${name}: ${String(settled.reason)}`);
+      return null;
+    }
+    return settled.value;
+  }
+  const stateRaw = extract(stateResult, "state");
+  const learningsRaw = extract(learningsResult, "learnings");
+  const handoffRaw = extract(handoffResult, "handoff");
+  const graphContextRaw = extract(graphResult, "graph");
+  const validationRaw = extract(validationResult, "validation");
+  const state = stateRaw && typeof stateRaw === "object" && "ok" in stateRaw ? stateRaw.ok ? stateRaw.value : (() => {
+    errors.push(`state: ${stateRaw.error.message}`);
+    return null;
+  })() : stateRaw;
+  const learnings = learningsRaw && typeof learningsRaw === "object" && "ok" in learningsRaw ? learningsRaw.ok ? learningsRaw.value : (() => {
+    errors.push(
+      `learnings: ${learningsRaw.error.message}`
+    );
+    return [];
+  })() : learningsRaw ?? [];
+  const handoff = handoffRaw && typeof handoffRaw === "object" && "ok" in handoffRaw ? handoffRaw.ok ? handoffRaw.value : (() => {
+    errors.push(`handoff: ${handoffRaw.error.message}`);
+    return null;
+  })() : handoffRaw;
+  const graphContext = graphContextRaw;
+  const validation = validationRaw;
+  const assembledIn = Date.now() - start;
+  const mode = input.mode ?? "summary";
+  const outputState = state ?? null;
+  const outputLearnings = learnings ?? [];
+  const outputHandoff = handoff ?? null;
+  const outputGraphContext = graphContext == null ? null : mode === "summary" ? {
+    blocksReturned: graphContext.blocksReturned ?? 0,
+    nodeCount: (graphContext.context ?? []).reduce(
+      (sum, b) => sum + (Array.isArray(b.nodes) ? b.nodes.length : 0),
+      0
+    ),
+    edgeCount: (graphContext.context ?? []).reduce(
+      (sum, b) => sum + (Array.isArray(b.edges) ? b.edges.length : 0),
+      0
+    ),
+    intent: graphContext.intent ?? null
+  } : graphContext;
+  const outputValidation = validation ?? null;
+  const output = {
+    state: outputState,
+    learnings: outputLearnings,
+    handoff: outputHandoff,
+    graphContext: outputGraphContext,
+    validation: outputValidation,
+    meta: {
+      assembledIn,
+      graphAvailable: graphContext !== null,
+      tokenEstimate: 0,
+      // set below from final serialization
+      errors
+    }
+  };
+  const outputText = JSON.stringify(output);
+  const tokenEstimate = Math.ceil(outputText.length / 4);
+  output.meta.tokenEstimate = tokenEstimate;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(output)
+      }
+    ]
+  };
+}
+
+// src/mcp/tools/assess-project.ts
+var assessProjectDefinition = {
+  name: "assess_project",
+  description: "Run all project health checks in parallel and return a unified report. Checks: validate, dependencies, docs, entropy, security, performance, lint.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      checks: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: ["validate", "deps", "docs", "entropy", "security", "perf", "lint"]
+        },
+        description: "Which checks to run (default: all)"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density. Default: summary"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleAssessProject(input) {
+  const start = Date.now();
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const checksToRun = new Set(
+    input.checks ?? ["validate", "deps", "docs", "entropy", "security", "perf", "lint"]
+  );
+  const mode = input.mode ?? "summary";
+  let validateResult = null;
+  if (checksToRun.has("validate")) {
+    try {
+      const { handleValidateProject: handleValidateProject2 } = await import("./validate-JN44D2Q7.js");
+      const result = await handleValidateProject2({ path: projectPath });
+      const first = result.content[0];
+      const parsed = first ? JSON.parse(first.text) : {};
+      validateResult = {
+        name: "validate",
+        passed: parsed.valid === true,
+        issueCount: parsed.errors?.length ?? 0,
+        ...parsed.errors?.length > 0 ? { topIssue: parsed.errors[0] } : {},
+        ...mode === "detailed" ? { detailed: parsed } : {}
+      };
+    } catch (error) {
+      validateResult = {
+        name: "validate",
+        passed: false,
+        issueCount: 1,
+        topIssue: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  const parallelChecks = [];
+  if (checksToRun.has("deps")) {
+    parallelChecks.push(
+      (async () => {
+        try {
+          const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-EXNUMH5R.js");
+          const result = await handleCheckDependencies2({ path: projectPath });
+          const first = result.content[0];
+          const parsed = first ? JSON.parse(first.text) : {};
+          const violations = parsed.violations ?? [];
+          return {
+            name: "deps",
+            passed: !result.isError && violations.length === 0,
+            issueCount: violations.length,
+            ...violations.length > 0 ? { topIssue: violations[0]?.message ?? String(violations[0]) } : {},
+            ...mode === "detailed" ? { detailed: parsed } : {}
+          };
+        } catch (error) {
+          return {
+            name: "deps",
+            passed: false,
+            issueCount: 1,
+            topIssue: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })()
+    );
+  }
+  if (checksToRun.has("docs")) {
+    parallelChecks.push(
+      (async () => {
+        try {
+          const { handleCheckDocs: handleCheckDocs2 } = await import("./docs-PWCUVYWU.js");
+          const result = await handleCheckDocs2({ path: projectPath, scope: "coverage" });
+          const first = result.content[0];
+          const parsed = first ? JSON.parse(first.text) : {};
+          const undocumented = parsed.undocumented ?? parsed.files?.undocumented ?? [];
+          return {
+            name: "docs",
+            passed: !result.isError,
+            issueCount: Array.isArray(undocumented) ? undocumented.length : 0,
+            ...Array.isArray(undocumented) && undocumented.length > 0 ? { topIssue: `Undocumented: ${undocumented[0]}` } : {},
+            ...mode === "detailed" ? { detailed: parsed } : {}
+          };
+        } catch (error) {
+          return {
+            name: "docs",
+            passed: false,
+            issueCount: 1,
+            topIssue: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })()
+    );
+  }
+  if (checksToRun.has("entropy")) {
+    parallelChecks.push(
+      (async () => {
+        try {
+          const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-4I6JEYAC.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,
+            issueCount: issues,
+            ...issues > 0 ? { topIssue: "Entropy detected -- run detect_entropy for details" } : {},
+            ...mode === "detailed" ? { detailed: parsed } : {}
+          };
+        } catch (error) {
+          return {
+            name: "entropy",
+            passed: false,
+            issueCount: 1,
+            topIssue: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })()
+    );
+  }
+  if (checksToRun.has("security")) {
+    parallelChecks.push(
+      (async () => {
+        try {
+          const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-4P2GGFF6.js");
+          const result = await handleRunSecurityScan2({ path: projectPath });
+          const first = result.content[0];
+          const parsed = first ? JSON.parse(first.text) : {};
+          const findings = parsed.findings ?? [];
+          const errorCount = findings.filter(
+            (f) => f.severity === "error"
+          ).length;
+          return {
+            name: "security",
+            passed: !result.isError && errorCount === 0,
+            issueCount: findings.length,
+            ...findings.length > 0 ? {
+              topIssue: `${findings[0]?.rule ?? findings[0]?.type ?? "finding"}: ${findings[0]?.message ?? ""}`
+            } : {},
+            ...mode === "detailed" ? { detailed: parsed } : {}
+          };
+        } catch (error) {
+          return {
+            name: "security",
+            passed: false,
+            issueCount: 1,
+            topIssue: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })()
+    );
+  }
+  if (checksToRun.has("perf")) {
+    parallelChecks.push(
+      (async () => {
+        try {
+          const { handleCheckPerformance: handleCheckPerformance2 } = await import("./performance-BTOJCPXU.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,
+            issueCount: issues,
+            ...issues > 0 ? { topIssue: "Performance issues detected" } : {},
+            ...mode === "detailed" ? { detailed: parsed } : {}
+          };
+        } catch (error) {
+          return {
+            name: "perf",
+            passed: false,
+            issueCount: 1,
+            topIssue: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })()
+    );
+  }
+  if (checksToRun.has("lint")) {
+    parallelChecks.push(
+      (async () => {
+        try {
+          const { execFileSync } = await import("child_process");
+          const output = execFileSync("npx", ["turbo", "run", "lint", "--force"], {
+            cwd: projectPath,
+            encoding: "utf-8",
+            timeout: 6e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          return {
+            name: "lint",
+            passed: true,
+            issueCount: 0,
+            ...mode === "detailed" ? { detailed: output } : {}
+          };
+        } catch (error) {
+          const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr) : "";
+          const stdout = error && typeof error === "object" && "stdout" in error ? String(error.stdout) : "";
+          const combined = (stderr + "\n" + stdout).trim();
+          const errorMatch = combined.match(/(\d+) error/);
+          const issueCount = errorMatch?.[1] ? parseInt(errorMatch[1], 10) : 1;
+          const firstError = combined.split("\n").find((line) => line.includes("error"));
+          return {
+            name: "lint",
+            passed: false,
+            issueCount,
+            topIssue: firstError?.trim() ?? (error instanceof Error ? error.message : String(error)),
+            ...mode === "detailed" ? { detailed: combined } : {}
+          };
+        }
+      })()
+    );
+  }
+  const parallelResults = await Promise.all(parallelChecks);
+  const allChecks = [];
+  if (validateResult) allChecks.push(validateResult);
+  allChecks.push(...parallelResults);
+  const healthy = allChecks.every((c) => c.passed);
+  const assessedIn = Date.now() - start;
+  if (mode === "summary") {
+    const summaryChecks = allChecks.map(({ detailed: _d, ...rest }) => rest);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ healthy, checks: summaryChecks, assessedIn })
+        }
+      ]
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ healthy, checks: allChecks, assessedIn })
+      }
+    ]
+  };
+}
+
+// src/mcp/tools/review-changes.ts
+var SIZE_GATE_LINES = 1e4;
+var reviewChangesDefinition = {
+  name: "review_changes",
+  description: "Review code changes at configurable depth: quick (diff analysis), standard (+ self-review), deep (full 7-phase pipeline). Auto-downgrades deep to standard for diffs > 10k lines.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      diff: {
+        type: "string",
+        description: "Raw git diff string. If omitted, auto-detects from git."
+      },
+      depth: {
+        type: "string",
+        enum: ["quick", "standard", "deep"],
+        description: "Review depth: quick, standard, or deep"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "Response density. Default: summary"
+      }
+    },
+    required: ["path", "depth"]
+  }
+};
+async function getDiff(projectPath, providedDiff) {
+  if (providedDiff) return providedDiff;
+  const { execFileSync } = await import("child_process");
+  try {
+    const staged = execFileSync("git", ["diff", "--cached"], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    if (staged.trim().length > 0) return staged;
+    const unstaged = execFileSync("git", ["diff"], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    if (unstaged.trim().length > 0) return unstaged;
+    throw new Error("No diff found -- provide a diff string or have uncommitted changes");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("No diff found")) throw error;
+    throw new Error(
+      `Failed to get diff from git: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+async function handleReviewChanges(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  let diff;
+  try {
+    diff = await getDiff(projectPath, input.diff);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const diffLines = diff.split("\n").length;
+  let effectiveDepth = input.depth;
+  let downgraded = false;
+  if (effectiveDepth === "deep" && diffLines > SIZE_GATE_LINES) {
+    effectiveDepth = "standard";
+    downgraded = true;
+  }
+  try {
+    if (effectiveDepth === "quick") {
+      const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-TNIW534S.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-TNIW534S.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-3YTW3463.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
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/task-independence.ts
+var checkTaskIndependenceDefinition = {
+  name: "check_task_independence",
+  description: "Check whether N tasks can safely run in parallel by detecting file overlaps and transitive dependency conflicts. Returns pairwise independence matrix and parallel groupings.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      tasks: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            files: { type: "array", items: { type: "string" } }
+          },
+          required: ["id", "files"]
+        },
+        minItems: 2,
+        description: "Tasks to check. Each task has an id and a list of file paths."
+      },
+      depth: {
+        type: "number",
+        description: "Expansion depth (0=file-only, 1=default, 2-3=thorough)"
+      },
+      edgeTypes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Edge types for graph expansion. Default: imports, calls, references"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "summary omits overlap details. Default: detailed"
+      }
+    },
+    required: ["path", "tasks"]
+  }
+};
+async function handleCheckTaskIndependence(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    const { TaskIndependenceAnalyzer } = await import("./dist-M6BQODWC.js");
+    const analyzer = new TaskIndependenceAnalyzer(store ?? void 0);
+    const result = analyzer.analyze({
+      tasks: input.tasks,
+      ...input.depth !== void 0 && { depth: input.depth },
+      ...input.edgeTypes !== void 0 && { edgeTypes: input.edgeTypes }
+    });
+    if (input.mode === "summary") {
+      const summaryPairs = result.pairs.map((p) => ({
+        taskA: p.taskA,
+        taskB: p.taskB,
+        independent: p.independent
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "summary",
+              verdict: result.verdict,
+              analysisLevel: result.analysisLevel,
+              depth: result.depth,
+              groups: result.groups,
+              pairs: summaryPairs
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/conflict-prediction.ts
+var predictConflictsDefinition = {
+  name: "predict_conflicts",
+  description: "Predict conflict severity for task pairs with automatic parallel group recomputation. Returns severity-classified conflicts, revised groups, and human-readable reasoning.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      tasks: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            files: { type: "array", items: { type: "string" } }
+          },
+          required: ["id", "files"]
+        },
+        minItems: 2,
+        description: "Tasks to check. Each task has an id and a list of file paths."
+      },
+      depth: {
+        type: "number",
+        description: "Expansion depth (0=file-only, 1=default, 2-3=thorough)"
+      },
+      edgeTypes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Edge types for graph expansion. Default: imports, calls, references"
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        description: "summary omits overlap details from conflicts. Default: detailed"
+      }
+    },
+    required: ["path", "tasks"]
+  }
+};
+async function handlePredictConflicts(input) {
+  try {
+    const projectPath = sanitizePath(input.path);
+    const store = await loadGraphStore(projectPath);
+    const { ConflictPredictor } = await import("./dist-M6BQODWC.js");
+    const predictor = new ConflictPredictor(store ?? void 0);
+    const result = predictor.predict({
+      tasks: input.tasks,
+      ...input.depth !== void 0 && { depth: input.depth },
+      ...input.edgeTypes !== void 0 && { edgeTypes: input.edgeTypes }
+    });
+    if (input.mode === "summary") {
+      const summaryConflicts = result.conflicts.map((c) => ({
+        taskA: c.taskA,
+        taskB: c.taskB,
+        severity: c.severity,
+        reason: c.reason,
+        mitigation: c.mitigation
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              mode: "summary",
+              tasks: result.tasks,
+              analysisLevel: result.analysisLevel,
+              depth: result.depth,
+              conflicts: summaryConflicts,
+              groups: result.groups,
+              summary: result.summary,
+              verdict: result.verdict
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/tools/stale-constraints.ts
+var detectStaleConstraintsDefinition = {
+  name: "detect_stale_constraints",
+  description: "Detect architectural constraint rules that have not been violated within a configurable time window. Surfaces stale constraints as candidates for removal or relaxation.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      windowDays: {
+        type: "number",
+        description: "Number of days without violation to consider a constraint stale (default: 30)"
+      },
+      category: {
+        type: "string",
+        description: "Optional filter by constraint category",
+        enum: [
+          "circular-deps",
+          "layer-violations",
+          "complexity",
+          "coupling",
+          "forbidden-imports",
+          "module-size",
+          "dependency-depth"
+        ]
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleDetectStaleConstraints(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const windowDays = input.windowDays ?? 30;
+    if (!Number.isFinite(windowDays) || windowDays < 1) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: windowDays must be a finite number >= 1"
+          }
+        ],
+        isError: true
+      };
+    }
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-KO4GJ5N2.js");
+    const store = await loadGraphStore2(projectPath);
+    if (!store) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                staleConstraints: [],
+                totalConstraints: 0,
+                windowDays,
+                note: "No graph available. Run ingest_source first to populate the knowledge graph."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const { detectStaleConstraints } = await import("./dist-JVZ2MKBC.js");
+    const result = detectStaleConstraints(
+      store,
+      windowDays,
+      input.category
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/server.ts
+var TOOL_DEFINITIONS = [
+  validateToolDefinition,
+  checkDependenciesDefinition,
+  checkDocsDefinition,
+  detectEntropyDefinition,
+  generateLinterDefinition,
+  validateLinterConfigDefinition,
+  initProjectDefinition,
+  listPersonasDefinition,
+  generatePersonaArtifactsDefinition,
+  runPersonaDefinition,
+  addComponentDefinition,
+  runAgentTaskDefinition,
+  runSkillDefinition,
+  manageStateDefinition,
+  createSelfReviewDefinition,
+  analyzeDiffDefinition,
+  requestPeerReviewDefinition,
+  checkPhaseGateDefinition,
+  validateCrossCheckDefinition,
+  createSkillDefinition,
+  generateSlashCommandsDefinition,
+  queryGraphDefinition,
+  searchSimilarDefinition,
+  findContextForDefinition,
+  getRelationshipsDefinition,
+  getImpactDefinition,
+  ingestSourceDefinition,
+  generateAgentDefinitionsDefinition,
+  runSecurityScanDefinition,
+  checkPerformanceDefinition,
+  getPerfBaselinesDefinition,
+  updatePerfBaselinesDefinition,
+  getCriticalPathsDefinition,
+  listStreamsDefinition,
+  manageRoadmapDefinition,
+  emitInteractionDefinition,
+  runCodeReviewDefinition,
+  gatherContextDefinition,
+  assessProjectDefinition,
+  reviewChangesDefinition,
+  detectAnomaliesDefinition,
+  askGraphDefinition,
+  checkTaskIndependenceDefinition,
+  predictConflictsDefinition,
+  detectStaleConstraintsDefinition
+];
+var TOOL_HANDLERS = {
+  validate_project: handleValidateProject,
+  check_dependencies: handleCheckDependencies,
+  check_docs: handleCheckDocs,
+  detect_entropy: handleDetectEntropy,
+  generate_linter: handleGenerateLinter,
+  validate_linter_config: handleValidateLinterConfig,
+  init_project: handleInitProject,
+  list_personas: handleListPersonas,
+  generate_persona_artifacts: handleGeneratePersonaArtifacts,
+  run_persona: handleRunPersona,
+  add_component: handleAddComponent,
+  run_agent_task: handleRunAgentTask,
+  run_skill: handleRunSkill,
+  manage_state: handleManageState,
+  create_self_review: handleCreateSelfReview,
+  analyze_diff: handleAnalyzeDiff,
+  request_peer_review: handleRequestPeerReview,
+  check_phase_gate: handleCheckPhaseGate,
+  validate_cross_check: handleValidateCrossCheck,
+  create_skill: handleCreateSkill,
+  generate_slash_commands: handleGenerateSlashCommands,
+  query_graph: handleQueryGraph,
+  search_similar: handleSearchSimilar,
+  find_context_for: handleFindContextFor,
+  get_relationships: handleGetRelationships,
+  get_impact: handleGetImpact,
+  ingest_source: handleIngestSource,
+  generate_agent_definitions: handleGenerateAgentDefinitions,
+  run_security_scan: handleRunSecurityScan,
+  check_performance: handleCheckPerformance,
+  get_perf_baselines: handleGetPerfBaselines,
+  update_perf_baselines: handleUpdatePerfBaselines,
+  get_critical_paths: handleGetCriticalPaths,
+  list_streams: handleListStreams,
+  manage_roadmap: handleManageRoadmap,
+  emit_interaction: handleEmitInteraction,
+  run_code_review: handleRunCodeReview,
+  gather_context: handleGatherContext,
+  assess_project: handleAssessProject,
+  review_changes: handleReviewChanges,
+  detect_anomalies: handleDetectAnomalies,
+  ask_graph: handleAskGraph,
+  check_task_independence: handleCheckTaskIndependence,
+  predict_conflicts: handlePredictConflicts,
+  detect_stale_constraints: handleDetectStaleConstraints
+};
+var RESOURCE_DEFINITIONS = [
+  {
+    uri: "harness://skills",
+    name: "Harness Skills",
+    description: "Available skills with metadata (name, description, cognitive_mode, type, triggers)",
+    mimeType: "application/json"
+  },
+  {
+    uri: "harness://rules",
+    name: "Harness Rules",
+    description: "Active linter rules and constraints from harness config",
+    mimeType: "application/json"
+  },
+  {
+    uri: "harness://project",
+    name: "Project Context",
+    description: "Project structure and agent instructions from AGENTS.md",
+    mimeType: "text/markdown"
+  },
+  {
+    uri: "harness://learnings",
+    name: "Learnings",
+    description: "Review learnings and anti-pattern log from .harness/",
+    mimeType: "text/markdown"
+  },
+  {
+    uri: "harness://state",
+    name: "Project State",
+    description: "Current harness state including position, progress, decisions, and blockers",
+    mimeType: "application/json"
+  },
+  {
+    uri: "harness://graph",
+    name: "Knowledge Graph",
+    description: "Graph statistics, node/edge counts by type, staleness",
+    mimeType: "application/json"
+  },
+  {
+    uri: "harness://entities",
+    name: "Graph Entities",
+    description: "All entity nodes with types and metadata",
+    mimeType: "application/json"
+  },
+  {
+    uri: "harness://relationships",
+    name: "Graph Relationships",
+    description: "All edges with types, confidence scores, and timestamps",
+    mimeType: "application/json"
+  }
+];
+var RESOURCE_HANDLERS = {
+  "harness://skills": getSkillsResource,
+  "harness://rules": getRulesResource,
+  "harness://project": getProjectResource,
+  "harness://learnings": getLearningsResource,
+  "harness://state": getStateResource,
+  "harness://graph": getGraphResource,
+  "harness://entities": getEntitiesResource,
+  "harness://relationships": getRelationshipsResource
+};
+function getToolDefinitions() {
+  return TOOL_DEFINITIONS;
+}
+function createHarnessServer(projectRoot) {
+  const resolvedRoot = projectRoot ?? process.cwd();
+  let sessionChecked = false;
+  const server = new Server(
+    { name: "harness-engineering", version: "0.1.0" },
+    { capabilities: { tools: {}, resources: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOL_DEFINITIONS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const handler = TOOL_HANDLERS[name];
+    if (!handler) {
+      return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
+    const result = await handler(args ?? {});
+    if (!sessionChecked) {
+      sessionChecked = true;
+      try {
+        const {
+          getUpdateNotification,
+          isUpdateCheckEnabled,
+          shouldRunCheck,
+          readCheckState,
+          spawnBackgroundCheck
+        } = await import("./dist-JVZ2MKBC.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 {
+      }
+    }
+    return result;
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: RESOURCE_DEFINITIONS
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const handler = RESOURCE_HANDLERS[uri];
+    if (!handler) {
+      throw new Error(`Unknown resource: ${uri}`);
+    }
+    const content = await handler(resolvedRoot);
+    const resourceDef = RESOURCE_DEFINITIONS.find((r) => r.uri === uri);
+    const mimeType = resourceDef?.mimeType ?? "text/plain";
+    return {
+      contents: [{ uri, text: content, mimeType }]
+    };
+  });
+  return server;
+}
+async function startServer() {
+  const server = createHarnessServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  generateSlashCommands,
+  handleOrphanDeletion,
+  createGenerateSlashCommandsCommand,
+  handleGetImpact,
+  getToolDefinitions,
+  createHarnessServer,
+  startServer
+};