@harness-engineering/cli 2.4.3 → 2.5.0

package/dist/{chunk-NDS6XSHS.js → chunk-LT244Y6E.js}

@@ -1,12 +1,32 @@
+import {
+  getSecurityTrendsDefinition,
+  handleGetSecurityTrends,
+  handleRunSecurityScan,
+  runSecurityScanDefinition
+} from "./chunk-TCSNO7YW.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition,
   sortFindingsBySeverity
-} from "./chunk-TW4NGPAW.js";
+} from "./chunk-JE5GQVCQ.js";
 import {
   assessProjectDefinition,
   handleAssessProject
-} from "./chunk-IWUKWHXV.js";
+} from "./chunk-65MJPWFN.js";
+import {
+  detectEntropyDefinition,
+  handleDetectEntropy
+} from "./chunk-UF7BKRH4.js";
+import {
+  checkPerformanceDefinition,
+  getCriticalPathsDefinition,
+  getPerfBaselinesDefinition,
+  handleCheckPerformance,
+  handleGetCriticalPaths,
+  handleGetPerfBaselines,
+  handleUpdatePerfBaselines,
+  updatePerfBaselinesDefinition
+} from "./chunk-XSI3RDH6.js";
 import {
   getBusinessKnowledgeResource
 } from "./chunk-IOW3MW2K.js";
@@ -17,45 +37,34 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-O7ZZ3FN4.js";
+} from "./chunk-6SRKI77C.js";
 import {
-  getSecurityTrendsDefinition,
-  handleGetSecurityTrends,
-  handleRunSecurityScan,
-  runSecurityScanDefinition
-} from "./chunk-GDGEFHXV.js";
+  GENERATED_HEADER_CLAUDE,
+  GENERATED_HEADER_CODEX,
+  GENERATED_HEADER_CURSOR,
+  GENERATED_HEADER_GEMINI,
+  VALID_PLATFORMS,
+  applySyncPlan,
+  computeSyncPlan
+} from "./chunk-3ISINLYT.js";
 import {
   loadGraphStore
 } from "./chunk-5FDBXUFW.js";
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-URHLDRYH.js";
+} from "./chunk-NOOPJD5R.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-NDTH6MGG.js";
+} from "./chunk-2RNGLYOG.js";
 import {
   resolveProjectConfig
-} from "./chunk-MTJ2LOXB.js";
+} from "./chunk-7DOGGXQU.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-JAS63FFQ.js";
-import {
-  detectEntropyDefinition,
-  handleDetectEntropy
-} from "./chunk-AP73KZP6.js";
-import {
-  checkPerformanceDefinition,
-  getCriticalPathsDefinition,
-  getPerfBaselinesDefinition,
-  handleCheckPerformance,
-  handleGetCriticalPaths,
-  handleGetPerfBaselines,
-  handleUpdatePerfBaselines,
-  updatePerfBaselinesDefinition
-} from "./chunk-LZXZQQKP.js";
+} from "./chunk-DOUS4ULX.js";
 import {
   resultToMcpResponse
 } from "./chunk-EPUKTTJZ.js";
@@ -65,18 +74,6 @@ import {
 import {
   loadOrRebuildIndex
 } from "./chunk-27AJKSQY.js";
-import {
-  resolveConfig
-} from "./chunk-GNZABDPB.js";
-import {
-  GENERATED_HEADER_CLAUDE,
-  GENERATED_HEADER_CODEX,
-  GENERATED_HEADER_CURSOR,
-  GENERATED_HEADER_GEMINI,
-  VALID_PLATFORMS,
-  applySyncPlan,
-  computeSyncPlan
-} from "./chunk-3ISINLYT.js";
 import {
   resolveCommunitySkillsDir,
   resolveGlobalCommunitySkillsDir,
@@ -86,6 +83,20 @@ import {
   resolveSkillsDir,
   resolveTemplatesDir
 } from "./chunk-6B6UN6SG.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-HIK6OEUF.js";
+import {
+  resolveConfig
+} from "./chunk-HIZXUWWC.js";
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
+import {
+  CLIError,
+  ExitCode,
+  handleError
+} from "./chunk-3WGJMBKH.js";
 import {
   CompactionPipeline,
   ConflictError,
@@ -99,7 +110,7 @@ import {
   detectChangeType,
   estimateTokens,
   extractLevel,
-  init_dist,
+  init_dist as init_dist2,
   loadProjectRoadmapMode,
   loadTrackerClientConfigFromProject,
   loadTrackerSyncConfig,
@@ -107,22 +118,14 @@ import {
   scanForInjection,
   serializeEnvelope,
   writeTaint
-} from "./chunk-5O3PNHUQ.js";
+} from "./chunk-KQ6TDRPS.js";
 import {
   Err,
-  Ok
-} from "./chunk-O63AAPIZ.js";
-import {
-  SkillMetadataSchema
-} from "./chunk-HIK6OEUF.js";
-import {
-  logger
-} from "./chunk-EBJQ6N4M.js";
-import {
-  CLIError,
-  ExitCode,
-  handleError
-} from "./chunk-3WGJMBKH.js";
+  INDEXED_FILE_KINDS,
+  INSIGHTS_KEYS,
+  Ok,
+  init_dist
+} from "./chunk-2LPUIBVH.js";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -316,6 +319,13 @@ events.jsonl
 telemetry.json
 .telemetry-notice-shown
 
+# Phase 3 webhook delivery queue \u2014 SQLite runtime DB (and WAL/SHM sidecars)
+webhook-queue.sqlite
+webhook-queue.sqlite-wal
+webhook-queue.sqlite-shm
+# Maintenance task run history (regenerated each tick)
+maintenance/
+
 # security/: track timeline.json (trend ledger), ignore everything else
 security/*
 !security/timeline.json
@@ -338,7 +348,7 @@ function appendFrameworkAgents(targetDir, framework, language) {
 }
 
 // src/mcp/middleware/injection-guard.ts
-init_dist();
+init_dist2();
 import { realpathSync } from "fs";
 import { resolve } from "path";
 function isDestructiveBash(command) {
@@ -459,7 +469,7 @@ function applyInjectionGuard(handlers, options = {}) {
 }
 
 // src/mcp/middleware/compaction.ts
-init_dist();
+init_dist2();
 var DEFAULT_PIPELINE = new CompactionPipeline([
   new StructuralStrategy(),
   new TruncationStrategy()
@@ -546,6 +556,185 @@ function applyCompaction(handlers) {
   return wrapped;
 }
 
+// src/mcp/tools/search-sessions.ts
+init_dist2();
+init_dist();
+var searchSessionsDefinition = {
+  name: "search_sessions",
+  description: "Full-text search over archived + live session content (Hermes Phase 1, FTS5/BM25).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      query: { type: "string", description: "FTS5 query (bare words AND-joined)" },
+      limit: { type: "number", description: "Max results (default 20)" },
+      archivedOnly: {
+        type: "boolean",
+        description: "Only search archived sessions (skip live)."
+      },
+      fileKinds: {
+        type: "array",
+        items: { type: "string", enum: INDEXED_FILE_KINDS },
+        description: "Subset of file kinds to search."
+      }
+    },
+    required: ["path", "query"]
+  }
+};
+async function handleSearchSessions(input) {
+  try {
+    const pathInput = typeof input.path === "string" ? input.path : "";
+    const projectPath = sanitizePath(pathInput);
+    const query = typeof input.query === "string" ? input.query : "";
+    if (!query || query.trim() === "") {
+      return resultToMcpResponse(Err({ message: "query is required" }));
+    }
+    const limit = typeof input.limit === "number" ? input.limit : void 0;
+    const archivedOnly = input.archivedOnly === true;
+    const fileKinds = Array.isArray(input.fileKinds) ? input.fileKinds.filter(
+      (k) => typeof k === "string" && INDEXED_FILE_KINDS.includes(k)
+    ) : void 0;
+    const orchestrator = await import("@harness-engineering/orchestrator");
+    const idx = orchestrator.openSearchIndex(projectPath);
+    try {
+      const result = idx.search(query, {
+        ...limit !== void 0 && { limit },
+        ...archivedOnly && { archivedOnly },
+        ...fileKinds && fileKinds.length > 0 && { fileKinds }
+      });
+      return resultToMcpResponse(Ok(result));
+    } finally {
+      idx.close();
+    }
+  } catch (e) {
+    return resultToMcpResponse(Err({ message: e instanceof Error ? e.message : String(e) }));
+  }
+}
+
+// src/mcp/tools/summarize-session.ts
+init_dist2();
+import * as fs2 from "fs";
+import * as path2 from "path";
+var summarizeSessionDefinition = {
+  name: "summarize_session",
+  description: "Generate or regenerate the LLM `llm-summary.md` for an archived session (Hermes Phase 1).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      sessionId: {
+        type: "string",
+        description: "Archived session id (basename of the directory inside .harness/archive/sessions/)"
+      },
+      force: {
+        type: "boolean",
+        description: "If true, overwrite an existing llm-summary.md. Default: false (no-op when present)."
+      }
+    },
+    required: ["path", "sessionId"]
+  }
+};
+async function resolveAnthropicProvider() {
+  try {
+    const intelligence = await import("@harness-engineering/intelligence");
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) return null;
+    const Provider = intelligence.AnthropicAnalysisProvider;
+    if (typeof Provider !== "function") return null;
+    return new Provider({ apiKey });
+  } catch {
+    return null;
+  }
+}
+async function handleSummarizeSession(input) {
+  try {
+    const pathInput = typeof input.path === "string" ? input.path : "";
+    const projectPath = sanitizePath(pathInput);
+    const sessionId = typeof input.sessionId === "string" ? input.sessionId : "";
+    if (!sessionId) {
+      return resultToMcpResponse(Err({ message: "sessionId is required" }));
+    }
+    const force = input.force === true;
+    const archiveDir = path2.join(projectPath, ".harness", "archive", "sessions", sessionId);
+    if (!fs2.existsSync(archiveDir)) {
+      return resultToMcpResponse(Err({ message: `archived session not found: ${sessionId}` }));
+    }
+    const llmSummary = path2.join(archiveDir, "llm-summary.md");
+    if (fs2.existsSync(llmSummary) && !force) {
+      return resultToMcpResponse(
+        Ok({
+          sessionId,
+          status: "exists",
+          filePath: llmSummary
+        })
+      );
+    }
+    const provider = await resolveAnthropicProvider();
+    if (!provider) {
+      return resultToMcpResponse(
+        Err({
+          message: "No analysis provider configured. Set ANTHROPIC_API_KEY to enable session summarization."
+        })
+      );
+    }
+    const { summarizeArchivedSession } = await import("@harness-engineering/orchestrator");
+    const result = await summarizeArchivedSession({
+      archiveDir,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      provider
+    });
+    if (!result.ok) {
+      return resultToMcpResponse(Err({ message: result.error.message }));
+    }
+    return resultToMcpResponse(
+      Ok({
+        sessionId,
+        status: "wrote",
+        filePath: result.value.filePath,
+        meta: result.value.meta
+      })
+    );
+  } catch (e) {
+    return resultToMcpResponse(Err({ message: e instanceof Error ? e.message : String(e) }));
+  }
+}
+
+// src/mcp/tools/insights-summary.ts
+init_dist2();
+init_dist();
+var insightsSummaryDefinition = {
+  name: "insights_summary",
+  description: "Composite report combining health, entropy, decay, attention, and impact (Hermes Phase 1).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" },
+      skip: {
+        type: "array",
+        items: { type: "string", enum: INSIGHTS_KEYS },
+        description: "Top-level keys to skip."
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleInsightsSummary(input) {
+  try {
+    const pathInput = typeof input.path === "string" ? input.path : "";
+    const projectPath = sanitizePath(pathInput);
+    const skip = Array.isArray(input.skip) ? input.skip.filter(
+      (k) => typeof k === "string" && INSIGHTS_KEYS.includes(k)
+    ) : void 0;
+    const { composeInsights } = await import("./dist-TKHVYUWZ.js");
+    const report = await composeInsights(projectPath, {
+      ...skip && skip.length > 0 && { skip }
+    });
+    return resultToMcpResponse(Ok(report));
+  } catch (e) {
+    return resultToMcpResponse(Err({ message: e instanceof Error ? e.message : String(e) }));
+  }
+}
+
 // src/mcp/tools/linter.ts
 var generateLinterDefinition = {
   name: "generate_linter",
@@ -615,8 +804,8 @@ async function handleValidateLinterConfig(input) {
 }
 
 // src/mcp/tools/init.ts
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path3 from "path";
+import * as fs3 from "fs";
 var initProjectDefinition = {
   name: "init_project",
   description: "Scaffold a new harness engineering project from a template",
@@ -649,7 +838,7 @@ function findFrameworkLanguage(engine, framework) {
   return templates.value.find((t) => t.framework === framework)?.language;
 }
 function tryDetectFramework(engine, safePath, input) {
-  if (input.framework || input.language || !fs2.existsSync(safePath)) return null;
+  if (input.framework || input.language || !fs3.existsSync(safePath)) return null;
   const result = engine.detectFramework(safePath);
   if (!result.ok || !result.value || result.value.length === 0) return null;
   const candidates = result.value.map((c) => `${c.framework} (${c.language}, score: ${c.score})`).join(", ");
@@ -681,7 +870,7 @@ function scaffoldMcp(engine, safePath, i, language) {
   const resolveResult = engine.resolveTemplate(level, i.framework, language);
   if (!resolveResult.ok) return resultToMcpResponse(resolveResult);
   const renderResult = engine.render(resolveResult.value, {
-    projectName: i.name ?? path2.basename(safePath),
+    projectName: i.name ?? path3.basename(safePath),
     level: level ?? "",
     ...i.framework !== void 0 && { framework: i.framework },
     ...language !== void 0 && { language }
@@ -712,7 +901,7 @@ ${skippedMsg}`
 async function handleInitProject(input) {
   const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-AAJLFT45.js");
+    const { TemplateEngine } = await import("./engine-5BXDQT5T.js");
     const engine = new TemplateEngine(resolveTemplatesDir());
     const safePath = sanitizePath(i.path);
     const detected = tryDetectFramework(engine, safePath, i);
@@ -726,15 +915,15 @@ async function handleInitProject(input) {
 }
 
 // src/mcp/tools/persona.ts
-init_dist();
-import * as path3 from "path";
+init_dist2();
+import * as path4 from "path";
 var listPersonasDefinition = {
   name: "list_personas",
   description: "List available agent personas",
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-TMZCNQWN.js");
+  const { listPersonas } = await import("./loader-6RTEYN5Q.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -758,12 +947,12 @@ async function handleGeneratePersonaArtifacts(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.name)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.name}`)));
   }
-  const { loadPersona } = await import("./loader-TMZCNQWN.js");
-  const { generateRuntime } = await import("./runtime-RITOSII6.js");
-  const { generateAgentsMd } = await import("./agents-md-WN2DOL7N.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-TIFZJZNY.js");
+  const { loadPersona } = await import("./loader-6RTEYN5Q.js");
+  const { generateRuntime } = await import("./runtime-SAZGLILX.js");
+  const { generateAgentsMd } = await import("./agents-md-KAD3L2NO.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-WAG4TOV6.js");
   const personasDir = resolvePersonasDir();
-  const filePath = path3.join(personasDir, `${input.name}.yaml`);
+  const filePath = path4.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona path: ${input.name}`)));
   }
@@ -816,11 +1005,11 @@ async function handleRunPersona(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.persona)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.persona}`)));
   }
-  const { loadPersona } = await import("./loader-TMZCNQWN.js");
+  const { loadPersona } = await import("./loader-6RTEYN5Q.js");
   const { runPersona } = await import("./runner-AAEF2TXY.js");
   const { executeSkill } = await import("./skill-executor-MOCUIAYS.js");
   const personasDir = resolvePersonasDir();
-  const filePath = path3.join(personasDir, `${input.persona}.yaml`);
+  const filePath = path4.join(personasDir, `${input.persona}.yaml`);
   if (!filePath.startsWith(personasDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona path: ${input.persona}`)));
   }
@@ -982,9 +1171,9 @@ async function handleRunAgentTask(input) {
 }
 
 // src/mcp/tools/skill.ts
-init_dist();
-import * as fs4 from "fs";
-import * as path5 from "path";
+init_dist2();
+import * as fs5 from "fs";
+import * as path6 from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/skill/dispatcher.ts
@@ -1171,8 +1360,8 @@ function formatSuggestions(suggestions) {
 }
 
 // src/skill/stack-profile.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var SIGNAL_DOMAIN_MAP = {
   "prisma/schema.prisma": ["database"],
   "drizzle.config.ts": ["database"],
@@ -1231,8 +1420,8 @@ function generateStackProfile(projectRoot) {
   const signals = {};
   const domainSet = /* @__PURE__ */ new Set();
   for (const [pattern, domains] of Object.entries(SIGNAL_DOMAIN_MAP)) {
-    const fullPath = path4.join(projectRoot, pattern);
-    const exists = fs3.existsSync(fullPath);
+    const fullPath = path5.join(projectRoot, pattern);
+    const exists = fs4.existsSync(fullPath);
     signals[pattern] = exists;
     if (exists) {
       for (const domain of domains) domainSet.add(domain);
@@ -1245,23 +1434,23 @@ function generateStackProfile(projectRoot) {
   };
 }
 function loadOrGenerateProfile(projectRoot) {
-  const profilePath = path4.join(projectRoot, ".harness", "stack-profile.json");
-  if (fs3.existsSync(profilePath)) {
+  const profilePath = path5.join(projectRoot, ".harness", "stack-profile.json");
+  if (fs4.existsSync(profilePath)) {
     try {
-      return JSON.parse(fs3.readFileSync(profilePath, "utf-8"));
+      return JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
     } catch {
     }
   }
   const profile = generateStackProfile(projectRoot);
-  fs3.mkdirSync(path4.dirname(profilePath), { recursive: true });
-  fs3.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+  fs4.mkdirSync(path5.dirname(profilePath), { recursive: true });
+  fs4.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
   return profile;
 }
 
 // src/mcp/tools/event-emitter.ts
 async function emitSkillEvent(projectPath, event) {
   try {
-    const { emitEvent } = await import("./dist-RYZFURLL.js");
+    const { emitEvent } = await import("./dist-TKHVYUWZ.js");
     await emitEvent(projectPath, event);
   } catch {
   }
@@ -1296,18 +1485,18 @@ async function handleRunSkill(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.skill)) {
     return resultToMcpResponse(Err(new Error(`Invalid skill name: ${input.skill}`)));
   }
-  const skillDir = path5.join(skillsDir, input.skill);
+  const skillDir = path6.join(skillsDir, input.skill);
   if (!skillDir.startsWith(skillsDir)) {
     return resultToMcpResponse(Err(new Error(`Invalid skill path: ${input.skill}`)));
   }
-  if (!fs4.existsSync(skillDir)) {
+  if (!fs5.existsSync(skillDir)) {
     return resultToMcpResponse(Err(new Error(`Skill not found: ${input.skill}`)));
   }
-  const skillMdPath = path5.join(skillDir, "SKILL.md");
-  if (!fs4.existsSync(skillMdPath)) {
+  const skillMdPath = path6.join(skillDir, "SKILL.md");
+  if (!fs5.existsSync(skillMdPath)) {
     return resultToMcpResponse(Err(new Error(`SKILL.md not found for skill: ${input.skill}`)));
   }
-  let content = fs4.readFileSync(skillMdPath, "utf-8");
+  let content = fs5.readFileSync(skillMdPath, "utf-8");
   const projectRoot = input.path ? sanitizePath(input.path) : process.cwd();
   const configResult = resolveConfig();
   const skillsConfig = configResult.ok ? configResult.value.skills : void 0;
@@ -1334,9 +1523,9 @@ async function handleRunSkill(input) {
   }
   if (input.path) {
     const projectPath = sanitizePath(input.path);
-    const stateFile = path5.join(projectPath, ".harness", "state.json");
-    if (fs4.existsSync(stateFile)) {
-      const stateContent = fs4.readFileSync(stateFile, "utf-8");
+    const stateFile = path6.join(projectPath, ".harness", "state.json");
+    if (fs5.existsSync(stateFile)) {
+      const stateContent = fs5.readFileSync(stateFile, "utf-8");
       content += `
 
 ---
@@ -1347,10 +1536,10 @@ ${stateContent}
 `;
     }
   }
-  const skillYamlPath = path5.join(skillDir, "skill.yaml");
-  if (fs4.existsSync(skillYamlPath)) {
+  const skillYamlPath = path6.join(skillDir, "skill.yaml");
+  if (fs5.existsSync(skillYamlPath)) {
     try {
-      const rawYaml = fs4.readFileSync(skillYamlPath, "utf-8");
+      const rawYaml = fs5.readFileSync(skillYamlPath, "utf-8");
       const skillMeta = parseYaml(rawYaml);
       if (skillMeta.type === "knowledge") {
         const boundary = content.indexOf("\n## Details");
@@ -1433,22 +1622,22 @@ async function handleCreateSkill(input) {
 }
 
 // src/mcp/resources/skills.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import * as yaml from "yaml";
 async function getSkillsResource(projectRoot) {
-  const skillsDir = path6.join(projectRoot, "agents", "skills", "claude-code");
+  const skillsDir = path7.join(projectRoot, "agents", "skills", "claude-code");
   const skills = [];
-  if (!fs5.existsSync(skillsDir)) {
+  if (!fs6.existsSync(skillsDir)) {
     return JSON.stringify(skills, null, 2);
   }
-  const entries = fs5.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillYamlPath = path6.join(skillsDir, entry.name, "skill.yaml");
-    if (!fs5.existsSync(skillYamlPath)) continue;
+    const skillYamlPath = path7.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs6.existsSync(skillYamlPath)) continue;
     try {
-      const content = fs5.readFileSync(skillYamlPath, "utf-8");
+      const content = fs6.readFileSync(skillYamlPath, "utf-8");
       const parsed = yaml.parse(content);
       skills.push({
         name: parsed.name,
@@ -1464,14 +1653,14 @@ async function getSkillsResource(projectRoot) {
 }
 
 // src/mcp/resources/rules.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 async function getRulesResource(projectRoot) {
   const rules = [];
-  const configPath = path7.join(projectRoot, "harness.config.json");
-  if (fs6.existsSync(configPath)) {
+  const configPath = path8.join(projectRoot, "harness.config.json");
+  if (fs7.existsSync(configPath)) {
     try {
-      const config = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
       if (config.layers) {
         rules.push({ type: "layer-enforcement", config: config.layers });
       }
@@ -1484,10 +1673,10 @@ async function getRulesResource(projectRoot) {
     } catch {
     }
   }
-  const linterPath = path7.join(projectRoot, ".harness", "linter.json");
-  if (fs6.existsSync(linterPath)) {
+  const linterPath = path8.join(projectRoot, ".harness", "linter.json");
+  if (fs7.existsSync(linterPath)) {
     try {
-      const linterConfig = JSON.parse(fs6.readFileSync(linterPath, "utf-8"));
+      const linterConfig = JSON.parse(fs7.readFileSync(linterPath, "utf-8"));
       rules.push({ type: "linter", config: linterConfig });
     } catch {
     }
@@ -1496,45 +1685,45 @@ async function getRulesResource(projectRoot) {
 }
 
 // src/mcp/resources/project.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 async function getProjectResource(projectRoot) {
-  const agentsPath = path8.join(projectRoot, "AGENTS.md");
-  if (fs7.existsSync(agentsPath)) {
-    return fs7.readFileSync(agentsPath, "utf-8");
+  const agentsPath = path9.join(projectRoot, "AGENTS.md");
+  if (fs8.existsSync(agentsPath)) {
+    return fs8.readFileSync(agentsPath, "utf-8");
   }
   return "# No AGENTS.md found";
 }
 
 // src/mcp/resources/learnings.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 async function getLearningsResource(projectRoot) {
   const sections = [];
-  const reviewPath = path9.join(projectRoot, ".harness", "review-learnings.md");
-  if (fs8.existsSync(reviewPath)) {
-    sections.push("## Review Learnings\n\n" + fs8.readFileSync(reviewPath, "utf-8"));
+  const reviewPath = path10.join(projectRoot, ".harness", "review-learnings.md");
+  if (fs9.existsSync(reviewPath)) {
+    sections.push("## Review Learnings\n\n" + fs9.readFileSync(reviewPath, "utf-8"));
   }
-  const antiPath = path9.join(projectRoot, ".harness", "anti-patterns.md");
-  if (fs8.existsSync(antiPath)) {
-    sections.push("## Anti-Pattern Log\n\n" + fs8.readFileSync(antiPath, "utf-8"));
+  const antiPath = path10.join(projectRoot, ".harness", "anti-patterns.md");
+  if (fs9.existsSync(antiPath)) {
+    sections.push("## Anti-Pattern Log\n\n" + fs9.readFileSync(antiPath, "utf-8"));
   }
   return sections.length > 0 ? sections.join("\n\n---\n\n") : "No learnings files found.";
 }
 
 // src/mcp/tools/state.ts
-init_dist();
+init_dist2();
 
 // src/mcp/tools/roadmap-auto-sync.ts
-init_dist();
-import * as fs9 from "fs";
-import * as path10 from "path";
+init_dist2();
+import * as fs10 from "fs";
+import * as path11 from "path";
 async function autoSyncRoadmap(projectPath) {
   try {
-    const roadmapFile = path10.join(projectPath, "docs", "roadmap.md");
-    if (!fs9.existsSync(roadmapFile)) return;
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-RYZFURLL.js");
-    const raw = fs9.readFileSync(roadmapFile, "utf-8");
+    const roadmapFile = path11.join(projectPath, "docs", "roadmap.md");
+    if (!fs10.existsSync(roadmapFile)) return;
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-TKHVYUWZ.js");
+    const raw = fs10.readFileSync(roadmapFile, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) return;
     const roadmap = parseResult.value;
@@ -1544,7 +1733,7 @@ async function autoSyncRoadmap(projectPath) {
       return;
     }
     applySyncChanges(roadmap, syncResult.value);
-    fs9.writeFileSync(roadmapFile, serializeRoadmap(roadmap), "utf-8");
+    fs10.writeFileSync(roadmapFile, serializeRoadmap(roadmap), "utf-8");
     await triggerExternalSync(projectPath, roadmapFile);
   } catch {
   }
@@ -1553,8 +1742,8 @@ async function triggerExternalSync(projectPath, roadmapFile) {
   try {
     const trackerConfig = loadTrackerSyncConfig(projectPath);
     if (!trackerConfig) return;
-    const projectEnvPath = path10.join(projectPath, ".env");
-    if (fs9.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+    const projectEnvPath = path11.join(projectPath, ".env");
+    if (fs10.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
       const { config: loadDotenv } = await import("dotenv");
       loadDotenv({ path: projectEnvPath });
     }
@@ -1563,7 +1752,7 @@ async function triggerExternalSync(projectPath, roadmapFile) {
       console.warn("[roadmap-sync] GITHUB_TOKEN not found \u2014 external sync skipped");
       return;
     }
-    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-RYZFURLL.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-TKHVYUWZ.js");
     const adapter = new GitHubIssuesSyncAdapter({
       token,
       config: trackerConfig
@@ -1660,12 +1849,12 @@ var manageStateDefinition = {
   }
 };
 async function handleShow(projectPath, input) {
-  const { loadState } = await import("./dist-RYZFURLL.js");
+  const { loadState } = await import("./dist-TKHVYUWZ.js");
   return resultToMcpResponse(await loadState(projectPath, input.stream, input.session));
 }
 async function handleLearn(projectPath, input) {
   if (!input.learning) return mcpError("Error: learning is required for learn action");
-  const { appendLearning } = await import("./dist-RYZFURLL.js");
+  const { appendLearning } = await import("./dist-TKHVYUWZ.js");
   const result = await appendLearning(
     projectPath,
     input.learning,
@@ -1680,7 +1869,7 @@ async function handleLearn(projectPath, input) {
 async function handleFailure(projectPath, input) {
   if (!input.description) return mcpError("Error: description is required for failure action");
   if (!input.failureType) return mcpError("Error: failureType is required for failure action");
-  const { appendFailure } = await import("./dist-RYZFURLL.js");
+  const { appendFailure } = await import("./dist-TKHVYUWZ.js");
   const result = await appendFailure(
     projectPath,
     input.description,
@@ -1699,19 +1888,19 @@ async function handleFailure(projectPath, input) {
   return resultToMcpResponse(Ok({ recorded: true }));
 }
 async function handleArchive(projectPath, input) {
-  const { archiveFailures } = await import("./dist-RYZFURLL.js");
+  const { archiveFailures } = await import("./dist-TKHVYUWZ.js");
   const result = await archiveFailures(projectPath, input.stream, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ archived: true }));
 }
 async function handleReset(projectPath, input) {
-  const { saveState, DEFAULT_STATE } = await import("./dist-RYZFURLL.js");
+  const { saveState, DEFAULT_STATE } = await import("./dist-TKHVYUWZ.js");
   const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ reset: true }));
 }
 async function handleGate(projectPath, input) {
-  const { runMechanicalGate } = await import("./dist-RYZFURLL.js");
+  const { runMechanicalGate } = await import("./dist-TKHVYUWZ.js");
   const result = await runMechanicalGate(projectPath);
   if (result.ok) {
     await emitSkillEvent(projectPath, {
@@ -1731,7 +1920,7 @@ async function handleGate(projectPath, input) {
 }
 async function handleSaveHandoff(projectPath, input) {
   if (!input.handoff) return mcpError("Error: handoff is required for save-handoff action");
-  const { saveHandoff } = await import("./dist-RYZFURLL.js");
+  const { saveHandoff } = await import("./dist-TKHVYUWZ.js");
   const result = await saveHandoff(
     projectPath,
     input.handoff,
@@ -1753,7 +1942,7 @@ async function handleSaveHandoff(projectPath, input) {
   return resultToMcpResponse(Ok({ saved: true }));
 }
 async function handleLoadHandoff(projectPath, input) {
-  const { loadHandoff } = await import("./dist-RYZFURLL.js");
+  const { loadHandoff } = await import("./dist-TKHVYUWZ.js");
   return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
 }
 async function handleAppendEntry(projectPath, input) {
@@ -1761,7 +1950,7 @@ async function handleAppendEntry(projectPath, input) {
   if (!input.authorSkill) return mcpError("Error: authorSkill is required for append_entry action");
   if (!input.content) return mcpError("Error: content is required for append_entry action");
   if (input.session) {
-    const { appendSessionEntry } = await import("./dist-RYZFURLL.js");
+    const { appendSessionEntry } = await import("./dist-TKHVYUWZ.js");
     const result = await appendSessionEntry(
       projectPath,
       input.session,
@@ -1774,7 +1963,7 @@ async function handleAppendEntry(projectPath, input) {
   if (input.section !== "decisions") {
     return mcpError("Error: session is required for non-decisions sections");
   }
-  const { loadState, saveState } = await import("./dist-RYZFURLL.js");
+  const { loadState, saveState } = await import("./dist-TKHVYUWZ.js");
   const lr = await loadState(projectPath, input.stream);
   if (!lr.ok) return resultToMcpResponse(lr);
   lr.value.decisions.push({
@@ -1792,7 +1981,7 @@ async function handleUpdateEntryStatus(projectPath, input) {
   if (!input.entryId) return mcpError("Error: entryId is required for update_entry_status action");
   if (!input.newStatus)
     return mcpError("Error: newStatus is required for update_entry_status action");
-  const { updateSessionEntryStatus } = await import("./dist-RYZFURLL.js");
+  const { updateSessionEntryStatus } = await import("./dist-TKHVYUWZ.js");
   const result = await updateSessionEntryStatus(
     projectPath,
     input.session,
@@ -1805,7 +1994,7 @@ async function handleUpdateEntryStatus(projectPath, input) {
 async function handleReadSection(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for read_section action");
   if (!input.section) return mcpError("Error: section is required for read_section action");
-  const { readSessionSection } = await import("./dist-RYZFURLL.js");
+  const { readSessionSection } = await import("./dist-TKHVYUWZ.js");
   const result = await readSessionSection(
     projectPath,
     input.session,
@@ -1815,14 +2004,16 @@ async function handleReadSection(projectPath, input) {
 }
 async function handleReadSections(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for read_sections action");
-  const { readSessionSections } = await import("./dist-RYZFURLL.js");
+  const { readSessionSections } = await import("./dist-TKHVYUWZ.js");
   const result = await readSessionSections(projectPath, input.session);
   return resultToMcpResponse(result);
 }
 async function handleArchiveSession(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for archive_session action");
-  const { archiveSession } = await import("./dist-RYZFURLL.js");
-  const result = await archiveSession(projectPath, input.session);
+  const { archiveSession } = await import("./dist-TKHVYUWZ.js");
+  const { buildArchiveHooks } = await import("@harness-engineering/orchestrator");
+  const hooks = buildArchiveHooks({ projectPath });
+  const result = await archiveSession(projectPath, input.session, { hooks });
   if (!result.ok) return resultToMcpResponse(result);
   await autoSyncRoadmap(projectPath);
   return resultToMcpResponse(Ok({ archived: true }));
@@ -1901,7 +2092,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-RYZFURLL.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-TKHVYUWZ.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -1939,7 +2130,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-JX522QQH.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-PD5MVEZT.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -1959,7 +2150,7 @@ async function handleCheckPhaseGate(input) {
 }
 
 // src/mcp/tools/cross-check.ts
-import * as path11 from "path";
+import * as path12 from "path";
 var validateCrossCheckDefinition = {
   name: "validate_cross_check",
   description: "Validate plan-to-implementation coverage: checks that specs have plans and plans have implementations, detects staleness",
@@ -1995,15 +2186,15 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-3QIA7O4F.js");
-    const specsDir = path11.resolve(projectPath, input.specsDir ?? "docs/specs");
+    const { runCrossCheck } = await import("./validate-cross-check-7PO7CBVT.js");
+    const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: specsDir escapes project root" }],
         isError: true
       };
     }
-    const plansDir = path11.resolve(projectPath, input.plansDir ?? "docs/plans");
+    const plansDir = path12.resolve(projectPath, input.plansDir ?? "docs/plans");
     if (!plansDir.startsWith(projectPath)) {
       return {
         content: [{ type: "text", text: "Error: plansDir escapes project root" }],
@@ -2033,18 +2224,18 @@ async function handleValidateCrossCheck(input) {
 }
 
 // src/mcp/tools/generate-slash-commands.ts
-init_dist();
+init_dist2();
 
 // src/commands/generate-slash-commands.ts
 import { Command } from "commander";
-import fs12 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path15 from "path";
 import os from "os";
 import readline from "readline";
 
 // src/slash-commands/normalize.ts
-import fs10 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
@@ -2064,7 +2255,7 @@ function normalizeName(skillName) {
 function readSkillYaml(yamlPath) {
   let raw;
   try {
-    raw = fs10.readFileSync(yamlPath, "utf-8");
+    raw = fs11.readFileSync(yamlPath, "utf-8");
   } catch {
     return null;
   }
@@ -2128,10 +2319,10 @@ function buildProcessLines(meta) {
   ];
 }
 function buildSpec(meta, normalized, entry, skillsDir, source) {
-  const skillMdPath = path12.join(skillsDir, entry.name, "SKILL.md");
-  const skillMdContent = fs10.existsSync(skillMdPath) ? fs10.readFileSync(skillMdPath, "utf-8") : "";
-  const skillMdRelative = path12.relative(process.cwd(), skillMdPath).replaceAll("\\", "/");
-  const skillYamlRelative = path12.relative(process.cwd(), path12.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
+  const skillMdPath = path13.join(skillsDir, entry.name, "SKILL.md");
+  const skillMdContent = fs11.existsSync(skillMdPath) ? fs11.readFileSync(skillMdPath, "utf-8") : "";
+  const skillMdRelative = path13.relative(process.cwd(), skillMdPath).replaceAll("\\", "/");
+  const skillYamlRelative = path13.relative(process.cwd(), path13.join(skillsDir, entry.name, "skill.yaml")).replaceAll("\\", "/");
   const args = (meta.cli?.args ?? []).map((a) => ({
     name: a.name,
     description: a.description ?? "",
@@ -2186,11 +2377,11 @@ function normalizeSkills(skillSources, platforms) {
   const specs = [];
   const nameMap = /* @__PURE__ */ new Map();
   for (const { dir: skillsDir, source } of skillSources) {
-    if (!fs10.existsSync(skillsDir)) continue;
-    const entries = fs10.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    if (!fs11.existsSync(skillsDir)) continue;
+    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const entry of entries) {
-      const yamlPath = path12.join(skillsDir, entry.name, "skill.yaml");
-      if (!fs10.existsSync(yamlPath)) continue;
+      const yamlPath = path13.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs11.existsSync(yamlPath)) continue;
       const result = readSkillYaml(yamlPath);
       if (!result) continue;
       if (!result.success) {
@@ -2390,27 +2581,27 @@ function renderCodexAgentsMd(specs) {
 }
 
 // src/slash-commands/sync-codex.ts
-import fs11 from "fs";
-import path13 from "path";
+import fs12 from "fs";
+import path14 from "path";
 function computeCodexSync(outputDir, specs, dryRun) {
   const added = [];
   const updated = [];
   const unchanged = [];
   const specSkillNames = /* @__PURE__ */ new Set();
   for (const spec of specs) {
-    const mdPath = path13.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-    const skillMd = fs11.existsSync(mdPath) ? fs11.readFileSync(mdPath, "utf-8") : "";
-    const skillDir = path13.join(outputDir, spec.skillYamlName);
+    const mdPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+    const skillMd = fs12.existsSync(mdPath) ? fs12.readFileSync(mdPath, "utf-8") : "";
+    const skillDir = path14.join(outputDir, spec.skillYamlName);
     specSkillNames.add(spec.skillYamlName);
     const renderedSkillMd = renderCodexSkill(skillMd);
     const renderedOpenaiYaml = renderCodexOpenaiYaml(spec);
-    const existingSkillMdPath = path13.join(skillDir, "SKILL.md");
-    const existingOpenaiYamlPath = path13.join(skillDir, "agents", "openai.yaml");
-    if (!fs11.existsSync(skillDir)) {
+    const existingSkillMdPath = path14.join(skillDir, "SKILL.md");
+    const existingOpenaiYamlPath = path14.join(skillDir, "agents", "openai.yaml");
+    if (!fs12.existsSync(skillDir)) {
       added.push(spec.skillYamlName);
     } else {
-      const existingSkillMd = fs11.existsSync(existingSkillMdPath) ? fs11.readFileSync(existingSkillMdPath, "utf-8") : "";
-      const existingOpenaiYaml = fs11.existsSync(existingOpenaiYamlPath) ? fs11.readFileSync(existingOpenaiYamlPath, "utf-8") : "";
+      const existingSkillMd = fs12.existsSync(existingSkillMdPath) ? fs12.readFileSync(existingSkillMdPath, "utf-8") : "";
+      const existingOpenaiYaml = fs12.existsSync(existingOpenaiYamlPath) ? fs12.readFileSync(existingOpenaiYamlPath, "utf-8") : "";
       if (existingSkillMd === renderedSkillMd && existingOpenaiYaml === renderedOpenaiYaml) {
         unchanged.push(spec.skillYamlName);
       } else {
@@ -2418,10 +2609,10 @@ function computeCodexSync(outputDir, specs, dryRun) {
       }
     }
     if (!dryRun && !unchanged.includes(spec.skillYamlName)) {
-      const agentsSubDir = path13.join(skillDir, "agents");
-      fs11.mkdirSync(agentsSubDir, { recursive: true });
-      fs11.writeFileSync(existingSkillMdPath, renderedSkillMd, "utf-8");
-      fs11.writeFileSync(existingOpenaiYamlPath, renderedOpenaiYaml, "utf-8");
+      const agentsSubDir = path14.join(skillDir, "agents");
+      fs12.mkdirSync(agentsSubDir, { recursive: true });
+      fs12.writeFileSync(existingSkillMdPath, renderedSkillMd, "utf-8");
+      fs12.writeFileSync(existingOpenaiYamlPath, renderedOpenaiYaml, "utf-8");
     }
   }
   const removed = detectCodexOrphans(outputDir, specSkillNames);
@@ -2429,13 +2620,13 @@ function computeCodexSync(outputDir, specs, dryRun) {
 }
 function detectCodexOrphans(outputDir, specSkillNames) {
   const removed = [];
-  if (!fs11.existsSync(outputDir)) return removed;
-  const existingDirs = fs11.readdirSync(outputDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs12.existsSync(outputDir)) return removed;
+  const existingDirs = fs12.readdirSync(outputDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   for (const dirName of existingDirs) {
     if (specSkillNames.has(dirName)) continue;
-    const skillMdPath = path13.join(outputDir, dirName, "SKILL.md");
-    if (fs11.existsSync(skillMdPath)) {
-      const content = fs11.readFileSync(skillMdPath, "utf-8");
+    const skillMdPath = path14.join(outputDir, dirName, "SKILL.md");
+    if (fs12.existsSync(skillMdPath)) {
+      const content = fs12.readFileSync(skillMdPath, "utf-8");
       if (content.includes(GENERATED_HEADER_CODEX)) {
         removed.push(dirName);
       }
@@ -2447,19 +2638,19 @@ function detectCodexOrphans(outputDir, specSkillNames) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path14.join(opts.output, "harness");
+    return path15.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os.homedir();
-    if (platform === "claude-code") return path14.join(home, ".claude", "commands", "harness");
-    if (platform === "gemini-cli") return path14.join(home, ".gemini", "commands", "harness");
-    if (platform === "cursor") return path14.join(home, ".cursor", "rules", "harness");
-    return path14.join(home, ".codex", "harness");
+    if (platform === "claude-code") return path15.join(home, ".claude", "commands", "harness");
+    if (platform === "gemini-cli") return path15.join(home, ".gemini", "commands", "harness");
+    if (platform === "cursor") return path15.join(home, ".cursor", "rules", "harness");
+    return path15.join(home, ".codex", "harness");
   }
-  if (platform === "claude-code") return path14.join("agents", "commands", "claude-code", "harness");
-  if (platform === "gemini-cli") return path14.join("agents", "commands", "gemini-cli", "harness");
-  if (platform === "cursor") return path14.join("agents", "commands", "cursor", "harness");
-  return path14.join("agents", "commands", "codex", "harness");
+  if (platform === "claude-code") return path15.join("agents", "commands", "claude-code", "harness");
+  if (platform === "gemini-cli") return path15.join("agents", "commands", "gemini-cli", "harness");
+  if (platform === "cursor") return path15.join("agents", "commands", "cursor", "harness");
+  return path15.join("agents", "commands", "codex", "harness");
 }
 async function confirmDeletion(files) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -2475,8 +2666,8 @@ function resolveSkillSources(opts) {
   const sources = [];
   const seenPaths = /* @__PURE__ */ new Set();
   function addSource(dir, source) {
-    const resolved = path14.resolve(dir);
-    if (!seenPaths.has(resolved) && fs12.existsSync(dir)) {
+    const resolved = path15.resolve(dir);
+    if (!seenPaths.has(resolved) && fs13.existsSync(dir)) {
       seenPaths.add(resolved);
       sources.push({ dir, source });
     }
@@ -2503,7 +2694,7 @@ function resolveAbsoluteExecutionContext(spec) {
     ...spec,
     prompt: {
       ...spec.prompt,
-      executionContext: spec.prompt.executionContext.split("\n").map((line) => line.startsWith("@") ? `@${path14.resolve(line.slice(1))}` : line).join("\n")
+      executionContext: spec.prompt.executionContext.split("\n").map((line) => line.startsWith("@") ? `@${path15.resolve(line.slice(1))}` : line).join("\n")
     }
   };
 }
@@ -2512,26 +2703,26 @@ function renderSpec(platform, spec, useAbsolutePaths, cursorMode = "rules") {
     if (cursorMode === "commands") {
       return [`${spec.name}.md`, renderCursorCommand(spec)];
     }
-    const mdPath2 = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-    const skillMd = fs12.existsSync(mdPath2) ? fs12.readFileSync(mdPath2, "utf-8") : "";
+    const mdPath2 = path15.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+    const skillMd = fs13.existsSync(mdPath2) ? fs13.readFileSync(mdPath2, "utf-8") : "";
     return [`${spec.skillYamlName}.mdc`, renderCursor(spec, skillMd, spec.cursor)];
   }
   if (platform === "claude-code") {
     const renderSpecValue = useAbsolutePaths ? resolveAbsoluteExecutionContext(spec) : spec;
     return [`${spec.name}.md`, renderClaudeCode(renderSpecValue)];
   }
-  const mdPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-  const yamlPath = path14.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
-  const mdContent = fs12.existsSync(mdPath) ? fs12.readFileSync(mdPath, "utf-8") : "";
-  const yamlContent = fs12.existsSync(yamlPath) ? fs12.readFileSync(yamlPath, "utf-8") : "";
+  const mdPath = path15.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+  const yamlPath = path15.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+  const mdContent = fs13.existsSync(mdPath) ? fs13.readFileSync(mdPath, "utf-8") : "";
+  const yamlContent = fs13.existsSync(yamlPath) ? fs13.readFileSync(yamlPath, "utf-8") : "";
   return [`${spec.name}.toml`, renderGemini(spec, mdContent, yamlContent)];
 }
 function generateForCodex(platform, outputDir, specs, dryRun) {
   const codexSync = computeCodexSync(outputDir, specs, dryRun);
-  const codexRoot = path14.dirname(outputDir);
+  const codexRoot = path15.dirname(outputDir);
   if (!dryRun) {
-    fs12.mkdirSync(codexRoot, { recursive: true });
-    fs12.writeFileSync(path14.join(codexRoot, "AGENTS.md"), renderCodexAgentsMd(specs), "utf-8");
+    fs13.mkdirSync(codexRoot, { recursive: true });
+    fs13.writeFileSync(path15.join(codexRoot, "AGENTS.md"), renderCodexAgentsMd(specs), "utf-8");
   }
   return { platform, ...codexSync, outputDir };
 }
@@ -2562,9 +2753,9 @@ function generateForPlatform(platform, outputDir, specs, opts) {
   const allUpdated = [...plan.updated];
   const allRemoved = [...plan.removed];
   const allUnchanged = [...plan.unchanged];
-  const parentDir = path14.dirname(outputDir);
+  const parentDir = path15.dirname(outputDir);
   for (const [ns, nsRendered] of customNamespaceRendered) {
-    const nsDir = path14.join(parentDir, ns);
+    const nsDir = path15.join(parentDir, ns);
     const nsPlan = computeSyncPlan(nsDir, nsRendered);
     if (!opts.dryRun) {
       applySyncPlan(nsDir, nsRendered, nsPlan, false);
@@ -2614,13 +2805,13 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (!shouldDelete) continue;
     for (const filename of result.removed) {
-      const filePath = path14.join(result.outputDir, filename);
-      if (!fs12.existsSync(filePath)) continue;
-      const stat = fs12.statSync(filePath);
+      const filePath = path15.join(result.outputDir, filename);
+      if (!fs13.existsSync(filePath)) continue;
+      const stat = fs13.statSync(filePath);
       if (stat.isDirectory()) {
-        fs12.rmSync(filePath, { recursive: true, force: true });
+        fs13.rmSync(filePath, { recursive: true, force: true });
       } else {
-        fs12.unlinkSync(filePath);
+        fs13.unlinkSync(filePath);
       }
     }
   }
@@ -2762,7 +2953,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-RYZFURLL.js");
+    const { loadState, migrateToStreams } = await import("./dist-TKHVYUWZ.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -2787,7 +2978,7 @@ async function getStateResource(projectRoot) {
 }
 
 // src/mcp/tools/graph/query-graph.ts
-init_dist();
+init_dist2();
 
 // src/mcp/tools/graph/shared.ts
 function graphNotFoundError() {
@@ -3085,7 +3276,7 @@ async function handleFindContextFor(input) {
 }
 
 // src/mcp/tools/graph/get-relationships.ts
-init_dist();
+init_dist2();
 var getRelationshipsDefinition = {
   name: "get_relationships",
   description: "Get relationships for a specific node in the knowledge graph, with configurable direction and depth.",
@@ -3351,7 +3542,7 @@ async function handleGetImpact(input) {
 }
 
 // src/mcp/tools/graph/ingest-source.ts
-import * as path15 from "path";
+import * as path16 from "path";
 var ingestSourceDefinition = {
   name: "ingest_source",
   description: "Ingest sources into the project knowledge graph. Supports code analysis, knowledge documents, git history, or all at once.",
@@ -3371,10 +3562,10 @@ var ingestSourceDefinition = {
 async function handleIngestSource(input) {
   try {
     const projectPath = sanitizePath(input.path);
-    const graphDir = path15.join(projectPath, ".harness", "graph");
+    const graphDir = path16.join(projectPath, ".harness", "graph");
     const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-QPWXPCPL.js");
-    const fs17 = await import("fs/promises");
-    await fs17.mkdir(graphDir, { recursive: true });
+    const fs18 = await import("fs/promises");
+    await fs18.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -3397,7 +3588,7 @@ async function handleIngestSource(input) {
     }
     if (input.source === "business-signals" || input.source === "all") {
       const { createExtractionRunner } = await import("./dist-QPWXPCPL.js");
-      const extractedDir = path15.join(projectPath, ".harness", "knowledge", "extracted");
+      const extractedDir = path16.join(projectPath, ".harness", "knowledge", "extracted");
       const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
       results.push(signalsResult);
     }
@@ -3437,7 +3628,7 @@ async function handleIngestSource(input) {
 }
 
 // src/mcp/tools/graph/detect-anomalies.ts
-init_dist();
+init_dist2();
 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",
@@ -3668,8 +3859,8 @@ async function handleComputeBlastRadius(input) {
 }
 
 // src/mcp/resources/graph.ts
-import * as fs13 from "fs/promises";
-import * as path16 from "path";
+import * as fs14 from "fs/promises";
+import * as path17 from "path";
 var MAX_ITEMS = 5e3;
 function formatStaleness(isoTimestamp) {
   const then = new Date(isoTimestamp).getTime();
@@ -3692,9 +3883,9 @@ function countByType(items) {
   return counts;
 }
 async function readLastScanTimestamp(projectRoot) {
-  const metadataPath = path16.join(projectRoot, ".harness", "graph", "metadata.json");
+  const metadataPath = path17.join(projectRoot, ".harness", "graph", "metadata.json");
   try {
-    const raw = JSON.parse(await fs13.readFile(metadataPath, "utf-8"));
+    const raw = JSON.parse(await fs14.readFile(metadataPath, "utf-8"));
     return raw.lastScanTimestamp ?? null;
   } catch {
     return null;
@@ -3764,7 +3955,7 @@ async function getRelationshipsResource(projectRoot) {
 }
 
 // src/mcp/tools/agent-definitions.ts
-init_dist();
+init_dist2();
 var generateAgentDefinitionsDefinition = {
   name: "generate_agent_definitions",
   description: "Generate agent definition files from personas for Claude Code and Gemini CLI",
@@ -3782,7 +3973,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-6UTHCELR.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-5PV4O3BD.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -3793,12 +3984,12 @@ async function handleGenerateAgentDefinitions(input) {
 }
 
 // src/mcp/tools/roadmap.ts
-init_dist();
-import * as fs14 from "fs";
-import * as path17 from "path";
+init_dist2();
+import * as fs15 from "fs";
+import * as path18 from "path";
 
 // src/mcp/tools/roadmap-file-less.ts
-init_dist();
+init_dist2();
 var ok = (text) => ({ content: [{ type: "text", text }] });
 var err = (text) => ({ content: [{ type: "text", text }], isError: true });
 async function handleManageRoadmapFileLess(input, client) {
@@ -3996,21 +4187,21 @@ var manageRoadmapDefinition = {
   }
 };
 function roadmapPath(projectRoot) {
-  return path17.join(projectRoot, "docs", "roadmap.md");
+  return path18.join(projectRoot, "docs", "roadmap.md");
 }
 function readRoadmapFile(projectRoot) {
   const filePath = roadmapPath(projectRoot);
   try {
-    return fs14.readFileSync(filePath, "utf-8");
+    return fs15.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writeRoadmapFile(projectRoot, content) {
   const filePath = roadmapPath(projectRoot);
-  const dir = path17.dirname(filePath);
-  fs14.mkdirSync(dir, { recursive: true });
-  fs14.writeFileSync(filePath, content, "utf-8");
+  const dir = path18.dirname(filePath);
+  fs15.mkdirSync(dir, { recursive: true });
+  fs15.writeFileSync(filePath, content, "utf-8");
 }
 function roadmapNotFoundError() {
   return {
@@ -4276,8 +4467,8 @@ async function handleManageRoadmap(input) {
     return handleManageRoadmapFileLess(input, clientResult.value);
   }
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-RYZFURLL.js");
-    const { Ok: Ok2 } = await import("./dist-O733ZU6I.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-TKHVYUWZ.js");
+    const { Ok: Ok2 } = await import("./dist-HVJUGPSY.js");
     const projectPath = projectPathPre;
     const deps = {
       parseRoadmap,
@@ -4715,7 +4906,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-RYZFURLL.js");
+    const { saveHandoff } = await import("./dist-TKHVYUWZ.js");
     await saveHandoff(
       projectPath,
       {
@@ -4796,7 +4987,7 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-RYZFURLL.js");
+    const { loadState, saveState } = await import("./dist-TKHVYUWZ.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -4812,7 +5003,7 @@ async function recordInteraction(projectPath, id, type, decision, stream) {
 }
 
 // src/mcp/tools/gather-context.ts
-init_dist();
+init_dist2();
 function flattenSessionSections(sections) {
   if (!sections) return [];
   return Object.entries(sections).flatMap(
@@ -4957,10 +5148,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation", "businessKnowledge"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-RYZFURLL.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-TKHVYUWZ.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-RYZFURLL.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-TKHVYUWZ.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -4969,7 +5160,7 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-RYZFURLL.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-TKHVYUWZ.js").then(
     (core) => core.loadHandoff(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
   const graphPromise = includeSet.has("graph") ? (async () => {
@@ -5013,11 +5204,11 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-RYZFURLL.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-TKHVYUWZ.js").then(
     (core) => core.readSessionSections(projectPath, input.session)
   ) : Promise.resolve(null);
   const shouldIncludeEvents = input.includeEvents !== void 0 ? input.includeEvents : includeSet.has("events") || !!input.session && !input.include;
-  const eventsPromise = shouldIncludeEvents ? import("./dist-RYZFURLL.js").then(async (core) => {
+  const eventsPromise = shouldIncludeEvents ? import("./dist-TKHVYUWZ.js").then(async (core) => {
     const result = await core.loadEvents(projectPath, {
       session: input.session
     });
@@ -5025,7 +5216,7 @@ async function handleGatherContext(input) {
     return core.formatEventTimeline(result.value);
   }) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-QWQMHJFD.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-AFJVI4OX.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -5128,7 +5319,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-RYZFURLL.js");
+      const core = await import("./dist-TKHVYUWZ.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -5168,7 +5359,7 @@ async function handleGatherContext(input) {
 }
 
 // src/mcp/tools/review-changes.ts
-init_dist();
+init_dist2();
 var SIZE_GATE_LINES = 1e4;
 var reviewChangesDefinition = {
   name: "review_changes",
@@ -5280,7 +5471,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-BAVIWDHH.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-ER2HRTFD.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -5315,7 +5506,7 @@ function extractFileCount(diffParsed) {
   return files?.length ?? 0;
 }
 async function runStandardReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-BAVIWDHH.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-ER2HRTFD.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -5350,7 +5541,7 @@ async function runStandardReview(projectPath, diff, diffLines, downgraded, offse
   };
 }
 async function runDeepReview(projectPath, diff, diffLines, _downgraded, offset, limit) {
-  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-QB3AND3K.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-4VF73V4V.js");
   const result = await handleRunCodeReview2({
     path: projectPath,
     diff,
@@ -5644,7 +5835,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-RYZFURLL.js");
+    const { detectStaleConstraints } = await import("./dist-TKHVYUWZ.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -5672,12 +5863,12 @@ async function handleDetectStaleConstraints(input) {
 }
 
 // src/mcp/tools/search-skills.ts
-init_dist();
+init_dist2();
 
 // src/skill/health-snapshot.ts
 import { execSync } from "child_process";
-import * as fs15 from "fs";
-import * as path18 from "path";
+import * as fs16 from "fs";
+import * as path19 from "path";
 var CACHE_FILE = "health-snapshot.json";
 var STALENESS_MS = 36e5;
 function isSnapshotFresh(snapshot, projectPath) {
@@ -5694,19 +5885,19 @@ function isSnapshotFresh(snapshot, projectPath) {
   return age < STALENESS_MS;
 }
 function loadCachedSnapshot(projectPath) {
-  const filePath = path18.join(projectPath, ".harness", CACHE_FILE);
+  const filePath = path19.join(projectPath, ".harness", CACHE_FILE);
   try {
-    const raw = fs15.readFileSync(filePath, "utf-8");
+    const raw = fs16.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function saveCachedSnapshot(snapshot, projectPath) {
-  const dir = path18.join(projectPath, ".harness");
-  fs15.mkdirSync(dir, { recursive: true });
-  const filePath = path18.join(dir, CACHE_FILE);
-  fs15.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
+  const dir = path19.join(projectPath, ".harness");
+  fs16.mkdirSync(dir, { recursive: true });
+  const filePath = path19.join(dir, CACHE_FILE);
+  fs16.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
 }
 var SIGNAL_RULES = [
   ["circular-deps", (c) => c.deps.circularDeps > 0],
@@ -5764,10 +5955,10 @@ function countCriticalFindings(securityData) {
   return findings.filter((f) => f.severity === "error").length;
 }
 async function runHealthChecks(projectPath) {
-  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-SIG4QAZA.js");
-  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-TUJ2FWM7.js");
-  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-TNA7IRJY.js");
-  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-UISVYDES.js");
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-ZGMRPTS3.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-OC7TFCFF.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-7FIUFACI.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-ZWRABJNE.js");
   const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
     handleAssessProject2({
       path: projectPath,
@@ -5956,7 +6147,7 @@ async function handleSearchSkills(input) {
 }
 
 // src/skill/dispatch-engine.ts
-init_dist();
+init_dist2();
 import { execSync as execSync2 } from "child_process";
 
 // src/skill/recommendation-rules.ts
@@ -6551,7 +6742,7 @@ async function handleDispatchSkills(input) {
 }
 
 // src/mcp/tools/decay-trends.ts
-init_dist();
+init_dist2();
 var getDecayTrendsDefinition = {
   name: "get_decay_trends",
   description: 'Get architecture decay trends over time. Returns stability score history and per-category trend analysis from timeline snapshots. Use to answer questions like "is the architecture decaying?" or "which metrics are getting worse?"',
@@ -6608,7 +6799,7 @@ async function handleGetDecayTrends(input) {
     };
   }
   try {
-    const core = await import("./dist-RYZFURLL.js");
+    const core = await import("./dist-TKHVYUWZ.js");
     const { TimelineManager } = core;
     const manager = new TimelineManager(projectPath);
     const timeline = manager.load();
@@ -6743,7 +6934,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-RYZFURLL.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-TKHVYUWZ.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -6762,7 +6953,7 @@ async function handleCodeOutline(input) {
         })
       );
       fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      const { paginate: paginate2 } = await import("./dist-RYZFURLL.js");
+      const { paginate: paginate2 } = await import("./dist-TKHVYUWZ.js");
       const paged = paginate2(fileStats, input.offset ?? 0, input.limit ?? 30);
       const results = [];
       for (const entry of paged.items) {
@@ -6835,7 +7026,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-RYZFURLL.js");
+    const { searchSymbols } = await import("./dist-TKHVYUWZ.js");
     const result = await searchSymbols(input.query, directory, input.glob);
     const lines = [`Search: "${result.query}" \u2014 ${result.matches.length} matches`];
     for (const match of result.matches) {
@@ -6904,7 +7095,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-RYZFURLL.js");
+      const { unfoldSymbol } = await import("./dist-TKHVYUWZ.js");
       const result = await unfoldSymbol(filePath, input.symbol);
       const header = result.warning ? `${result.file}:${result.startLine}-${result.endLine} ${result.warning}
 ` : `${result.file}:${result.startLine}-${result.endLine}
@@ -6912,7 +7103,7 @@ async function handleCodeUnfold(input) {
       return { content: [{ type: "text", text: header + result.content }] };
     }
     if (input.startLine != null && input.endLine != null) {
-      const { unfoldRange } = await import("./dist-RYZFURLL.js");
+      const { unfoldRange } = await import("./dist-TKHVYUWZ.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -7097,7 +7288,7 @@ async function handlePredictFailures(input) {
     };
   }
   try {
-    const core = await import("./dist-RYZFURLL.js");
+    const core = await import("./dist-TKHVYUWZ.js");
     const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
     const manager = new TimelineManager(projectPath);
     const includeRoadmap = input.includeRoadmap !== false;
@@ -7200,12 +7391,12 @@ async function handleRecommendSkills(input) {
 }
 
 // src/mcp/tools/advise-skills.ts
-import path20 from "path";
+import path21 from "path";
 
 // src/commands/advise-skills.ts
 import { Command as Command2 } from "commander";
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 import chalk from "chalk";
 
 // src/skill/content-matcher-types.ts
@@ -7724,10 +7915,10 @@ function renderTable(matches) {
 
 // src/commands/advise-skills.ts
 function readPackageDeps(cwd) {
-  const pkgPath = path19.join(cwd, "package.json");
-  if (!fs16.existsSync(pkgPath)) return { deps: {}, devDeps: {} };
+  const pkgPath = path20.join(cwd, "package.json");
+  if (!fs17.existsSync(pkgPath)) return { deps: {}, devDeps: {} };
   try {
-    const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
     const deps = typeof pkg.dependencies === "object" && pkg.dependencies !== null ? pkg.dependencies : {};
     const devDeps = typeof pkg.devDependencies === "object" && pkg.devDependencies !== null ? pkg.devDependencies : {};
     return { deps, devDeps };
@@ -7736,10 +7927,10 @@ function readPackageDeps(cwd) {
   }
 }
 function readSpecText(specPath) {
-  if (!fs16.existsSync(specPath)) {
+  if (!fs17.existsSync(specPath)) {
     throw new Error(`Spec not found: ${specPath}`);
   }
-  return fs16.readFileSync(specPath, "utf-8");
+  return fs17.readFileSync(specPath, "utf-8");
 }
 function filterMatchesByTier(result, top, thorough) {
   const applySkills = result.matches.filter((m) => m.tier === "apply").slice(0, top);
@@ -7749,11 +7940,11 @@ function filterMatchesByTier(result, top, thorough) {
 }
 function extractFeatureName(specText, specPath) {
   const titleMatch = specText.match(/^#\s+(.+)/m);
-  return titleMatch?.[1] ?? path19.basename(path19.dirname(specPath));
+  return titleMatch?.[1] ?? path20.basename(path20.dirname(specPath));
 }
 async function runAdviseSkills(options) {
   const cwd = options.cwd ?? process.cwd();
-  const specPath = path19.resolve(cwd, options.specPath);
+  const specPath = path20.resolve(cwd, options.specPath);
   const specText = readSpecText(specPath);
   const { deps, devDeps } = readPackageDeps(cwd);
   const signals = extractSignals(specText, deps, devDeps);
@@ -7764,9 +7955,9 @@ async function runAdviseSkills(options) {
   const result = matchContent(index, signals);
   const filteredResult = filterMatchesByTier(result, options.top ?? 5, !!options.thorough);
   const featureName = extractFeatureName(specText, specPath);
-  const skillsMdPath = path19.join(path19.dirname(specPath), "SKILLS.md");
+  const skillsMdPath = path20.join(path20.dirname(specPath), "SKILLS.md");
   const md = generateSkillsMd(featureName, filteredResult, totalSkills);
-  fs16.writeFileSync(skillsMdPath, md, "utf-8");
+  fs17.writeFileSync(skillsMdPath, md, "utf-8");
   return { result: filteredResult, skillsMdPath, featureName, totalSkills };
 }
 function formatOutput(featureName, result, skillsMdPath, totalSkills) {
@@ -7860,7 +8051,7 @@ async function handleAdviseSkills(input) {
     });
     const response = {
       featureName,
-      skillsPath: path20.relative(projectRoot, skillsMdPath).replaceAll("\\", "/"),
+      skillsPath: path21.relative(projectRoot, skillsMdPath).replaceAll("\\", "/"),
       totalScanned: totalSkills,
       scanDuration: result.scanDuration,
       apply: result.matches.filter((m) => m.tier === "apply").map((m) => ({
@@ -7893,7 +8084,7 @@ async function handleAdviseSkills(input) {
 }
 
 // src/mcp/tools/compact.ts
-init_dist();
+init_dist2();
 var COMPACT_TOOL_DEFAULT_BUDGET = 2e3;
 var compactToolDefinition = {
   name: "compact",
@@ -8206,7 +8397,7 @@ async function handleDetectConstraintEmergence(input) {
     }
     const nodePath = await import("path");
     const historyPath = nodePath.resolve(projectPath, ".harness/arch/violation-history.json");
-    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-RYZFURLL.js");
+    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-TKHVYUWZ.js");
     const manager = new ViolationHistoryManager(historyPath);
     const history = manager.load();
     const options = { windowWeeks, minOccurrences };
@@ -8294,7 +8485,7 @@ async function handleRunCIChecks(input) {
     };
   }
   try {
-    const { runCIChecks } = await import("./dist-RYZFURLL.js");
+    const { runCIChecks } = await import("./dist-TKHVYUWZ.js");
     const skip = input.checks ? VALID_CHECKS.filter((c) => !input.checks.includes(c)) : [];
     const result = await runCIChecks({
       projectRoot: projectPath,
@@ -8356,7 +8547,7 @@ async function handleGenerateBlueprint(input) {
     };
   }
   try {
-    const { ProjectScanner } = await import("./dist-RYZFURLL.js");
+    const { ProjectScanner } = await import("./dist-TKHVYUWZ.js");
     const scanner = new ProjectScanner(projectPath);
     const data = await scanner.scan();
     return {
@@ -8543,7 +8734,10 @@ var TOOL_DEFINITIONS = [
   generateBlueprintDefinition,
   triggerMaintenanceJobDefinition,
   listGatewayTokensDefinition,
-  subscribeWebhookDefinition
+  subscribeWebhookDefinition,
+  searchSessionsDefinition,
+  summarizeSessionDefinition,
+  insightsSummaryDefinition
 ].map((def) => ({ ...def, trustedOutput: true }));
 var TOOL_HANDLERS = {
   validate_project: handleValidateProject,
@@ -8609,7 +8803,10 @@ var TOOL_HANDLERS = {
   generate_blueprint: handleGenerateBlueprint,
   trigger_maintenance_job: handleTriggerMaintenanceJob,
   list_gateway_tokens: handleListGatewayTokens,
-  subscribe_webhook: handleSubscribeWebhook
+  subscribe_webhook: handleSubscribeWebhook,
+  search_sessions: handleSearchSessions,
+  summarize_session: handleSummarizeSession,
+  insights_summary: handleInsightsSummary
 };
 var RESOURCE_DEFINITIONS = [
   {
@@ -8711,7 +8908,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-RYZFURLL.js");
+    } = await import("./dist-TKHVYUWZ.js");
     const { CLI_VERSION } = await import("./version-CUI434OP.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;