@massu/core 1.9.2 → 1.9.5

package/dist/cli.js

@@ -39,6 +39,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/lib/memory-path.ts
+function encodeMemoryDirName(projectRoot) {
+  return projectRoot.replace(/\//g, "-");
+}
+var init_memory_path = __esm({
+  "src/lib/memory-path.ts"() {
+    "use strict";
+  }
+});
+
 // src/config.ts
 import { resolve, dirname } from "path";
 import { existsSync, readFileSync } from "fs";
@@ -193,7 +203,7 @@ function getResolvedPaths() {
     plansDir: resolve(root, "docs/plans"),
     docsDir: resolve(root, "docs"),
     claudeDir: resolve(root, claudeDirName),
-    memoryDir: resolve(homedir(), claudeDirName, "projects", root.replace(/\//g, "-"), "memory"),
+    memoryDir: resolve(homedir(), claudeDirName, "projects", encodeMemoryDirName(root), "memory"),
     sessionStatePath: resolve(root, config.conventions?.sessionStatePath ?? `${claudeDirName}/session-state/CURRENT.md`),
     sessionArchivePath: resolve(root, config.conventions?.sessionArchivePath ?? `${claudeDirName}/session-state/archive`),
     mcpJsonPath: resolve(root, ".mcp.json"),
@@ -208,6 +218,7 @@ var DomainConfigSchema, PatternRuleConfigSchema, CostModelSchema, AnalyticsConfi
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
+    init_memory_path();
     DomainConfigSchema = z.object({
       name: z.string().default("Unknown"),
       routers: z.array(z.string()).default([]),
@@ -8045,41 +8056,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p19 = new Promise(function(resolve40, reject) {
+        var p19 = new Promise(function(resolve41, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve40(result);
+            resolve41(result);
           });
         });
         p19.catch(noop);
         return p19;
       }
       function unshift(value) {
-        var p19 = new Promise(function(resolve40, reject) {
+        var p19 = new Promise(function(resolve41, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve40(result);
+            resolve41(result);
           });
         });
         p19.catch(noop);
         return p19;
       }
       function drained() {
-        var p19 = new Promise(function(resolve40) {
+        var p19 = new Promise(function(resolve41) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve40();
+              resolve41();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve40();
+                resolve41();
                 queue.drain = previousDrain;
               };
             }
@@ -8565,9 +8576,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve40, reject) => {
+        return new Promise((resolve41, reject) => {
           this._stat(filepath, this._fsStatSettings, (error, stats) => {
-            return error === null ? resolve40(stats) : reject(error);
+            return error === null ? resolve41(stats) : reject(error);
           });
         });
       }
@@ -8591,10 +8602,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve40, reject) => {
+        return new Promise((resolve41, reject) => {
           this._walkAsync(root, options, (error, entries) => {
             if (error === null) {
-              resolve40(entries);
+              resolve41(entries);
             } else {
               reject(error);
             }
@@ -8604,10 +8615,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve40, reject) => {
+        return new Promise((resolve41, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve40(entries));
+          stream.once("end", () => resolve41(entries));
         });
       }
     };
@@ -12982,10 +12993,12 @@ __export(init_exports, {
   detectFramework: () => detectFramework,
   detectPython: () => detectPython,
   generateConfig: () => generateConfig,
+  getInstallerVersion: () => getInstallerVersion,
   initMemoryDir: () => initMemoryDir,
   installHooks: () => installHooks,
   isTemplateName: () => isTemplateName,
   listTemplates: () => listTemplates,
+  mergeHooksConfig: () => mergeHooksConfig,
   parseInitArgs: () => parseInitArgs,
   printInitHelp: () => printInitHelp,
   registerMcpServer: () => registerMcpServer,
@@ -13529,6 +13542,26 @@ function copyTemplateConfig(templateName, targetPath, projectName) {
     return { success: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
+function getInstallerVersion() {
+  const candidates = [
+    resolve7(__dirname2, "../package.json"),
+    resolve7(__dirname2, "../../package.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync11(candidate)) {
+      try {
+        const pkg = JSON.parse(readFileSync11(candidate, "utf-8"));
+        if (typeof pkg.version === "string" && pkg.version.length > 0 && pkg.name === "@massu/core") {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+  }
+  throw new Error(
+    "getInstallerVersion: could not resolve @massu/core package.json. This indicates a corrupt install. Re-install via `npx -y @massu/core init`."
+  );
+}
 function registerMcpServer(projectRoot) {
   const mcpPath = resolve7(projectRoot, ".mcp.json");
   let existing = {};
@@ -13543,10 +13576,11 @@ function registerMcpServer(projectRoot) {
   if (servers.massu) {
     return false;
   }
+  const version = getInstallerVersion();
   servers.massu = {
     type: "stdio",
     command: "npx",
-    args: ["-y", "@massu/core"]
+    args: ["-y", `@massu/core@${version}`]
   };
   existing.mcpServers = servers;
   writeFileSync2(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
@@ -13564,15 +13598,16 @@ function resolveHooksDir() {
   }
   return "node_modules/@massu/core/dist/hooks";
 }
-function hookCmd(hooksDir, hookFile) {
-  return `node ${hooksDir}/${hookFile}`;
+function hookCmd(version, hookName) {
+  return `npx -y @massu/core@${version} hook-runner ${hookName}`;
 }
-function buildHooksConfig(hooksDir) {
+function buildHooksConfig(_hooksDir) {
+  const version = getInstallerVersion();
   return {
     SessionStart: [
       {
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "session-start.js"), timeout: 10 }
+          { type: "command", command: hookCmd(version, "session-start"), timeout: 10 }
         ]
       }
     ],
@@ -13580,32 +13615,32 @@ function buildHooksConfig(hooksDir) {
       {
         matcher: "Bash",
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "security-gate.js"), timeout: 5 }
+          { type: "command", command: hookCmd(version, "security-gate"), timeout: 5 }
         ]
       },
       {
         matcher: "Bash|Write",
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "pre-delete-check.js"), timeout: 5 }
+          { type: "command", command: hookCmd(version, "pre-delete-check"), timeout: 5 }
         ]
       }
     ],
     PostToolUse: [
       {
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "post-tool-use.js"), timeout: 10 },
-          { type: "command", command: hookCmd(hooksDir, "quality-event.js"), timeout: 5 },
-          { type: "command", command: hookCmd(hooksDir, "cost-tracker.js"), timeout: 5 }
+          { type: "command", command: hookCmd(version, "post-tool-use"), timeout: 10 },
+          { type: "command", command: hookCmd(version, "quality-event"), timeout: 5 },
+          { type: "command", command: hookCmd(version, "cost-tracker"), timeout: 5 }
         ]
       },
       {
         matcher: "Edit|Write",
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "post-edit-context.js"), timeout: 5 },
+          { type: "command", command: hookCmd(version, "post-edit-context"), timeout: 5 },
           // Auto-learning pipeline — classifies failures and detects fixes on
           // file changes. See Phase 5-6 of the autodetect plan.
-          { type: "command", command: hookCmd(hooksDir, "fix-detector.js"), timeout: 5 },
-          { type: "command", command: hookCmd(hooksDir, "classify-failure.js"), timeout: 5 }
+          { type: "command", command: hookCmd(version, "fix-detector"), timeout: 5 },
+          { type: "command", command: hookCmd(version, "classify-failure"), timeout: 5 }
         ]
       },
       {
@@ -13613,37 +13648,86 @@ function buildHooksConfig(hooksDir) {
         hooks: [
           // Incident + rule enforcement pipelines fire on Write-only (incidents
           // are authored as .md files; rules are enforced after new-file drops).
-          { type: "command", command: hookCmd(hooksDir, "incident-pipeline.js"), timeout: 5 },
-          { type: "command", command: hookCmd(hooksDir, "rule-enforcement-pipeline.js"), timeout: 5 }
+          { type: "command", command: hookCmd(version, "incident-pipeline"), timeout: 5 },
+          { type: "command", command: hookCmd(version, "rule-enforcement-pipeline"), timeout: 5 }
         ]
       }
     ],
     Stop: [
       {
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "session-end.js"), timeout: 15 },
+          { type: "command", command: hookCmd(version, "session-end"), timeout: 15 },
           // Session-end auto-learning aggregation (failure-class roll-up).
-          { type: "command", command: hookCmd(hooksDir, "auto-learning-pipeline.js"), timeout: 10 }
+          { type: "command", command: hookCmd(version, "auto-learning-pipeline"), timeout: 10 }
         ]
       }
     ],
     PreCompact: [
       {
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "pre-compact.js"), timeout: 10 }
+          { type: "command", command: hookCmd(version, "pre-compact"), timeout: 10 }
         ]
       }
     ],
     UserPromptSubmit: [
       {
         hooks: [
-          { type: "command", command: hookCmd(hooksDir, "user-prompt.js"), timeout: 5 },
-          { type: "command", command: hookCmd(hooksDir, "intent-suggester.js"), timeout: 5 }
+          { type: "command", command: hookCmd(version, "user-prompt"), timeout: 5 },
+          { type: "command", command: hookCmd(version, "intent-suggester"), timeout: 5 }
         ]
       }
     ]
   };
 }
+function mergeHooksConfig(existing, additions) {
+  const eventNames = /* @__PURE__ */ new Set([
+    ...Object.keys(existing ?? {}),
+    ...Object.keys(additions ?? {})
+  ]);
+  const merged = {};
+  for (const event of eventNames) {
+    const existingGroups = existing?.[event] ?? [];
+    const additionGroups = additions?.[event] ?? [];
+    const byMatcher = /* @__PURE__ */ new Map();
+    for (const group of existingGroups) {
+      const key = group.matcher ?? "";
+      const existingGroup = byMatcher.get(key);
+      if (existingGroup) {
+        existingGroup.hooks = mergeHookEntries(existingGroup.hooks, group.hooks);
+      } else {
+        byMatcher.set(key, { ...group, hooks: [...group.hooks ?? []] });
+      }
+    }
+    for (const group of additionGroups) {
+      const key = group.matcher ?? "";
+      const existingGroup = byMatcher.get(key);
+      if (existingGroup) {
+        existingGroup.hooks = mergeHookEntries(existingGroup.hooks, group.hooks);
+      } else {
+        byMatcher.set(key, { ...group, hooks: [...group.hooks ?? []] });
+      }
+    }
+    merged[event] = Array.from(byMatcher.values());
+  }
+  return merged;
+}
+function mergeHookEntries(existing, additions) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of additions ?? []) {
+    if (!entry || typeof entry.command !== "string") continue;
+    if (seen.has(entry.command)) continue;
+    seen.add(entry.command);
+    result.push(entry);
+  }
+  for (const entry of existing ?? []) {
+    if (!entry || typeof entry.command !== "string") continue;
+    if (seen.has(entry.command)) continue;
+    seen.add(entry.command);
+    result.push(entry);
+  }
+  return result;
+}
 function installHooks(projectRoot) {
   let claudeDirName = ".claude";
   try {
@@ -13656,21 +13740,39 @@ function installHooks(projectRoot) {
     mkdirSync5(claudeDir, { recursive: true });
   }
   const settings = readSettingsLocal(claudeDir);
-  const hooksDir = resolveHooksDir();
-  const hooksConfig = buildHooksConfig(hooksDir);
+  const hooksConfig = buildHooksConfig(resolveHooksDir());
+  const existingHooks = settings.hooks ?? {};
+  const mergedHooks = mergeHooksConfig(existingHooks, hooksConfig);
   let hookCount = 0;
-  for (const groups of Object.values(hooksConfig)) {
+  for (const groups of Object.values(mergedHooks)) {
     for (const group of groups) {
       hookCount += group.hooks.length;
     }
   }
-  settings.hooks = hooksConfig;
+  settings.hooks = mergedHooks;
   writeSettingsLocalAtomic(claudeDir, settings);
   return { installed: true, count: hookCount };
 }
 function initMemoryDir(projectRoot) {
-  const encodedRoot = "-" + projectRoot.replace(/\//g, "-");
+  const encodedRoot = encodeMemoryDirName(projectRoot);
   const memoryDir = resolve7(homedir4(), `.claude/projects/${encodedRoot}/memory`);
+  let migratedFromLegacy = false;
+  const legacyDir = resolve7(homedir4(), `.claude/projects/-${encodedRoot}/memory`);
+  if (existsSync11(legacyDir) && !existsSync11(memoryDir)) {
+    try {
+      mkdirSync5(resolve7(memoryDir, ".."), { recursive: true });
+      renameSync3(legacyDir, memoryDir);
+      try {
+        const legacyParent = resolve7(legacyDir, "..");
+        if (existsSync11(legacyParent) && readdirSync10(legacyParent).length === 0) {
+          rmSync2(legacyParent, { recursive: false });
+        }
+      } catch {
+      }
+      migratedFromLegacy = true;
+    } catch {
+    }
+  }
   let created = false;
   if (!existsSync11(memoryDir)) {
     mkdirSync5(memoryDir, { recursive: true });
@@ -13697,7 +13799,7 @@ function initMemoryDir(projectRoot) {
     writeFileSync2(memoryMdPath, memoryContent, "utf-8");
     memoryMdCreated = true;
   }
-  return { created, memoryMdCreated };
+  return { created, memoryMdCreated, migratedFromLegacy };
 }
 function parseInitArgs(argv) {
   const opts = {};
@@ -13956,16 +14058,19 @@ function installSideEffects(projectRoot, log, skipCommands = false, emptyStack =
     } catch {
     }
   }
-  const { created: memDirCreated, memoryMdCreated } = initMemoryDir(projectRoot);
+  const { created: memDirCreated, memoryMdCreated, migratedFromLegacy } = initMemoryDir(projectRoot);
   if (memDirCreated) {
     log("  Created memory directory");
   }
   if (memoryMdCreated) {
     log("  Created initial MEMORY.md");
   }
+  if (migratedFromLegacy) {
+    log("  Migrated memory directory from legacy double-dash path (pre-1.9.4)");
+  }
   (async () => {
     try {
-      const encodedRoot = projectRoot.replace(/\//g, "-");
+      const encodedRoot = encodeMemoryDirName(projectRoot);
       const memoryDir = resolve7(homedir4(), ".claude", "projects", encodedRoot, "memory");
       const memFiles = existsSync11(memoryDir) ? readdirSync10(memoryDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md") : [];
       if (memFiles.length > 0) {
@@ -14025,6 +14130,7 @@ var init_init = __esm({
     init_config();
     init_install_commands();
     init_settings_local();
+    init_memory_path();
     init_detect();
     init_drift();
     __filename2 = fileURLToPath2(import.meta.url);
@@ -14069,7 +14175,7 @@ function annotateToolDefinitions(defs) {
     const label = TIER_LABELS[tier];
     return {
       ...def,
-      tier,
+      annotations: { ...def.annotations ?? {}, tier },
       description: label ? `${label}${def.description}` : def.description
     };
   });
@@ -14756,13 +14862,113 @@ var init_install_hooks = __esm({
   }
 });
 
+// src/commands/hook-runner.ts
+var hook_runner_exports = {};
+__export(hook_runner_exports, {
+  HOOK_NAME_TO_FILE: () => HOOK_NAME_TO_FILE,
+  resolveHookFile: () => resolveHookFile,
+  runHookRunner: () => runHookRunner
+});
+import { existsSync as existsSync13 } from "fs";
+import { resolve as resolve9, dirname as dirname8 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { spawn } from "child_process";
+function resolveHookFile(hookName) {
+  const file = HOOK_NAME_TO_FILE[hookName];
+  if (!file) {
+    throw new Error(
+      `Unknown hook: "${hookName}". Recognized: ${Object.keys(HOOK_NAME_TO_FILE).join(", ")}`
+    );
+  }
+  const candidates = [
+    // Bundled compiled layout: dist/cli.js → ./hooks/<file>.js
+    resolve9(__dirname4, "hooks", file),
+    // TS-source dev / sibling layout: src/commands/ → ../hooks/<file>
+    resolve9(__dirname4, "../hooks", file),
+    // TS-source dev fallback: src/commands/ → ../../dist/hooks/<file>
+    resolve9(__dirname4, "../../dist/hooks", file)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync13(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Hook file not found for "${hookName}". Searched: ${candidates.join(", ")}. This indicates a broken @massu/core install. Re-run \`npx -y @massu/core init\`.`
+  );
+}
+async function runHookRunner(args2) {
+  const hookName = args2[0];
+  if (!hookName) {
+    process.stderr.write(
+      `massu hook-runner: missing hook name.
+Usage: massu hook-runner <hook-name>
+Recognized: ${Object.keys(HOOK_NAME_TO_FILE).join(", ")}
+`
+    );
+    return { exitCode: 2 };
+  }
+  let hookFile;
+  try {
+    hookFile = resolveHookFile(hookName);
+  } catch (err) {
+    process.stderr.write(`massu hook-runner: ${err instanceof Error ? err.message : String(err)}
+`);
+    return { exitCode: 2 };
+  }
+  return new Promise((resolvePromise) => {
+    const child = spawn(process.execPath, [hookFile], {
+      stdio: ["inherit", "inherit", "inherit"],
+      env: process.env
+    });
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        resolvePromise({ exitCode: 128 });
+        return;
+      }
+      resolvePromise({ exitCode: code ?? 0 });
+    });
+    child.on("error", (err) => {
+      process.stderr.write(`massu hook-runner: failed to spawn hook "${hookName}": ${err.message}
+`);
+      resolvePromise({ exitCode: 2 });
+    });
+  });
+}
+var __filename4, __dirname4, HOOK_NAME_TO_FILE;
+var init_hook_runner = __esm({
+  "src/commands/hook-runner.ts"() {
+    "use strict";
+    __filename4 = fileURLToPath4(import.meta.url);
+    __dirname4 = dirname8(__filename4);
+    HOOK_NAME_TO_FILE = {
+      "session-start": "session-start.js",
+      "session-end": "session-end.js",
+      "security-gate": "security-gate.js",
+      "pre-delete-check": "pre-delete-check.js",
+      "post-tool-use": "post-tool-use.js",
+      "post-edit-context": "post-edit-context.js",
+      "quality-event": "quality-event.js",
+      "cost-tracker": "cost-tracker.js",
+      "fix-detector": "fix-detector.js",
+      "classify-failure": "classify-failure.js",
+      "incident-pipeline": "incident-pipeline.js",
+      "rule-enforcement-pipeline": "rule-enforcement-pipeline.js",
+      "auto-learning-pipeline": "auto-learning-pipeline.js",
+      "pre-compact": "pre-compact.js",
+      "user-prompt": "user-prompt.js",
+      "intent-suggester": "intent-suggester.js"
+    };
+  }
+});
+
 // src/commands/permissions.ts
 var permissions_exports = {};
 __export(permissions_exports, {
   handlePermissionsSubcommand: () => handlePermissionsSubcommand,
   printPermissionsHelp: () => printPermissionsHelp
 });
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 function resolveClaudeDir2() {
   let claudeDirName = ".claude";
   try {
@@ -14770,7 +14976,7 @@ function resolveClaudeDir2() {
   } catch {
     claudeDirName = ".claude";
   }
-  return resolve9(process.cwd(), claudeDirName);
+  return resolve10(process.cwd(), claudeDirName);
 }
 async function handlePermissionsSubcommand(args2) {
   const sub = args2[0];
@@ -14884,8 +15090,8 @@ var init_permissions2 = __esm({
 });
 
 // src/changelog-generator.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync12 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, readdirSync as readdirSync12 } from "fs";
+import { resolve as resolve11 } from "path";
 function parseCommitsForPlanTokens(subjects) {
   const tokens = /* @__PURE__ */ new Set();
   const maintenance = [];
@@ -14902,7 +15108,7 @@ function parseCommitsForPlanTokens(subjects) {
 function loadPlanSummaries(tokens, planDir) {
   const result = /* @__PURE__ */ new Map();
   if (tokens.size === 0) return result;
-  if (!existsSync13(planDir)) {
+  if (!existsSync14(planDir)) {
     throw new Error(`Plan directory does not exist: ${planDir}`);
   }
   const files = readdirSync12(planDir).filter((f2) => f2.endsWith(".md"));
@@ -14910,7 +15116,7 @@ function loadPlanSummaries(tokens, planDir) {
     let matchedFile = null;
     let content = "";
     for (const file of files) {
-      const path = resolve10(planDir, file);
+      const path = resolve11(planDir, file);
       const text18 = readFileSync13(path, "utf-8");
       const tokenRe = new RegExp(
         `^\\*\\*Plan Token\\*\\*:\\s*\`?${token.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\`?(\\s|$)`,
@@ -14992,8 +15198,8 @@ __export(changelog_exports, {
   printChangelogHelp: () => printChangelogHelp
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+import { resolve as resolve12 } from "path";
 function resolveRepoRoot() {
   try {
     return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
@@ -15017,8 +15223,8 @@ function getCommitSubjects(range) {
   }
 }
 function getCurrentVersion(repoRoot) {
-  const pkgPath = resolve11(repoRoot, "packages/core/package.json");
-  if (!existsSync14(pkgPath)) return "0.0.0";
+  const pkgPath = resolve12(repoRoot, "packages/core/package.json");
+  if (!existsSync15(pkgPath)) return "0.0.0";
   const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
   return pkg.version || "0.0.0";
 }
@@ -15026,8 +15232,8 @@ function todayDate() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 function getLatestChangelogEntryBody(repoRoot) {
-  const path = resolve11(repoRoot, "CHANGELOG.md");
-  if (!existsSync14(path)) return "";
+  const path = resolve12(repoRoot, "CHANGELOG.md");
+  if (!existsSync15(path)) return "";
   const content = readFileSync14(path, "utf-8");
   const m3 = content.match(/^## \[[\d.]+\][^\n]*\n([\s\S]*?)(?=\n## \[|$)/m);
   return m3 ? m3[1] : "";
@@ -15035,7 +15241,7 @@ function getLatestChangelogEntryBody(repoRoot) {
 async function handleChangelogSubcommand(args2) {
   const sub = args2[0];
   const repoRoot = resolveRepoRoot();
-  const planDir = resolve11(repoRoot, "docs/plans");
+  const planDir = resolve12(repoRoot, "docs/plans");
   switch (sub) {
     case "generate": {
       const lastTag = getLastTag();
@@ -15127,8 +15333,8 @@ var show_template_exports = {};
 __export(show_template_exports, {
   runShowTemplate: () => runShowTemplate
 });
-import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve13 } from "path";
 function normalizeBaseName(input) {
   return input.endsWith(".md") ? input.slice(0, -".md".length) : input;
 }
@@ -15156,8 +15362,8 @@ async function runShowTemplate(args2) {
     return;
   }
   const suffix = choice.kind === "hit" ? choice.suffix : "";
-  const file = suffix === "" ? resolve12(sourceDir, `${baseName}.md`) : resolve12(sourceDir, `${baseName}${suffix}.md`);
-  if (!existsSync15(file)) {
+  const file = suffix === "" ? resolve13(sourceDir, `${baseName}.md`) : resolve13(sourceDir, `${baseName}${suffix}.md`);
+  if (!existsSync16(file)) {
     process.stderr.write(`massu: resolved template "${file}" no longer exists
 `);
     process.exit(1);
@@ -15217,7 +15423,7 @@ var init_passthrough = __esm({
 
 // src/lib/fileLock.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync16, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 import * as lockfile from "proper-lockfile";
 function readLockHolderPid(lockPath) {
   try {
@@ -15240,7 +15446,7 @@ function busyWaitSync(ms) {
   Atomics.wait(view, 0, 0, ms);
 }
 function withFileLockSync(lockPath, fn, opts = {}) {
-  mkdirSync6(dirname8(lockPath), { recursive: true });
+  mkdirSync6(dirname9(lockPath), { recursive: true });
   const staleMs = opts.staleMs ?? 3e4;
   const blockMs = opts.retries === 0 ? 0 : opts.blockMs ?? 3e4;
   const pollIntervalMs = opts.pollIntervalMs ?? 100;
@@ -15308,9 +15514,9 @@ var init_fileLock = __esm({
 });
 
 // src/lib/installLock.ts
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 function withInstallLock(projectRoot, fn, opts = {}) {
-  const lockPath = resolve13(projectRoot, ".massu", "installAll.lock");
+  const lockPath = resolve14(projectRoot, ".massu", "installAll.lock");
   return withFileLockSync(
     lockPath,
     fn,
@@ -15346,8 +15552,8 @@ __export(config_refresh_exports, {
   mergeRefresh: () => mergeRefresh,
   runConfigRefresh: () => runConfigRefresh
 });
-import { existsSync as existsSync16, readFileSync as readFileSync17, rmSync as rmSync4 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17, rmSync as rmSync4 } from "fs";
+import { resolve as resolve15 } from "path";
 import { parse as parseYaml5 } from "yaml";
 function flatten(obj, prefix3 = "") {
   const out = {};
@@ -15475,10 +15681,10 @@ function renderDiff(diff) {
 }
 async function runConfigRefresh(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve14(cwd, "massu.config.yaml");
+  const configPath = resolve15(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
-  if (!existsSync16(configPath)) {
+  if (!existsSync17(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     if (!opts.silent) process.stderr.write(message + "\n");
     return { exitCode: 1, applied: false, dryRun: !!opts.dryRun, diff: [], message };
@@ -15558,8 +15764,8 @@ async function runConfigRefresh(opts = {}) {
 `);
       const stackResolved = installResult.totalInstalled > 0 || installResult.totalUpdated > 0;
       if (stackResolved) {
-        const placeholderPath = resolve14(installResult.claudeDir, "commands", "_massu-needs-stack.md");
-        if (existsSync16(placeholderPath)) {
+        const placeholderPath = resolve15(installResult.claudeDir, "commands", "_massu-needs-stack.md");
+        if (existsSync17(placeholderPath)) {
           try {
             rmSync4(placeholderPath, { force: true });
             log("Removed _massu-needs-stack.md (stack now declared).\n");
@@ -15668,12 +15874,12 @@ var init_gitToplevel = __esm({
 });
 
 // src/watch/lockfile-detector.ts
-import { existsSync as existsSync17, statSync as statSync8 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync18, statSync as statSync8 } from "fs";
+import { resolve as resolve16 } from "path";
 function lockfileMidWrite(projectRoot, now = Date.now(), windowMs = LOCKFILE_WINDOW_MS) {
   for (const lf of KNOWN_LOCKFILES) {
-    const p19 = resolve15(projectRoot, lf);
-    if (!existsSync17(p19)) continue;
+    const p19 = resolve16(projectRoot, lf);
+    if (!existsSync18(p19)) continue;
     try {
       const stat = statSync8(p19);
       const delta = now - stat.mtimeMs;
@@ -15686,7 +15892,7 @@ function lockfileMidWrite(projectRoot, now = Date.now(), windowMs = LOCKFILE_WIN
 function gitMidOperation(projectRoot) {
   const sentinels = ["MERGE_HEAD", "REBASE_HEAD", "CHERRY_PICK_HEAD", "rebase-apply", "rebase-merge"];
   for (const s of sentinels) {
-    if (existsSync17(resolve15(projectRoot, ".git", s))) return true;
+    if (existsSync18(resolve16(projectRoot, ".git", s))) return true;
   }
   return false;
 }
@@ -15883,17 +16089,17 @@ var init_paths = __esm({
 });
 
 // src/watch/state.ts
-import { closeSync as closeSync3, existsSync as existsSync18, fsyncSync as fsyncSync3, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync18, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync4, writeSync as writeSync3 } from "fs";
-import { dirname as dirname9, resolve as resolve16 } from "path";
+import { closeSync as closeSync3, existsSync as existsSync19, fsyncSync as fsyncSync3, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync18, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync4, writeSync as writeSync3 } from "fs";
+import { dirname as dirname10, resolve as resolve17 } from "path";
 function watchStatePath(projectRoot) {
-  return resolve16(projectRoot, ".massu", "watch-state.json");
+  return resolve17(projectRoot, ".massu", "watch-state.json");
 }
 function backupStatePath(projectRoot) {
-  return resolve16(projectRoot, ".massu", "watch-state.v0.bak.json");
+  return resolve17(projectRoot, ".massu", "watch-state.v0.bak.json");
 }
 function readState(projectRoot) {
   const path = watchStatePath(projectRoot);
-  if (!existsSync18(path)) return { ...DEFAULT_STATE };
+  if (!existsSync19(path)) return { ...DEFAULT_STATE };
   const content = readFileSync18(path, "utf-8");
   let raw;
   try {
@@ -15936,14 +16142,14 @@ function readState(projectRoot) {
 }
 function archiveCorrupt(projectRoot, content) {
   const bak = backupStatePath(projectRoot);
-  mkdirSync7(dirname9(bak), { recursive: true });
+  mkdirSync7(dirname10(bak), { recursive: true });
   writeFileSync4(bak, content, "utf-8");
 }
 function writeStateAtomic(projectRoot, state) {
   const path = watchStatePath(projectRoot);
   writeStateAtomicCounter = writeStateAtomicCounter + 1 >>> 0;
   const tmp = `${path}.${process.pid}.${writeStateAtomicCounter}.tmp`;
-  mkdirSync7(dirname9(path), { recursive: true });
+  mkdirSync7(dirname10(path), { recursive: true });
   let renamed = false;
   try {
     const fd = openSync3(tmp, "w");
@@ -15957,7 +16163,7 @@ function writeStateAtomic(projectRoot, state) {
     renameSync4(tmp, path);
     renamed = true;
   } finally {
-    if (!renamed && existsSync18(tmp)) {
+    if (!renamed && existsSync19(tmp)) {
       try {
         rmSync5(tmp, { force: true });
       } catch {
@@ -16237,8 +16443,8 @@ __export(watch_exports, {
   runWatch: () => runWatch
 });
 import { spawnSync as spawnSync3 } from "child_process";
-import { basename as basename5, dirname as dirname10, resolve as resolve17 } from "path";
-import { appendFileSync, existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync19 } from "fs";
+import { basename as basename5, dirname as dirname11, resolve as resolve18 } from "path";
+import { appendFileSync, existsSync as existsSync20, mkdirSync as mkdirSync8, readFileSync as readFileSync19 } from "fs";
 function parseFlags(args2) {
   const out = {
     foreground: false,
@@ -16263,8 +16469,8 @@ function parseFlags(args2) {
 }
 function findClaudeBg() {
   const home = process.env.HOME ?? "";
-  const fixed = home ? resolve17(home, ".claude", "bin", "claude-bg") : null;
-  if (fixed && existsSync19(fixed)) return fixed;
+  const fixed = home ? resolve18(home, ".claude", "bin", "claude-bg") : null;
+  if (fixed && existsSync20(fixed)) return fixed;
   const which = spawnSync3("which", ["claude-bg"], { encoding: "utf-8" });
   if (which.status === 0 && which.stdout) {
     const p19 = which.stdout.trim();
@@ -16325,7 +16531,7 @@ async function runWatch(args2) {
 }
 function runStatus(root) {
   const path = watchStatePath(root);
-  if (!existsSync19(path)) {
+  if (!existsSync20(path)) {
     process.stdout.write("massu watch: not running (no state file)\n");
     return { exitCode: 0 };
   }
@@ -16407,7 +16613,7 @@ async function runForeground(root) {
     }
     throw err;
   }
-  return new Promise((resolve40) => {
+  return new Promise((resolve41) => {
     const shutdown = async () => {
       if (stopped) return;
       stopped = true;
@@ -16417,7 +16623,7 @@ async function runForeground(root) {
         process.chdir(priorCwd);
       } catch {
       }
-      resolve40({ exitCode: 0 });
+      resolve41({ exitCode: 0 });
     };
     process.on("SIGINT", () => {
       void shutdown();
@@ -16478,19 +16684,19 @@ async function runOnQuiescent(projectRoot) {
   );
 }
 function refreshLogPath(projectRoot) {
-  return resolve17(projectRoot, ".massu", "refresh-log.jsonl");
+  return resolve18(projectRoot, ".massu", "refresh-log.jsonl");
 }
 function appendRefreshLog(projectRoot, event) {
   const path = refreshLogPath(projectRoot);
   try {
-    mkdirSync8(dirname10(path), { recursive: true });
+    mkdirSync8(dirname11(path), { recursive: true });
     appendFileSync(path, JSON.stringify(event) + "\n", "utf-8");
   } catch {
   }
 }
 function readRefreshLog(projectRoot, limit = 10, opts = {}) {
   const path = refreshLogPath(projectRoot);
-  if (!existsSync19(path)) return [];
+  if (!existsSync20(path)) return [];
   const warn = opts.warn ?? ((s) => {
     process.stderr.write(s);
   });
@@ -16567,7 +16773,7 @@ var init_refresh_log = __esm({
 import {
   chmodSync as chmodSync3,
   closeSync as closeSync4,
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   fsyncSync as fsyncSync4,
   mkdirSync as mkdirSync9,
   openSync as openSync4,
@@ -16576,12 +16782,12 @@ import {
   statSync as statSync9,
   writeSync as writeSync4
 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 function atomicWrite(path, content, opts = {}) {
   const tmpPath = `${path}.tmp`;
-  const parentDir = dirname11(path);
+  const parentDir = dirname12(path);
   try {
-    if (!existsSync20(parentDir)) {
+    if (!existsSync21(parentDir)) {
       const mkdirOpts = { recursive: true };
       if (opts.ensureParentDirMode !== void 0) {
         mkdirOpts.mode = opts.ensureParentDirMode;
@@ -16603,7 +16809,7 @@ function atomicWrite(path, content, opts = {}) {
     renameSync5(tmpPath, path);
     return { written: true };
   } catch (err) {
-    if (existsSync20(tmpPath)) {
+    if (existsSync21(tmpPath)) {
       try {
         rmSync6(tmpPath, { force: true });
       } catch {
@@ -16946,19 +17152,19 @@ var init_fetcher = __esm({
 });
 
 // src/security/manifest-cache.ts
-import { existsSync as existsSync21, readFileSync as readFileSync20, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync20, statSync as statSync10 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 import { z as z4 } from "zod";
 function defaultCachePaths() {
-  const dir = resolve18(homedir5(), ".massu");
+  const dir = resolve19(homedir5(), ".massu");
   return {
-    cachePath: resolve18(dir, "adapter-manifest.json"),
-    lockPath: resolve18(dir, ".adapter-manifest.lock")
+    cachePath: resolve19(dir, "adapter-manifest.json"),
+    lockPath: resolve19(dir, ".adapter-manifest.lock")
   };
 }
 function loadCachedManifest(paths = defaultCachePaths()) {
-  if (!existsSync21(paths.cachePath)) {
+  if (!existsSync22(paths.cachePath)) {
     return { kind: "absent" };
   }
   let raw;
@@ -17152,15 +17358,15 @@ var init_adapter_origin = __esm({
 });
 
 // src/security/local-fingerprint.ts
-import { existsSync as existsSync22, readFileSync as readFileSync21, lstatSync as lstatSync5 } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync21, lstatSync as lstatSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { resolve as resolve19, isAbsolute } from "node:path";
+import { resolve as resolve20, isAbsolute } from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 import { z as z5 } from "zod";
 function computeLocalFingerprint(localPaths, projectRoot) {
   const tuples = [];
   for (const p19 of localPaths) {
-    const abs = isAbsolute(p19) ? p19 : resolve19(projectRoot, p19);
+    const abs = isAbsolute(p19) ? p19 : resolve20(projectRoot, p19);
     let contentTag;
     try {
       const lst = lstatSync5(abs);
@@ -17181,7 +17387,7 @@ function computeLocalFingerprint(localPaths, projectRoot) {
   return createHash7("sha256").update(canonical).digest("hex");
 }
 function readFingerprintSentinel(path = FINGERPRINT_PATH) {
-  if (!existsSync22(path)) return null;
+  if (!existsSync23(path)) return null;
   let raw;
   try {
     raw = JSON.parse(readFileSync21(path, "utf-8"));
@@ -17232,7 +17438,7 @@ var init_local_fingerprint = __esm({
     "use strict";
     init_atomic_write();
     init_manifest_schema();
-    FINGERPRINT_PATH = resolve19(homedir6(), ".massu", "adapters-local-fingerprint.json");
+    FINGERPRINT_PATH = resolve20(homedir6(), ".massu", "adapters-local-fingerprint.json");
     FingerprintSentinelSchema = z5.object({
       fingerprint: z5.string().regex(/^[0-9a-f]{64}$/),
       source: z5.enum(["cli", "cli-resync"]),
@@ -17248,15 +17454,15 @@ var init_local_fingerprint = __esm({
 });
 
 // src/security/install-tracking.ts
-import { readFileSync as readFileSync22, readdirSync as readdirSync13, lstatSync as lstatSync6, existsSync as existsSync23 } from "node:fs";
+import { readFileSync as readFileSync22, readdirSync as readdirSync13, lstatSync as lstatSync6, existsSync as existsSync24 } from "node:fs";
 import { join as join11, relative as relative5, sep } from "node:path";
 import { homedir as homedir7 } from "node:os";
-import { resolve as resolve20 } from "node:path";
+import { resolve as resolve21 } from "node:path";
 import { createHash as createHash8 } from "node:crypto";
 import { z as z6 } from "zod";
 function containsHiddenDirs(packageDir) {
   for (const hidden of EXCLUDED_DIR_NAMES) {
-    if (existsSync23(`${packageDir}/${hidden}`)) {
+    if (existsSync24(`${packageDir}/${hidden}`)) {
       return hidden;
     }
   }
@@ -17311,7 +17517,7 @@ function sha256OfDir(dir, opts = {}) {
   return top.digest("hex");
 }
 function readInstalledManifest(path = INSTALLED_MANIFEST_PATH) {
-  if (!existsSync23(path)) return {};
+  if (!existsSync24(path)) return {};
   let raw;
   try {
     raw = JSON.parse(readFileSync22(path, "utf-8"));
@@ -17378,7 +17584,7 @@ var init_install_tracking = __esm({
   "src/security/install-tracking.ts"() {
     "use strict";
     init_atomic_write();
-    INSTALLED_MANIFEST_PATH = resolve20(homedir7(), ".massu", "adapter-manifest-installed.json");
+    INSTALLED_MANIFEST_PATH = resolve21(homedir7(), ".massu", "adapter-manifest-installed.json");
     DEFAULT_MAX_FILE_BYTES = 64 * 1024 * 1024;
     EXCLUDED_DIR_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", ".cache", ".tmp"]);
     InstallEntrySchema = z6.object({
@@ -17401,12 +17607,12 @@ var init_install_tracking = __esm({
 });
 
 // src/detect/adapters/discover.ts
-import { existsSync as existsSync24, readdirSync as readdirSync14, readFileSync as readFileSync23, lstatSync as lstatSync7 } from "node:fs";
-import { resolve as resolve21, isAbsolute as isAbsolute2 } from "node:path";
+import { existsSync as existsSync25, readdirSync as readdirSync14, readFileSync as readFileSync23, lstatSync as lstatSync7 } from "node:fs";
+import { resolve as resolve22, isAbsolute as isAbsolute2 } from "node:path";
 import { z as z7 } from "zod";
 function walkNodeModules(projectRoot, warnings) {
-  const nodeModulesDir = resolve21(projectRoot, "node_modules");
-  if (!existsSync24(nodeModulesDir)) {
+  const nodeModulesDir = resolve22(projectRoot, "node_modules");
+  if (!existsSync25(nodeModulesDir)) {
     return [];
   }
   const candidates = [];
@@ -17419,7 +17625,7 @@ function walkNodeModules(projectRoot, warnings) {
   }
   for (const entry of topLevelEntries) {
     if (entry.startsWith(".")) continue;
-    const entryPath = resolve21(nodeModulesDir, entry);
+    const entryPath = resolve22(nodeModulesDir, entry);
     let entryStat;
     try {
       entryStat = lstatSync7(entryPath);
@@ -17441,7 +17647,7 @@ function walkNodeModules(projectRoot, warnings) {
         continue;
       }
       for (const sub of scopedEntries) {
-        const subPath = resolve21(entryPath, sub);
+        const subPath = resolve22(entryPath, sub);
         let subStat;
         try {
           subStat = lstatSync7(subPath);
@@ -17460,8 +17666,8 @@ function walkNodeModules(projectRoot, warnings) {
   return candidates;
 }
 function tryReadAdapterPackage(packageDir, warnings) {
-  const pkgJsonPath = resolve21(packageDir, "package.json");
-  if (!existsSync24(pkgJsonPath)) return null;
+  const pkgJsonPath = resolve22(packageDir, "package.json");
+  if (!existsSync25(pkgJsonPath)) return null;
   let raw;
   try {
     raw = JSON.parse(readFileSync23(pkgJsonPath, "utf-8"));
@@ -17598,8 +17804,8 @@ function discoverAdapters(opts) {
   const localSet = new Set(opts.configLocalPaths);
   for (const localPath of opts.configLocalPaths) {
     if (seenIds.has(localPath)) continue;
-    const absPath = isAbsolute2(localPath) ? localPath : resolve21(opts.projectRoot, localPath);
-    if (!existsSync24(absPath)) {
+    const absPath = isAbsolute2(localPath) ? localPath : resolve22(opts.projectRoot, localPath);
+    if (!existsSync25(absPath)) {
       warnings.push(
         `local adapter file not found: ${localPath} (resolved to ${absPath}). Remove via: massu adapters remove-local ${localPath}`
       );
@@ -17680,8 +17886,8 @@ __export(adapters_exports, {
   runAdaptersResyncLocalFingerprint: () => runAdaptersResyncLocalFingerprint,
   runAdaptersSearch: () => runAdaptersSearch
 });
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
-import { resolve as resolve22 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync24 } from "node:fs";
+import { resolve as resolve23 } from "node:path";
 import { parseDocument } from "yaml";
 async function handleAdaptersSubcommand(args2) {
   const sub = args2[0];
@@ -17948,8 +18154,8 @@ function mutateLocalArray(mutator, command) {
     );
     return { exitCode: 2 };
   }
-  const yamlPath = resolve22(projectRoot, "massu.config.yaml");
-  if (!existsSync25(yamlPath)) {
+  const yamlPath = resolve23(projectRoot, "massu.config.yaml");
+  if (!existsSync26(yamlPath)) {
     process.stderr.write(
       `${command}: massu.config.yaml not found at ${yamlPath}. Run \`massu init\` first.
 `
@@ -17979,7 +18185,7 @@ function mutateLocalArray(mutator, command) {
   if (next === null) {
     return { exitCode: 0 };
   }
-  const lockPath = resolve22(projectRoot, ".massu", "adapters-local-mutate.lock");
+  const lockPath = resolve23(projectRoot, ".massu", "adapters-local-mutate.lock");
   return withFileLockSync(lockPath, () => {
     doc.setIn(["adapters", "local"], next);
     const newYaml = doc.toString();
@@ -18048,16 +18254,16 @@ async function runAdaptersInstall(args2) {
 `);
     return { exitCode: 1 };
   }
-  const packageDir = resolve22(projectRoot, "node_modules", ...packageName.split("/"));
-  if (!existsSync25(packageDir)) {
+  const packageDir = resolve23(projectRoot, "node_modules", ...packageName.split("/"));
+  if (!existsSync26(packageDir)) {
     process.stderr.write(
       `install: ${packageName} is not installed in node_modules. Run \`npm install ${packageName}\` first.
 `
     );
     return { exitCode: 1 };
   }
-  const pkgJsonPath = resolve22(packageDir, "package.json");
-  if (!existsSync25(pkgJsonPath)) {
+  const pkgJsonPath = resolve23(packageDir, "package.json");
+  if (!existsSync26(pkgJsonPath)) {
     process.stderr.write(`install: ${packageName} has no package.json at ${pkgJsonPath}
 `);
     return { exitCode: 1 };
@@ -18183,8 +18389,8 @@ async function runAdaptersResign(_args) {
       removeInstalledManifestEntry(name);
       continue;
     }
-    const packageDir = resolve22(projectRoot, "node_modules", ...name.split("/"));
-    if (!existsSync25(packageDir)) {
+    const packageDir = resolve23(projectRoot, "node_modules", ...name.split("/"));
+    if (!existsSync26(packageDir)) {
       removed++;
       warnings.push(`${name}@${entry.version}: not present in node_modules \u2014 REMOVED from sidecar`);
       removeInstalledManifestEntry(name);
@@ -18271,11 +18477,11 @@ var init_adapters2 = __esm({
 
 // src/db.ts
 import Database2 from "better-sqlite3";
-import { dirname as dirname12, join as join12 } from "path";
-import { existsSync as existsSync26, mkdirSync as mkdirSync10, readdirSync as readdirSync15, statSync as statSync11 } from "fs";
+import { dirname as dirname13, join as join12 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync10, readdirSync as readdirSync15, statSync as statSync11 } from "fs";
 function getCodeGraphDb() {
   const dbPath = getResolvedPaths().codegraphDbPath;
-  if (!existsSync26(dbPath)) {
+  if (!existsSync27(dbPath)) {
     throw new CodegraphDbNotInitializedError(dbPath);
   }
   const db = new Database2(dbPath, { readonly: true });
@@ -18284,8 +18490,8 @@ function getCodeGraphDb() {
 }
 function getDataDb() {
   const dbPath = getResolvedPaths().dataDbPath;
-  const dir = dirname12(dbPath);
-  if (!existsSync26(dir)) {
+  const dir = dirname13(dbPath);
+  if (!existsSync27(dir)) {
     mkdirSync10(dir, { recursive: true });
   }
   const db = new Database2(dbPath);
@@ -18592,10 +18798,10 @@ var init_db = __esm({
 });
 
 // src/security-utils.ts
-import { resolve as resolve23, normalize } from "path";
+import { resolve as resolve24, normalize } from "path";
 function ensureWithinRoot(filePath, projectRoot) {
-  const resolvedRoot = resolve23(projectRoot);
-  const resolvedPath = resolve23(resolvedRoot, filePath);
+  const resolvedRoot = resolve24(projectRoot);
+  const resolvedPath = resolve24(resolvedRoot, filePath);
   const normalizedPath = normalize(resolvedPath);
   const normalizedRoot = normalize(resolvedRoot);
   if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
@@ -18668,8 +18874,8 @@ var init_rules = __esm({
 });
 
 // src/import-resolver.ts
-import { readFileSync as readFileSync25, existsSync as existsSync27, statSync as statSync12 } from "fs";
-import { resolve as resolve24, dirname as dirname13, join as join13 } from "path";
+import { readFileSync as readFileSync25, existsSync as existsSync28, statSync as statSync12 } from "fs";
+import { resolve as resolve25, dirname as dirname14, join as join13 } from "path";
 function parseImports(source) {
   const imports = [];
   const lines = source.split("\n");
@@ -18725,23 +18931,23 @@ function resolveImportPath(specifier, fromFile) {
   let basePath;
   if (specifier.startsWith("@/")) {
     const paths = getResolvedPaths();
-    basePath = resolve24(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
+    basePath = resolve25(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
   } else {
-    basePath = resolve24(dirname13(fromFile), specifier);
+    basePath = resolve25(dirname14(fromFile), specifier);
   }
-  if (existsSync27(basePath) && !isDirectory(basePath)) {
+  if (existsSync28(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
   }
   const resolvedPaths = getResolvedPaths();
   for (const ext of resolvedPaths.extensions) {
     const withExt = basePath + ext;
-    if (existsSync27(withExt)) {
+    if (existsSync28(withExt)) {
       return toRelative(withExt);
     }
   }
   for (const indexFile of resolvedPaths.indexFiles) {
     const indexPath = join13(basePath, indexFile);
-    if (existsSync27(indexPath)) {
+    if (existsSync28(indexPath)) {
       return toRelative(indexPath);
     }
   }
@@ -18777,8 +18983,8 @@ function buildImportIndex(dataDb, codegraphDb) {
   const batchSize = 500;
   let batch = [];
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve24(projectRoot, file.path), projectRoot);
-    if (!existsSync27(absPath)) continue;
+    const absPath = ensureWithinRoot(resolve25(projectRoot, file.path), projectRoot);
+    if (!existsSync28(absPath)) continue;
     let source;
     try {
       source = readFileSync25(absPath, "utf-8");
@@ -18817,12 +19023,12 @@ var init_import_resolver = __esm({
 });
 
 // src/trpc-index.ts
-import { readFileSync as readFileSync26, existsSync as existsSync28, readdirSync as readdirSync16 } from "fs";
-import { resolve as resolve25, join as join14 } from "path";
+import { readFileSync as readFileSync26, existsSync as existsSync29, readdirSync as readdirSync16 } from "fs";
+import { resolve as resolve26, join as join14 } from "path";
 function parseRootRouter() {
   const paths = getResolvedPaths();
   const rootPath = paths.rootRouterPath;
-  if (!existsSync28(rootPath)) {
+  if (!existsSync29(rootPath)) {
     throw new Error(`Root router not found at ${rootPath}`);
   }
   const source = readFileSync26(rootPath, "utf-8");
@@ -18833,16 +19039,16 @@ function parseRootRouter() {
   while ((match = importRegex.exec(source)) !== null) {
     const variable = match[1];
     let filePath = match[2];
-    const fullPath = resolve25(paths.routersDir, filePath);
+    const fullPath = resolve26(paths.routersDir, filePath);
     for (const ext of [".ts", ".tsx", ""]) {
       const candidate = fullPath + ext;
       const routersRelPath = getConfig().paths.routers ?? "src/server/api/routers";
-      if (existsSync28(candidate)) {
+      if (existsSync29(candidate)) {
         filePath = routersRelPath + "/" + filePath + ext;
         break;
       }
       const indexCandidate = join14(fullPath, "index.ts");
-      if (existsSync28(indexCandidate)) {
+      if (existsSync29(indexCandidate)) {
         filePath = routersRelPath + "/" + filePath + "/index.ts";
         break;
       }
@@ -18861,8 +19067,8 @@ function parseRootRouter() {
   return mappings;
 }
 function extractProcedures(routerFilePath) {
-  const absPath = resolve25(getProjectRoot(), routerFilePath);
-  if (!existsSync28(absPath)) return [];
+  const absPath = resolve26(getProjectRoot(), routerFilePath);
+  if (!existsSync29(absPath)) return [];
   const source = readFileSync26(absPath, "utf-8");
   const procedures = [];
   const seen = /* @__PURE__ */ new Set();
@@ -18886,13 +19092,13 @@ function findUICallSites(routerKey, procedureName) {
   const root = getProjectRoot();
   const src = config.paths.source;
   const searchDirs = [
-    resolve25(root, config.paths.pages ?? src + "/app"),
-    resolve25(root, config.paths.components ?? src + "/components"),
-    resolve25(root, config.paths.hooks ?? src + "/hooks")
+    resolve26(root, config.paths.pages ?? src + "/app"),
+    resolve26(root, config.paths.components ?? src + "/components"),
+    resolve26(root, config.paths.hooks ?? src + "/hooks")
   ];
   const searchPattern = `api.${routerKey}.${procedureName}`;
   for (const dir of searchDirs) {
-    if (!existsSync28(dir)) continue;
+    if (!existsSync29(dir)) continue;
     searchDirectory(dir, searchPattern, callSites);
   }
   return callSites;
@@ -18969,8 +19175,8 @@ var init_trpc_index = __esm({
 });
 
 // src/page-deps.ts
-import { readFileSync as readFileSync27, existsSync as existsSync29 } from "fs";
-import { resolve as resolve26 } from "path";
+import { readFileSync as readFileSync27, existsSync as existsSync30 } from "fs";
+import { resolve as resolve27 } from "path";
 function deriveRoute(pageFile) {
   let route = pageFile.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "").replace(/\/page\.jsx?$/, "");
   return route || "/";
@@ -19008,8 +19214,8 @@ function findRouterCalls(files) {
   const routers = /* @__PURE__ */ new Set();
   const projectRoot = getProjectRoot();
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve26(projectRoot, file), projectRoot);
-    if (!existsSync29(absPath)) continue;
+    const absPath = ensureWithinRoot(resolve27(projectRoot, file), projectRoot);
+    if (!existsSync30(absPath)) continue;
     try {
       const source = readFileSync27(absPath, "utf-8");
       const apiCallRegex = /api\.(\w+)\.\w+/g;
@@ -19029,8 +19235,8 @@ function findTablesFromRouters(routerNames, dataDb) {
       "SELECT DISTINCT router_file FROM massu_trpc_procedures WHERE router_name = ?"
     ).all(routerName);
     for (const proc of procs) {
-      const absPath = ensureWithinRoot(resolve26(getProjectRoot(), proc.router_file), getProjectRoot());
-      if (!existsSync29(absPath)) continue;
+      const absPath = ensureWithinRoot(resolve27(getProjectRoot(), proc.router_file), getProjectRoot());
+      if (!existsSync30(absPath)) continue;
       try {
         const source = readFileSync27(absPath, "utf-8");
         const dbPattern = getConfig().dbAccessPattern ?? "ctx.db.{table}";
@@ -19301,11 +19507,11 @@ var init_domains = __esm({
 });
 
 // src/schema-mapper.ts
-import { readFileSync as readFileSync28, existsSync as existsSync30, readdirSync as readdirSync17 } from "fs";
+import { readFileSync as readFileSync28, existsSync as existsSync31, readdirSync as readdirSync17 } from "fs";
 import { join as join15 } from "path";
 function parsePrismaSchema() {
   const schemaPath = getResolvedPaths().prismaSchemaPath;
-  if (!existsSync30(schemaPath)) {
+  if (!existsSync31(schemaPath)) {
     throw new Error(`Prisma schema not found at ${schemaPath}`);
   }
   const source = readFileSync28(schemaPath, "utf-8");
@@ -19366,7 +19572,7 @@ function toSnakeCase(str) {
 function findColumnUsageInRouters(tableName) {
   const usage = /* @__PURE__ */ new Map();
   const routersDir = getResolvedPaths().routersDir;
-  if (!existsSync30(routersDir)) return usage;
+  if (!existsSync31(routersDir)) return usage;
   scanDirectory(routersDir, tableName, usage);
   return usage;
 }
@@ -19428,7 +19634,7 @@ function detectMismatches(models) {
 }
 function findFilesUsingColumn(dir, column, tableName) {
   const result = [];
-  if (!existsSync30(dir)) return result;
+  if (!existsSync31(dir)) return result;
   const entries = readdirSync17(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join15(dir, entry.name);
@@ -19581,14 +19787,14 @@ var init_import_parser = __esm({
 });
 
 // src/python/import-resolver.ts
-import { readFileSync as readFileSync29, existsSync as existsSync31, readdirSync as readdirSync18 } from "fs";
-import { resolve as resolve28, join as join16, relative as relative6, dirname as dirname14 } from "path";
+import { readFileSync as readFileSync29, existsSync as existsSync32, readdirSync as readdirSync18 } from "fs";
+import { resolve as resolve29, join as join16, relative as relative6, dirname as dirname15 } from "path";
 function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
   const projectRoot = getProjectRoot();
   if (level > 0) {
-    let baseDir = dirname14(resolve28(projectRoot, fromFile));
+    let baseDir = dirname15(resolve29(projectRoot, fromFile));
     for (let i = 1; i < level; i++) {
-      baseDir = dirname14(baseDir);
+      baseDir = dirname15(baseDir);
     }
     const modulePart = module.replace(/^\.+/, "");
     if (modulePart) {
@@ -19598,17 +19804,17 @@ function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
     return tryResolvePythonPath(baseDir, projectRoot);
   }
   const parts = module.split(".");
-  const candidate = join16(resolve28(projectRoot, pythonRoot), ...parts);
+  const candidate = join16(resolve29(projectRoot, pythonRoot), ...parts);
   return tryResolvePythonPath(candidate, projectRoot);
 }
 function tryResolvePythonPath(basePath, projectRoot) {
-  if (existsSync31(basePath + ".py")) {
+  if (existsSync32(basePath + ".py")) {
     return relative6(projectRoot, basePath + ".py");
   }
-  if (existsSync31(join16(basePath, "__init__.py"))) {
+  if (existsSync32(join16(basePath, "__init__.py"))) {
     return relative6(projectRoot, join16(basePath, "__init__.py"));
   }
-  if (basePath.endsWith(".py") && existsSync31(basePath)) {
+  if (basePath.endsWith(".py") && existsSync32(basePath)) {
     return relative6(projectRoot, basePath);
   }
   return null;
@@ -19631,7 +19837,7 @@ function walkPythonFiles(dir, excludeDirs) {
 }
 function buildPythonImportIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = resolve28(projectRoot, pythonRoot);
+  const absRoot = resolve29(projectRoot, pythonRoot);
   dataDb.exec("DELETE FROM massu_py_imports");
   const insertStmt = dataDb.prepare(
     "INSERT INTO massu_py_imports (source_file, target_file, import_type, imported_names, line) VALUES (?, ?, ?, ?, ?)"
@@ -20956,8 +21162,8 @@ var init_memory_tools = __esm({
 });
 
 // src/docs-tools.ts
-import { readFileSync as readFileSync34, existsSync as existsSync32 } from "fs";
-import { resolve as resolve29, basename as basename6 } from "path";
+import { readFileSync as readFileSync34, existsSync as existsSync33 } from "fs";
+import { resolve as resolve30, basename as basename6 } from "path";
 function p3(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -21012,7 +21218,7 @@ function handleDocsToolCall(name, args2) {
 }
 function loadDocsMap() {
   const mapPath = getResolvedPaths().docsMapPath;
-  if (!existsSync32(mapPath)) {
+  if (!existsSync33(mapPath)) {
     throw new Error(`docs-map.json not found at ${mapPath}`);
   }
   return JSON.parse(readFileSync34(mapPath, "utf-8"));
@@ -21085,10 +21291,10 @@ function extractFrontmatter(content) {
 }
 function extractProcedureNames(routerPath) {
   const root = getProjectRoot();
-  const absPath = ensureWithinRoot(resolve29(getResolvedPaths().srcDir, "..", routerPath), root);
-  if (!existsSync32(absPath)) {
-    const altPath = ensureWithinRoot(resolve29(getResolvedPaths().srcDir, "../server/api/routers", basename6(routerPath)), root);
-    if (!existsSync32(altPath)) return [];
+  const absPath = ensureWithinRoot(resolve30(getResolvedPaths().srcDir, "..", routerPath), root);
+  if (!existsSync33(absPath)) {
+    const altPath = ensureWithinRoot(resolve30(getResolvedPaths().srcDir, "../server/api/routers", basename6(routerPath)), root);
+    if (!existsSync33(altPath)) return [];
     return extractProcedureNamesFromContent(readFileSync34(altPath, "utf-8"));
   }
   return extractProcedureNamesFromContent(readFileSync34(absPath, "utf-8"));
@@ -21131,8 +21337,8 @@ function handleDocsAudit(args2) {
   for (const [mappingId, triggeringFiles] of affectedMappings) {
     const mapping = docsMap.mappings.find((m3) => m3.id === mappingId);
     if (!mapping) continue;
-    const helpPagePath = ensureWithinRoot(resolve29(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    if (!existsSync32(helpPagePath)) {
+    const helpPagePath = ensureWithinRoot(resolve30(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    if (!existsSync33(helpPagePath)) {
       results.push({
         helpPage: mapping.helpPage,
         mappingId,
@@ -21184,8 +21390,8 @@ function handleDocsAudit(args2) {
     });
     for (const [guideName, parentId] of Object.entries(docsMap.userGuideInheritance.examples)) {
       if (parentId === mappingId) {
-        const guidePath = ensureWithinRoot(resolve29(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
-        if (existsSync32(guidePath)) {
+        const guidePath = ensureWithinRoot(resolve30(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
+        if (existsSync33(guidePath)) {
           const guideContent = readFileSync34(guidePath, "utf-8");
           const guideFrontmatter = extractFrontmatter(guideContent);
           if (!guideFrontmatter?.lastVerified || status === "STALE") {
@@ -21219,8 +21425,8 @@ function handleDocsCoverage(args2) {
   const gaps = [];
   const mappings = filterDomain ? docsMap.mappings.filter((m3) => m3.id === filterDomain) : docsMap.mappings;
   for (const mapping of mappings) {
-    const helpPagePath = ensureWithinRoot(resolve29(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    const exists = existsSync32(helpPagePath);
+    const helpPagePath = ensureWithinRoot(resolve30(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    const exists = existsSync33(helpPagePath);
     let hasContent = false;
     let lineCount = 0;
     let lastVerified = null;
@@ -21567,8 +21773,8 @@ var init_observability_tools = __esm({
 });
 
 // src/sentinel-db.ts
-import { existsSync as existsSync33 } from "fs";
-import { resolve as resolve30 } from "path";
+import { existsSync as existsSync34 } from "fs";
+import { resolve as resolve31 } from "path";
 function parsePortalScope(raw) {
   if (!raw) return [];
   try {
@@ -21804,23 +22010,23 @@ function validateFeatures(db, domainFilter) {
     const missingProcedures = [];
     const missingPages = [];
     for (const comp of components) {
-      const absPath = resolve30(PROJECT_ROOT, comp.component_file);
-      if (!existsSync33(absPath)) {
+      const absPath = resolve31(PROJECT_ROOT, comp.component_file);
+      if (!existsSync34(absPath)) {
         missingComponents.push(comp.component_file);
       }
     }
     for (const proc of procedures) {
-      const routerPath = resolve30(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
-      if (!existsSync33(routerPath)) {
+      const routerPath = resolve31(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
+      if (!existsSync34(routerPath)) {
         missingProcedures.push({ router: proc.router_name, procedure: proc.procedure_name });
       }
     }
     for (const page of pages) {
       const routeToPath = page.page_route.replace(/^\/(portal-[^/]+\/)?/, "src/app/").replace(/\/$/, "") + "/page.tsx";
-      const absPath = resolve30(PROJECT_ROOT, routeToPath);
-      if (page.page_route.startsWith("/") && !existsSync33(absPath)) {
-        const altPath = resolve30(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
-        if (!existsSync33(altPath)) {
+      const absPath = resolve31(PROJECT_ROOT, routeToPath);
+      if (page.page_route.startsWith("/") && !existsSync34(absPath)) {
+        const altPath = resolve31(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
+        if (!existsSync34(altPath)) {
           missingPages.push(page.page_route);
         }
       }
@@ -22344,8 +22550,8 @@ var init_sentinel_tools = __esm({
 });
 
 // src/sentinel-scanner.ts
-import { readFileSync as readFileSync35, existsSync as existsSync34, readdirSync as readdirSync23, statSync as statSync13 } from "fs";
-import { resolve as resolve31, join as join21, basename as basename7, dirname as dirname15, relative as relative11 } from "path";
+import { readFileSync as readFileSync35, existsSync as existsSync35, readdirSync as readdirSync23, statSync as statSync13 } from "fs";
+import { resolve as resolve32, join as join21, basename as basename7, dirname as dirname16, relative as relative11 } from "path";
 function inferDomain(filePath) {
   const domains = getConfig().domains;
   const path = filePath.toLowerCase();
@@ -22474,8 +22680,8 @@ function scanComponentExports(dataDb) {
   const projectRoot = getProjectRoot();
   const componentsBase = config.paths.components ?? config.paths.source + "/components";
   const componentDirs = [];
-  const basePath = resolve31(projectRoot, componentsBase);
-  if (existsSync34(basePath)) {
+  const basePath = resolve32(projectRoot, componentsBase);
+  if (existsSync35(basePath)) {
     try {
       const entries = readdirSync23(basePath, { withFileTypes: true });
       for (const entry of entries) {
@@ -22487,8 +22693,8 @@ function scanComponentExports(dataDb) {
     }
   }
   for (const dir of componentDirs) {
-    const absDir = resolve31(projectRoot, dir);
-    if (!existsSync34(absDir)) continue;
+    const absDir = resolve32(projectRoot, dir);
+    if (!existsSync35(absDir)) continue;
     const files = walkDir2(absDir).filter((f2) => f2.endsWith(".tsx") || f2.endsWith(".ts"));
     for (const file of files) {
       const relPath = relative11(projectRoot, file);
@@ -22518,7 +22724,7 @@ function scanComponentExports(dataDb) {
       if (hasHandlers && exportMatch) {
         const componentName = exportMatch[1];
         const domain = inferDomain(relPath);
-        const subdomain = basename7(dirname15(relPath));
+        const subdomain = basename7(dirname16(relPath));
         const featureKey = `component.${subdomain}.${componentName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "")}`;
         if (!annotations.some((a2) => a2.featureKey === featureKey)) {
           features.push({
@@ -23531,7 +23737,7 @@ var init_audit_trail = __esm({
 });
 
 // src/validation-engine.ts
-import { existsSync as existsSync35, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync36 } from "fs";
 function p10(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -23562,7 +23768,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  if (!existsSync35(absPath)) {
+  if (!existsSync36(absPath)) {
     checks.push({
       name: "file_exists",
       severity: "error",
@@ -24016,7 +24222,7 @@ var init_adr_generator = __esm({
 });
 
 // src/security-scorer.ts
-import { existsSync as existsSync36, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync37 } from "fs";
 function p12(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -24040,7 +24246,7 @@ function scoreFileSecurity(filePath, projectRoot) {
       }]
     };
   }
-  if (!existsSync36(absPath)) {
+  if (!existsSync37(absPath)) {
     return { riskScore: 0, findings: [] };
   }
   let source;
@@ -24334,8 +24540,8 @@ var init_security_scorer = __esm({
 });
 
 // src/dependency-scorer.ts
-import { existsSync as existsSync37, readFileSync as readFileSync38 } from "fs";
-import { resolve as resolve32 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync38 } from "fs";
+import { resolve as resolve33 } from "path";
 function p13(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -24367,8 +24573,8 @@ function calculateDepRisk(factors) {
   return Math.min(100, risk);
 }
 function getInstalledPackages(projectRoot) {
-  const pkgPath = resolve32(projectRoot, "package.json");
-  if (!existsSync37(pkgPath)) return /* @__PURE__ */ new Map();
+  const pkgPath = resolve33(projectRoot, "package.json");
+  if (!existsSync38(pkgPath)) return /* @__PURE__ */ new Map();
   try {
     const pkg = JSON.parse(readFileSync38(pkgPath, "utf-8"));
     const packages = /* @__PURE__ */ new Map();
@@ -24973,8 +25179,8 @@ var init_regression_detector = __esm({
 
 // src/knowledge-indexer.ts
 import { createHash as createHash9 } from "crypto";
-import { readFileSync as readFileSync39, readdirSync as readdirSync24, statSync as statSync14, existsSync as existsSync38 } from "fs";
-import { resolve as resolve33, relative as relative12, basename as basename8, extname as extname2 } from "path";
+import { readFileSync as readFileSync39, readdirSync as readdirSync24, statSync as statSync14, existsSync as existsSync39 } from "fs";
+import { resolve as resolve34, relative as relative12, basename as basename8, extname as extname2 } from "path";
 function getKnowledgePaths() {
   const resolved = getResolvedPaths();
   const config = getConfig();
@@ -25002,7 +25208,7 @@ function discoverMarkdownFiles(baseDir) {
     try {
       const entries = readdirSync24(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = resolve33(dir, entry.name);
+        const fullPath = resolve34(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "archive" && dir.includes("session-state")) continue;
           if (entry.name === "archive" && dir.includes("status")) continue;
@@ -25280,11 +25486,11 @@ function indexAllKnowledge(db) {
     files.push(...memFiles);
   } catch {
   }
-  if (existsSync38(paths.plansDir)) {
+  if (existsSync39(paths.plansDir)) {
     const planFiles = discoverMarkdownFiles(paths.plansDir);
     files.push(...planFiles);
   }
-  if (existsSync38(paths.docsDir)) {
+  if (existsSync39(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
     const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f2) => !f2.includes("/plans/") && !excludePatterns.some((p19) => f2.includes(p19)));
     files.push(...docsFiles);
@@ -25327,7 +25533,7 @@ function indexAllKnowledge(db) {
     } catch {
     }
     for (const filePath of files) {
-      if (!existsSync38(filePath)) continue;
+      if (!existsSync39(filePath)) continue;
       const content = readFileSync39(filePath, "utf-8");
       const hash = hashContent2(content);
       const relPath = filePath.startsWith(paths.claudeDir) ? relative12(paths.claudeDir, filePath) : filePath.startsWith(paths.plansDir) ? "plans/" + relative12(paths.plansDir, filePath) : filePath.startsWith(paths.docsDir) ? "docs/" + relative12(paths.docsDir, filePath) : filePath.startsWith(paths.memoryDir) ? `memory/${relative12(paths.memoryDir, filePath)}` : basename8(filePath);
@@ -25448,10 +25654,10 @@ function isKnowledgeStale(db) {
     files.push(...discoverMarkdownFiles(paths.memoryDir));
   } catch {
   }
-  if (existsSync38(paths.plansDir)) {
+  if (existsSync39(paths.plansDir)) {
     files.push(...discoverMarkdownFiles(paths.plansDir));
   }
-  if (existsSync38(paths.docsDir)) {
+  if (existsSync39(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
     const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f2) => !f2.includes("/plans/") && !excludePatterns.some((p19) => f2.includes(p19)));
     files.push(...docsFiles);
@@ -25481,7 +25687,7 @@ var init_knowledge_indexer = __esm({
 
 // src/knowledge-tools.ts
 import { readFileSync as readFileSync40, writeFileSync as writeFileSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync25 } from "fs";
-import { resolve as resolve34, basename as basename9 } from "path";
+import { resolve as resolve35, basename as basename9 } from "path";
 function p16(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -26218,7 +26424,7 @@ function handleCorrect(db, args2) {
   if (!wrong || !correction || !rule) {
     return text15("Error: wrong, correction, and rule are all required.");
   }
-  const correctionsPath = resolve34(getResolvedPaths().memoryDir, "corrections.md");
+  const correctionsPath = resolve35(getResolvedPaths().memoryDir, "corrections.md");
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const title = rule.slice(0, 60);
   const entry = `
@@ -26569,12 +26775,12 @@ var init_knowledge_tools = __esm({
 
 // src/knowledge-db.ts
 import Database3 from "better-sqlite3";
-import { dirname as dirname16 } from "path";
-import { existsSync as existsSync40, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname17 } from "path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync11 } from "fs";
 function getKnowledgeDb() {
   const dbPath = getResolvedPaths().knowledgeDbPath;
-  const dir = dirname16(dbPath);
-  if (!existsSync40(dir)) {
+  const dir = dirname17(dbPath);
+  if (!existsSync41(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   const db = new Database3(dbPath);
@@ -27308,8 +27514,8 @@ var init_python_tools = __esm({
 });
 
 // src/tools.ts
-import { readFileSync as readFileSync41, existsSync as existsSync41 } from "fs";
-import { resolve as resolve35, basename as basename10 } from "path";
+import { readFileSync as readFileSync41, existsSync as existsSync42 } from "fs";
+import { resolve as resolve36, basename as basename10 } from "path";
 function prefix2() {
   return getConfig().toolPrefix;
 }
@@ -27344,7 +27550,7 @@ function ensureIndexes(dataDb, codegraphDb, force = false) {
   if (config.python?.root) {
     const pythonRoot = config.python.root;
     const excludeDirs = config.python.exclude_dirs || ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"];
-    if (force || isPythonDataStale(dataDb, resolve35(getProjectRoot(), pythonRoot))) {
+    if (force || isPythonDataStale(dataDb, resolve36(getProjectRoot(), pythonRoot))) {
       const pyImports = buildPythonImportIndex(dataDb, pythonRoot, excludeDirs);
       results.push(`Python imports: ${pyImports}`);
       const pyRoutes = buildPythonRouteIndex(dataDb, pythonRoot, excludeDirs);
@@ -27779,8 +27985,8 @@ function handleContext(file, dataDb, codegraphDb) {
         try {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
-          const absFilePath = ensureWithinRoot(resolve35(resolvedPaths.srcDir, "..", file), root);
-          if (existsSync41(absFilePath)) {
+          const absFilePath = ensureWithinRoot(resolve36(resolvedPaths.srcDir, "..", file), root);
+          if (existsSync42(absFilePath)) {
             const fileContent = readFileSync41(absFilePath, "utf-8").slice(0, 3e3);
             const keywords = [];
             if (fileContent.includes("ctx.db")) keywords.push("database", "schema");
@@ -28205,8 +28411,8 @@ function handleSchema(args2) {
     lines.push("Checking all column references against Prisma schema...");
     lines.push("");
     const projectRoot = getProjectRoot();
-    const absPath = ensureWithinRoot(resolve35(projectRoot, file), projectRoot);
-    if (!existsSync41(absPath)) {
+    const absPath = ensureWithinRoot(resolve36(projectRoot, file), projectRoot);
+    if (!existsSync42(absPath)) {
       return text17(`File not found: ${file}`);
     }
     const source = readFileSync41(absPath, "utf-8");
@@ -28579,8 +28785,8 @@ var init_server_dispatch = __esm({
 // src/server.ts
 var server_exports = {};
 import { readFileSync as readFileSync42 } from "fs";
-import { resolve as resolve36, dirname as dirname17 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { resolve as resolve37, dirname as dirname18 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 function pruneMemoryOnStartup() {
   try {
     const memDb = getMemoryDb();
@@ -28604,17 +28810,17 @@ function pruneMemoryOnStartup() {
     );
   }
 }
-var __dirname4, PKG_VERSION, dispatcher, buffer;
+var __dirname5, PKG_VERSION, dispatcher, buffer;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
     init_memory_db();
     init_license();
     init_server_dispatch();
-    __dirname4 = dirname17(fileURLToPath4(import.meta.url));
+    __dirname5 = dirname18(fileURLToPath5(import.meta.url));
     PKG_VERSION = (() => {
       try {
-        const pkg = JSON.parse(readFileSync42(resolve36(__dirname4, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync42(resolve37(__dirname5, "..", "package.json"), "utf-8"));
         return pkg.version ?? "0.0.0";
       } catch {
         return "0.0.0";
@@ -28900,19 +29106,19 @@ var config_upgrade_exports = {};
 __export(config_upgrade_exports, {
   runConfigUpgrade: () => runConfigUpgrade
 });
-import { existsSync as existsSync42, readFileSync as readFileSync43, writeFileSync as writeFileSync6, copyFileSync, unlinkSync as unlinkSync2 } from "fs";
-import { resolve as resolve37 } from "path";
+import { existsSync as existsSync43, readFileSync as readFileSync43, writeFileSync as writeFileSync6, copyFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve38 } from "path";
 import { parse as parseYaml6 } from "yaml";
 async function runConfigUpgrade(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve37(cwd, "massu.config.yaml");
+  const configPath = resolve38(cwd, "massu.config.yaml");
   const bakPath = `${configPath}.bak`;
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
   if (opts.rollback) {
-    if (!existsSync42(bakPath)) {
+    if (!existsSync43(bakPath)) {
       const message = `No backup found at ${bakPath}`;
       err(message + "\n");
       return { exitCode: 1, action: "none", message };
@@ -28928,7 +29134,7 @@ async function runConfigUpgrade(opts = {}) {
       return { exitCode: 2, action: "none", message };
     }
   }
-  if (!existsSync42(configPath)) {
+  if (!existsSync43(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return { exitCode: 1, action: "none", message };
@@ -28992,8 +29198,8 @@ var config_check_drift_exports = {};
 __export(config_check_drift_exports, {
   runConfigCheckDrift: () => runConfigCheckDrift
 });
-import { existsSync as existsSync43, readFileSync as readFileSync44 } from "fs";
-import { resolve as resolve38 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync44 } from "fs";
+import { resolve as resolve39 } from "path";
 import { parse as parseYaml7 } from "yaml";
 function renderChanges(changes) {
   if (changes.length === 0) return "(none)\n";
@@ -29001,12 +29207,12 @@ function renderChanges(changes) {
 }
 async function runConfigCheckDrift(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve38(cwd, "massu.config.yaml");
+  const configPath = resolve39(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
-  if (!existsSync43(configPath)) {
+  if (!existsSync44(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return {
@@ -29088,10 +29294,10 @@ var init_config_check_drift = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync45 } from "fs";
-import { resolve as resolve39, dirname as dirname18 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-var __filename4 = fileURLToPath5(import.meta.url);
-var __dirname5 = dirname18(__filename4);
+import { resolve as resolve40, dirname as dirname19 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+var __filename5 = fileURLToPath6(import.meta.url);
+var __dirname6 = dirname19(__filename5);
 var args = process.argv.slice(2);
 var subcommand = args[0];
 async function main() {
@@ -29111,6 +29317,12 @@ async function main() {
       await runInstallHooks2();
       break;
     }
+    case "hook-runner": {
+      const { runHookRunner: runHookRunner2 } = await Promise.resolve().then(() => (init_hook_runner(), hook_runner_exports));
+      const result = await runHookRunner2(args.slice(1));
+      process.exit(result.exitCode);
+      return;
+    }
     case "install-commands": {
       const { runInstallCommands: runInstallCommands2 } = await Promise.resolve().then(() => (init_install_commands(), install_commands_exports));
       await runInstallCommands2();
@@ -29287,7 +29499,7 @@ Examples:
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync45(resolve39(__dirname5, "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync45(resolve40(__dirname6, "../package.json"), "utf-8"));
     console.log(`massu v${pkg.version}`);
   } catch {
     console.log("massu v0.1.0");