@massu/core 1.8.0 → 1.9.0

package/dist/cli.js

@@ -8045,41 +8045,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p19 = new Promise(function(resolve38, reject) {
+        var p19 = new Promise(function(resolve40, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve38(result);
+            resolve40(result);
           });
         });
         p19.catch(noop);
         return p19;
       }
       function unshift(value) {
-        var p19 = new Promise(function(resolve38, reject) {
+        var p19 = new Promise(function(resolve40, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve38(result);
+            resolve40(result);
           });
         });
         p19.catch(noop);
         return p19;
       }
       function drained() {
-        var p19 = new Promise(function(resolve38) {
+        var p19 = new Promise(function(resolve40) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve38();
+              resolve40();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve38();
+                resolve40();
                 queue.drain = previousDrain;
               };
             }
@@ -8565,9 +8565,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve38, reject) => {
+        return new Promise((resolve40, reject) => {
           this._stat(filepath, this._fsStatSettings, (error, stats) => {
-            return error === null ? resolve38(stats) : reject(error);
+            return error === null ? resolve40(stats) : reject(error);
           });
         });
       }
@@ -8591,10 +8591,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve38, reject) => {
+        return new Promise((resolve40, reject) => {
           this._walkAsync(root, options, (error, entries) => {
             if (error === null) {
-              resolve38(entries);
+              resolve40(entries);
             } else {
               reject(error);
             }
@@ -8604,10 +8604,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve38, reject) => {
+        return new Promise((resolve40, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve38(entries));
+          stream.once("end", () => resolve40(entries));
         });
       }
     };
@@ -14883,13 +14883,252 @@ 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";
+function parseCommitsForPlanTokens(subjects) {
+  const tokens = /* @__PURE__ */ new Set();
+  const maintenance = [];
+  for (const subject of subjects) {
+    const m3 = subject.match(PLAN_TOKEN_RE);
+    if (m3 && m3[2]) {
+      tokens.add(m3[2]);
+    } else {
+      maintenance.push(subject);
+    }
+  }
+  return { tokens, maintenance };
+}
+function loadPlanSummaries(tokens, planDir) {
+  const result = /* @__PURE__ */ new Map();
+  if (tokens.size === 0) return result;
+  if (!existsSync13(planDir)) {
+    throw new Error(`Plan directory does not exist: ${planDir}`);
+  }
+  const files = readdirSync12(planDir).filter((f2) => f2.endsWith(".md"));
+  for (const token of tokens) {
+    let matchedFile = null;
+    let content = "";
+    for (const file of files) {
+      const path = resolve10(planDir, file);
+      const text18 = readFileSync13(path, "utf-8");
+      const tokenRe = new RegExp(
+        `^\\*\\*Plan Token\\*\\*:\\s*\`?${token.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\`?(\\s|$)`,
+        "m"
+      );
+      if (tokenRe.test(text18)) {
+        matchedFile = file;
+        content = text18;
+        break;
+      }
+    }
+    if (!matchedFile) {
+      throw new MissingPlanFileError(token);
+    }
+    const titleMatch = content.match(/^# (.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : token;
+    const sectionRe = /^## Changelog Summary\s*\n([\s\S]*?)(?=\n## |\n---|\n# |$)/m;
+    const sectionMatch = content.match(sectionRe);
+    if (!sectionMatch || !sectionMatch[1].trim()) {
+      throw new MissingChangelogSummaryError(token, matchedFile);
+    }
+    const summary = sectionMatch[1].trim();
+    result.set(token, { title, summary });
+  }
+  return result;
+}
+function generateChangelogEntry(opts) {
+  const parts = [];
+  parts.push(`## [${opts.version}] - ${opts.date}
+`);
+  parts.push("");
+  for (const [, planSum] of opts.planSummaries) {
+    parts.push(planSum.summary);
+    parts.push("");
+  }
+  if (opts.maintenance.length > 0) {
+    parts.push("### Maintenance");
+    parts.push("");
+    for (const subject of opts.maintenance) {
+      parts.push(`- ${subject}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n") + "\n";
+}
+function findCoverageGaps(entryText, tokens) {
+  const gaps = [];
+  for (const token of tokens) {
+    if (!entryText.includes(token)) {
+      gaps.push(token);
+    }
+  }
+  return gaps;
+}
+var PLAN_TOKEN_RE, MissingPlanFileError, MissingChangelogSummaryError;
+var init_changelog_generator = __esm({
+  "src/changelog-generator.ts"() {
+    "use strict";
+    PLAN_TOKEN_RE = /^(feat|fix|chore|docs)\((plan-[a-z0-9._-]+)\)/;
+    MissingPlanFileError = class extends Error {
+      constructor(token) {
+        super(`No plan file found in plans directory matching Plan Token: ${token}`);
+        this.name = "MissingPlanFileError";
+      }
+    };
+    MissingChangelogSummaryError = class extends Error {
+      constructor(token, planFile) {
+        super(`Plan file ${planFile} for token ${token} has no '## Changelog Summary' section`);
+        this.name = "MissingChangelogSummaryError";
+      }
+    };
+  }
+});
+
+// src/commands/changelog.ts
+var changelog_exports = {};
+__export(changelog_exports, {
+  handleChangelogSubcommand: () => handleChangelogSubcommand,
+  printChangelogHelp: () => printChangelogHelp
+});
+import { execSync } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
+import { resolve as resolve11 } from "path";
+function resolveRepoRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+function getLastTag() {
+  try {
+    return execSync("git describe --tags --abbrev=0", { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function getCommitSubjects(range) {
+  try {
+    const out = execSync(`git log ${range} --pretty=format:%s`, { encoding: "utf-8" });
+    return out.split("\n").filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
+function getCurrentVersion(repoRoot) {
+  const pkgPath = resolve11(repoRoot, "packages/core/package.json");
+  if (!existsSync14(pkgPath)) return "0.0.0";
+  const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+  return pkg.version || "0.0.0";
+}
+function todayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function getLatestChangelogEntryBody(repoRoot) {
+  const path = resolve11(repoRoot, "CHANGELOG.md");
+  if (!existsSync14(path)) return "";
+  const content = readFileSync14(path, "utf-8");
+  const m3 = content.match(/^## \[[\d.]+\][^\n]*\n([\s\S]*?)(?=\n## \[|$)/m);
+  return m3 ? m3[1] : "";
+}
+async function handleChangelogSubcommand(args2) {
+  const sub = args2[0];
+  const repoRoot = resolveRepoRoot();
+  const planDir = resolve11(repoRoot, "docs/plans");
+  switch (sub) {
+    case "generate": {
+      const lastTag = getLastTag();
+      const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
+      const subjects = getCommitSubjects(range);
+      const { tokens, maintenance } = parseCommitsForPlanTokens(subjects);
+      let planSummaries;
+      try {
+        planSummaries = loadPlanSummaries(tokens, planDir);
+      } catch (err) {
+        if (err instanceof MissingPlanFileError || err instanceof MissingChangelogSummaryError) {
+          process.stderr.write(`changelog generate: ${err.message}
+`);
+          return { exitCode: 2 };
+        }
+        throw err;
+      }
+      const entry = generateChangelogEntry({
+        version: getCurrentVersion(repoRoot),
+        date: todayDate(),
+        planSummaries,
+        maintenance
+      });
+      process.stdout.write(entry);
+      return { exitCode: 0 };
+    }
+    case "verify": {
+      const lastTag = getLastTag();
+      const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
+      const subjects = getCommitSubjects(range);
+      const { tokens } = parseCommitsForPlanTokens(subjects);
+      const entryBody = getLatestChangelogEntryBody(repoRoot);
+      const gaps = findCoverageGaps(entryBody, tokens);
+      if (gaps.length === 0) {
+        process.stdout.write("All plan-tokens referenced.\n");
+        return { exitCode: 0 };
+      }
+      for (const t of gaps) {
+        process.stderr.write(`gap: ${t}
+`);
+      }
+      return { exitCode: 1 };
+    }
+    case "--help":
+    case "-h":
+    case void 0: {
+      printChangelogHelp();
+      return { exitCode: 0 };
+    }
+    default: {
+      process.stderr.write(`massu: unknown changelog subcommand: ${sub}
+`);
+      printChangelogHelp();
+      return { exitCode: 1 };
+    }
+  }
+}
+function printChangelogHelp() {
+  process.stdout.write(`
+massu changelog <subcommand>
+
+Subcommands:
+  generate    Emit a draft CHANGELOG.md entry to stdout. Reads commit subjects
+              since the last git tag, groups by (plan-<token>) paren-notation,
+              looks up each plan file's ## Changelog Summary section, and emits
+              a Keep-a-Changelog 1.1.0 entry. Operator pipes/copies into
+              CHANGELOG.md (no forced overwrite).
+
+  verify      Read-only check that the latest CHANGELOG.md entry references
+              every plan-token in commits since the last tag. Exit 0 if clean,
+              exit 1 with one 'gap: <token>' per missing.
+
+Examples:
+  npx massu changelog generate > /tmp/draft-entry.md
+  npx massu changelog verify
+
+Documentation: https://massu.ai/docs/reference/cli-reference#massu-changelog
+`);
+}
+var init_changelog = __esm({
+  "src/commands/changelog.ts"() {
+    "use strict";
+    init_changelog_generator();
+  }
+});
+
 // src/commands/show-template.ts
 var show_template_exports = {};
 __export(show_template_exports, {
   runShowTemplate: () => runShowTemplate
 });
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve12 } from "path";
 function normalizeBaseName(input) {
   return input.endsWith(".md") ? input.slice(0, -".md".length) : input;
 }
@@ -14917,14 +15156,14 @@ async function runShowTemplate(args2) {
     return;
   }
   const suffix = choice.kind === "hit" ? choice.suffix : "";
-  const file = suffix === "" ? resolve10(sourceDir, `${baseName}.md`) : resolve10(sourceDir, `${baseName}${suffix}.md`);
-  if (!existsSync13(file)) {
+  const file = suffix === "" ? resolve12(sourceDir, `${baseName}.md`) : resolve12(sourceDir, `${baseName}${suffix}.md`);
+  if (!existsSync15(file)) {
     process.stderr.write(`massu: resolved template "${file}" no longer exists
 `);
     process.exit(1);
     return;
   }
-  process.stdout.write(readFileSync13(file, "utf-8"));
+  process.stdout.write(readFileSync15(file, "utf-8"));
 }
 var init_show_template = __esm({
   "src/commands/show-template.ts"() {
@@ -14977,12 +15216,12 @@ var init_passthrough = __esm({
 });
 
 // src/lib/fileLock.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync16, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname8 } from "path";
 import * as lockfile from "proper-lockfile";
 function readLockHolderPid(lockPath) {
   try {
-    const raw = readFileSync14(`${lockPath}.pid`, "utf-8").trim();
+    const raw = readFileSync16(`${lockPath}.pid`, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     if (!Number.isFinite(pid) || pid <= 0) return null;
     return pid;
@@ -15069,9 +15308,9 @@ var init_fileLock = __esm({
 });
 
 // src/lib/installLock.ts
-import { resolve as resolve11 } from "path";
+import { resolve as resolve13 } from "path";
 function withInstallLock(projectRoot, fn, opts = {}) {
-  const lockPath = resolve11(projectRoot, ".massu", "installAll.lock");
+  const lockPath = resolve13(projectRoot, ".massu", "installAll.lock");
   return withFileLockSync(
     lockPath,
     fn,
@@ -15107,8 +15346,8 @@ __export(config_refresh_exports, {
   mergeRefresh: () => mergeRefresh,
   runConfigRefresh: () => runConfigRefresh
 });
-import { existsSync as existsSync14, readFileSync as readFileSync15, rmSync as rmSync4 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync17, rmSync as rmSync4 } from "fs";
+import { resolve as resolve14 } from "path";
 import { parse as parseYaml5 } from "yaml";
 function flatten(obj, prefix3 = "") {
   const out = {};
@@ -15236,17 +15475,17 @@ function renderDiff(diff) {
 }
 async function runConfigRefresh(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve12(cwd, "massu.config.yaml");
+  const configPath = resolve14(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
-  if (!existsSync14(configPath)) {
+  if (!existsSync16(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 };
   }
   let existing;
   try {
-    const content = readFileSync15(configPath, "utf-8");
+    const content = readFileSync17(configPath, "utf-8");
     const parsed = parseYaml5(content);
     if (!parsed || typeof parsed !== "object") {
       throw new Error("config is not a YAML object");
@@ -15319,8 +15558,8 @@ async function runConfigRefresh(opts = {}) {
 `);
       const stackResolved = installResult.totalInstalled > 0 || installResult.totalUpdated > 0;
       if (stackResolved) {
-        const placeholderPath = resolve12(installResult.claudeDir, "commands", "_massu-needs-stack.md");
-        if (existsSync14(placeholderPath)) {
+        const placeholderPath = resolve14(installResult.claudeDir, "commands", "_massu-needs-stack.md");
+        if (existsSync16(placeholderPath)) {
           try {
             rmSync4(placeholderPath, { force: true });
             log("Removed _massu-needs-stack.md (stack now declared).\n");
@@ -15429,12 +15668,12 @@ var init_gitToplevel = __esm({
 });
 
 // src/watch/lockfile-detector.ts
-import { existsSync as existsSync15, statSync as statSync8 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync17, statSync as statSync8 } from "fs";
+import { resolve as resolve15 } from "path";
 function lockfileMidWrite(projectRoot, now = Date.now(), windowMs = LOCKFILE_WINDOW_MS) {
   for (const lf of KNOWN_LOCKFILES) {
-    const p19 = resolve13(projectRoot, lf);
-    if (!existsSync15(p19)) continue;
+    const p19 = resolve15(projectRoot, lf);
+    if (!existsSync17(p19)) continue;
     try {
       const stat = statSync8(p19);
       const delta = now - stat.mtimeMs;
@@ -15447,7 +15686,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 (existsSync15(resolve13(projectRoot, ".git", s))) return true;
+    if (existsSync17(resolve15(projectRoot, ".git", s))) return true;
   }
   return false;
 }
@@ -15644,18 +15883,18 @@ var init_paths = __esm({
 });
 
 // src/watch/state.ts
-import { closeSync as closeSync3, existsSync as existsSync16, fsyncSync as fsyncSync3, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync16, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync4, writeSync as writeSync3 } from "fs";
-import { dirname as dirname9, resolve as resolve14 } from "path";
+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";
 function watchStatePath(projectRoot) {
-  return resolve14(projectRoot, ".massu", "watch-state.json");
+  return resolve16(projectRoot, ".massu", "watch-state.json");
 }
 function backupStatePath(projectRoot) {
-  return resolve14(projectRoot, ".massu", "watch-state.v0.bak.json");
+  return resolve16(projectRoot, ".massu", "watch-state.v0.bak.json");
 }
 function readState(projectRoot) {
   const path = watchStatePath(projectRoot);
-  if (!existsSync16(path)) return { ...DEFAULT_STATE };
-  const content = readFileSync16(path, "utf-8");
+  if (!existsSync18(path)) return { ...DEFAULT_STATE };
+  const content = readFileSync18(path, "utf-8");
   let raw;
   try {
     raw = JSON.parse(content);
@@ -15718,7 +15957,7 @@ function writeStateAtomic(projectRoot, state) {
     renameSync4(tmp, path);
     renamed = true;
   } finally {
-    if (!renamed && existsSync16(tmp)) {
+    if (!renamed && existsSync18(tmp)) {
       try {
         rmSync5(tmp, { force: true });
       } catch {
@@ -15998,8 +16237,8 @@ __export(watch_exports, {
   runWatch: () => runWatch
 });
 import { spawnSync as spawnSync3 } from "child_process";
-import { basename as basename5, dirname as dirname10, resolve as resolve15 } from "path";
-import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync17 } from "fs";
+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";
 function parseFlags(args2) {
   const out = {
     foreground: false,
@@ -16024,8 +16263,8 @@ function parseFlags(args2) {
 }
 function findClaudeBg() {
   const home = process.env.HOME ?? "";
-  const fixed = home ? resolve15(home, ".claude", "bin", "claude-bg") : null;
-  if (fixed && existsSync17(fixed)) return fixed;
+  const fixed = home ? resolve17(home, ".claude", "bin", "claude-bg") : null;
+  if (fixed && existsSync19(fixed)) return fixed;
   const which = spawnSync3("which", ["claude-bg"], { encoding: "utf-8" });
   if (which.status === 0 && which.stdout) {
     const p19 = which.stdout.trim();
@@ -16086,7 +16325,7 @@ async function runWatch(args2) {
 }
 function runStatus(root) {
   const path = watchStatePath(root);
-  if (!existsSync17(path)) {
+  if (!existsSync19(path)) {
     process.stdout.write("massu watch: not running (no state file)\n");
     return { exitCode: 0 };
   }
@@ -16168,7 +16407,7 @@ async function runForeground(root) {
     }
     throw err;
   }
-  return new Promise((resolve38) => {
+  return new Promise((resolve40) => {
     const shutdown = async () => {
       if (stopped) return;
       stopped = true;
@@ -16178,7 +16417,7 @@ async function runForeground(root) {
         process.chdir(priorCwd);
       } catch {
       }
-      resolve38({ exitCode: 0 });
+      resolve40({ exitCode: 0 });
     };
     process.on("SIGINT", () => {
       void shutdown();
@@ -16239,7 +16478,7 @@ async function runOnQuiescent(projectRoot) {
   );
 }
 function refreshLogPath(projectRoot) {
-  return resolve15(projectRoot, ".massu", "refresh-log.jsonl");
+  return resolve17(projectRoot, ".massu", "refresh-log.jsonl");
 }
 function appendRefreshLog(projectRoot, event) {
   const path = refreshLogPath(projectRoot);
@@ -16251,11 +16490,11 @@ function appendRefreshLog(projectRoot, event) {
 }
 function readRefreshLog(projectRoot, limit = 10, opts = {}) {
   const path = refreshLogPath(projectRoot);
-  if (!existsSync17(path)) return [];
+  if (!existsSync19(path)) return [];
   const warn = opts.warn ?? ((s) => {
     process.stderr.write(s);
   });
-  const lines = readFileSync17(path, "utf-8").split("\n").filter(Boolean);
+  const lines = readFileSync19(path, "utf-8").split("\n").filter(Boolean);
   const tail = lines.slice(-limit);
   const out = [];
   let corrupt = 0;
@@ -16328,7 +16567,7 @@ var init_refresh_log = __esm({
 import {
   chmodSync as chmodSync3,
   closeSync as closeSync4,
-  existsSync as existsSync18,
+  existsSync as existsSync20,
   fsyncSync as fsyncSync4,
   mkdirSync as mkdirSync9,
   openSync as openSync4,
@@ -16342,7 +16581,7 @@ function atomicWrite(path, content, opts = {}) {
   const tmpPath = `${path}.tmp`;
   const parentDir = dirname11(path);
   try {
-    if (!existsSync18(parentDir)) {
+    if (!existsSync20(parentDir)) {
       const mkdirOpts = { recursive: true };
       if (opts.ensureParentDirMode !== void 0) {
         mkdirOpts.mode = opts.ensureParentDirMode;
@@ -16364,7 +16603,7 @@ function atomicWrite(path, content, opts = {}) {
     renameSync5(tmpPath, path);
     return { written: true };
   } catch (err) {
-    if (existsSync18(tmpPath)) {
+    if (existsSync20(tmpPath)) {
       try {
         rmSync6(tmpPath, { force: true });
       } catch {
@@ -16707,24 +16946,24 @@ var init_fetcher = __esm({
 });
 
 // src/security/manifest-cache.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync20, statSync as statSync10 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 import { z as z4 } from "zod";
 function defaultCachePaths() {
-  const dir = resolve16(homedir5(), ".massu");
+  const dir = resolve18(homedir5(), ".massu");
   return {
-    cachePath: resolve16(dir, "adapter-manifest.json"),
-    lockPath: resolve16(dir, ".adapter-manifest.lock")
+    cachePath: resolve18(dir, "adapter-manifest.json"),
+    lockPath: resolve18(dir, ".adapter-manifest.lock")
   };
 }
 function loadCachedManifest(paths = defaultCachePaths()) {
-  if (!existsSync19(paths.cachePath)) {
+  if (!existsSync21(paths.cachePath)) {
     return { kind: "absent" };
   }
   let raw;
   try {
-    const content = readFileSync18(paths.cachePath, "utf-8");
+    const content = readFileSync20(paths.cachePath, "utf-8");
     raw = JSON.parse(content);
   } catch (err) {
     return {
@@ -16913,15 +17152,15 @@ var init_adapter_origin = __esm({
 });
 
 // src/security/local-fingerprint.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19, lstatSync as lstatSync5 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync21, lstatSync as lstatSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { resolve as resolve17, isAbsolute } from "node:path";
+import { resolve as resolve19, 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 : resolve17(projectRoot, p19);
+    const abs = isAbsolute(p19) ? p19 : resolve19(projectRoot, p19);
     let contentTag;
     try {
       const lst = lstatSync5(abs);
@@ -16930,7 +17169,7 @@ function computeLocalFingerprint(localPaths, projectRoot) {
       } else if (!lst.isFile()) {
         contentTag = "<not-a-file>";
       } else {
-        contentTag = createHash7("sha256").update(readFileSync19(abs)).digest("hex");
+        contentTag = createHash7("sha256").update(readFileSync21(abs)).digest("hex");
       }
     } catch {
       contentTag = "<missing>";
@@ -16942,10 +17181,10 @@ function computeLocalFingerprint(localPaths, projectRoot) {
   return createHash7("sha256").update(canonical).digest("hex");
 }
 function readFingerprintSentinel(path = FINGERPRINT_PATH) {
-  if (!existsSync20(path)) return null;
+  if (!existsSync22(path)) return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync19(path, "utf-8"));
+    raw = JSON.parse(readFileSync21(path, "utf-8"));
   } catch {
     return null;
   }
@@ -16993,7 +17232,7 @@ var init_local_fingerprint = __esm({
     "use strict";
     init_atomic_write();
     init_manifest_schema();
-    FINGERPRINT_PATH = resolve17(homedir6(), ".massu", "adapters-local-fingerprint.json");
+    FINGERPRINT_PATH = resolve19(homedir6(), ".massu", "adapters-local-fingerprint.json");
     FingerprintSentinelSchema = z5.object({
       fingerprint: z5.string().regex(/^[0-9a-f]{64}$/),
       source: z5.enum(["cli", "cli-resync"]),
@@ -17009,15 +17248,15 @@ var init_local_fingerprint = __esm({
 });
 
 // src/security/install-tracking.ts
-import { readFileSync as readFileSync20, readdirSync as readdirSync12, lstatSync as lstatSync6, existsSync as existsSync21 } from "node:fs";
+import { readFileSync as readFileSync22, readdirSync as readdirSync13, lstatSync as lstatSync6, existsSync as existsSync23 } from "node:fs";
 import { join as join11, relative as relative5, sep } from "node:path";
 import { homedir as homedir7 } from "node:os";
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve20 } 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 (existsSync21(`${packageDir}/${hidden}`)) {
+    if (existsSync23(`${packageDir}/${hidden}`)) {
       return hidden;
     }
   }
@@ -17029,7 +17268,7 @@ function sha256OfDir(dir, opts = {}) {
   function walk(currentDir) {
     let entries;
     try {
-      entries = readdirSync12(currentDir);
+      entries = readdirSync13(currentDir);
     } catch {
       return;
     }
@@ -17063,7 +17302,7 @@ function sha256OfDir(dir, opts = {}) {
   files.sort((a2, b2) => a2.relativePath < b2.relativePath ? -1 : a2.relativePath > b2.relativePath ? 1 : 0);
   const top = createHash8("sha256");
   for (const f2 of files) {
-    const fileHash = createHash8("sha256").update(readFileSync20(f2.absPath)).digest("hex");
+    const fileHash = createHash8("sha256").update(readFileSync22(f2.absPath)).digest("hex");
     top.update(f2.relativePath, "utf-8");
     top.update("\0", "utf-8");
     top.update(fileHash, "utf-8");
@@ -17072,10 +17311,10 @@ function sha256OfDir(dir, opts = {}) {
   return top.digest("hex");
 }
 function readInstalledManifest(path = INSTALLED_MANIFEST_PATH) {
-  if (!existsSync21(path)) return {};
+  if (!existsSync23(path)) return {};
   let raw;
   try {
-    raw = JSON.parse(readFileSync20(path, "utf-8"));
+    raw = JSON.parse(readFileSync22(path, "utf-8"));
   } catch {
     return {};
   }
@@ -17139,7 +17378,7 @@ var init_install_tracking = __esm({
   "src/security/install-tracking.ts"() {
     "use strict";
     init_atomic_write();
-    INSTALLED_MANIFEST_PATH = resolve18(homedir7(), ".massu", "adapter-manifest-installed.json");
+    INSTALLED_MANIFEST_PATH = resolve20(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({
@@ -17162,25 +17401,25 @@ var init_install_tracking = __esm({
 });
 
 // src/detect/adapters/discover.ts
-import { existsSync as existsSync22, readdirSync as readdirSync13, readFileSync as readFileSync21, lstatSync as lstatSync7 } from "node:fs";
-import { resolve as resolve19, isAbsolute as isAbsolute2 } from "node:path";
+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 { z as z7 } from "zod";
 function walkNodeModules(projectRoot, warnings) {
-  const nodeModulesDir = resolve19(projectRoot, "node_modules");
-  if (!existsSync22(nodeModulesDir)) {
+  const nodeModulesDir = resolve21(projectRoot, "node_modules");
+  if (!existsSync24(nodeModulesDir)) {
     return [];
   }
   const candidates = [];
   let topLevelEntries;
   try {
-    topLevelEntries = readdirSync13(nodeModulesDir);
+    topLevelEntries = readdirSync14(nodeModulesDir);
   } catch (err) {
     warnings.push(`failed to read node_modules: ${err instanceof Error ? err.message : String(err)}`);
     return [];
   }
   for (const entry of topLevelEntries) {
     if (entry.startsWith(".")) continue;
-    const entryPath = resolve19(nodeModulesDir, entry);
+    const entryPath = resolve21(nodeModulesDir, entry);
     let entryStat;
     try {
       entryStat = lstatSync7(entryPath);
@@ -17197,12 +17436,12 @@ function walkNodeModules(projectRoot, warnings) {
     if (entry.startsWith("@")) {
       let scopedEntries;
       try {
-        scopedEntries = readdirSync13(entryPath);
+        scopedEntries = readdirSync14(entryPath);
       } catch {
         continue;
       }
       for (const sub of scopedEntries) {
-        const subPath = resolve19(entryPath, sub);
+        const subPath = resolve21(entryPath, sub);
         let subStat;
         try {
           subStat = lstatSync7(subPath);
@@ -17221,11 +17460,11 @@ function walkNodeModules(projectRoot, warnings) {
   return candidates;
 }
 function tryReadAdapterPackage(packageDir, warnings) {
-  const pkgJsonPath = resolve19(packageDir, "package.json");
-  if (!existsSync22(pkgJsonPath)) return null;
+  const pkgJsonPath = resolve21(packageDir, "package.json");
+  if (!existsSync24(pkgJsonPath)) return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync21(pkgJsonPath, "utf-8"));
+    raw = JSON.parse(readFileSync23(pkgJsonPath, "utf-8"));
   } catch (err) {
     warnings.push(
       `skipping ${packageDir}: package.json parse failed (${err instanceof Error ? err.message : String(err)})`
@@ -17359,8 +17598,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 : resolve19(opts.projectRoot, localPath);
-    if (!existsSync22(absPath)) {
+    const absPath = isAbsolute2(localPath) ? localPath : resolve21(opts.projectRoot, localPath);
+    if (!existsSync24(absPath)) {
       warnings.push(
         `local adapter file not found: ${localPath} (resolved to ${absPath}). Remove via: massu adapters remove-local ${localPath}`
       );
@@ -17441,8 +17680,8 @@ __export(adapters_exports, {
   runAdaptersResyncLocalFingerprint: () => runAdaptersResyncLocalFingerprint,
   runAdaptersSearch: () => runAdaptersSearch
 });
-import { existsSync as existsSync23, readFileSync as readFileSync22 } from "node:fs";
-import { resolve as resolve20 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
+import { resolve as resolve22 } from "node:path";
 import { parseDocument } from "yaml";
 async function handleAdaptersSubcommand(args2) {
   const sub = args2[0];
@@ -17709,8 +17948,8 @@ function mutateLocalArray(mutator, command) {
     );
     return { exitCode: 2 };
   }
-  const yamlPath = resolve20(projectRoot, "massu.config.yaml");
-  if (!existsSync23(yamlPath)) {
+  const yamlPath = resolve22(projectRoot, "massu.config.yaml");
+  if (!existsSync25(yamlPath)) {
     process.stderr.write(
       `${command}: massu.config.yaml not found at ${yamlPath}. Run \`massu init\` first.
 `
@@ -17719,7 +17958,7 @@ function mutateLocalArray(mutator, command) {
   }
   let yamlText;
   try {
-    yamlText = readFileSync22(yamlPath, "utf-8");
+    yamlText = readFileSync24(yamlPath, "utf-8");
   } catch (err) {
     process.stderr.write(`${command}: failed to read ${yamlPath}: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -17740,7 +17979,7 @@ function mutateLocalArray(mutator, command) {
   if (next === null) {
     return { exitCode: 0 };
   }
-  const lockPath = resolve20(projectRoot, ".massu", "adapters-local-mutate.lock");
+  const lockPath = resolve22(projectRoot, ".massu", "adapters-local-mutate.lock");
   return withFileLockSync(lockPath, () => {
     doc.setIn(["adapters", "local"], next);
     const newYaml = doc.toString();
@@ -17809,23 +18048,23 @@ async function runAdaptersInstall(args2) {
 `);
     return { exitCode: 1 };
   }
-  const packageDir = resolve20(projectRoot, "node_modules", ...packageName.split("/"));
-  if (!existsSync23(packageDir)) {
+  const packageDir = resolve22(projectRoot, "node_modules", ...packageName.split("/"));
+  if (!existsSync25(packageDir)) {
     process.stderr.write(
       `install: ${packageName} is not installed in node_modules. Run \`npm install ${packageName}\` first.
 `
     );
     return { exitCode: 1 };
   }
-  const pkgJsonPath = resolve20(packageDir, "package.json");
-  if (!existsSync23(pkgJsonPath)) {
+  const pkgJsonPath = resolve22(packageDir, "package.json");
+  if (!existsSync25(pkgJsonPath)) {
     process.stderr.write(`install: ${packageName} has no package.json at ${pkgJsonPath}
 `);
     return { exitCode: 1 };
   }
   let pkgJson;
   try {
-    pkgJson = JSON.parse(readFileSync22(pkgJsonPath, "utf-8"));
+    pkgJson = JSON.parse(readFileSync24(pkgJsonPath, "utf-8"));
   } catch (err) {
     process.stderr.write(`install: ${packageName} has malformed package.json: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -17944,8 +18183,8 @@ async function runAdaptersResign(_args) {
       removeInstalledManifestEntry(name);
       continue;
     }
-    const packageDir = resolve20(projectRoot, "node_modules", ...name.split("/"));
-    if (!existsSync23(packageDir)) {
+    const packageDir = resolve22(projectRoot, "node_modules", ...name.split("/"));
+    if (!existsSync25(packageDir)) {
       removed++;
       warnings.push(`${name}@${entry.version}: not present in node_modules \u2014 REMOVED from sidecar`);
       removeInstalledManifestEntry(name);
@@ -18033,10 +18272,10 @@ var init_adapters2 = __esm({
 // src/db.ts
 import Database2 from "better-sqlite3";
 import { dirname as dirname12, join as join12 } from "path";
-import { existsSync as existsSync24, mkdirSync as mkdirSync10, readdirSync as readdirSync14, statSync as statSync11 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync10, readdirSync as readdirSync15, statSync as statSync11 } from "fs";
 function getCodeGraphDb() {
   const dbPath = getResolvedPaths().codegraphDbPath;
-  if (!existsSync24(dbPath)) {
+  if (!existsSync26(dbPath)) {
     throw new CodegraphDbNotInitializedError(dbPath);
   }
   const db = new Database2(dbPath, { readonly: true });
@@ -18046,7 +18285,7 @@ function getCodeGraphDb() {
 function getDataDb() {
   const dbPath = getResolvedPaths().dataDbPath;
   const dir = dirname12(dbPath);
-  if (!existsSync24(dir)) {
+  if (!existsSync26(dir)) {
     mkdirSync10(dir, { recursive: true });
   }
   const db = new Database2(dbPath);
@@ -18317,7 +18556,7 @@ function isPythonDataStale(dataDb, pythonRoot) {
   const lastBuildTime = new Date(lastBuild.value).getTime();
   function checkDir(dir) {
     try {
-      const entries = readdirSync14(dir, { withFileTypes: true });
+      const entries = readdirSync15(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = join12(dir, entry.name);
         if (entry.isDirectory()) {
@@ -18353,10 +18592,10 @@ var init_db = __esm({
 });
 
 // src/security-utils.ts
-import { resolve as resolve21, normalize } from "path";
+import { resolve as resolve23, normalize } from "path";
 function ensureWithinRoot(filePath, projectRoot) {
-  const resolvedRoot = resolve21(projectRoot);
-  const resolvedPath = resolve21(resolvedRoot, filePath);
+  const resolvedRoot = resolve23(projectRoot);
+  const resolvedPath = resolve23(resolvedRoot, filePath);
   const normalizedPath = normalize(resolvedPath);
   const normalizedRoot = normalize(resolvedRoot);
   if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
@@ -18429,8 +18668,8 @@ var init_rules = __esm({
 });
 
 // src/import-resolver.ts
-import { readFileSync as readFileSync23, existsSync as existsSync25, statSync as statSync12 } from "fs";
-import { resolve as resolve22, dirname as dirname13, join as join13 } from "path";
+import { readFileSync as readFileSync25, existsSync as existsSync27, statSync as statSync12 } from "fs";
+import { resolve as resolve24, dirname as dirname13, join as join13 } from "path";
 function parseImports(source) {
   const imports = [];
   const lines = source.split("\n");
@@ -18486,23 +18725,23 @@ function resolveImportPath(specifier, fromFile) {
   let basePath;
   if (specifier.startsWith("@/")) {
     const paths = getResolvedPaths();
-    basePath = resolve22(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
+    basePath = resolve24(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
   } else {
-    basePath = resolve22(dirname13(fromFile), specifier);
+    basePath = resolve24(dirname13(fromFile), specifier);
   }
-  if (existsSync25(basePath) && !isDirectory(basePath)) {
+  if (existsSync27(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
   }
   const resolvedPaths = getResolvedPaths();
   for (const ext of resolvedPaths.extensions) {
     const withExt = basePath + ext;
-    if (existsSync25(withExt)) {
+    if (existsSync27(withExt)) {
       return toRelative(withExt);
     }
   }
   for (const indexFile of resolvedPaths.indexFiles) {
     const indexPath = join13(basePath, indexFile);
-    if (existsSync25(indexPath)) {
+    if (existsSync27(indexPath)) {
       return toRelative(indexPath);
     }
   }
@@ -18538,11 +18777,11 @@ function buildImportIndex(dataDb, codegraphDb) {
   const batchSize = 500;
   let batch = [];
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve22(projectRoot, file.path), projectRoot);
-    if (!existsSync25(absPath)) continue;
+    const absPath = ensureWithinRoot(resolve24(projectRoot, file.path), projectRoot);
+    if (!existsSync27(absPath)) continue;
     let source;
     try {
-      source = readFileSync23(absPath, "utf-8");
+      source = readFileSync25(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -18578,15 +18817,15 @@ var init_import_resolver = __esm({
 });
 
 // src/trpc-index.ts
-import { readFileSync as readFileSync24, existsSync as existsSync26, readdirSync as readdirSync15 } from "fs";
-import { resolve as resolve23, join as join14 } from "path";
+import { readFileSync as readFileSync26, existsSync as existsSync28, readdirSync as readdirSync16 } from "fs";
+import { resolve as resolve25, join as join14 } from "path";
 function parseRootRouter() {
   const paths = getResolvedPaths();
   const rootPath = paths.rootRouterPath;
-  if (!existsSync26(rootPath)) {
+  if (!existsSync28(rootPath)) {
     throw new Error(`Root router not found at ${rootPath}`);
   }
-  const source = readFileSync24(rootPath, "utf-8");
+  const source = readFileSync26(rootPath, "utf-8");
   const mappings = [];
   const importMap = /* @__PURE__ */ new Map();
   const importRegex = /import\s+\{[^}]*?(\w+Router)[^}]*\}\s+from\s+['"]\.\/routers\/([^'"]+)['"]/g;
@@ -18594,16 +18833,16 @@ function parseRootRouter() {
   while ((match = importRegex.exec(source)) !== null) {
     const variable = match[1];
     let filePath = match[2];
-    const fullPath = resolve23(paths.routersDir, filePath);
+    const fullPath = resolve25(paths.routersDir, filePath);
     for (const ext of [".ts", ".tsx", ""]) {
       const candidate = fullPath + ext;
       const routersRelPath = getConfig().paths.routers ?? "src/server/api/routers";
-      if (existsSync26(candidate)) {
+      if (existsSync28(candidate)) {
         filePath = routersRelPath + "/" + filePath + ext;
         break;
       }
       const indexCandidate = join14(fullPath, "index.ts");
-      if (existsSync26(indexCandidate)) {
+      if (existsSync28(indexCandidate)) {
         filePath = routersRelPath + "/" + filePath + "/index.ts";
         break;
       }
@@ -18622,9 +18861,9 @@ function parseRootRouter() {
   return mappings;
 }
 function extractProcedures(routerFilePath) {
-  const absPath = resolve23(getProjectRoot(), routerFilePath);
-  if (!existsSync26(absPath)) return [];
-  const source = readFileSync24(absPath, "utf-8");
+  const absPath = resolve25(getProjectRoot(), routerFilePath);
+  if (!existsSync28(absPath)) return [];
+  const source = readFileSync26(absPath, "utf-8");
   const procedures = [];
   const seen = /* @__PURE__ */ new Set();
   const procRegex = /(\w+)\s*:\s*(protected|public)Procedure/g;
@@ -18647,19 +18886,19 @@ function findUICallSites(routerKey, procedureName) {
   const root = getProjectRoot();
   const src = config.paths.source;
   const searchDirs = [
-    resolve23(root, config.paths.pages ?? src + "/app"),
-    resolve23(root, config.paths.components ?? src + "/components"),
-    resolve23(root, config.paths.hooks ?? src + "/hooks")
+    resolve25(root, config.paths.pages ?? src + "/app"),
+    resolve25(root, config.paths.components ?? src + "/components"),
+    resolve25(root, config.paths.hooks ?? src + "/hooks")
   ];
   const searchPattern = `api.${routerKey}.${procedureName}`;
   for (const dir of searchDirs) {
-    if (!existsSync26(dir)) continue;
+    if (!existsSync28(dir)) continue;
     searchDirectory(dir, searchPattern, callSites);
   }
   return callSites;
 }
 function searchDirectory(dir, pattern, results) {
-  const entries = readdirSync15(dir, { withFileTypes: true });
+  const entries = readdirSync16(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join14(dir, entry.name);
     if (entry.isDirectory()) {
@@ -18667,7 +18906,7 @@ function searchDirectory(dir, pattern, results) {
       searchDirectory(fullPath, pattern, results);
     } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
       try {
-        const source = readFileSync24(fullPath, "utf-8");
+        const source = readFileSync26(fullPath, "utf-8");
         const lines = source.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (lines[i].includes(pattern)) {
@@ -18730,8 +18969,8 @@ var init_trpc_index = __esm({
 });
 
 // src/page-deps.ts
-import { readFileSync as readFileSync25, existsSync as existsSync27 } from "fs";
-import { resolve as resolve24 } from "path";
+import { readFileSync as readFileSync27, existsSync as existsSync29 } from "fs";
+import { resolve as resolve26 } from "path";
 function deriveRoute(pageFile) {
   let route = pageFile.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "").replace(/\/page\.jsx?$/, "");
   return route || "/";
@@ -18769,10 +19008,10 @@ function findRouterCalls(files) {
   const routers = /* @__PURE__ */ new Set();
   const projectRoot = getProjectRoot();
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve24(projectRoot, file), projectRoot);
-    if (!existsSync27(absPath)) continue;
+    const absPath = ensureWithinRoot(resolve26(projectRoot, file), projectRoot);
+    if (!existsSync29(absPath)) continue;
     try {
-      const source = readFileSync25(absPath, "utf-8");
+      const source = readFileSync27(absPath, "utf-8");
       const apiCallRegex = /api\.(\w+)\.\w+/g;
       let match;
       while ((match = apiCallRegex.exec(source)) !== null) {
@@ -18790,10 +19029,10 @@ 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(resolve24(getProjectRoot(), proc.router_file), getProjectRoot());
-      if (!existsSync27(absPath)) continue;
+      const absPath = ensureWithinRoot(resolve26(getProjectRoot(), proc.router_file), getProjectRoot());
+      if (!existsSync29(absPath)) continue;
       try {
-        const source = readFileSync25(absPath, "utf-8");
+        const source = readFileSync27(absPath, "utf-8");
         const dbPattern = getConfig().dbAccessPattern ?? "ctx.db.{table}";
         const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
         const tableRegex = new RegExp(regexStr + "\\.", "g");
@@ -19062,14 +19301,14 @@ var init_domains = __esm({
 });
 
 // src/schema-mapper.ts
-import { readFileSync as readFileSync26, existsSync as existsSync28, readdirSync as readdirSync16 } from "fs";
+import { readFileSync as readFileSync28, existsSync as existsSync30, readdirSync as readdirSync17 } from "fs";
 import { join as join15 } from "path";
 function parsePrismaSchema() {
   const schemaPath = getResolvedPaths().prismaSchemaPath;
-  if (!existsSync28(schemaPath)) {
+  if (!existsSync30(schemaPath)) {
     throw new Error(`Prisma schema not found at ${schemaPath}`);
   }
-  const source = readFileSync26(schemaPath, "utf-8");
+  const source = readFileSync28(schemaPath, "utf-8");
   const models = [];
   const sourceLines = source.split("\n");
   let i = 0;
@@ -19127,12 +19366,12 @@ function toSnakeCase(str) {
 function findColumnUsageInRouters(tableName) {
   const usage = /* @__PURE__ */ new Map();
   const routersDir = getResolvedPaths().routersDir;
-  if (!existsSync28(routersDir)) return usage;
+  if (!existsSync30(routersDir)) return usage;
   scanDirectory(routersDir, tableName, usage);
   return usage;
 }
 function scanDirectory(dir, tableName, usage) {
-  const entries = readdirSync16(dir, { withFileTypes: true });
+  const entries = readdirSync17(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join15(dir, entry.name);
     if (entry.isDirectory()) {
@@ -19144,7 +19383,7 @@ function scanDirectory(dir, tableName, usage) {
 }
 function scanFile(absPath, tableName, usage) {
   try {
-    const source = readFileSync26(absPath, "utf-8");
+    const source = readFileSync28(absPath, "utf-8");
     if (!source.includes(tableName)) return;
     const relPath = absPath.slice(getProjectRoot().length + 1);
     const lines = source.split("\n");
@@ -19189,15 +19428,15 @@ function detectMismatches(models) {
 }
 function findFilesUsingColumn(dir, column, tableName) {
   const result = [];
-  if (!existsSync28(dir)) return result;
-  const entries = readdirSync16(dir, { withFileTypes: true });
+  if (!existsSync30(dir)) return result;
+  const entries = readdirSync17(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join15(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...findFilesUsingColumn(fullPath, column, tableName));
     } else if (entry.name.endsWith(".ts")) {
       try {
-        const source = readFileSync26(fullPath, "utf-8");
+        const source = readFileSync28(fullPath, "utf-8");
         if (source.includes(tableName) && source.includes(column)) {
           result.push(fullPath.slice(getProjectRoot().length + 1));
         }
@@ -19342,12 +19581,12 @@ var init_import_parser = __esm({
 });
 
 // src/python/import-resolver.ts
-import { readFileSync as readFileSync27, existsSync as existsSync29, readdirSync as readdirSync17 } from "fs";
-import { resolve as resolve26, join as join16, relative as relative6, dirname as dirname14 } from "path";
+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";
 function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
   const projectRoot = getProjectRoot();
   if (level > 0) {
-    let baseDir = dirname14(resolve26(projectRoot, fromFile));
+    let baseDir = dirname14(resolve28(projectRoot, fromFile));
     for (let i = 1; i < level; i++) {
       baseDir = dirname14(baseDir);
     }
@@ -19359,17 +19598,17 @@ function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
     return tryResolvePythonPath(baseDir, projectRoot);
   }
   const parts = module.split(".");
-  const candidate = join16(resolve26(projectRoot, pythonRoot), ...parts);
+  const candidate = join16(resolve28(projectRoot, pythonRoot), ...parts);
   return tryResolvePythonPath(candidate, projectRoot);
 }
 function tryResolvePythonPath(basePath, projectRoot) {
-  if (existsSync29(basePath + ".py")) {
+  if (existsSync31(basePath + ".py")) {
     return relative6(projectRoot, basePath + ".py");
   }
-  if (existsSync29(join16(basePath, "__init__.py"))) {
+  if (existsSync31(join16(basePath, "__init__.py"))) {
     return relative6(projectRoot, join16(basePath, "__init__.py"));
   }
-  if (basePath.endsWith(".py") && existsSync29(basePath)) {
+  if (basePath.endsWith(".py") && existsSync31(basePath)) {
     return relative6(projectRoot, basePath);
   }
   return null;
@@ -19377,7 +19616,7 @@ function tryResolvePythonPath(basePath, projectRoot) {
 function walkPythonFiles(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync17(dir, { withFileTypes: true });
+    const entries = readdirSync18(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
@@ -19392,7 +19631,7 @@ function walkPythonFiles(dir, excludeDirs) {
 }
 function buildPythonImportIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = resolve26(projectRoot, pythonRoot);
+  const absRoot = resolve28(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 (?, ?, ?, ?, ?)"
@@ -19409,7 +19648,7 @@ function buildPythonImportIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__"
     const relFile = relative6(projectRoot, absFile);
     let source;
     try {
-      source = readFileSync27(absFile, "utf-8");
+      source = readFileSync29(absFile, "utf-8");
     } catch {
       continue;
     }
@@ -19675,12 +19914,12 @@ var init_route_parser = __esm({
 });
 
 // src/python/route-indexer.ts
-import { readFileSync as readFileSync28, readdirSync as readdirSync18 } from "fs";
+import { readFileSync as readFileSync30, readdirSync as readdirSync19 } from "fs";
 import { join as join17, relative as relative7 } from "path";
 function walkPyFiles(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync18(dir, { withFileTypes: true });
+    const entries = readdirSync19(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
@@ -19708,7 +19947,7 @@ function buildPythonRouteIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__",
       const relFile = relative7(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync28(absFile, "utf-8");
+        source = readFileSync30(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -19919,12 +20158,12 @@ var init_model_parser = __esm({
 });
 
 // src/python/model-indexer.ts
-import { readFileSync as readFileSync29, readdirSync as readdirSync19 } from "fs";
+import { readFileSync as readFileSync31, readdirSync as readdirSync20 } from "fs";
 import { join as join18, relative as relative8 } from "path";
 function walkPyFiles2(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync19(dir, { withFileTypes: true });
+    const entries = readdirSync20(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
@@ -19955,7 +20194,7 @@ function buildPythonModelIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__",
       const relFile = relative8(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync29(absFile, "utf-8");
+        source = readFileSync31(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -20215,7 +20454,7 @@ var init_migration_parser = __esm({
 });
 
 // src/python/migration-indexer.ts
-import { readFileSync as readFileSync30, readdirSync as readdirSync20 } from "fs";
+import { readFileSync as readFileSync32, readdirSync as readdirSync21 } from "fs";
 import { join as join19, relative as relative9 } from "path";
 function buildPythonMigrationIndex(dataDb, alembicDir) {
   const projectRoot = getProjectRoot();
@@ -20224,10 +20463,10 @@ function buildPythonMigrationIndex(dataDb, alembicDir) {
   const versionsDir = join19(absDir, "versions");
   let files = [];
   try {
-    files = readdirSync20(versionsDir).filter((f2) => f2.endsWith(".py")).map((f2) => join19(versionsDir, f2));
+    files = readdirSync21(versionsDir).filter((f2) => f2.endsWith(".py")).map((f2) => join19(versionsDir, f2));
   } catch {
     try {
-      files = readdirSync20(absDir).filter((f2) => f2.endsWith(".py") && f2 !== "env.py").map((f2) => join19(absDir, f2));
+      files = readdirSync21(absDir).filter((f2) => f2.endsWith(".py") && f2 !== "env.py").map((f2) => join19(absDir, f2));
     } catch {
     }
   }
@@ -20241,7 +20480,7 @@ function buildPythonMigrationIndex(dataDb, alembicDir) {
   for (const absFile of files) {
     let source;
     try {
-      source = readFileSync30(absFile, "utf-8");
+      source = readFileSync32(absFile, "utf-8");
     } catch {
       continue;
     }
@@ -20275,7 +20514,7 @@ var init_migration_indexer = __esm({
 });
 
 // src/python/coupling-detector.ts
-import { readFileSync as readFileSync31, readdirSync as readdirSync21 } from "fs";
+import { readFileSync as readFileSync33, readdirSync as readdirSync22 } from "fs";
 import { join as join20, relative as relative10 } from "path";
 function buildPythonCouplingIndex(dataDb) {
   const projectRoot = getProjectRoot();
@@ -20312,7 +20551,7 @@ function buildPythonCouplingIndex(dataDb) {
       const relFile = relative10(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync31(absFile, "utf-8");
+        source = readFileSync33(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -20340,7 +20579,7 @@ function walkFrontendFiles(dir) {
   const files = [];
   const exclude = ["node_modules", ".next", "dist", ".git", "__pycache__", ".venv", "venv"];
   try {
-    const entries = readdirSync21(dir, { withFileTypes: true });
+    const entries = readdirSync22(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (exclude.includes(entry.name)) continue;
@@ -20717,8 +20956,8 @@ var init_memory_tools = __esm({
 });
 
 // src/docs-tools.ts
-import { readFileSync as readFileSync32, existsSync as existsSync30 } from "fs";
-import { resolve as resolve27, basename as basename6 } from "path";
+import { readFileSync as readFileSync34, existsSync as existsSync32 } from "fs";
+import { resolve as resolve29, basename as basename6 } from "path";
 function p3(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -20773,10 +21012,10 @@ function handleDocsToolCall(name, args2) {
 }
 function loadDocsMap() {
   const mapPath = getResolvedPaths().docsMapPath;
-  if (!existsSync30(mapPath)) {
+  if (!existsSync32(mapPath)) {
     throw new Error(`docs-map.json not found at ${mapPath}`);
   }
-  return JSON.parse(readFileSync32(mapPath, "utf-8"));
+  return JSON.parse(readFileSync34(mapPath, "utf-8"));
 }
 function matchesPattern(filePath, pattern) {
   const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
@@ -20846,13 +21085,13 @@ function extractFrontmatter(content) {
 }
 function extractProcedureNames(routerPath) {
   const root = getProjectRoot();
-  const absPath = ensureWithinRoot(resolve27(getResolvedPaths().srcDir, "..", routerPath), root);
-  if (!existsSync30(absPath)) {
-    const altPath = ensureWithinRoot(resolve27(getResolvedPaths().srcDir, "../server/api/routers", basename6(routerPath)), root);
-    if (!existsSync30(altPath)) return [];
-    return extractProcedureNamesFromContent(readFileSync32(altPath, "utf-8"));
+  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 [];
+    return extractProcedureNamesFromContent(readFileSync34(altPath, "utf-8"));
   }
-  return extractProcedureNamesFromContent(readFileSync32(absPath, "utf-8"));
+  return extractProcedureNamesFromContent(readFileSync34(absPath, "utf-8"));
 }
 function extractProcedureNamesFromContent(content) {
   const procRegex = /\.(?:query|mutation)\s*\(/g;
@@ -20892,8 +21131,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(resolve27(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    if (!existsSync30(helpPagePath)) {
+    const helpPagePath = ensureWithinRoot(resolve29(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    if (!existsSync32(helpPagePath)) {
       results.push({
         helpPage: mapping.helpPage,
         mappingId,
@@ -20905,7 +21144,7 @@ function handleDocsAudit(args2) {
       });
       continue;
     }
-    const content = readFileSync32(helpPagePath, "utf-8");
+    const content = readFileSync34(helpPagePath, "utf-8");
     const sections = extractSections(content);
     const frontmatter = extractFrontmatter(content);
     const staleReasons = [];
@@ -20945,9 +21184,9 @@ function handleDocsAudit(args2) {
     });
     for (const [guideName, parentId] of Object.entries(docsMap.userGuideInheritance.examples)) {
       if (parentId === mappingId) {
-        const guidePath = ensureWithinRoot(resolve27(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
-        if (existsSync30(guidePath)) {
-          const guideContent = readFileSync32(guidePath, "utf-8");
+        const guidePath = ensureWithinRoot(resolve29(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
+        if (existsSync32(guidePath)) {
+          const guideContent = readFileSync34(guidePath, "utf-8");
           const guideFrontmatter = extractFrontmatter(guideContent);
           if (!guideFrontmatter?.lastVerified || status === "STALE") {
             results.push({
@@ -20980,14 +21219,14 @@ 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(resolve27(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    const exists = existsSync30(helpPagePath);
+    const helpPagePath = ensureWithinRoot(resolve29(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    const exists = existsSync32(helpPagePath);
     let hasContent = false;
     let lineCount = 0;
     let lastVerified = null;
     let status = null;
     if (exists) {
-      const content = readFileSync32(helpPagePath, "utf-8");
+      const content = readFileSync34(helpPagePath, "utf-8");
       lineCount = content.split("\n").length;
       hasContent = lineCount > 10;
       const frontmatter = extractFrontmatter(content);
@@ -21328,8 +21567,8 @@ var init_observability_tools = __esm({
 });
 
 // src/sentinel-db.ts
-import { existsSync as existsSync31 } from "fs";
-import { resolve as resolve28 } from "path";
+import { existsSync as existsSync33 } from "fs";
+import { resolve as resolve30 } from "path";
 function parsePortalScope(raw) {
   if (!raw) return [];
   try {
@@ -21565,23 +21804,23 @@ function validateFeatures(db, domainFilter) {
     const missingProcedures = [];
     const missingPages = [];
     for (const comp of components) {
-      const absPath = resolve28(PROJECT_ROOT, comp.component_file);
-      if (!existsSync31(absPath)) {
+      const absPath = resolve30(PROJECT_ROOT, comp.component_file);
+      if (!existsSync33(absPath)) {
         missingComponents.push(comp.component_file);
       }
     }
     for (const proc of procedures) {
-      const routerPath = resolve28(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
-      if (!existsSync31(routerPath)) {
+      const routerPath = resolve30(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
+      if (!existsSync33(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 = resolve28(PROJECT_ROOT, routeToPath);
-      if (page.page_route.startsWith("/") && !existsSync31(absPath)) {
-        const altPath = resolve28(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
-        if (!existsSync31(altPath)) {
+      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)) {
           missingPages.push(page.page_route);
         }
       }
@@ -22105,8 +22344,8 @@ var init_sentinel_tools = __esm({
 });
 
 // src/sentinel-scanner.ts
-import { readFileSync as readFileSync33, existsSync as existsSync32, readdirSync as readdirSync22, statSync as statSync13 } from "fs";
-import { resolve as resolve29, join as join21, basename as basename7, dirname as dirname15, relative as relative11 } from "path";
+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";
 function inferDomain(filePath) {
   const domains = getConfig().domains;
   const path = filePath.toLowerCase();
@@ -22235,10 +22474,10 @@ function scanComponentExports(dataDb) {
   const projectRoot = getProjectRoot();
   const componentsBase = config.paths.components ?? config.paths.source + "/components";
   const componentDirs = [];
-  const basePath = resolve29(projectRoot, componentsBase);
-  if (existsSync32(basePath)) {
+  const basePath = resolve31(projectRoot, componentsBase);
+  if (existsSync34(basePath)) {
     try {
-      const entries = readdirSync22(basePath, { withFileTypes: true });
+      const entries = readdirSync23(basePath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           componentDirs.push(componentsBase + "/" + entry.name);
@@ -22248,12 +22487,12 @@ function scanComponentExports(dataDb) {
     }
   }
   for (const dir of componentDirs) {
-    const absDir = resolve29(projectRoot, dir);
-    if (!existsSync32(absDir)) continue;
+    const absDir = resolve31(projectRoot, dir);
+    if (!existsSync34(absDir)) continue;
     const files = walkDir2(absDir).filter((f2) => f2.endsWith(".tsx") || f2.endsWith(".ts"));
     for (const file of files) {
       const relPath = relative11(projectRoot, file);
-      const source = readFileSync33(file, "utf-8");
+      const source = readFileSync35(file, "utf-8");
       const annotations = parseFeatureAnnotations(source);
       if (annotations.length > 0) {
         for (const ann of annotations) {
@@ -22302,7 +22541,7 @@ function scanComponentExports(dataDb) {
 function walkDir2(dir) {
   const results = [];
   try {
-    const entries = readdirSync22(dir);
+    const entries = readdirSync23(dir);
     for (const entry of entries) {
       const fullPath = join21(dir, entry);
       try {
@@ -23292,7 +23531,7 @@ var init_audit_trail = __esm({
 });
 
 // src/validation-engine.ts
-import { existsSync as existsSync33, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync36 } from "fs";
 function p10(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -23323,7 +23562,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  if (!existsSync33(absPath)) {
+  if (!existsSync35(absPath)) {
     checks.push({
       name: "file_exists",
       severity: "error",
@@ -23332,7 +23571,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  const source = readFileSync34(absPath, "utf-8");
+  const source = readFileSync36(absPath, "utf-8");
   const lines = source.split("\n");
   if (activeChecks.rule_compliance !== false) {
     for (const ruleSet of config.rules) {
@@ -23777,7 +24016,7 @@ var init_adr_generator = __esm({
 });
 
 // src/security-scorer.ts
-import { existsSync as existsSync34, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync37 } from "fs";
 function p12(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -23801,12 +24040,12 @@ function scoreFileSecurity(filePath, projectRoot) {
       }]
     };
   }
-  if (!existsSync34(absPath)) {
+  if (!existsSync36(absPath)) {
     return { riskScore: 0, findings: [] };
   }
   let source;
   try {
-    source = readFileSync35(absPath, "utf-8");
+    source = readFileSync37(absPath, "utf-8");
   } catch {
     return { riskScore: 0, findings: [] };
   }
@@ -24095,8 +24334,8 @@ var init_security_scorer = __esm({
 });
 
 // src/dependency-scorer.ts
-import { existsSync as existsSync35, readFileSync as readFileSync36 } from "fs";
-import { resolve as resolve30 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync38 } from "fs";
+import { resolve as resolve32 } from "path";
 function p13(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -24128,10 +24367,10 @@ function calculateDepRisk(factors) {
   return Math.min(100, risk);
 }
 function getInstalledPackages(projectRoot) {
-  const pkgPath = resolve30(projectRoot, "package.json");
-  if (!existsSync35(pkgPath)) return /* @__PURE__ */ new Map();
+  const pkgPath = resolve32(projectRoot, "package.json");
+  if (!existsSync37(pkgPath)) return /* @__PURE__ */ new Map();
   try {
-    const pkg = JSON.parse(readFileSync36(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync38(pkgPath, "utf-8"));
     const packages = /* @__PURE__ */ new Map();
     for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
       packages.set(name, version);
@@ -24734,8 +24973,8 @@ var init_regression_detector = __esm({
 
 // src/knowledge-indexer.ts
 import { createHash as createHash9 } from "crypto";
-import { readFileSync as readFileSync37, readdirSync as readdirSync23, statSync as statSync14, existsSync as existsSync36 } from "fs";
-import { resolve as resolve31, relative as relative12, basename as basename8, extname as extname2 } from "path";
+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";
 function getKnowledgePaths() {
   const resolved = getResolvedPaths();
   const config = getConfig();
@@ -24761,9 +25000,9 @@ function discoverMarkdownFiles(baseDir) {
   const files = [];
   function walk(dir) {
     try {
-      const entries = readdirSync23(dir, { withFileTypes: true });
+      const entries = readdirSync24(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = resolve31(dir, entry.name);
+        const fullPath = resolve33(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "archive" && dir.includes("session-state")) continue;
           if (entry.name === "archive" && dir.includes("status")) continue;
@@ -25041,11 +25280,11 @@ function indexAllKnowledge(db) {
     files.push(...memFiles);
   } catch {
   }
-  if (existsSync36(paths.plansDir)) {
+  if (existsSync38(paths.plansDir)) {
     const planFiles = discoverMarkdownFiles(paths.plansDir);
     files.push(...planFiles);
   }
-  if (existsSync36(paths.docsDir)) {
+  if (existsSync38(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);
@@ -25088,8 +25327,8 @@ function indexAllKnowledge(db) {
     } catch {
     }
     for (const filePath of files) {
-      if (!existsSync36(filePath)) continue;
-      const content = readFileSync37(filePath, "utf-8");
+      if (!existsSync38(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);
       const category = categorizeFile(filePath);
@@ -25209,10 +25448,10 @@ function isKnowledgeStale(db) {
     files.push(...discoverMarkdownFiles(paths.memoryDir));
   } catch {
   }
-  if (existsSync36(paths.plansDir)) {
+  if (existsSync38(paths.plansDir)) {
     files.push(...discoverMarkdownFiles(paths.plansDir));
   }
-  if (existsSync36(paths.docsDir)) {
+  if (existsSync38(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);
@@ -25241,8 +25480,8 @@ var init_knowledge_indexer = __esm({
 });
 
 // src/knowledge-tools.ts
-import { readFileSync as readFileSync38, writeFileSync as writeFileSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync24 } from "fs";
-import { resolve as resolve32, basename as basename9 } from "path";
+import { readFileSync as readFileSync40, writeFileSync as writeFileSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync25 } from "fs";
+import { resolve as resolve34, basename as basename9 } from "path";
 function p16(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -25979,7 +26218,7 @@ function handleCorrect(db, args2) {
   if (!wrong || !correction || !rule) {
     return text15("Error: wrong, correction, and rule are all required.");
   }
-  const correctionsPath = resolve32(getResolvedPaths().memoryDir, "corrections.md");
+  const correctionsPath = resolve34(getResolvedPaths().memoryDir, "corrections.md");
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const title = rule.slice(0, 60);
   const entry = `
@@ -25992,7 +26231,7 @@ ${crRule ? `- **CR**: ${crRule}
 `;
   let existing = "";
   try {
-    existing = readFileSync38(correctionsPath, "utf-8");
+    existing = readFileSync40(correctionsPath, "utf-8");
   } catch {
   }
   const archiveIdx = existing.indexOf("## Archived");
@@ -26174,7 +26413,7 @@ function handleGaps(db, args2) {
   } else if (checkType === "routers") {
     try {
       const routersDir = getResolvedPaths().routersDir;
-      const routerFiles = readdirSync24(routersDir).filter((f2) => f2.endsWith(".ts") && !f2.startsWith("_"));
+      const routerFiles = readdirSync25(routersDir).filter((f2) => f2.endsWith(".ts") && !f2.startsWith("_"));
       lines.push(`| Router | Knowledge Hits | Status |`);
       lines.push(`|--------|----------------|--------|`);
       for (const file of routerFiles) {
@@ -26331,11 +26570,11 @@ var init_knowledge_tools = __esm({
 // src/knowledge-db.ts
 import Database3 from "better-sqlite3";
 import { dirname as dirname16 } from "path";
-import { existsSync as existsSync38, mkdirSync as mkdirSync11 } from "fs";
+import { existsSync as existsSync40, mkdirSync as mkdirSync11 } from "fs";
 function getKnowledgeDb() {
   const dbPath = getResolvedPaths().knowledgeDbPath;
   const dir = dirname16(dbPath);
-  if (!existsSync38(dir)) {
+  if (!existsSync40(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   const db = new Database3(dbPath);
@@ -27069,8 +27308,8 @@ var init_python_tools = __esm({
 });
 
 // src/tools.ts
-import { readFileSync as readFileSync39, existsSync as existsSync39 } from "fs";
-import { resolve as resolve33, basename as basename10 } from "path";
+import { readFileSync as readFileSync41, existsSync as existsSync41 } from "fs";
+import { resolve as resolve35, basename as basename10 } from "path";
 function prefix2() {
   return getConfig().toolPrefix;
 }
@@ -27105,7 +27344,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, resolve33(getProjectRoot(), pythonRoot))) {
+    if (force || isPythonDataStale(dataDb, resolve35(getProjectRoot(), pythonRoot))) {
       const pyImports = buildPythonImportIndex(dataDb, pythonRoot, excludeDirs);
       results.push(`Python imports: ${pyImports}`);
       const pyRoutes = buildPythonRouteIndex(dataDb, pythonRoot, excludeDirs);
@@ -27540,9 +27779,9 @@ function handleContext(file, dataDb, codegraphDb) {
         try {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
-          const absFilePath = ensureWithinRoot(resolve33(resolvedPaths.srcDir, "..", file), root);
-          if (existsSync39(absFilePath)) {
-            const fileContent = readFileSync39(absFilePath, "utf-8").slice(0, 3e3);
+          const absFilePath = ensureWithinRoot(resolve35(resolvedPaths.srcDir, "..", file), root);
+          if (existsSync41(absFilePath)) {
+            const fileContent = readFileSync41(absFilePath, "utf-8").slice(0, 3e3);
             const keywords = [];
             if (fileContent.includes("ctx.db")) keywords.push("database", "schema");
             if (fileContent.includes("BigInt") || fileContent.includes("Decimal")) keywords.push("BigInt", "serialization");
@@ -27966,11 +28205,11 @@ function handleSchema(args2) {
     lines.push("Checking all column references against Prisma schema...");
     lines.push("");
     const projectRoot = getProjectRoot();
-    const absPath = ensureWithinRoot(resolve33(projectRoot, file), projectRoot);
-    if (!existsSync39(absPath)) {
+    const absPath = ensureWithinRoot(resolve35(projectRoot, file), projectRoot);
+    if (!existsSync41(absPath)) {
       return text17(`File not found: ${file}`);
     }
-    const source = readFileSync39(absPath, "utf-8");
+    const source = readFileSync41(absPath, "utf-8");
     const config = getConfig();
     const dbPattern = config.dbAccessPattern ?? "ctx.db.{table}";
     const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
@@ -28339,8 +28578,8 @@ var init_server_dispatch = __esm({
 
 // src/server.ts
 var server_exports = {};
-import { readFileSync as readFileSync40 } from "fs";
-import { resolve as resolve34, dirname as dirname17 } from "path";
+import { readFileSync as readFileSync42 } from "fs";
+import { resolve as resolve36, dirname as dirname17 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function pruneMemoryOnStartup() {
   try {
@@ -28375,7 +28614,7 @@ var init_server = __esm({
     __dirname4 = dirname17(fileURLToPath4(import.meta.url));
     PKG_VERSION = (() => {
       try {
-        const pkg = JSON.parse(readFileSync40(resolve34(__dirname4, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync42(resolve36(__dirname4, "..", "package.json"), "utf-8"));
         return pkg.version ?? "0.0.0";
       } catch {
         return "0.0.0";
@@ -28661,19 +28900,19 @@ var config_upgrade_exports = {};
 __export(config_upgrade_exports, {
   runConfigUpgrade: () => runConfigUpgrade
 });
-import { existsSync as existsSync40, readFileSync as readFileSync41, writeFileSync as writeFileSync6, copyFileSync, unlinkSync as unlinkSync2 } from "fs";
-import { resolve as resolve35 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync43, writeFileSync as writeFileSync6, copyFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve37 } from "path";
 import { parse as parseYaml6 } from "yaml";
 async function runConfigUpgrade(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve35(cwd, "massu.config.yaml");
+  const configPath = resolve37(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 (!existsSync40(bakPath)) {
+    if (!existsSync42(bakPath)) {
       const message = `No backup found at ${bakPath}`;
       err(message + "\n");
       return { exitCode: 1, action: "none", message };
@@ -28689,14 +28928,14 @@ async function runConfigUpgrade(opts = {}) {
       return { exitCode: 2, action: "none", message };
     }
   }
-  if (!existsSync40(configPath)) {
+  if (!existsSync42(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return { exitCode: 1, action: "none", message };
   }
   let existing;
   try {
-    const content = readFileSync41(configPath, "utf-8");
+    const content = readFileSync43(configPath, "utf-8");
     const parsed = parseYaml6(content);
     if (!parsed || typeof parsed !== "object") {
       throw new Error("config is not a YAML object");
@@ -28719,7 +28958,7 @@ async function runConfigUpgrade(opts = {}) {
     fingerprint: computeFingerprint(detection)
   };
   try {
-    const original = readFileSync41(configPath, "utf-8");
+    const original = readFileSync43(configPath, "utf-8");
     writeFileSync6(bakPath, original, "utf-8");
   } catch (e2) {
     const message = `Failed to write backup: ${e2 instanceof Error ? e2.message : String(e2)}`;
@@ -28753,8 +28992,8 @@ var config_check_drift_exports = {};
 __export(config_check_drift_exports, {
   runConfigCheckDrift: () => runConfigCheckDrift
 });
-import { existsSync as existsSync41, readFileSync as readFileSync42 } from "fs";
-import { resolve as resolve36 } from "path";
+import { existsSync as existsSync43, readFileSync as readFileSync44 } from "fs";
+import { resolve as resolve38 } from "path";
 import { parse as parseYaml7 } from "yaml";
 function renderChanges(changes) {
   if (changes.length === 0) return "(none)\n";
@@ -28762,12 +29001,12 @@ function renderChanges(changes) {
 }
 async function runConfigCheckDrift(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve36(cwd, "massu.config.yaml");
+  const configPath = resolve38(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
-  if (!existsSync41(configPath)) {
+  if (!existsSync43(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return {
@@ -28781,7 +29020,7 @@ async function runConfigCheckDrift(opts = {}) {
   }
   let config;
   try {
-    const content = readFileSync42(configPath, "utf-8");
+    const content = readFileSync44(configPath, "utf-8");
     const parsed = parseYaml7(content);
     if (!parsed || typeof parsed !== "object") {
       throw new Error("config is not a YAML object");
@@ -28848,8 +29087,8 @@ var init_config_check_drift = __esm({
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync43 } from "fs";
-import { resolve as resolve37, dirname as dirname18 } from "path";
+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);
@@ -28883,6 +29122,12 @@ async function main() {
       process.exit(result.exitCode);
       return;
     }
+    case "changelog": {
+      const { handleChangelogSubcommand: handleChangelogSubcommand2 } = await Promise.resolve().then(() => (init_changelog(), changelog_exports));
+      const result = await handleChangelogSubcommand2(args.slice(1));
+      process.exit(result.exitCode);
+      return;
+    }
     case "show-template": {
       const { runShowTemplate: runShowTemplate2 } = await Promise.resolve().then(() => (init_show_template(), show_template_exports));
       await runShowTemplate2(args.slice(1));
@@ -29002,6 +29247,7 @@ Commands:
   validate-config   Validate massu.config.yaml (alias: config validate)
   config <sub>      Config lifecycle: refresh | validate | upgrade | doctor | check-drift
   permissions <sub> MCP permission lifecycle: install | verify | check-drift
+  changelog <sub>   CHANGELOG generation / verification: generate | verify
   adapters <sub>    Third-party adapter registry: list | refresh | search | add-local | remove-local | install | resign
 
 Options:
@@ -29041,7 +29287,7 @@ Examples:
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync43(resolve37(__dirname5, "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync45(resolve39(__dirname5, "../package.json"), "utf-8"));
     console.log(`massu v${pkg.version}`);
   } catch {
     console.log("massu v0.1.0");