@massu/core 1.16.2 → 1.16.3

package/dist/cli.js

@@ -49,16 +49,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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/credentials.ts
 import { homedir } from "os";
 import { resolve } from "path";
@@ -168,6 +158,385 @@ var init_credentials = __esm({
   }
 });
 
+// src/lib/fileLock.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+import * as lockfile from "proper-lockfile";
+function readLockHolderPid(lockPath) {
+  try {
+    const raw = readFileSync2(`${lockPath}.pid`, "utf-8").trim();
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    return pid;
+  } catch {
+    return null;
+  }
+}
+function busyWaitSync(ms) {
+  if (typeof SharedArrayBuffer === "undefined" || typeof Atomics === "undefined") {
+    throw new Error(
+      `withFileLockSync requires SharedArrayBuffer + Atomics for its retry-loop wait. This Node runtime does not provide them \u2014 refusing to fall back to a CPU spinloop. If you hit this in a sandboxed serverless env, the fix is to perform the lock-protected operation in a host runtime that supports Atomics.`
+    );
+  }
+  const sab = new SharedArrayBuffer(4);
+  const view = new Int32Array(sab);
+  Atomics.wait(view, 0, 0, ms);
+}
+function withFileLockSync(lockPath, fn, opts = {}) {
+  mkdirSync2(dirname(lockPath), { recursive: true });
+  const staleMs = opts.staleMs ?? 3e4;
+  const blockMs = opts.retries === 0 ? 0 : opts.blockMs ?? 3e4;
+  const pollIntervalMs = opts.pollIntervalMs ?? 100;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? busyWaitSync;
+  const makeBusyError = opts.errorFactory ?? ((path, pid, retrySeconds, code) => new FileLockBusyError(path, pid, retrySeconds, code));
+  let release = null;
+  const deadline = now() + blockMs;
+  for (; ; ) {
+    try {
+      release = lockfile.lockSync(lockPath, {
+        stale: staleMs,
+        retries: 0,
+        realpath: false
+      });
+      try {
+        writeFileSync2(`${lockPath}.pid`, String(process.pid), "utf-8");
+      } catch {
+      }
+      break;
+    } catch (err) {
+      const e2 = err;
+      const code = e2.code;
+      if (code !== "ELOCKED" && code !== "EBUSY") {
+        throw err;
+      }
+      if (now() >= deadline) {
+        const holderPid = readLockHolderPid(lockPath);
+        const remainingMs = Math.max(0, deadline - now());
+        const retryAfterSeconds = blockMs === 0 ? Math.round(staleMs / 1e3) : Math.round(remainingMs / 1e3);
+        throw makeBusyError(lockPath, holderPid, retryAfterSeconds, code);
+      }
+      sleep(pollIntervalMs);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      if (release) release();
+    } catch {
+    }
+    try {
+      rmSync2(`${lockPath}.pid`, { force: true });
+    } catch {
+    }
+  }
+}
+var FileLockBusyError;
+var init_fileLock = __esm({
+  "src/lib/fileLock.ts"() {
+    "use strict";
+    FileLockBusyError = class extends Error {
+      constructor(lockPath, holderPid, retryAfterSeconds, causeCode) {
+        const pidPart = holderPid != null ? `(PID=${holderPid})` : "(PID=unknown)";
+        super(`File lock at ${lockPath} held by another process ${pidPart} \u2014 try again in ${retryAfterSeconds}s`);
+        this.lockPath = lockPath;
+        this.holderPid = holderPid;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.causeCode = causeCode;
+        this.name = "FileLockBusyError";
+      }
+      lockPath;
+      holderPid;
+      retryAfterSeconds;
+      causeCode;
+    };
+  }
+});
+
+// src/lib/sqlite-loader.ts
+import { createRequire } from "module";
+import { spawnSync } from "child_process";
+import { accessSync, appendFileSync, chmodSync as chmodSync2, constants as fsConstants, existsSync as existsSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2, join } from "path";
+function isNativeAbiError(err) {
+  const code = err?.code;
+  if (code === "ERR_DLOPEN_FAILED") return true;
+  const msg = err instanceof Error ? err.message : String(err);
+  return /NODE_MODULE_VERSION/.test(msg) || /was compiled against a different Node\.js version/.test(msg) || /ERR_DLOPEN_FAILED/.test(msg) || /\.node\b/.test(msg) && /dlopen|invalid ELF|mach-o|image not found|no such file|not a valid Win32/i.test(msg);
+}
+function loadBetterSqlite3(opts = {}) {
+  if (_testCtor) return _testCtor;
+  if (opts.fresh) bustNativeCache();
+  return req("better-sqlite3");
+}
+function bustNativeCache() {
+  try {
+    const cache = req.cache;
+    if (!cache) return;
+    for (const key of Object.keys(cache)) {
+      if (/better[-_]sqlite3|better_sqlite3\.node|[\\/]bindings[\\/]/.test(key)) {
+        delete cache[key];
+      }
+    }
+  } catch {
+  }
+}
+function openDatabase(dbPath, opts = {}) {
+  const { selfHeal: selfHealOpt = true, ...ctorOpts } = opts;
+  const selfHeal = selfHealOpt && process.env.MASSU_HOOK_RUNTIME !== "1";
+  const Ctor = loadBetterSqlite3();
+  try {
+    return new Ctor(dbPath, ctorOpts);
+  } catch (err) {
+    if (!isNativeAbiError(err)) {
+      throw err;
+    }
+    if (!selfHeal) {
+      recordHealEvent({ phase: "skipped", reason: "self-heal-disabled", abiTo: process.versions.modules });
+      throw new MemoryEngineUnusableError("abi-mismatch", detailOf(err));
+    }
+    const result = (_testHeal ?? attemptNativeHeal)(err);
+    if (!result.healed && !result.contended) {
+      throw new MemoryEngineUnusableError(result.reason ?? "heal-failed", result.detail ?? detailOf(err));
+    }
+    try {
+      const FreshCtor = loadBetterSqlite3({ fresh: true });
+      return new FreshCtor(dbPath, ctorOpts);
+    } catch (retryErr) {
+      throw new MemoryEngineUnusableError("heal-failed", detailOf(retryErr));
+    }
+  }
+}
+function probeMemoryDbUsable(opts = {}) {
+  const selfHeal = opts.selfHeal ?? false;
+  try {
+    const db = openDatabase(":memory:", { selfHeal });
+    try {
+      db.prepare("SELECT 1").get();
+    } finally {
+      db.close();
+    }
+  } catch (err) {
+    if (err instanceof MemoryEngineUnusableError) {
+      return { ok: false, reason: err.reason, remedy: err.remedy, detail: err.detail };
+    }
+    return {
+      ok: false,
+      reason: isNativeAbiError(err) ? "abi-mismatch" : "unreadable",
+      remedy: NATIVE_DB_REMEDY,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const dbPath = opts.dbPath;
+  if (dbPath && dbPath !== ":memory:" && existsSync2(dbPath)) {
+    try {
+      const rdb = openDatabase(dbPath, { readonly: true, selfHeal: false });
+      try {
+        rdb.prepare("SELECT 1").get();
+      } finally {
+        rdb.close();
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        reason: err instanceof MemoryEngineUnusableError ? err.reason : "unreadable",
+        remedy: NATIVE_DB_REMEDY,
+        detail: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  return { ok: true };
+}
+function attemptNativeHeal(err) {
+  const start = Date.now();
+  const abiTo = process.versions.modules;
+  const abiFrom = parseAbiFrom(err);
+  let pkgDir;
+  try {
+    pkgDir = dirname2(req.resolve("better-sqlite3/package.json"));
+  } catch {
+    recordHealEvent({ phase: "skipped", reason: "not-resolvable", abiFrom, abiTo });
+    return { healed: false, reason: "missing", abiFrom, abiTo, detail: "better-sqlite3 not resolvable" };
+  }
+  if (!isWritable(pkgDir)) {
+    recordHealEvent({ phase: "skipped", reason: "dir-not-writable", abiFrom, abiTo });
+    return { healed: false, reason: "heal-failed", abiFrom, abiTo, detail: `install dir not writable: ${pkgDir}` };
+  }
+  recordHealEvent({ phase: "attempt", reason: "abi-mismatch", abiFrom, abiTo });
+  try {
+    return withFileLockSync(
+      join(credentialsDir(), "native-heal.lock"),
+      () => runRebuild(pkgDir, abiFrom, abiTo, start),
+      { blockMs: 6e4, staleMs: 3e5 }
+    );
+  } catch (lockErr) {
+    const detail = lockErr instanceof Error ? lockErr.message : String(lockErr);
+    recordHealEvent({ phase: "failed", reason: "heal-failed", abiFrom, abiTo, detail: `lock: ${detail}` });
+    return { healed: false, contended: true, reason: "heal-failed", abiFrom, abiTo, detail: `heal lock contended: ${detail}` };
+  }
+}
+function runRebuild(pkgDir, abiFrom, abiTo, start) {
+  try {
+    const FreshCtor = loadBetterSqlite3({ fresh: true });
+    new FreshCtor(":memory:").close();
+    const res2 = {
+      healed: true,
+      abiFrom,
+      abiTo,
+      durationMs: Date.now() - start,
+      detail: "already healed by a concurrent process"
+    };
+    recordHealEvent({ phase: "success", reason: "already-healed", abiFrom, abiTo, durationMs: res2.durationMs });
+    return res2;
+  } catch (probeErr) {
+    if (!isNativeAbiError(probeErr)) {
+      return { healed: false, reason: "heal-failed", abiFrom, abiTo, durationMs: Date.now() - start, detail: detailOf(probeErr) };
+    }
+  }
+  const prebuildBin = resolveLocalBin(pkgDir, "prebuild-install");
+  if (prebuildBin) {
+    const r2 = spawnSync(process.execPath, [prebuildBin], {
+      cwd: pkgDir,
+      encoding: "utf-8",
+      timeout: 12e4
+    });
+    if (r2.status === 0) {
+      const res2 = { healed: true, method: "prebuild-install", abiFrom, abiTo, durationMs: Date.now() - start };
+      recordHealEvent({ phase: "success", reason: "abi-mismatch", ...res2 });
+      return res2;
+    }
+  }
+  const gypBin = resolveNodeGypBin();
+  if (gypBin && hasCompiler()) {
+    const r2 = spawnSync(process.execPath, [gypBin, "rebuild", "--release"], {
+      cwd: pkgDir,
+      encoding: "utf-8",
+      timeout: 3e5
+    });
+    if (r2.status === 0) {
+      const res2 = { healed: true, method: "node-gyp", abiFrom, abiTo, durationMs: Date.now() - start };
+      recordHealEvent({ phase: "success", reason: "abi-mismatch", ...res2 });
+      return res2;
+    }
+  }
+  const res = {
+    healed: false,
+    reason: "heal-failed",
+    abiFrom,
+    abiTo,
+    durationMs: Date.now() - start,
+    detail: prebuildBin ? "prebuild-install failed; node-gyp fallback unavailable or failed" : "no prebuild-install bin resolvable"
+  };
+  recordHealEvent({ phase: "failed", reason: "heal-failed", abiFrom, abiTo, durationMs: res.durationMs });
+  return res;
+}
+function recordHealEvent(event) {
+  try {
+    const rec = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      node: process.versions.node,
+      platform: process.platform,
+      arch: process.arch,
+      ...event
+    };
+    const dir = credentialsDir();
+    mkdirSync3(dir, { recursive: true });
+    const file = join(dir, "native-heal-events.jsonl");
+    appendFileSync(file, JSON.stringify(rec) + "\n", "utf-8");
+    try {
+      chmodSync2(file, 384);
+    } catch {
+    }
+  } catch {
+  }
+}
+function parseAbiFrom(err) {
+  const msg = err instanceof Error ? err.message : String(err ?? "");
+  const m3 = /NODE_MODULE_VERSION (\d+)/.exec(msg);
+  if (m3 && /^\d+$/.test(m3[1])) return m3[1];
+  return void 0;
+}
+function detailOf(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.slice(0, 300);
+}
+function isWritable(dir) {
+  try {
+    accessSync(dir, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveLocalBin(pkgDir, name) {
+  const candidates = [
+    join(pkgDir, "node_modules", ".bin", name),
+    // nested install
+    join(pkgDir, "..", ".bin", name),
+    // hoisted (node_modules/.bin)
+    join(pkgDir, "..", "..", "node_modules", ".bin", name)
+    // workspace hoist
+  ];
+  for (const c2 of candidates) {
+    if (existsSync2(c2)) return c2;
+  }
+  return void 0;
+}
+function resolveNodeGypBin() {
+  try {
+    return req.resolve("node-gyp/bin/node-gyp.js");
+  } catch {
+    return void 0;
+  }
+}
+function hasCompiler() {
+  for (const cc of ["cc", "clang", "gcc"]) {
+    try {
+      const r2 = spawnSync(cc, ["--version"], { encoding: "utf-8", timeout: 5e3 });
+      if (r2.status === 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var req, NATIVE_DB_REMEDY, MemoryEngineUnusableError, _testCtor, _testHeal;
+var init_sqlite_loader = __esm({
+  "src/lib/sqlite-loader.ts"() {
+    "use strict";
+    init_credentials();
+    init_fileLock();
+    req = createRequire(import.meta.url);
+    NATIVE_DB_REMEDY = "Run 'massu heal' to rebuild the database engine for your Node version, then restart your MCP client / Claude Code.";
+    MemoryEngineUnusableError = class extends Error {
+      reason;
+      remedy;
+      detail;
+      constructor(reason, detail) {
+        super(
+          `Massu memory engine is unusable (${reason}). ${NATIVE_DB_REMEDY}` + (detail ? ` [${detail}]` : "")
+        );
+        this.name = "MemoryEngineUnusableError";
+        this.reason = reason;
+        this.remedy = NATIVE_DB_REMEDY;
+        this.detail = detail;
+      }
+    };
+    _testCtor = null;
+    _testHeal = null;
+  }
+});
+
+// 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-memory-schema.ts
 import { z } from "zod";
 var MemoryConfigSchema;
@@ -317,8 +686,8 @@ __export(config_exports, {
   getResolvedPaths: () => getResolvedPaths,
   resetConfig: () => resetConfig
 });
-import { resolve as resolve2, dirname } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2, dirname as dirname3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
 import { parse as parseYaml } from "yaml";
 import { z as z2 } from "zod";
@@ -326,22 +695,22 @@ function findProjectRoot() {
   const cwd = process.cwd();
   let dir = cwd;
   while (true) {
-    if (existsSync2(resolve2(dir, "massu.config.yaml"))) {
+    if (existsSync3(resolve2(dir, "massu.config.yaml"))) {
       return dir;
     }
-    const parent = dirname(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = cwd;
   while (true) {
-    if (existsSync2(resolve2(dir, "package.json"))) {
+    if (existsSync3(resolve2(dir, "package.json"))) {
       return dir;
     }
-    if (existsSync2(resolve2(dir, ".git"))) {
+    if (existsSync3(resolve2(dir, ".git"))) {
       return dir;
     }
-    const parent = dirname(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -358,8 +727,8 @@ function getConfig() {
   const root = getProjectRoot();
   const configPath = resolve2(root, "massu.config.yaml");
   let rawYaml = {};
-  if (existsSync2(configPath)) {
-    const content = readFileSync2(configPath, "utf-8");
+  if (existsSync3(configPath)) {
+    const content = readFileSync3(configPath, "utf-8");
     rawYaml = parseYaml(content) ?? {};
   }
   const result = RawConfigSchema.safeParse(rawYaml);
@@ -440,9 +809,13 @@ Hint: run \`massu config refresh\` to regenerate a valid config or fix the liste
   const resolvedEndpoint = resolveEndpoint({ configEndpoint: _config.cloud?.endpoint });
   if (resolvedKey.apiKey) {
     _config.cloud = {
-      enabled: true,
       sync: { memory: true, analytics: true, audit: true },
       ..._config.cloud,
+      // Spread FIRST, then decide `enabled`, so a workspace that declares a `cloud:`
+      // block only to tune `requestTimeoutMs` does not disable its own sync. An
+      // EXPLICIT `enabled: false` is still honoured; `undefined` (not stated) means
+      // "a key resolved, so turn it on". (plan-2026-07-20-cloud-sync-timeout)
+      enabled: _config.cloud?.enabled ?? true,
       apiKey: resolvedKey.apiKey,
       endpoint: resolvedEndpoint
     };
@@ -671,9 +1044,22 @@ var init_config = __esm({
       })).default([])
     }).optional();
     CloudConfigSchema = z2.object({
-      enabled: z2.boolean().default(false),
+      // OPTIONAL, not `.default(false)`. A zod default is indistinguishable from an
+      // explicit value once parsed, so `.default(false)` meant that merely declaring a
+      // `cloud:` block (to set any OTHER key) silently produced `enabled: false`, which
+      // then overrode the `enabled: true` auto-enable below via object spread — turning
+      // cloud sync OFF as a side effect of tuning it. `undefined` now means "not stated",
+      // and the auto-enable preserves it. (plan-2026-07-20-cloud-sync-timeout)
+      enabled: z2.boolean().optional(),
       apiKey: z2.string().optional(),
       endpoint: z2.string().optional(),
+      // Per-request POST budget for the `/sync` ingest. cloud-sync.ts reads this
+      // (`(cloud as { requestTimeoutMs?: number }).requestTimeoutMs`) but it was ABSENT
+      // from this schema, and zod strips unknown keys — so the knob was unreachable from
+      // massu.config.yaml and the default could never be tuned. Measured 2026-07-20: a
+      // 423-observation payload takes ~9.2s against the live ingest. Capped at
+      // SYNC_DEADLINE_MS (20s) since the overall deadline clamps each attempt anyway.
+      requestTimeoutMs: z2.number().int().positive().max(2e4).optional(),
       sync: z2.object({
         memory: z2.boolean().default(true),
         analytics: z2.boolean().default(true),
@@ -931,27 +1317,26 @@ var init_memory_vector = __esm({
 });
 
 // src/db-backup.ts
-import Database from "better-sqlite3";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, statSync, unlinkSync, copyFileSync, rmSync as rmSync2 } from "fs";
-import { resolve as resolve3, join, basename, dirname as dirname2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync, statSync, unlinkSync, copyFileSync, rmSync as rmSync3 } from "fs";
+import { resolve as resolve3, join as join2, basename, dirname as dirname4 } from "path";
 import { homedir as homedir3 } from "os";
 function dbBackupsRoot(home = homedir3()) {
   return resolve3(home, ".massu", "db-backups");
 }
 function projectBackupDir(projectRoot, home = homedir3()) {
   const slug = basename(projectRoot).replace(/[^A-Za-z0-9._-]/g, "_") || "project";
-  return join(dbBackupsRoot(home), slug);
+  return join2(dbBackupsRoot(home), slug);
 }
 function backupStamp(nowMs) {
   return new Date(nowMs).toISOString().replace(/[:.]/g, "-");
 }
 function listDbBackups(projectRoot, home = homedir3()) {
   const dir = projectBackupDir(projectRoot, home);
-  if (!existsSync3(dir)) return [];
+  if (!existsSync4(dir)) return [];
   const out = [];
   for (const f2 of readdirSync(dir)) {
     if (!f2.endsWith(".db")) continue;
-    const p19 = join(dir, f2);
+    const p19 = join2(dir, f2);
     const st = statSync(p19);
     const db = f2.replace(/-\d{4}-\d{2}-\d{2}T.*$/, "");
     out.push({ db, path: p19, bytes: st.size, mtimeMs: st.mtimeMs });
@@ -964,13 +1349,13 @@ function hasFreshDbBackup(projectRoot, dbPath, nowMs = Date.now(), home = homedi
   if (backups.length === 0) return false;
   const newest = backups[0];
   if (nowMs - newest.mtimeMs > FRESH_WINDOW_MS) return false;
-  if (existsSync3(dbPath) && statSync(dbPath).mtimeMs > newest.mtimeMs) return false;
+  if (existsSync4(dbPath) && statSync(dbPath).mtimeMs > newest.mtimeMs) return false;
   return true;
 }
 function integrityOk(dbPath) {
   let db = null;
   try {
-    db = new Database(dbPath, { readonly: true });
+    db = openDatabase(dbPath, { readonly: true });
     const rows = db.pragma("integrity_check");
     return rows.length === 1 && rows[0].integrity_check === "ok";
   } catch {
@@ -983,16 +1368,16 @@ function integrityOk(dbPath) {
   }
 }
 function backupDb(projectRoot, dbPath, nowMs = Date.now(), home = homedir3()) {
-  if (!existsSync3(dbPath)) {
+  if (!existsSync4(dbPath)) {
     throw new DbBackupError(`cannot back up a database that does not exist: ${dbPath}`);
   }
   const dir = projectBackupDir(projectRoot, home);
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   const name = basename(dbPath, ".db");
-  const dest = join(dir, `${name}-${backupStamp(nowMs)}.db`);
+  const dest = join2(dir, `${name}-${backupStamp(nowMs)}.db`);
   let src = null;
   try {
-    src = new Database(dbPath, { readonly: true });
+    src = openDatabase(dbPath, { readonly: true });
     src.exec(`VACUUM INTO '${dest.replace(/'/g, "''")}'`);
   } catch (err) {
     throw new DbBackupError(
@@ -1030,7 +1415,7 @@ function pruneDbBackups(projectRoot, dbName, keep = DEFAULT_RETENTION, home = ho
   return removed;
 }
 function restoreDb(backupPath, dbPath, nowMs = Date.now(), home = homedir3()) {
-  if (!existsSync3(backupPath)) {
+  if (!existsSync4(backupPath)) {
     throw new DbBackupError(`backup not found: ${backupPath}`);
   }
   if (!integrityOk(backupPath)) {
@@ -1039,15 +1424,15 @@ function restoreDb(backupPath, dbPath, nowMs = Date.now(), home = homedir3()) {
     );
   }
   let preserved = null;
-  if (existsSync3(dbPath)) {
-    const dir = dirname2(backupPath) || projectBackupDir(process.cwd(), home);
-    mkdirSync2(dir, { recursive: true });
-    preserved = join(dir, `${basename(dbPath, ".db")}.corrupt-${backupStamp(nowMs)}.db`);
+  if (existsSync4(dbPath)) {
+    const dir = dirname4(backupPath) || projectBackupDir(process.cwd(), home);
+    mkdirSync4(dir, { recursive: true });
+    preserved = join2(dir, `${basename(dbPath, ".db")}.corrupt-${backupStamp(nowMs)}.db`);
     copyFileSync(dbPath, preserved);
   }
   for (const suffix of ["", "-wal", "-shm"]) {
     const p19 = `${dbPath}${suffix}`;
-    if (existsSync3(p19)) rmSync2(p19, { force: true });
+    if (existsSync4(p19)) rmSync3(p19, { force: true });
   }
   copyFileSync(backupPath, dbPath);
   if (!integrityOk(dbPath)) {
@@ -1059,7 +1444,7 @@ function restoreDb(backupPath, dbPath, nowMs = Date.now(), home = homedir3()) {
 }
 function backupBeforeSchemaChange(projectRoot, dbPath, onError, nowMs = Date.now(), home = homedir3()) {
   try {
-    if (!existsSync3(dbPath)) return null;
+    if (!existsSync4(dbPath)) return null;
     if (hasFreshDbBackup(projectRoot, dbPath, nowMs, home)) return null;
     return backupDb(projectRoot, dbPath, nowMs, home);
   } catch (err) {
@@ -1071,6 +1456,7 @@ var DEFAULT_RETENTION, FRESH_WINDOW_MS, DbBackupError;
 var init_db_backup = __esm({
   "src/db-backup.ts"() {
     "use strict";
+    init_sqlite_loader();
     DEFAULT_RETENTION = 5;
     FRESH_WINDOW_MS = 24 * 60 * 60 * 1e3;
     DbBackupError = class extends Error {
@@ -1233,21 +1619,21 @@ var init_rule_candidate_store = __esm({
 });
 
 // src/hooks/lib/hook-failure-signal.ts
-import { appendFileSync, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
-import { join as join2, dirname as dirname3 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, existsSync as existsSync5 } from "fs";
+import { join as join3, dirname as dirname5 } from "path";
 function resolveFailureLogPath() {
   const explicit = process.env.MASSU_HOOK_FAILURE_LOG;
   if (explicit) return explicit;
   let dir = process.cwd();
   for (let i = 0; i < 12; i++) {
-    if (existsSync4(join2(dir, ".massu")) || existsSync4(join2(dir, "massu.config.yaml"))) {
-      return join2(dir, ".massu", "hook-failures.jsonl");
+    if (existsSync5(join3(dir, ".massu")) || existsSync5(join3(dir, "massu.config.yaml"))) {
+      return join3(dir, ".massu", "hook-failures.jsonl");
     }
-    const parent = dirname3(dir);
+    const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return join2(process.cwd(), ".massu", "hook-failures.jsonl");
+  return join3(process.cwd(), ".massu", "hook-failures.jsonl");
 }
 function recordHookFailure(hook, error, context) {
   const record = {
@@ -1260,8 +1646,8 @@ function recordHookFailure(hook, error, context) {
   let wroteSomething = false;
   try {
     const path = resolveFailureLogPath();
-    mkdirSync3(dirname3(path), { recursive: true });
-    appendFileSync(path, JSON.stringify(record) + "\n", "utf-8");
+    mkdirSync5(dirname5(path), { recursive: true });
+    appendFileSync2(path, JSON.stringify(record) + "\n", "utf-8");
     wroteSomething = true;
   } catch {
   }
@@ -1304,9 +1690,9 @@ var init_hook_failure_signal = __esm({
 });
 
 // src/memory-embedder-tokenizer.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 function loadVocab(vocabPath) {
-  const lines = readFileSync3(vocabPath, "utf-8").split("\n");
+  const lines = readFileSync4(vocabPath, "utf-8").split("\n");
   const vocab = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
     const tok = lines[i].replace(/\r$/, "");
@@ -1426,9 +1812,9 @@ var init_memory_embedder_tokenizer = __esm({
 
 // src/memory-embedder.ts
 import { fileURLToPath } from "url";
-import { dirname as dirname4, join as join3 } from "path";
-import { existsSync as existsSync5 } from "fs";
-import { createRequire } from "module";
+import { dirname as dirname6, join as join4 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { createRequire as createRequire2 } from "module";
 function getActiveEmbedModel() {
   return _activeModel;
 }
@@ -1449,21 +1835,21 @@ function embeddingsDisabled() {
 }
 function resolveModelDir() {
   try {
-    let dir = dirname4(fileURLToPath(import.meta.url));
+    let dir = dirname6(fileURLToPath(import.meta.url));
     let root = null;
     for (let i = 0; i < 8; i++) {
-      if (existsSync5(join3(dir, "package.json"))) {
+      if (existsSync6(join4(dir, "package.json"))) {
         root = dir;
         break;
       }
-      const parent = dirname4(dir);
+      const parent = dirname6(dir);
       if (parent === dir) break;
       dir = parent;
     }
     if (!root) return null;
     for (const rel of ["dist/embedder", "assets/embedder"]) {
-      const candidate = join3(root, rel);
-      if (existsSync5(join3(candidate, "model_quantized.onnx"))) return candidate;
+      const candidate = join4(root, rel);
+      if (existsSync6(join4(candidate, "model_quantized.onnx"))) return candidate;
     }
     return null;
   } catch {
@@ -1472,9 +1858,9 @@ function resolveModelDir() {
 }
 function resolveWasmDir() {
   try {
-    const req = createRequire(import.meta.url);
-    const main2 = req.resolve(ORT_PKG);
-    return dirname4(main2);
+    const req2 = createRequire2(import.meta.url);
+    const main2 = req2.resolve(ORT_PKG);
+    return dirname6(main2);
   } catch {
     return null;
   }
@@ -1494,8 +1880,8 @@ async function getSession() {
       ort.env.wasm.proxy = false;
       ort.env.wasm.wasmPaths = wasmDir.endsWith("/") ? wasmDir : wasmDir + "/";
       _ortTensor = ort.Tensor;
-      const modelPath = join3(modelDir, "model_quantized.onnx");
-      const vocabPath = join3(modelDir, "vocab.txt");
+      const modelPath = join4(modelDir, "model_quantized.onnx");
+      const vocabPath = join4(modelDir, "vocab.txt");
       _vocab = loadVocab(vocabPath);
       const session = await ort.InferenceSession.create(modelPath, {
         executionProviders: ["wasm"],
@@ -1847,9 +2233,8 @@ __export(memory_db_exports, {
   upsertObservationEmbedding: () => upsertObservationEmbedding,
   usageWarmupElapsed: () => usageWarmupElapsed
 });
-import Database2 from "better-sqlite3";
-import { dirname as dirname5, basename as basename2 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname7, basename as basename2 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
 function sanitizeFts5Query(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return '""';
@@ -1865,12 +2250,12 @@ function sanitizeFts5QueryOr(raw) {
 }
 function getMemoryDb() {
   const dbPath = getResolvedPaths().memoryDbPath;
-  const dir = dirname5(dbPath);
-  if (!existsSync6(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname7(dbPath);
+  if (!existsSync7(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
-  const preExisting = existsSync6(dbPath);
-  const db = new Database2(dbPath);
+  const preExisting = existsSync7(dbPath);
+  const db = openDatabase(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   const onDisk = db.pragma("user_version", { simple: true });
@@ -3576,6 +3961,7 @@ var MEMORY_SCHEMA_VERSION, TOOL_COST_EVENTS_RETENTION_DAYS, MAX_DRAFT_TEXT_LEN,
 var init_memory_db = __esm({
   "src/memory-db.ts"() {
     "use strict";
+    init_sqlite_loader();
     init_config();
     init_memory_vector();
     init_db_backup();
@@ -3596,8 +3982,8 @@ var init_memory_db = __esm({
 });
 
 // src/memory-file-ingest.ts
-import { readFileSync as readFileSync4, existsSync as existsSync7, readdirSync as readdirSync2 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync8, readdirSync as readdirSync2 } from "fs";
+import { join as join5 } from "path";
 import { parse as parseYaml2 } from "yaml";
 import { basename as pathBasename } from "path";
 import { createHash } from "crypto";
@@ -3703,8 +4089,8 @@ function upsertMemoryFileMirror(db, f2) {
   return "inserted";
 }
 function ingestMemoryFile(db, sessionId, filePath) {
-  if (!existsSync7(filePath)) return "skipped";
-  const content = readFileSync4(filePath, "utf-8");
+  if (!existsSync8(filePath)) return "skipped";
+  const content = readFileSync5(filePath, "utf-8");
   if (Buffer.byteLength(content, "utf-8") > MAX_MEMORY_FILE_BYTES) {
     process.stderr.write(
       `[massu] memory file exceeds ${MAX_MEMORY_FILE_BYTES} bytes, not ingested: ${filePath}
@@ -3774,14 +4160,14 @@ ${body}` : body;
 }
 function backfillMemoryFiles(db, memoryDir, sessionId) {
   const stats = { inserted: 0, updated: 0, skipped: 0, total: 0 };
-  if (!existsSync7(memoryDir)) return stats;
+  if (!existsSync8(memoryDir)) return stats;
   const files = readdirSync2(memoryDir).filter(
     (f2) => f2.endsWith(".md") && f2 !== "MEMORY.md"
   );
   stats.total = files.length;
   const sid = sessionId ?? `backfill-${Date.now()}`;
   for (const file of files) {
-    const result = ingestMemoryFile(db, sid, join4(memoryDir, file));
+    const result = ingestMemoryFile(db, sid, join5(memoryDir, file));
     stats[result]++;
   }
   return stats;
@@ -3990,16 +4376,16 @@ var init_template_engine = __esm({
 // src/lib/settings-local.ts
 import {
   closeSync,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   fsyncSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync7,
   openSync,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   renameSync,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   writeSync
 } from "fs";
-import { dirname as dirname6, resolve as resolve5 } from "path";
+import { dirname as dirname8, resolve as resolve5 } from "path";
 function atomicWriteFile(targetPath, content, mode = 420) {
   const tmpPath = `${targetPath}.${process.pid}.tmp`;
   try {
@@ -4013,9 +4399,9 @@ function atomicWriteFile(targetPath, content, mode = 420) {
     }
     renameSync(tmpPath, targetPath);
   } catch (err) {
-    if (existsSync8(tmpPath)) {
+    if (existsSync9(tmpPath)) {
       try {
-        rmSync3(tmpPath, { force: true });
+        rmSync4(tmpPath, { force: true });
       } catch {
       }
     }
@@ -4023,11 +4409,11 @@ function atomicWriteFile(targetPath, content, mode = 420) {
   }
 }
 function readSettingsAtPath(absolutePath) {
-  if (!existsSync8(absolutePath)) {
+  if (!existsSync9(absolutePath)) {
     return {};
   }
   try {
-    const raw = readFileSync5(absolutePath, "utf-8");
+    const raw = readFileSync6(absolutePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return {};
@@ -4042,9 +4428,9 @@ function readSettingsLocal(claudeDir) {
 }
 function writeSettingsLocalAtomic(claudeDir, settings) {
   const targetPath = resolve5(claudeDir, "settings.local.json");
-  const dir = dirname6(targetPath);
-  if (!existsSync8(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname8(targetPath);
+  if (!existsSync9(dir)) {
+    mkdirSync7(dir, { recursive: true });
   }
   const content = JSON.stringify(settings, null, 2) + "\n";
   atomicWriteFile(targetPath, content);
@@ -4058,7 +4444,7 @@ var init_settings_local = __esm({
 // src/permissions.ts
 import { createHash as createHash2 } from "crypto";
 import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function canonicalJson(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -4097,7 +4483,7 @@ function detectInvalidDefaultMode(settings) {
   return { invalid: false };
 }
 function readGlobalSettings() {
-  return readSettingsAtPath(join5(homedir4(), ".claude", "settings.json"));
+  return readSettingsAtPath(join6(homedir4(), ".claude", "settings.json"));
 }
 function mergedPermissionState(global2, local, canonical) {
   const globalPerm = global2.permissions ?? {};
@@ -4285,17 +4671,17 @@ __export(install_commands_exports, {
   syncDirectory: () => syncDirectory
 });
 import {
-  existsSync as existsSync9,
-  readFileSync as readFileSync6,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync10,
+  readFileSync as readFileSync7,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync3,
   statSync as statSync2
 } from "fs";
-import { resolve as resolve6, dirname as dirname7, join as join6 } from "path";
+import { resolve as resolve6, dirname as dirname9, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createHash as createHash3 } from "crypto";
 function dirHoldsAssets(dir) {
-  if (!existsSync9(dir)) return false;
+  if (!existsSync10(dir)) return false;
   try {
     return readdirSync3(dir).some(
       (e2) => e2.endsWith(".md") || statSync2(resolve6(dir, e2)).isDirectory()
@@ -4330,10 +4716,10 @@ function canonicalizeOwned(content) {
 }
 function massuOwnedSourceIsValid(resolvedSourcePath, content) {
   const sidecar = `${resolvedSourcePath}.sha256`;
-  if (!existsSync9(sidecar)) return false;
+  if (!existsSync10(sidecar)) return false;
   let expected;
   try {
-    expected = readFileSync6(sidecar, "utf-8").trim();
+    expected = readFileSync7(sidecar, "utf-8").trim();
   } catch {
     return false;
   }
@@ -4344,11 +4730,11 @@ function hashContent(content) {
 }
 function loadManifest(claudeDir) {
   const path = resolve6(claudeDir, MANIFEST_RELPATH);
-  if (!existsSync9(path)) {
+  if (!existsSync10(path)) {
     return emptyManifest();
   }
   try {
-    const raw = readFileSync6(path, "utf-8");
+    const raw = readFileSync7(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || !parsed.entries) {
       return emptyManifest();
@@ -4360,8 +4746,8 @@ function loadManifest(claudeDir) {
 }
 function saveManifest(claudeDir, manifest) {
   const dir = resolve6(claudeDir, ".massu");
-  if (!existsSync9(dir)) {
-    mkdirSync6(dir, { recursive: true });
+  if (!existsSync10(dir)) {
+    mkdirSync8(dir, { recursive: true });
   }
   const finalPath = resolve6(dir, "install-manifest.json");
   manifest.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -4426,17 +4812,17 @@ function pickVariant(baseName, sourceDir, framework) {
   for (const cand of candidates) {
     if (cand.subFramework) {
       const subPath = resolve6(sourceDir, `${baseName}.${cand.lang}-${cand.subFramework}.md`);
-      if (existsSync9(subPath)) {
+      if (existsSync10(subPath)) {
         return { kind: "hit", suffix: `.${cand.lang}-${cand.subFramework}` };
       }
     }
     const langPath = resolve6(sourceDir, `${baseName}.${cand.lang}.md`);
-    if (existsSync9(langPath)) {
+    if (existsSync10(langPath)) {
       return { kind: "hit", suffix: `.${cand.lang}` };
     }
   }
   const defaultPath = resolve6(sourceDir, `${baseName}.md`);
-  if (existsSync9(defaultPath)) {
+  if (existsSync10(defaultPath)) {
     return { kind: "hit", suffix: "" };
   }
   if (framework.type === "multi" && !framework.primary) {
@@ -4452,8 +4838,8 @@ function isVariantFilename(entry) {
 }
 function syncDirectory(sourceDir, targetDir, framework, manifest, manifestKeyPrefix, topLevel = true, templateVars = {}) {
   const stats = { installed: 0, updated: 0, skipped: 0, kept: 0 };
-  if (!existsSync9(targetDir)) {
-    mkdirSync6(targetDir, { recursive: true });
+  if (!existsSync10(targetDir)) {
+    mkdirSync8(targetDir, { recursive: true });
   }
   const entries = readdirSync3(sourceDir);
   for (const entry of entries) {
@@ -4490,12 +4876,12 @@ function syncDirectory(sourceDir, targetDir, framework, manifest, manifestKeyPre
       sourceFilename = suffix === "" ? `${baseName}.md` : `${baseName}${suffix}.md`;
     }
     const resolvedSourcePath = resolve6(sourceDir, sourceFilename);
-    if (!existsSync9(resolvedSourcePath)) {
+    if (!existsSync10(resolvedSourcePath)) {
       continue;
     }
     const targetFilename = topLevel ? `${baseName}.md` : entry;
     const targetPath = resolve6(targetDir, targetFilename);
-    const rawContent = readFileSync6(resolvedSourcePath, "utf-8");
+    const rawContent = readFileSync7(resolvedSourcePath, "utf-8");
     let sourceContent;
     try {
       sourceContent = renderTemplate(rawContent, templateVars);
@@ -4513,11 +4899,11 @@ function syncDirectory(sourceDir, targetDir, framework, manifest, manifestKeyPre
     const sourceHash = hashContent(sourceContent);
     const manifestKey = manifestKeyPrefix === "" ? targetFilename : `${manifestKeyPrefix}/${targetFilename}`;
     const lastInstalledHash = manifest.entries[manifestKey];
-    if (existsSync9(targetPath)) {
+    if (existsSync10(targetPath)) {
       let existingContent;
       try {
         if (!statSync2(targetPath).isFile()) throw new Error("not a regular file");
-        existingContent = readFileSync6(targetPath, "utf-8");
+        existingContent = readFileSync7(targetPath, "utf-8");
       } catch (err) {
         process.stderr.write(
           `massu: skipping ${manifestKey}: target is not a readable file (${err instanceof Error ? err.message : String(err)}). Remove it and re-install.
@@ -4600,8 +4986,8 @@ function installCommands(projectRoot, opts = {}) {
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
   const claudeDir = resolve6(projectRoot, claudeDirName);
   const targetDir = resolve6(claudeDir, "commands");
-  if (!existsSync9(targetDir)) {
-    mkdirSync6(targetDir, { recursive: true });
+  if (!existsSync10(targetDir)) {
+    mkdirSync8(targetDir, { recursive: true });
   }
   const sourceDir = resolveAssetDir("commands");
   if (!sourceDir) {
@@ -4730,7 +5116,7 @@ var init_install_commands = __esm({
     init_settings_local();
     init_permissions();
     __filename = fileURLToPath2(import.meta.url);
-    __dirname = dirname7(__filename);
+    __dirname = dirname9(__filename);
     ASSET_TYPES = [
       { name: "commands", targetSubdir: "commands", description: "slash commands" },
       { name: "agents", targetSubdir: "agents", description: "agent definitions" },
@@ -4739,7 +5125,7 @@ var init_install_commands = __esm({
       { name: "reference", targetSubdir: "reference", description: "reference files" }
     ];
     MANIFEST_VERSION = 1;
-    MANIFEST_RELPATH = join6(".massu", "install-manifest.json");
+    MANIFEST_RELPATH = join7(".massu", "install-manifest.json");
     MASSU_OWNED_PATHS = ["commands/_verification-laws.md"];
     PASSTHROUGH_LANG_KEYS = [
       "typescript",
@@ -4952,17 +5338,17 @@ var init_manifest_registry = __esm({
 });
 
 // src/detect/package-detector.ts
-import { readFileSync as readFileSync7, existsSync as existsSync10, statSync as statSync3, lstatSync, readdirSync as readdirSync4 } from "fs";
-import { join as join7, relative as relative2 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync11, statSync as statSync3, lstatSync, readdirSync as readdirSync4 } from "fs";
+import { join as join8, relative as relative2 } from "path";
 import { parse as parseToml } from "smol-toml";
 function safeRead(path) {
   try {
-    if (!existsSync10(path)) return null;
+    if (!existsSync11(path)) return null;
     const ls = lstatSync(path);
     if (ls.isSymbolicLink()) return null;
     const st = statSync3(path);
     if (!st.isFile()) return null;
-    return readFileSync7(path, "utf-8");
+    return readFileSync8(path, "utf-8");
   } catch {
     return null;
   }
@@ -4993,7 +5379,7 @@ function parsePackageJson(path, directory, root, warnings) {
   const peer = Object.keys(
     pkg.peerDependencies ?? {}
   );
-  const hasTs = deps.includes("typescript") || devDeps.includes("typescript") || existsSync10(join7(directory, "tsconfig.json"));
+  const hasTs = deps.includes("typescript") || devDeps.includes("typescript") || existsSync11(join8(directory, "tsconfig.json"));
   const language = hasTs ? "typescript" : "javascript";
   const scripts = Object.keys(
     pkg.scripts ?? {}
@@ -5419,8 +5805,8 @@ function detectManifestsInDir(dir, root, warnings) {
   let dirEntries = null;
   for (const entry of getManifestRegistry2()) {
     if (!entry.pattern.startsWith("*")) {
-      const path = join7(dir, entry.pattern);
-      if (!existsSync10(path)) continue;
+      const path = join8(dir, entry.pattern);
+      if (!existsSync11(path)) continue;
       const m3 = entry.parse(path, dir, root, warnings);
       if (m3 !== null) out.push(m3);
     } else {
@@ -5433,8 +5819,8 @@ function detectManifestsInDir(dir, root, warnings) {
       }
       for (const fname of dirEntries) {
         if (!matchManifestPattern2(fname, entry.pattern)) continue;
-        const path = join7(dir, fname);
-        if (!existsSync10(path)) continue;
+        const path = join8(dir, fname);
+        if (!existsSync11(path)) continue;
         const m3 = entry.parse(path, dir, root, warnings);
         if (m3 !== null) out.push(m3);
       }
@@ -5444,7 +5830,7 @@ function detectManifestsInDir(dir, root, warnings) {
 }
 function listSubdirs(dir) {
   try {
-    return readdirSync4(dir, { withFileTypes: true }).filter((e2) => e2.isDirectory() && !IGNORED_DIRS.has(e2.name)).map((e2) => join7(dir, e2.name));
+    return readdirSync4(dir, { withFileTypes: true }).filter((e2) => e2.isDirectory() && !IGNORED_DIRS.has(e2.name)).map((e2) => join8(dir, e2.name));
   } catch {
     return [];
   }
@@ -5454,8 +5840,8 @@ function detectPackageManifests(projectRoot) {
   const manifests = [];
   manifests.push(...detectManifestsInDir(projectRoot, projectRoot, warnings));
   for (const ws of WORKSPACE_DIRS) {
-    const wsRoot = join7(projectRoot, ws);
-    if (!existsSync10(wsRoot)) continue;
+    const wsRoot = join8(projectRoot, ws);
+    if (!existsSync11(wsRoot)) continue;
     for (const sub of listSubdirs(wsRoot)) {
       manifests.push(...detectManifestsInDir(sub, projectRoot, warnings));
       for (const sub2 of listSubdirs(sub)) {
@@ -5702,20 +6088,20 @@ var init_framework_detector = __esm({
 
 // src/lib/safe-write.ts
 import {
-  writeFileSync as writeFileSync2,
+  writeFileSync as writeFileSync3,
   renameSync as renameSync2,
   openSync as openSync2,
   fsyncSync as fsyncSync2,
   closeSync as closeSync2,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   realpathSync,
   unlinkSync as unlinkSync2,
-  accessSync,
+  accessSync as accessSync2,
   statSync as statSync4,
-  chmodSync as chmodSync2,
+  chmodSync as chmodSync3,
   constants
 } from "fs";
-import { dirname as dirname8, resolve as resolve7, relative as relative3, isAbsolute, basename as basename3, sep } from "path";
+import { dirname as dirname10, resolve as resolve7, relative as relative3, isAbsolute, basename as basename3, sep } from "path";
 import { createHash as createHash4 } from "crypto";
 function assertContainedIn(rootDir, candidate, opts = {}) {
   if (candidate.includes("\0")) {
@@ -5747,8 +6133,8 @@ function isContainedIn(rootDir, candidate, opts = {}) {
   if (rel === "" && !opts.allowRoot) return false;
   if (rel.startsWith("..") || isAbsolute(rel)) return false;
   let probe = abs;
-  while (!existsSync11(probe) && probe.length > 1) {
-    const parent = dirname8(probe);
+  while (!existsSync12(probe) && probe.length > 1) {
+    const parent = dirname10(probe);
     if (parent === probe) break;
     probe = parent;
   }
@@ -5765,17 +6151,17 @@ function isContainedIn(rootDir, candidate, opts = {}) {
   return !realRel.startsWith("..") && !isAbsolute(realRel);
 }
 function atomicWriteFileSync(destPath, contents) {
-  const dir = dirname8(destPath);
+  const dir = dirname10(destPath);
   const tmp = resolve7(dir, `.${basename3(destPath)}.massu-tmp-${process.pid}`);
   let destMode;
-  if (existsSync11(destPath)) {
-    accessSync(destPath, constants.W_OK);
+  if (existsSync12(destPath)) {
+    accessSync2(destPath, constants.W_OK);
     destMode = statSync4(destPath).mode & 511;
   }
   let fd;
   try {
-    writeFileSync2(tmp, contents, "utf-8");
-    if (destMode !== void 0) chmodSync2(tmp, destMode);
+    writeFileSync3(tmp, contents, "utf-8");
+    if (destMode !== void 0) chmodSync3(tmp, destMode);
     fd = openSync2(tmp, "r+");
     fsyncSync2(fd);
     closeSync2(fd);
@@ -5789,7 +6175,7 @@ function atomicWriteFileSync(destPath, contents) {
       }
     }
     try {
-      if (existsSync11(tmp)) unlinkSync2(tmp);
+      if (existsSync12(tmp)) unlinkSync2(tmp);
     } catch {
     }
     throw err;
@@ -11800,38 +12186,38 @@ var init_source_dir_detector = __esm({
 });
 
 // src/detect/monorepo-detector.ts
-import { readFileSync as readFileSync8, existsSync as existsSync12, statSync as statSync5, lstatSync as lstatSync2, readdirSync as readdirSync5 } from "fs";
-import { join as join8, relative as relative4 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync13, statSync as statSync5, lstatSync as lstatSync2, readdirSync as readdirSync5 } from "fs";
+import { join as join9, relative as relative4 } from "path";
 import { parse as parseYaml3 } from "yaml";
 import { parse as parseToml2 } from "smol-toml";
 function safeReadText(path) {
   try {
-    if (!existsSync12(path)) return null;
+    if (!existsSync13(path)) return null;
     const ls = lstatSync2(path);
     if (ls.isSymbolicLink()) return null;
     const st = statSync5(path);
     if (!st.isFile()) return null;
-    return readFileSync8(path, "utf-8");
+    return readFileSync9(path, "utf-8");
   } catch {
     return null;
   }
 }
 function firstManifestIn(dir) {
   for (const m3 of MANIFEST_PRIORITY) {
-    if (existsSync12(join8(dir, m3))) return m3;
+    if (existsSync13(join9(dir, m3))) return m3;
   }
   return null;
 }
 function manifestName(dir, manifest) {
   try {
     if (manifest === "package.json") {
-      const raw = safeReadText(join8(dir, "package.json"));
+      const raw = safeReadText(join9(dir, "package.json"));
       if (!raw) return null;
       const pkg = JSON.parse(raw);
       return typeof pkg.name === "string" ? pkg.name : null;
     }
     if (manifest === "pyproject.toml") {
-      const raw = safeReadText(join8(dir, "pyproject.toml"));
+      const raw = safeReadText(join9(dir, "pyproject.toml"));
       if (!raw) return null;
       const toml = parseToml2(raw);
       const project = toml.project;
@@ -11842,7 +12228,7 @@ function manifestName(dir, manifest) {
       return null;
     }
     if (manifest === "Cargo.toml") {
-      const raw = safeReadText(join8(dir, "Cargo.toml"));
+      const raw = safeReadText(join9(dir, "Cargo.toml"));
       if (!raw) return null;
       const toml = parseToml2(raw);
       const pkg = toml.package;
@@ -11850,7 +12236,7 @@ function manifestName(dir, manifest) {
       return null;
     }
     if (manifest === "go.mod") {
-      const raw = safeReadText(join8(dir, "go.mod"));
+      const raw = safeReadText(join9(dir, "go.mod"));
       if (!raw) return null;
       for (const line of raw.split(/\r?\n/)) {
         const trimmed = line.trim();
@@ -11874,7 +12260,7 @@ function pkgFromDir(root, dir) {
 }
 function listSubdirs2(dir) {
   try {
-    return readdirSync5(dir, { withFileTypes: true }).filter((e2) => e2.isDirectory() && !IGNORED_DIRS2.has(e2.name)).map((e2) => join8(dir, e2.name));
+    return readdirSync5(dir, { withFileTypes: true }).filter((e2) => e2.isDirectory() && !IGNORED_DIRS2.has(e2.name)).map((e2) => join9(dir, e2.name));
   } catch {
     return [];
   }
@@ -11882,8 +12268,8 @@ function listSubdirs2(dir) {
 function genericWorkspaces(root) {
   const out = [];
   for (const parent of CONVENTIONAL_WORKSPACE_PARENTS) {
-    const p19 = join8(root, parent);
-    if (!existsSync12(p19)) continue;
+    const p19 = join9(root, parent);
+    if (!existsSync13(p19)) continue;
     for (const sub of listSubdirs2(p19)) {
       const pkg = pkgFromDir(root, sub);
       if (pkg) out.push(pkg);
@@ -11892,7 +12278,7 @@ function genericWorkspaces(root) {
   return out;
 }
 function detectYarnWorkspaces(root) {
-  const raw = safeReadText(join8(root, "package.json"));
+  const raw = safeReadText(join9(root, "package.json"));
   if (!raw) return null;
   let pkg;
   try {
@@ -11907,7 +12293,7 @@ function detectYarnWorkspaces(root) {
   return expandWorkspaceGlobs(root, globs);
 }
 function detectPnpmWorkspaces(root) {
-  const raw = safeReadText(join8(root, "pnpm-workspace.yaml"));
+  const raw = safeReadText(join9(root, "pnpm-workspace.yaml"));
   if (!raw) return null;
   try {
     const parsed = parseYaml3(raw);
@@ -11923,8 +12309,8 @@ function expandWorkspaceGlobs(root, globs) {
   for (const pattern of globs) {
     const parts = pattern.split("/");
     if (parts.length === 2 && (parts[1] === "*" || parts[1] === "**")) {
-      const parent = join8(root, parts[0]);
-      if (!existsSync12(parent)) continue;
+      const parent = join9(root, parts[0]);
+      if (!existsSync13(parent)) continue;
       for (const sub of listSubdirs2(parent)) {
         const pkg = pkgFromDir(root, sub);
         if (pkg && !seen.has(pkg.path)) {
@@ -11934,8 +12320,8 @@ function expandWorkspaceGlobs(root, globs) {
       }
       continue;
     }
-    const direct = join8(root, pattern);
-    if (existsSync12(direct)) {
+    const direct = join9(root, pattern);
+    if (existsSync13(direct)) {
       const pkg = pkgFromDir(root, direct);
       if (pkg && !seen.has(pkg.path)) {
         seen.add(pkg.path);
@@ -11946,16 +12332,16 @@ function expandWorkspaceGlobs(root, globs) {
   return out;
 }
 function hasTurbo(root) {
-  return existsSync12(join8(root, "turbo.json"));
+  return existsSync13(join9(root, "turbo.json"));
 }
 function hasNx(root) {
-  return existsSync12(join8(root, "nx.json"));
+  return existsSync13(join9(root, "nx.json"));
 }
 function hasLerna(root) {
-  return existsSync12(join8(root, "lerna.json"));
+  return existsSync13(join9(root, "lerna.json"));
 }
 function hasBazel(root) {
-  return existsSync12(join8(root, "WORKSPACE")) || existsSync12(join8(root, "WORKSPACE.bazel")) || existsSync12(join8(root, "MODULE.bazel"));
+  return existsSync13(join9(root, "WORKSPACE")) || existsSync13(join9(root, "WORKSPACE.bazel")) || existsSync13(join9(root, "MODULE.bazel"));
 }
 function detectMonorepo(projectRoot) {
   const nested = [];
@@ -12146,8 +12532,8 @@ var init_vr_command_map = __esm({
 });
 
 // src/detect/domain-inferrer.ts
-import { existsSync as existsSync13, readdirSync as readdirSync6 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync6 } from "fs";
+import { join as join10 } from "path";
 function titleCase(s) {
   if (!s) return s;
   return s.split(/[-_\s]+/).filter(Boolean).map((p19) => p19.charAt(0).toUpperCase() + p19.slice(1)).join(" ");
@@ -12167,8 +12553,8 @@ function topLevelSrcSubdirs(root, sourceDirs) {
   const effective = sourceDirs.length > 0 ? sourceDirs : ["src"];
   const seen = /* @__PURE__ */ new Set();
   for (const rel of effective) {
-    const abs = join9(root, rel);
-    if (!existsSync13(abs)) continue;
+    const abs = join10(root, rel);
+    if (!existsSync14(abs)) continue;
     try {
       for (const e2 of readdirSync6(abs, { withFileTypes: true })) {
         if (!e2.isDirectory()) continue;
@@ -12255,8 +12641,8 @@ var init_domain_inferrer = __esm({
 });
 
 // src/detect/regex-fallback.ts
-import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
-import { resolve as resolve8, join as join10, basename as basename4 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync7, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
+import { resolve as resolve8, join as join11, basename as basename4 } from "path";
 function introspectPython(detection, projectRoot) {
   const sourceDir = resolveSourceDir(detection, "python", projectRoot);
   if (!sourceDir) return null;
@@ -12423,9 +12809,9 @@ function resolveSourceDir(detection, lang, projectRoot) {
   if (list.length > 0) {
     const first = list[0];
     const abs = resolve8(projectRoot, first);
-    return existsSync14(abs) ? abs : null;
+    return existsSync15(abs) ? abs : null;
   }
-  return existsSync14(projectRoot) ? projectRoot : null;
+  return existsSync15(projectRoot) ? projectRoot : null;
 }
 function sampleFiles(dir, nameRegex, pathFilter) {
   const out = [];
@@ -12445,7 +12831,7 @@ function sampleFiles(dir, nameRegex, pathFilter) {
       if (entry === "__pycache__") continue;
       if (entry === "venv" || entry === ".venv") continue;
       if (entry === "dist" || entry === "build") continue;
-      const child = join10(path, entry);
+      const child = join11(path, entry);
       let st;
       try {
         st = statSync6(child);
@@ -12470,7 +12856,7 @@ function readSafe(path) {
   try {
     const st = statSync6(path);
     if (st.size > MAX_FILE_BYTES) return null;
-    return readFileSync9(path, "utf-8");
+    return readFileSync10(path, "utf-8");
   } catch {
     return null;
   }
@@ -12551,8 +12937,8 @@ var init_parse_guard = __esm({
 
 // src/detect/adapters/runner.ts
 import { basename as basename5, relative as relative5 } from "path";
-import { existsSync as existsSync15, readdirSync as readdirSync8, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync8, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
+import { join as join12 } from "path";
 async function runAdapters(adapters, rootDir, signals, options = {}) {
   const out = {
     byAdapter: {},
@@ -12649,7 +13035,7 @@ function buildDetectionSignals(rootDir) {
     for (const entry of readdirSync8(rootDir)) {
       if (entry.startsWith(".")) continue;
       try {
-        const st = statSync7(join11(rootDir, entry));
+        const st = statSync7(join12(rootDir, entry));
         if (st.isDirectory()) presentDirs.add(entry);
         else if (st.isFile()) presentFiles.add(entry);
       } catch {
@@ -12658,14 +13044,14 @@ function buildDetectionSignals(rootDir) {
   } catch {
   }
   return {
-    packageJson: tryReadJson(join11(rootDir, "package.json")),
-    pyprojectToml: tryReadToml(join11(rootDir, "pyproject.toml")),
-    gemfile: tryReadString(join11(rootDir, "Gemfile")),
-    cargoToml: tryReadToml(join11(rootDir, "Cargo.toml")),
-    goMod: tryReadString(join11(rootDir, "go.mod")),
-    mixExs: tryReadString(join11(rootDir, "mix.exs")),
+    packageJson: tryReadJson(join12(rootDir, "package.json")),
+    pyprojectToml: tryReadToml(join12(rootDir, "pyproject.toml")),
+    gemfile: tryReadString(join12(rootDir, "Gemfile")),
+    cargoToml: tryReadToml(join12(rootDir, "Cargo.toml")),
+    goMod: tryReadString(join12(rootDir, "go.mod")),
+    mixExs: tryReadString(join12(rootDir, "mix.exs")),
     csproj: tryReadFirstCsproj(rootDir, presentFiles),
-    pomXml: tryReadString(join11(rootDir, "pom.xml")),
+    pomXml: tryReadString(join12(rootDir, "pom.xml")),
     gradleBuild: tryReadGradleBuild(rootDir, presentFiles),
     presentDirs,
     presentFiles
@@ -12674,21 +13060,21 @@ function buildDetectionSignals(rootDir) {
 function tryReadFirstCsproj(rootDir, presentFiles) {
   const csprojNames = [...presentFiles].filter((f2) => f2.endsWith(".csproj")).sort();
   if (csprojNames.length === 0) return void 0;
-  return tryReadString(join11(rootDir, csprojNames[0]));
+  return tryReadString(join12(rootDir, csprojNames[0]));
 }
 function tryReadGradleBuild(rootDir, presentFiles) {
   if (presentFiles.has("build.gradle.kts")) {
-    return tryReadString(join11(rootDir, "build.gradle.kts"));
+    return tryReadString(join12(rootDir, "build.gradle.kts"));
   }
   if (presentFiles.has("build.gradle")) {
-    return tryReadString(join11(rootDir, "build.gradle"));
+    return tryReadString(join12(rootDir, "build.gradle"));
   }
   return void 0;
 }
 function tryReadString(path) {
-  if (!existsSync15(path)) return void 0;
+  if (!existsSync16(path)) return void 0;
   try {
-    return readFileSync10(path, "utf-8");
+    return readFileSync11(path, "utf-8");
   } catch {
     return void 0;
   }
@@ -12805,24 +13191,24 @@ ${querySource}`
 // src/detect/adapters/tree-sitter-loader.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync11,
-  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync12,
+  writeFileSync as writeFileSync4,
   renameSync as renameSync3,
   unlinkSync as unlinkSync3,
   lstatSync as lstatSync3,
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync4,
   utimesSync
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname9, join as join12 } from "path";
+import { dirname as dirname11, join as join13 } from "path";
 import { Language, Parser } from "web-tree-sitter";
 function getCacheDir() {
-  return process.env.MASSU_WASM_CACHE_DIR ?? join12(homedir5(), ".massu", "wasm-cache");
+  return process.env.MASSU_WASM_CACHE_DIR ?? join13(homedir5(), ".massu", "wasm-cache");
 }
 function getCachedPath(language, sha) {
-  return join12(getCacheDir(), `${language}-${sha}.wasm`);
+  return join13(getCacheDir(), `${language}-${sha}.wasm`);
 }
 function getCacheRetainCount() {
   const env = process.env.MASSU_WASM_CACHE_RETAIN;
@@ -12850,7 +13236,7 @@ function evictBeyondRetainCount(retain = getCacheRetainCount()) {
   const candidates = [];
   for (const name of entries) {
     if (!name.endsWith(".wasm")) continue;
-    const path = join12(dir, name);
+    const path = join13(dir, name);
     let stat;
     try {
       stat = lstatSync3(path);
@@ -12907,7 +13293,7 @@ async function loadGrammar(language, options = {}) {
     }
     let bytes;
     try {
-      bytes = readFileSync11(cachePath);
+      bytes = readFileSync12(cachePath);
     } catch (e2) {
       bytes = new Uint8Array(0);
     }
@@ -12947,21 +13333,21 @@ async function loadGrammar(language, options = {}) {
     throw new GrammarSHAMismatchError(language, manifest.sha256, downloadedSha);
   }
   try {
-    mkdirSync7(dirname9(cachePath), { recursive: true, mode: 448 });
+    mkdirSync9(dirname11(cachePath), { recursive: true, mode: 448 });
     try {
-      chmodSync3(dirname9(cachePath), 448);
+      chmodSync4(dirname11(cachePath), 448);
     } catch {
     }
     const tmpPath = `${cachePath}.tmp.${process.pid}`;
-    writeFileSync3(tmpPath, body, { mode: 384 });
+    writeFileSync4(tmpPath, body, { mode: 384 });
     try {
-      chmodSync3(tmpPath, 384);
+      chmodSync4(tmpPath, 384);
     } catch {
     }
     try {
       renameSync3(tmpPath, cachePath);
       try {
-        chmodSync3(cachePath, 384);
+        chmodSync4(cachePath, 384);
       } catch {
       }
     } catch (e2) {
@@ -13825,8 +14211,8 @@ __export(file_sampler_exports, {
   SAMPLE_TEST_FILE_PATTERNS: () => SAMPLE_TEST_FILE_PATTERNS,
   sampleFilesForAdapter: () => sampleFilesForAdapter
 });
-import { readdirSync as readdirSync10, readFileSync as readFileSync12, lstatSync as lstatSync4 } from "node:fs";
-import { join as join13, extname } from "node:path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync13, lstatSync as lstatSync4 } from "node:fs";
+import { join as join14, extname } from "node:path";
 function sampleFilesForAdapter(adapter, projectRoot, detection, options = {}) {
   const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
   const maxFiles = options.maxFilesPerAdapter ?? DEFAULT_MAX_FILES;
@@ -13841,7 +14227,7 @@ function sampleFilesForAdapter(adapter, projectRoot, detection, options = {}) {
     const langDetection = detection.sourceDirs[langKey];
     const candidateDirs = [];
     if (langDetection?.source_dirs && langDetection.source_dirs.length > 0) {
-      candidateDirs.push(...langDetection.source_dirs.map((d2) => join13(projectRoot, d2)));
+      candidateDirs.push(...langDetection.source_dirs.map((d2) => join14(projectRoot, d2)));
     } else {
       candidateDirs.push(projectRoot);
     }
@@ -13865,7 +14251,7 @@ function walkDir(dir, exts, testPatterns, lang, maxDepth, curDepth, out, seen, m
     if (out.length >= maxFiles) return;
     if (entry.startsWith(".")) continue;
     if (IGNORED_DIRS3.has(entry)) continue;
-    const fullPath = join13(dir, entry);
+    const fullPath = join14(dir, entry);
     let st;
     try {
       st = lstatSync4(fullPath);
@@ -13886,7 +14272,7 @@ function walkDir(dir, exts, testPatterns, lang, maxDepth, curDepth, out, seen, m
     seen.add(fullPath);
     let content;
     try {
-      content = readFileSync12(fullPath, "utf-8");
+      content = readFileSync13(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -15310,8 +15696,8 @@ __export(init_exports, {
   validateWrittenConfig: () => validateWrittenConfig,
   writeConfigAtomic: () => writeConfigAtomic
 });
-import { closeSync as closeSync3, existsSync as existsSync16, fsyncSync as fsyncSync3, openSync as openSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4, writeSync as writeSync2, mkdirSync as mkdirSync8, readdirSync as readdirSync11, renameSync as renameSync4, rmSync as rmSync4, statSync as statSync9, chmodSync as chmodSync4 } from "fs";
-import { resolve as resolve9, basename as basename6, dirname as dirname10 } from "path";
+import { closeSync as closeSync3, existsSync as existsSync17, fsyncSync as fsyncSync3, openSync as openSync3, readFileSync as readFileSync14, writeFileSync as writeFileSync5, writeSync as writeSync2, mkdirSync as mkdirSync10, readdirSync as readdirSync11, renameSync as renameSync4, rmSync as rmSync5, statSync as statSync9, chmodSync as chmodSync5 } from "fs";
+import { resolve as resolve9, basename as basename6, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { homedir as homedir6 } from "os";
 import { stringify as yamlStringify, parse as yamlParse } from "yaml";
@@ -15323,9 +15709,9 @@ function detectFramework(projectRoot) {
     ui: "none"
   };
   const pkgPath = resolve9(projectRoot, "package.json");
-  if (!existsSync16(pkgPath)) return result;
+  if (!existsSync17(pkgPath)) return result;
   try {
-    const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
     const allDeps = {
       ...pkg.dependencies,
       ...pkg.devDependencies
@@ -15359,7 +15745,7 @@ function detectPython(projectRoot) {
     alembicDir: null
   };
   const markers = ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"];
-  const hasMarker = markers.some((m3) => existsSync16(resolve9(projectRoot, m3)));
+  const hasMarker = markers.some((m3) => existsSync17(resolve9(projectRoot, m3)));
   if (!hasMarker) return result;
   result.detected = true;
   const depFiles = [
@@ -15370,32 +15756,32 @@ function detectPython(projectRoot) {
   ];
   for (const { file } of depFiles) {
     const filePath = resolve9(projectRoot, file);
-    if (existsSync16(filePath)) {
+    if (existsSync17(filePath)) {
       try {
-        const content = readFileSync13(filePath, "utf-8").toLowerCase();
+        const content = readFileSync14(filePath, "utf-8").toLowerCase();
         if (content.includes("fastapi")) result.hasFastapi = true;
         if (content.includes("sqlalchemy")) result.hasSqlalchemy = true;
       } catch {
       }
     }
   }
-  if (existsSync16(resolve9(projectRoot, "alembic.ini"))) {
+  if (existsSync17(resolve9(projectRoot, "alembic.ini"))) {
     result.hasAlembic = true;
-    if (existsSync16(resolve9(projectRoot, "alembic"))) {
+    if (existsSync17(resolve9(projectRoot, "alembic"))) {
       result.alembicDir = "alembic";
     }
-  } else if (existsSync16(resolve9(projectRoot, "alembic"))) {
+  } else if (existsSync17(resolve9(projectRoot, "alembic"))) {
     result.hasAlembic = true;
     result.alembicDir = "alembic";
   }
   const candidateRoots = ["app", "src", "backend", "api"];
   for (const candidate of candidateRoots) {
     const candidatePath = resolve9(projectRoot, candidate);
-    if (existsSync16(candidatePath) && existsSync16(resolve9(candidatePath, "__init__.py"))) {
+    if (existsSync17(candidatePath) && existsSync17(resolve9(candidatePath, "__init__.py"))) {
       result.root = candidate;
       break;
     }
-    if (existsSync16(candidatePath)) {
+    if (existsSync17(candidatePath)) {
       try {
         const files = readdirSync11(candidatePath);
         if (files.some((f2) => f2.endsWith(".py"))) {
@@ -15416,7 +15802,7 @@ function generateConfig(projectRoot, framework) {
     "[@massu/core] generateConfig() is deprecated since 1.2.1 \u2014 use buildConfigFromDetection instead. It cannot produce valid configs for monorepos."
   );
   const configPath = resolve9(projectRoot, "massu.config.yaml");
-  if (existsSync16(configPath)) {
+  if (existsSync17(configPath)) {
     return false;
   }
   const projectName = basename6(projectRoot);
@@ -15462,7 +15848,7 @@ function generateConfig(projectRoot, framework) {
 # Documentation: https://massu.ai/docs/getting-started/configuration
 
 ${yamlStringify(config)}`;
-  writeFileSync4(configPath, yamlContent, "utf-8");
+  writeFileSync5(configPath, yamlContent, "utf-8");
   return true;
 }
 function monorepoCommonRoot(packages) {
@@ -15527,10 +15913,10 @@ function buildConfigFromDetection(opts) {
       pathsSource = monorepoCommonRoot(detection.monorepo.packages);
     }
   }
-  if (pathsSource === "src" && !existsSync16(resolve9(projectRoot, "src"))) {
+  if (pathsSource === "src" && !existsSync17(resolve9(projectRoot, "src"))) {
     const fallbacks = ["app", "pages", "."];
     for (const fallback of fallbacks) {
-      if (fallback === "." || existsSync16(resolve9(projectRoot, fallback))) {
+      if (fallback === "." || existsSync17(resolve9(projectRoot, fallback))) {
         pathsSource = fallback;
         break;
       }
@@ -15614,7 +16000,7 @@ function buildConfigFromDetection(opts) {
     };
     if (pyFw?.framework) pythonBlock.framework = pyFw.framework;
     if (pyFw?.orm) pythonBlock.orm = pyFw.orm;
-    if (existsSync16(resolve9(projectRoot, "alembic.ini")) || existsSync16(resolve9(projectRoot, "alembic"))) {
+    if (existsSync17(resolve9(projectRoot, "alembic.ini")) || existsSync17(resolve9(projectRoot, "alembic"))) {
       pythonBlock.alembic_dir = "alembic";
     }
     config.python = pythonBlock;
@@ -15639,10 +16025,10 @@ function applyVariantTemplate(config, templatesDir) {
   }
   if (templateId === null) return config;
   const templatePath = resolve9(templatesDir, templateId, "massu.config.yaml");
-  if (!existsSync16(templatePath)) return config;
+  if (!existsSync17(templatePath)) return config;
   let template;
   try {
-    template = yamlParse(readFileSync13(templatePath, "utf-8"));
+    template = yamlParse(readFileSync14(templatePath, "utf-8"));
   } catch {
     return config;
   }
@@ -15701,7 +16087,7 @@ ${yamlStringify(config)}`;
 function writeConfigAtomic(configPath, content) {
   const tmpPath = `${configPath}.tmp`;
   let existingMode;
-  if (existsSync16(configPath)) {
+  if (existsSync17(configPath)) {
     try {
       existingMode = statSync9(configPath).mode;
     } catch {
@@ -15709,7 +16095,7 @@ function writeConfigAtomic(configPath, content) {
     }
   }
   try {
-    mkdirSync8(dirname10(configPath), { recursive: true });
+    mkdirSync10(dirname12(configPath), { recursive: true });
     const fd = openSync3(tmpPath, "w", 420);
     try {
       const buf = Buffer.from(content, "utf-8");
@@ -15725,15 +16111,15 @@ function writeConfigAtomic(configPath, content) {
     renameSync4(tmpPath, configPath);
     if (existingMode !== void 0) {
       try {
-        chmodSync4(configPath, existingMode);
+        chmodSync5(configPath, existingMode);
       } catch {
       }
     }
     return { validated: true };
   } catch (err) {
-    if (existsSync16(tmpPath)) {
+    if (existsSync17(tmpPath)) {
       try {
-        rmSync4(tmpPath, { force: true });
+        rmSync5(tmpPath, { force: true });
       } catch {
       }
     }
@@ -15742,8 +16128,8 @@ function writeConfigAtomic(configPath, content) {
 }
 function validateWrittenConfig(configPath, projectRoot, checkPaths = true) {
   try {
-    if (!existsSync16(configPath)) return "Config file does not exist after write";
-    const content = readFileSync13(configPath, "utf-8");
+    if (!existsSync17(configPath)) return "Config file does not exist after write";
+    const content = readFileSync14(configPath, "utf-8");
     const parsed = yamlParse(content);
     if (parsed === null || typeof parsed !== "object") {
       return "Config is not a valid YAML object";
@@ -15764,7 +16150,7 @@ function validateWrittenConfig(configPath, projectRoot, checkPaths = true) {
         const src = cfg.paths.source;
         if (src && src !== ".") {
           const srcAbs = resolve9(projectRoot, src);
-          if (!existsSync16(srcAbs)) {
+          if (!existsSync17(srcAbs)) {
             return `paths.source '${src}' does not exist on disk`;
           }
         }
@@ -15775,7 +16161,7 @@ function validateWrittenConfig(configPath, projectRoot, checkPaths = true) {
           for (const d2 of rawDirs) {
             if (typeof d2 !== "string" || d2 === ".") continue;
             const abs = resolve9(projectRoot, d2);
-            if (!existsSync16(abs)) {
+            if (!existsSync17(abs)) {
               return `framework.languages.${lang}.source_dirs '${d2}' does not exist on disk`;
             }
           }
@@ -15784,7 +16170,7 @@ function validateWrittenConfig(configPath, projectRoot, checkPaths = true) {
         if (Array.isArray(mRoots)) {
           for (const r2 of mRoots) {
             if (typeof r2 !== "string" || r2 === ".") continue;
-            if (!existsSync16(resolve9(projectRoot, r2))) {
+            if (!existsSync17(resolve9(projectRoot, r2))) {
               return `paths.monorepo_roots '${r2}' does not exist on disk`;
             }
           }
@@ -15830,7 +16216,7 @@ function resolveTemplatesDir() {
     resolve9(__dirname2, "../../../templates")
   ];
   for (const c2 of candidates) {
-    if (existsSync16(c2)) return c2;
+    if (existsSync17(c2)) return c2;
   }
   return null;
 }
@@ -15840,13 +16226,13 @@ function copyTemplateConfig(templateName, targetPath, projectName) {
     return { success: false, error: `Templates directory not found (looked in node_modules and dist/src)` };
   }
   const srcPath = resolve9(templatesDir, templateName, "massu.config.yaml");
-  if (!existsSync16(srcPath)) {
+  if (!existsSync17(srcPath)) {
     return { success: false, error: `Template '${templateName}' not found at ${srcPath}` };
   }
   try {
-    let content = readFileSync13(srcPath, "utf-8");
+    let content = readFileSync14(srcPath, "utf-8");
     content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
-    writeFileSync4(targetPath, content, "utf-8");
+    writeFileSync5(targetPath, content, "utf-8");
     return { success: true };
   } catch (err) {
     return { success: false, error: err instanceof Error ? err.message : String(err) };
@@ -15858,9 +16244,9 @@ function getInstallerVersion() {
     resolve9(__dirname2, "../../package.json")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate)) {
+    if (existsSync17(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync13(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync14(candidate, "utf-8"));
         if (typeof pkg.version === "string" && pkg.version.length > 0 && pkg.name === "@massu/core") {
           return pkg.version;
         }
@@ -15875,9 +16261,9 @@ function getInstallerVersion() {
 function registerMcpServer(projectRoot) {
   const mcpPath = resolve9(projectRoot, ".mcp.json");
   let existing = {};
-  if (existsSync16(mcpPath)) {
+  if (existsSync17(mcpPath)) {
     try {
-      existing = JSON.parse(readFileSync13(mcpPath, "utf-8"));
+      existing = JSON.parse(readFileSync14(mcpPath, "utf-8"));
     } catch {
       existing = {};
     }
@@ -15893,17 +16279,17 @@ function registerMcpServer(projectRoot) {
     args: ["-y", `@massu/core@${version}`]
   };
   existing.mcpServers = servers;
-  writeFileSync4(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  writeFileSync5(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
   return true;
 }
 function resolveHooksDir() {
   const cwd = process.cwd();
   const nodeModulesPath = resolve9(cwd, "node_modules/@massu/core/dist/hooks");
-  if (existsSync16(nodeModulesPath)) {
+  if (existsSync17(nodeModulesPath)) {
     return "node_modules/@massu/core/dist/hooks";
   }
   const localPath = resolve9(__dirname2, "../dist/hooks");
-  if (existsSync16(localPath)) {
+  if (existsSync17(localPath)) {
     return localPath;
   }
   return "node_modules/@massu/core/dist/hooks";
@@ -16053,8 +16439,8 @@ function installHooks(projectRoot) {
     claudeDirName = ".claude";
   }
   const claudeDir = resolve9(projectRoot, claudeDirName);
-  if (!existsSync16(claudeDir)) {
-    mkdirSync8(claudeDir, { recursive: true });
+  if (!existsSync17(claudeDir)) {
+    mkdirSync10(claudeDir, { recursive: true });
   }
   const settings = readSettingsLocal(claudeDir);
   const hooksConfig = buildHooksConfig(resolveHooksDir());
@@ -16075,14 +16461,14 @@ function initMemoryDir(projectRoot) {
   const memoryDir = resolve9(homedir6(), `.claude/projects/${encodedRoot}/memory`);
   let migratedFromLegacy = false;
   const legacyDir = resolve9(homedir6(), `.claude/projects/-${encodedRoot}/memory`);
-  if (existsSync16(legacyDir) && !existsSync16(memoryDir)) {
+  if (existsSync17(legacyDir) && !existsSync17(memoryDir)) {
     try {
-      mkdirSync8(resolve9(memoryDir, ".."), { recursive: true });
+      mkdirSync10(resolve9(memoryDir, ".."), { recursive: true });
       renameSync4(legacyDir, memoryDir);
       try {
         const legacyParent = resolve9(legacyDir, "..");
-        if (existsSync16(legacyParent) && readdirSync11(legacyParent).length === 0) {
-          rmSync4(legacyParent, { recursive: false });
+        if (existsSync17(legacyParent) && readdirSync11(legacyParent).length === 0) {
+          rmSync5(legacyParent, { recursive: false });
         }
       } catch {
       }
@@ -16091,13 +16477,13 @@ function initMemoryDir(projectRoot) {
     }
   }
   let created = false;
-  if (!existsSync16(memoryDir)) {
-    mkdirSync8(memoryDir, { recursive: true });
+  if (!existsSync17(memoryDir)) {
+    mkdirSync10(memoryDir, { recursive: true });
     created = true;
   }
   const memoryMdPath = resolve9(memoryDir, "MEMORY.md");
   let memoryMdCreated = false;
-  if (!existsSync16(memoryMdPath)) {
+  if (!existsSync17(memoryMdPath)) {
     const projectName = basename6(projectRoot);
     const memoryContent = `# ${projectName} - Massu Memory
 
@@ -16113,7 +16499,7 @@ function initMemoryDir(projectRoot) {
 ## File Index
 <!-- Significant files and directories -->
 `;
-    writeFileSync4(memoryMdPath, memoryContent, "utf-8");
+    writeFileSync5(memoryMdPath, memoryContent, "utf-8");
     memoryMdCreated = true;
   }
   return { created, memoryMdCreated, migratedFromLegacy };
@@ -16212,7 +16598,7 @@ async function runInit(argv, overrides) {
   log("========================");
   log("");
   const configPath = resolve9(projectRoot, "massu.config.yaml");
-  if (existsSync16(configPath)) {
+  if (existsSync17(configPath)) {
     if (opts.ci && !opts.force) {
       errLog(`error: massu.config.yaml already exists at ${configPath}`);
       errLog("       rerun with --force to overwrite, or remove the file first");
@@ -16240,7 +16626,7 @@ async function runInit(argv, overrides) {
     const validation2 = validateWrittenConfig(configPath, projectRoot, false);
     if (validation2 !== null) {
       try {
-        rmSync4(configPath, { force: true });
+        rmSync5(configPath, { force: true });
       } catch {
       }
       errLog(`error: template config failed validation: ${validation2}`);
@@ -16318,7 +16704,7 @@ async function runInit(argv, overrides) {
   const validation = validateWrittenConfig(configPath, projectRoot, !emptyStack);
   if (validation !== null) {
     try {
-      rmSync4(configPath, { force: true });
+      rmSync5(configPath, { force: true });
     } catch {
     }
     errLog(`error: generated config failed validation: ${validation}`);
@@ -16352,7 +16738,7 @@ function installSideEffects(projectRoot, log, skipCommands = false, emptyStack =
       const stackResolved = !emptyStack && commandStats && (commandStats.installed > 0 || commandStats.updated > 0 || commandStats.kept > 0);
       if (!stackResolved) {
         const placeholderPath = resolve9(cmdResult.claudeDir, "commands", "_massu-needs-stack.md");
-        if (!existsSync16(placeholderPath)) {
+        if (!existsSync17(placeholderPath)) {
           const placeholderBody = [
             "# Massu \u2014 stack not yet detected",
             "",
@@ -16373,8 +16759,8 @@ function installSideEffects(projectRoot, log, skipCommands = false, emptyStack =
             "\u2014 Massu"
           ].join("\n");
           try {
-            mkdirSync8(resolve9(cmdResult.claudeDir, "commands"), { recursive: true });
-            writeFileSync4(placeholderPath, placeholderBody, "utf-8");
+            mkdirSync10(resolve9(cmdResult.claudeDir, "commands"), { recursive: true });
+            writeFileSync5(placeholderPath, placeholderBody, "utf-8");
             log("  Wrote _massu-needs-stack.md placeholder (no stack detected yet)");
           } catch {
           }
@@ -16397,7 +16783,7 @@ function installSideEffects(projectRoot, log, skipCommands = false, emptyStack =
     try {
       const encodedRoot = encodeMemoryDirName(projectRoot);
       const memoryDir = resolve9(homedir6(), ".claude", "projects", encodedRoot, "memory");
-      const memFiles = existsSync16(memoryDir) ? readdirSync11(memoryDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md") : [];
+      const memFiles = existsSync17(memoryDir) ? readdirSync11(memoryDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md") : [];
       if (memFiles.length > 0) {
         const { getMemoryDb: getMemoryDb2 } = await Promise.resolve().then(() => (init_memory_db(), memory_db_exports));
         const db = getMemoryDb2();
@@ -16460,7 +16846,7 @@ var init_init = __esm({
     init_detect();
     init_drift();
     __filename2 = fileURLToPath3(import.meta.url);
-    __dirname2 = dirname10(__filename2);
+    __dirname2 = dirname12(__filename2);
     FRAMEWORK_TO_TEMPLATE_ID = {
       rails: "rails",
       phoenix: "phoenix",
@@ -17081,21 +17467,22 @@ var init_hook_registry = __esm({
 // src/commands/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
+  checkNativeModules: () => checkNativeModules,
   formatLicenseCheck: () => formatLicenseCheck,
   runDoctor: () => runDoctor,
   runValidateConfig: () => runValidateConfig
 });
-import { existsSync as existsSync17, readFileSync as readFileSync14, readdirSync as readdirSync12 } from "fs";
-import { resolve as resolve10, dirname as dirname11 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync12 } from "fs";
+import { resolve as resolve10, dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { parse as parseYaml4 } from "yaml";
 function checkConfig(projectRoot) {
   const configPath = resolve10(projectRoot, "massu.config.yaml");
-  if (!existsSync17(configPath)) {
+  if (!existsSync18(configPath)) {
     return { name: "Configuration", status: "fail", detail: "massu.config.yaml not found. Run: npx massu init" };
   }
   try {
-    const content = readFileSync14(configPath, "utf-8");
+    const content = readFileSync15(configPath, "utf-8");
     const parsed = parseYaml4(content);
     if (!parsed || typeof parsed !== "object") {
       return { name: "Configuration", status: "fail", detail: "massu.config.yaml is empty or invalid YAML" };
@@ -17107,11 +17494,11 @@ function checkConfig(projectRoot) {
 }
 function checkMcpServer(projectRoot) {
   const mcpPath = getResolvedPaths().mcpJsonPath;
-  if (!existsSync17(mcpPath)) {
+  if (!existsSync18(mcpPath)) {
     return { name: "MCP Server", status: "fail", detail: ".mcp.json not found. Run: npx massu init" };
   }
   try {
-    const content = JSON.parse(readFileSync14(mcpPath, "utf-8"));
+    const content = JSON.parse(readFileSync15(mcpPath, "utf-8"));
     const servers = content.mcpServers ?? {};
     if (!servers.massu) {
       return { name: "MCP Server", status: "fail", detail: "massu not registered in .mcp.json. Run: npx massu init" };
@@ -17123,7 +17510,7 @@ function checkMcpServer(projectRoot) {
 }
 function checkHooksConfig(projectRoot) {
   const settingsPath = getResolvedPaths().settingsLocalPath;
-  if (!existsSync17(settingsPath)) {
+  if (!existsSync18(settingsPath)) {
     return { name: "Hooks Config", status: "fail", detail: ".claude/settings.local.json not found. Run: npx massu init" };
   }
   try {
@@ -17153,9 +17540,9 @@ function checkHooksConfig(projectRoot) {
 function checkHookFiles(projectRoot) {
   const nodeModulesHooksDir = resolve10(projectRoot, "node_modules/@massu/core/dist/hooks");
   let hooksDir = nodeModulesHooksDir;
-  if (!existsSync17(nodeModulesHooksDir)) {
+  if (!existsSync18(nodeModulesHooksDir)) {
     const devHooksDir = resolve10(__dirname3, "../../dist/hooks");
-    if (existsSync17(devHooksDir)) {
+    if (existsSync18(devHooksDir)) {
       hooksDir = devHooksDir;
     } else {
       return { name: "Hook Files", status: "fail", detail: "Compiled hooks not found. Run: npm install @massu/core" };
@@ -17163,7 +17550,7 @@ function checkHookFiles(projectRoot) {
   }
   const missing = [];
   for (const hookFile of EXPECTED_HOOKS) {
-    if (!existsSync17(resolve10(hooksDir, hookFile))) {
+    if (!existsSync18(resolve10(hooksDir, hookFile))) {
       missing.push(hookFile);
     }
   }
@@ -17173,12 +17560,17 @@ function checkHookFiles(projectRoot) {
   return { name: "Hook Files", status: "pass", detail: `${EXPECTED_HOOKS.length}/${EXPECTED_HOOKS.length} compiled hooks present` };
 }
 async function checkNativeModules() {
-  try {
-    await import("better-sqlite3");
-    return { name: "Native Modules", status: "pass", detail: "better-sqlite3 loads correctly" };
-  } catch (err) {
-    return { name: "Native Modules", status: "fail", detail: `better-sqlite3 failed: ${err instanceof Error ? err.message : String(err)}. Try: npm rebuild better-sqlite3` };
+  const memoryDbPath = getResolvedPaths().memoryDbPath;
+  const verdict = probeMemoryDbUsable({ dbPath: memoryDbPath, selfHeal: false });
+  if (verdict.ok) {
+    return { name: "Native Modules", status: "pass", detail: "better-sqlite3 constructs a DB and SELECT 1 succeeds" };
   }
+  const because = verdict.detail ? ` (${verdict.detail})` : "";
+  return {
+    name: "Native Modules",
+    status: "fail",
+    detail: `better-sqlite3 unusable \u2014 ${verdict.reason}${because}. ${verdict.remedy ?? NATIVE_DB_REMEDY}`
+  };
 }
 function checkNodeVersion() {
   const version = process.versions.node;
@@ -17190,12 +17582,12 @@ function checkNodeVersion() {
 }
 async function checkGitRepo(projectRoot) {
   const gitDir = resolve10(projectRoot, ".git");
-  if (!existsSync17(gitDir)) {
+  if (!existsSync18(gitDir)) {
     return { name: "Git Repository", status: "warn", detail: "Not a git repository (optional but recommended)" };
   }
   try {
-    const { spawnSync: spawnSync4 } = await import("child_process");
-    const result = spawnSync4("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const { spawnSync: spawnSync5 } = await import("child_process");
+    const result = spawnSync5("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd: projectRoot
@@ -17208,7 +17600,7 @@ async function checkGitRepo(projectRoot) {
 }
 function checkKnowledgeDb(projectRoot) {
   const knowledgeDbPath = getResolvedPaths().memoryDbPath;
-  if (!existsSync17(knowledgeDbPath)) {
+  if (!existsSync18(knowledgeDbPath)) {
     return {
       name: "Knowledge DB",
       status: "warn",
@@ -17219,7 +17611,7 @@ function checkKnowledgeDb(projectRoot) {
 }
 function checkMemoryDir(_projectRoot2) {
   const memoryDir = getResolvedPaths().memoryDir;
-  if (!existsSync17(memoryDir)) {
+  if (!existsSync18(memoryDir)) {
     return {
       name: "Memory Directory",
       status: "warn",
@@ -17230,7 +17622,7 @@ function checkMemoryDir(_projectRoot2) {
 }
 function checkShellHooksWired(_projectRoot2) {
   const settingsPath = getResolvedPaths().settingsLocalPath;
-  if (!existsSync17(settingsPath)) {
+  if (!existsSync18(settingsPath)) {
     return {
       name: "Shell Hooks",
       status: "fail",
@@ -17306,8 +17698,8 @@ async function checkLicenseStatus() {
 async function checkApiKeyHygiene(projectRoot) {
   if (getResolvedApiKeySource() !== "config") return null;
   try {
-    const { spawnSync: spawnSync4 } = await import("child_process");
-    const res = spawnSync4("git", ["ls-files", "--error-unmatch", "massu.config.yaml"], {
+    const { spawnSync: spawnSync5 } = await import("child_process");
+    const res = spawnSync5("git", ["ls-files", "--error-unmatch", "massu.config.yaml"], {
       cwd: projectRoot,
       timeout: 5e3,
       encoding: "utf-8"
@@ -17327,7 +17719,7 @@ function checkPythonHealth(projectRoot) {
   const config = getConfig();
   if (!config.python?.root) return null;
   const pythonRoot = resolve10(projectRoot, config.python.root);
-  if (!existsSync17(pythonRoot)) {
+  if (!existsSync18(pythonRoot)) {
     return {
       name: "Python",
       status: "fail",
@@ -17347,7 +17739,7 @@ function checkPythonHealth(projectRoot) {
           const excludeDirs = config.python?.exclude_dirs || ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"];
           if (!excludeDirs.includes(entry.name)) {
             const subdir = resolve10(dir, entry.name);
-            if (depth <= 2 && !existsSync17(resolve10(subdir, "__init__.py"))) {
+            if (depth <= 2 && !existsSync18(resolve10(subdir, "__init__.py"))) {
               try {
                 const subEntries = readdirSync12(subdir);
                 if (subEntries.some((f2) => f2.endsWith(".py") && f2 !== "__init__.py")) {
@@ -17445,14 +17837,14 @@ async function runDoctor() {
 async function runValidateConfig() {
   const projectRoot = process.cwd();
   const configPath = resolve10(projectRoot, "massu.config.yaml");
-  if (!existsSync17(configPath)) {
+  if (!existsSync18(configPath)) {
     console.error("Error: massu.config.yaml not found in current directory");
     console.error("Run: npx massu init");
     process.exit(1);
     return;
   }
   try {
-    const content = readFileSync14(configPath, "utf-8");
+    const content = readFileSync15(configPath, "utf-8");
     const parsed = parseYaml4(content);
     if (!parsed || typeof parsed !== "object") {
       console.error("Error: massu.config.yaml is empty or not a valid YAML object");
@@ -17493,8 +17885,9 @@ var init_doctor = __esm({
     init_credentials();
     init_settings_local();
     init_hook_registry();
+    init_sqlite_loader();
     __filename3 = fileURLToPath4(import.meta.url);
-    __dirname3 = dirname11(__filename3);
+    __dirname3 = dirname13(__filename3);
     EXPECTED_HOOKS = getExpectedHookFiles();
   }
 });
@@ -17682,6 +18075,67 @@ var init_login = __esm({
   }
 });
 
+// src/commands/heal.ts
+var heal_exports = {};
+__export(heal_exports, {
+  runHeal: () => runHeal
+});
+async function runHeal(argv = []) {
+  const check = argv.includes("--check");
+  const runningAbi = process.versions.modules;
+  const verdict = probeMemoryDbUsable({ selfHeal: false });
+  const abiFrom = (() => {
+    const m3 = /NODE_MODULE_VERSION (\d+)/.exec(verdict.detail ?? "");
+    return m3 ? m3[1] : void 0;
+  })();
+  const probe = { ok: verdict.ok, abiFrom, detail: verdict.detail };
+  if (check) {
+    if (probe.ok) {
+      process.stdout.write(
+        `massu heal --check: native engine OK \u2014 better-sqlite3 matches this Node (NODE_MODULE_VERSION ${runningAbi}, ${process.version}).
+`
+      );
+      return { exitCode: 0 };
+    }
+    process.stdout.write(
+      `massu heal --check: ABI MISMATCH \u2014 this Node needs NODE_MODULE_VERSION ${runningAbi} (${process.version})` + (probe.abiFrom ? `, the installed binary is ${probe.abiFrom}` : "") + `. Run 'massu heal' to rebuild it.
+`
+    );
+    return { exitCode: 1 };
+  }
+  if (probe.ok) {
+    process.stdout.write(
+      `massu heal: native engine already healthy for ${process.version} (NODE_MODULE_VERSION ${runningAbi}) \u2014 nothing to do.
+`
+    );
+    return { exitCode: 0 };
+  }
+  process.stdout.write(
+    `massu heal: rebuilding better-sqlite3 for ${process.version} (NODE_MODULE_VERSION ${runningAbi})\u2026
+`
+  );
+  const result = attemptNativeHeal(probe.detail ? new Error(probe.detail) : void 0);
+  if (result.healed) {
+    process.stdout.write(
+      `massu heal: rebuilt via ${result.method} (ABI ${result.abiFrom ?? "?"} \u2192 ${result.abiTo}, ${result.durationMs ?? "?"}ms). Restart your MCP client / Claude Code to pick up the healed engine.
+`
+    );
+    return { exitCode: 0 };
+  }
+  process.stderr.write(
+    `massu heal: could not rebuild the native engine (${result.reason}${result.detail ? `: ${result.detail}` : ""}).
+  Ensure the install directory is writable and either network access (for a compiler-free prebuilt) or a C/C++ toolchain (for a source build) is available, then retry.
+`
+  );
+  return { exitCode: 1 };
+}
+var init_heal = __esm({
+  "src/commands/heal.ts"() {
+    "use strict";
+    init_sqlite_loader();
+  }
+});
+
 // src/commands/install-hooks.ts
 var install_hooks_exports = {};
 __export(install_hooks_exports, {
@@ -17713,8 +18167,8 @@ __export(hook_runner_exports, {
   resolveHookFile: () => resolveHookFile,
   runHookRunner: () => runHookRunner
 });
-import { existsSync as existsSync18 } from "fs";
-import { resolve as resolve11, dirname as dirname12 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve11, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn } from "child_process";
 function resolveHookFile(hookName) {
@@ -17733,7 +18187,7 @@ function resolveHookFile(hookName) {
     resolve11(__dirname4, "../../dist/hooks", file)
   ];
   for (const candidate of candidates) {
-    if (existsSync18(candidate)) {
+    if (existsSync19(candidate)) {
       return candidate;
     }
   }
@@ -17763,7 +18217,10 @@ Recognized: ${Object.keys(HOOK_NAME_TO_FILE).join(", ")}
   return new Promise((resolvePromise) => {
     const child = spawn(process.execPath, [hookFile], {
       stdio: ["inherit", "inherit", "inherit"],
-      env: process.env
+      // MASSU_HOOK_RUNTIME marks the hook process so the SSOT SQLite loader NEVER
+      // self-heals here (5s budget / CR-12, CR-65 P0-003) — even for indirect opens
+      // via getMemoryDb(). The next server/CLI touch performs the rebuild.
+      env: { ...process.env, MASSU_HOOK_RUNTIME: "1" }
     });
     child.on("exit", (code, signal) => {
       if (signal) {
@@ -17785,7 +18242,7 @@ var init_hook_runner = __esm({
     "use strict";
     init_hook_registry();
     __filename4 = fileURLToPath5(import.meta.url);
-    __dirname4 = dirname12(__filename4);
+    __dirname4 = dirname14(__filename4);
     HOOK_NAME_TO_FILE = Object.freeze(
       Object.fromEntries(REGISTERED_HOOKS.map((name) => [name, `${name}.js`]))
     );
@@ -17924,7 +18381,7 @@ var db_exports = {};
 __export(db_exports, {
   handleDbSubcommand: () => handleDbSubcommand
 });
-import { existsSync as existsSync19, statSync as statSync10 } from "fs";
+import { existsSync as existsSync20, statSync as statSync10 } from "fs";
 import { basename as basename7 } from "path";
 function human(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -17969,7 +18426,7 @@ async function handleDbSubcommand(args2) {
 
 `);
     for (const store of allStores()) {
-      if (!existsSync19(store.path)) {
+      if (!existsSync20(store.path)) {
         process.stdout.write(`  ${"\u2014"} ${store.name.padEnd(10)} not present, skipped
 `);
         continue;
@@ -18067,7 +18524,7 @@ Restore with:  massu db restore --latest memory
       target = found.path;
     }
     try {
-      const before = existsSync19(target) ? statSync10(target).size : 0;
+      const before = existsSync20(target) ? statSync10(target).size : 0;
       const res = restoreDb(backupPath, target);
       process.stdout.write(
         `Restored ${basename7(target)}
@@ -18233,7 +18690,7 @@ var init_license2 = __esm({
 });
 
 // src/changelog-generator.ts
-import { existsSync as existsSync20, readFileSync as readFileSync15, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync16, readdirSync as readdirSync13 } from "fs";
 import { resolve as resolve13 } from "path";
 function parseCommitsForPlanTokens(subjects) {
   const tokens = /* @__PURE__ */ new Set();
@@ -18251,7 +18708,7 @@ function parseCommitsForPlanTokens(subjects) {
 function loadPlanSummaries(tokens, planDir) {
   const result = /* @__PURE__ */ new Map();
   if (tokens.size === 0) return result;
-  if (!existsSync20(planDir)) {
+  if (!existsSync21(planDir)) {
     throw new Error(`Plan directory does not exist: ${planDir}`);
   }
   const files = readdirSync13(planDir).filter((f2) => f2.endsWith(".md"));
@@ -18260,7 +18717,7 @@ function loadPlanSummaries(tokens, planDir) {
     let content = "";
     for (const file of files) {
       const path = resolve13(planDir, file);
-      const text18 = readFileSync15(path, "utf-8");
+      const text18 = readFileSync16(path, "utf-8");
       const tokenRe = new RegExp(
         `^\\*\\*Plan Token\\*\\*:\\s*\`?${token.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\`?(\\s|$)`,
         "m"
@@ -18341,7 +18798,7 @@ __export(changelog_exports, {
   printChangelogHelp: () => printChangelogHelp
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync17 } from "fs";
 import { resolve as resolve14 } from "path";
 function resolveRepoRoot() {
   try {
@@ -18367,8 +18824,8 @@ function getCommitSubjects(range) {
 }
 function getCurrentVersion(repoRoot) {
   const pkgPath = resolve14(repoRoot, "packages/core/package.json");
-  if (!existsSync21(pkgPath)) return "0.0.0";
-  const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
+  if (!existsSync22(pkgPath)) return "0.0.0";
+  const pkg = JSON.parse(readFileSync17(pkgPath, "utf-8"));
   return pkg.version || "0.0.0";
 }
 function todayDate() {
@@ -18376,8 +18833,8 @@ function todayDate() {
 }
 function getLatestChangelogEntryBody(repoRoot) {
   const path = resolve14(repoRoot, "CHANGELOG.md");
-  if (!existsSync21(path)) return "";
-  const content = readFileSync16(path, "utf-8");
+  if (!existsSync22(path)) return "";
+  const content = readFileSync17(path, "utf-8");
   const m3 = content.match(/^## \[[\d.]+\][^\n]*\n([\s\S]*?)(?=\n## \[|$)/m);
   return m3 ? m3[1] : "";
 }
@@ -18472,16 +18929,15 @@ var init_changelog = __esm({
 });
 
 // src/knowledge-db.ts
-import Database3 from "better-sqlite3";
-import { dirname as dirname13 } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync9 } from "fs";
+import { dirname as dirname15 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync11 } from "fs";
 function getKnowledgeDb() {
   const dbPath = getResolvedPaths().knowledgeDbPath;
-  const dir = dirname13(dbPath);
-  if (!existsSync22(dir)) {
-    mkdirSync9(dir, { recursive: true });
+  const dir = dirname15(dbPath);
+  if (!existsSync23(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
-  const db = new Database3(dbPath);
+  const db = openDatabase(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   initKnowledgeSchema(db);
@@ -18693,6 +19149,7 @@ async function embedMissingChunks(db, opts = {}) {
 var init_knowledge_db = __esm({
   "src/knowledge-db.ts"() {
     "use strict";
+    init_sqlite_loader();
     init_config();
     init_memory_vector();
     init_memory_embed_sweep();
@@ -18704,7 +19161,7 @@ var memory_embed_backfill_exports = {};
 __export(memory_embed_backfill_exports, {
   runMemoryEmbedBackfill: () => runMemoryEmbedBackfill
 });
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 async function runMemoryEmbedBackfill(_args = []) {
   await embed("massu memory embed backfill probe");
   const active = getActiveEmbedModel();
@@ -18731,7 +19188,7 @@ async function runMemoryEmbedBackfill(_args = []) {
   );
   let chunks = { embedded: 0, scanned: 0 };
   const knowledgeDbPath = getResolvedPaths().knowledgeDbPath;
-  if (existsSync23(knowledgeDbPath)) {
+  if (existsSync24(knowledgeDbPath)) {
     const knowledgeDb = getKnowledgeDb();
     try {
       chunks = await embedMissingChunks(knowledgeDb);
@@ -18764,7 +19221,7 @@ var init_memory_embed_backfill = __esm({
 
 // src/memory-authorship.ts
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync5, existsSync as existsSync24, mkdirSync as mkdirSync10, chmodSync as chmodSync5, statSync as statSync11 } from "fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync6, existsSync as existsSync25, mkdirSync as mkdirSync12, chmodSync as chmodSync6, statSync as statSync11 } from "fs";
 import { homedir as homedir7 } from "os";
 import { resolve as resolve15 } from "path";
 function renderKeyPath(home = homedir7()) {
@@ -18773,8 +19230,8 @@ function renderKeyPath(home = homedir7()) {
 function readRenderKey(home = homedir7()) {
   const p19 = renderKeyPath(home);
   try {
-    if (!existsSync24(p19)) return void 0;
-    const raw = readFileSync17(p19);
+    if (!existsSync25(p19)) return void 0;
+    const raw = readFileSync18(p19);
     if (raw.length !== 32) return void 0;
     return raw;
   } catch {
@@ -18787,15 +19244,15 @@ function ensureRenderKey(home = homedir7()) {
   const p19 = renderKeyPath(home);
   try {
     const dir = resolve15(home, ".massu");
-    mkdirSync10(dir, { recursive: true, mode: 448 });
+    mkdirSync12(dir, { recursive: true, mode: 448 });
     try {
-      chmodSync5(dir, 448);
+      chmodSync6(dir, 448);
     } catch {
     }
     const key = randomBytes(32);
-    writeFileSync5(p19, key, { mode: 384 });
+    writeFileSync6(p19, key, { mode: 384 });
     try {
-      chmodSync5(p19, 384);
+      chmodSync6(p19, 384);
     } catch {
     }
     return key;
@@ -18844,11 +19301,11 @@ var init_memory_authorship = __esm({
 });
 
 // src/rule-candidate-snapshot.ts
-import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync19, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4 } from "fs";
 function takeSnapshots(paths) {
   const out = /* @__PURE__ */ new Map();
   for (const p19 of paths) {
-    if (existsSync25(p19)) out.set(p19, readFileSync18(p19, "utf-8"));
+    if (existsSync26(p19)) out.set(p19, readFileSync19(p19, "utf-8"));
     else out.set(p19, null);
   }
   return out;
@@ -18858,9 +19315,9 @@ function restoreSnapshots(snapshot) {
   for (const [path, content] of snapshot) {
     try {
       if (content === null) {
-        if (existsSync25(path)) unlinkSync4(path);
+        if (existsSync26(path)) unlinkSync4(path);
       } else {
-        writeFileSync6(path, content, "utf-8");
+        writeFileSync7(path, content, "utf-8");
       }
     } catch (err) {
       errors.push(`${path}: ${err instanceof Error ? err.message : String(err)}`);
@@ -18938,18 +19395,18 @@ var init_memory_render_path = __esm({
 });
 
 // src/memory-tombstones.ts
-import { readFileSync as readFileSync19, appendFileSync as appendFileSync2, existsSync as existsSync26 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync20, appendFileSync as appendFileSync3, existsSync as existsSync27 } from "fs";
+import { join as join15 } from "path";
 function tombstoneLedgerPath(memoryDir) {
-  return join14(memoryDir, TOMBSTONE_LEDGER);
+  return join15(memoryDir, TOMBSTONE_LEDGER);
 }
 function readTombstones(memoryDir) {
   const out = /* @__PURE__ */ new Map();
   const p19 = tombstoneLedgerPath(memoryDir);
-  if (!existsSync26(p19)) return out;
+  if (!existsSync27(p19)) return out;
   let raw;
   try {
-    raw = readFileSync19(p19, "utf8");
+    raw = readFileSync20(p19, "utf8");
   } catch {
     return out;
   }
@@ -18977,7 +19434,7 @@ function tombstone(memoryDir, relPath, reason, nowEpoch) {
     reason
   };
   try {
-    appendFileSync2(tombstoneLedgerPath(memoryDir), `${JSON.stringify(entry)}
+    appendFileSync3(tombstoneLedgerPath(memoryDir), `${JSON.stringify(entry)}
 `, "utf8");
   } catch (err) {
     throw new TombstoneWriteError(
@@ -19173,15 +19630,15 @@ var init_memory_llm = __esm({
 // src/memory-backup.ts
 import {
   readdirSync as readdirSync14,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync13,
   copyFileSync as copyFileSync2,
   statSync as statSync12,
-  existsSync as existsSync27,
-  rmSync as rmSync5,
-  readFileSync as readFileSync20
+  existsSync as existsSync28,
+  rmSync as rmSync6,
+  readFileSync as readFileSync21
 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join15, resolve as resolve16 } from "path";
+import { join as join16, resolve as resolve16 } from "path";
 function backupsRoot(home = homedir8()) {
   return resolve16(home, ".massu", "memory-backups");
 }
@@ -19189,10 +19646,10 @@ function backupStamp2(nowMs) {
   return new Date(nowMs).toISOString().replace(/:/g, "-");
 }
 function newestMtimeMs(dir) {
-  if (!existsSync27(dir)) return 0;
+  if (!existsSync28(dir)) return 0;
   let newest = 0;
   for (const entry of readdirSync14(dir)) {
-    const p19 = join15(dir, entry);
+    const p19 = join16(dir, entry);
     try {
       const st = statSync12(p19);
       if (st.isFile() && st.mtimeMs > newest) newest = st.mtimeMs;
@@ -19204,10 +19661,10 @@ function newestMtimeMs(dir) {
 }
 function listBackups(home = homedir8()) {
   const root = backupsRoot(home);
-  if (!existsSync27(root)) return [];
+  if (!existsSync28(root)) return [];
   const out = [];
   for (const stamp of readdirSync14(root)) {
-    const dir = join15(root, stamp);
+    const dir = join16(root, stamp);
     try {
       const st = statSync12(dir);
       if (!st.isDirectory()) continue;
@@ -19225,21 +19682,21 @@ function hasFreshBackup(memoryDir, home = homedir8()) {
   return backups[0].createdMs >= newestChange;
 }
 function takeBackup(memoryDir, nowMs, home = homedir8(), retention = DEFAULT_RETENTION2) {
-  if (!existsSync27(memoryDir)) {
+  if (!existsSync28(memoryDir)) {
     throw new BackupError(`memory directory does not exist: ${memoryDir}`);
   }
   const stamp = backupStamp2(nowMs);
-  const dir = join15(backupsRoot(home), stamp);
+  const dir = join16(backupsRoot(home), stamp);
   try {
-    mkdirSync11(dir, { recursive: true, mode: 448 });
+    mkdirSync13(dir, { recursive: true, mode: 448 });
     for (const entry of readdirSync14(memoryDir)) {
-      const srcPath = join15(memoryDir, entry);
+      const srcPath = join16(memoryDir, entry);
       try {
         if (!statSync12(srcPath).isFile()) continue;
       } catch {
         continue;
       }
-      copyFileSync2(srcPath, join15(dir, entry));
+      copyFileSync2(srcPath, join16(dir, entry));
     }
   } catch (err) {
     throw new BackupError(`backup failed: ${err.message}`);
@@ -19251,7 +19708,7 @@ function pruneBackups(home = homedir8(), retention = DEFAULT_RETENTION2) {
   const backups = listBackups(home);
   for (const stale of backups.slice(Math.max(retention, 1))) {
     try {
-      rmSync5(stale.dir, { recursive: true, force: true });
+      rmSync6(stale.dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -19265,14 +19722,14 @@ function restoreBackup(memoryDir, opts = {}) {
   const wouldRestore = [];
   for (const entry of readdirSync14(chosen.dir)) {
     try {
-      if (statSync12(join15(chosen.dir, entry)).isFile()) wouldRestore.push(entry);
+      if (statSync12(join16(chosen.dir, entry)).isFile()) wouldRestore.push(entry);
     } catch {
       continue;
     }
   }
-  const currentFiles = existsSync27(memoryDir) ? readdirSync14(memoryDir).filter((e2) => {
+  const currentFiles = existsSync28(memoryDir) ? readdirSync14(memoryDir).filter((e2) => {
     try {
-      return statSync12(join15(memoryDir, e2)).isFile();
+      return statSync12(join16(memoryDir, e2)).isFile();
     } catch {
       return false;
     }
@@ -19287,10 +19744,10 @@ function restoreBackup(memoryDir, opts = {}) {
       presentButNotInBackup
     };
   }
-  mkdirSync11(memoryDir, { recursive: true });
+  mkdirSync13(memoryDir, { recursive: true });
   let n = 0;
   for (const entry of wouldRestore) {
-    copyFileSync2(join15(chosen.dir, entry), join15(memoryDir, entry));
+    copyFileSync2(join16(chosen.dir, entry), join16(memoryDir, entry));
     n++;
   }
   return {
@@ -19315,105 +19772,9 @@ var init_memory_backup = __esm({
   }
 });
 
-// src/lib/fileLock.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync21, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname14 } from "path";
-import * as lockfile from "proper-lockfile";
-function readLockHolderPid(lockPath) {
-  try {
-    const raw = readFileSync21(`${lockPath}.pid`, "utf-8").trim();
-    const pid = Number.parseInt(raw, 10);
-    if (!Number.isFinite(pid) || pid <= 0) return null;
-    return pid;
-  } catch {
-    return null;
-  }
-}
-function busyWaitSync(ms) {
-  if (typeof SharedArrayBuffer === "undefined" || typeof Atomics === "undefined") {
-    throw new Error(
-      `withFileLockSync requires SharedArrayBuffer + Atomics for its retry-loop wait. This Node runtime does not provide them \u2014 refusing to fall back to a CPU spinloop. If you hit this in a sandboxed serverless env, the fix is to perform the lock-protected operation in a host runtime that supports Atomics.`
-    );
-  }
-  const sab = new SharedArrayBuffer(4);
-  const view = new Int32Array(sab);
-  Atomics.wait(view, 0, 0, ms);
-}
-function withFileLockSync(lockPath, fn, opts = {}) {
-  mkdirSync12(dirname14(lockPath), { recursive: true });
-  const staleMs = opts.staleMs ?? 3e4;
-  const blockMs = opts.retries === 0 ? 0 : opts.blockMs ?? 3e4;
-  const pollIntervalMs = opts.pollIntervalMs ?? 100;
-  const now = opts.now ?? Date.now;
-  const sleep = opts.sleep ?? busyWaitSync;
-  const makeBusyError = opts.errorFactory ?? ((path, pid, retrySeconds, code) => new FileLockBusyError(path, pid, retrySeconds, code));
-  let release = null;
-  const deadline = now() + blockMs;
-  for (; ; ) {
-    try {
-      release = lockfile.lockSync(lockPath, {
-        stale: staleMs,
-        retries: 0,
-        realpath: false
-      });
-      try {
-        writeFileSync7(`${lockPath}.pid`, String(process.pid), "utf-8");
-      } catch {
-      }
-      break;
-    } catch (err) {
-      const e2 = err;
-      const code = e2.code;
-      if (code !== "ELOCKED" && code !== "EBUSY") {
-        throw err;
-      }
-      if (now() >= deadline) {
-        const holderPid = readLockHolderPid(lockPath);
-        const remainingMs = Math.max(0, deadline - now());
-        const retryAfterSeconds = blockMs === 0 ? Math.round(staleMs / 1e3) : Math.round(remainingMs / 1e3);
-        throw makeBusyError(lockPath, holderPid, retryAfterSeconds, code);
-      }
-      sleep(pollIntervalMs);
-    }
-  }
-  try {
-    return fn();
-  } finally {
-    try {
-      if (release) release();
-    } catch {
-    }
-    try {
-      rmSync6(`${lockPath}.pid`, { force: true });
-    } catch {
-    }
-  }
-}
-var FileLockBusyError;
-var init_fileLock = __esm({
-  "src/lib/fileLock.ts"() {
-    "use strict";
-    FileLockBusyError = class extends Error {
-      constructor(lockPath, holderPid, retryAfterSeconds, causeCode) {
-        const pidPart = holderPid != null ? `(PID=${holderPid})` : "(PID=unknown)";
-        super(`File lock at ${lockPath} held by another process ${pidPart} \u2014 try again in ${retryAfterSeconds}s`);
-        this.lockPath = lockPath;
-        this.holderPid = holderPid;
-        this.retryAfterSeconds = retryAfterSeconds;
-        this.causeCode = causeCode;
-        this.name = "FileLockBusyError";
-      }
-      lockPath;
-      holderPid;
-      retryAfterSeconds;
-      causeCode;
-    };
-  }
-});
-
 // src/memory-index-region.ts
-import { readFileSync as readFileSync22, existsSync as existsSync28 } from "fs";
-import { dirname as dirname15, join as join16 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync29 } from "fs";
+import { dirname as dirname16, join as join17 } from "path";
 function parseRegion(content) {
   const begins = countOccurrences(content, BEGIN_SENTINEL);
   const ends = countOccurrences(content, END_SENTINEL);
@@ -19505,7 +19866,7 @@ function readRegionLines(content) {
   return inner.split("\n").filter((l2) => l2.trim().length > 0);
 }
 function memoryIndexLockPath(memoryDir) {
-  return join16(dirname15(memoryDir), ".massu-memory-index.lock");
+  return join17(dirname16(memoryDir), ".massu-memory-index.lock");
 }
 function withMemoryIndexLock(memoryDir, fn) {
   return withFileLockSync(memoryIndexLockPath(memoryDir), fn, {
@@ -19517,7 +19878,7 @@ function withMemoryIndexLock(memoryDir, fn) {
   });
 }
 function readMemoryIndex(indexPath) {
-  if (!existsSync28(indexPath)) return void 0;
+  if (!existsSync29(indexPath)) return void 0;
   try {
     return readFileSync22(indexPath, "utf8");
   } catch {
@@ -19590,8 +19951,8 @@ var init_memory_files_config = __esm({
 });
 
 // src/memory-renderer.ts
-import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync23 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir9 } from "os";
 import { createHash as createHash8 } from "crypto";
 function renderMemoryFiles(db, candidates, opts) {
@@ -19605,7 +19966,7 @@ function renderMemoryFiles(db, candidates, opts) {
   const audit = opts.audit ?? (() => {
   });
   const { memoryDir } = opts;
-  if (!existsSync29(memoryDir)) {
+  if (!existsSync30(memoryDir)) {
     return EMPTY("no_memory_dir");
   }
   try {
@@ -19673,7 +20034,7 @@ function renderLocked(db, candidates, o) {
       refusals.push({ name: c2.name, reason: "tombstoned" });
       continue;
     }
-    if (existsSync29(absPath)) {
+    if (existsSync30(absPath)) {
       const existing = readFileSync23(absPath, "utf8");
       const fm = readMemoryFileFrontmatter(existing);
       const storeRow = db.prepare(
@@ -19723,7 +20084,7 @@ function renderLocked(db, candidates, o) {
       return EMPTY("backup_failed");
     }
   }
-  const indexPath = o.indexPath ?? join17(memoryDir, "MEMORY.md");
+  const indexPath = o.indexPath ?? join18(memoryDir, "MEMORY.md");
   const targets = [...planned.map((p19) => p19.absPath), indexPath];
   const snapshot = takeSnapshots(targets);
   let bytesWritten = 0;
@@ -19895,16 +20256,16 @@ var init_memory_renderer = __esm({
 });
 
 // src/commands/memory-render-cli.ts
-import { readdirSync as readdirSync15, readFileSync as readFileSync24, existsSync as existsSync30, rmSync as rmSync7, statSync as statSync13 } from "fs";
-import { join as join18 } from "path";
+import { readdirSync as readdirSync15, readFileSync as readFileSync24, existsSync as existsSync31, rmSync as rmSync7, statSync as statSync13 } from "fs";
+import { join as join19 } from "path";
 import { homedir as homedir10 } from "os";
 function memoryFiles(memoryDir) {
-  if (!existsSync30(memoryDir)) return [];
+  if (!existsSync31(memoryDir)) return [];
   return readdirSync15(memoryDir).filter((f2) => {
     if (!f2.endsWith(".md")) return false;
     if (f2 === "MEMORY.md") return false;
     try {
-      return statSync13(join18(memoryDir, f2)).isFile();
+      return statSync13(join19(memoryDir, f2)).isFile();
     } catch {
       return false;
     }
@@ -19915,7 +20276,7 @@ function massuAuthoredFiles(db, memoryDir, home = homedir10()) {
   for (const f2 of memoryFiles(memoryDir)) {
     let content;
     try {
-      content = readFileSync24(join18(memoryDir, f2), "utf8");
+      content = readFileSync24(join19(memoryDir, f2), "utf8");
     } catch {
       continue;
     }
@@ -19943,7 +20304,7 @@ function memoryAdopt(db, memoryDir, opts = {}) {
   for (const f2 of memoryFiles(memoryDir)) {
     const row = db.prepare(`SELECT id FROM memory_files WHERE rel_path = ? COLLATE NOCASE`).get(f2);
     if (row) continue;
-    const content = readFileSync24(join18(memoryDir, f2), "utf8");
+    const content = readFileSync24(join19(memoryDir, f2), "utf8");
     if (verifyAuthorship(stripFrontmatter(content), readMemoryFileFrontmatter(content), null, home)) {
       candidates.push(f2);
     }
@@ -19973,7 +20334,7 @@ function memoryAdopt(db, memoryDir, opts = {}) {
   db.exec("BEGIN");
   try {
     for (const f2 of candidates) {
-      const content = readFileSync24(join18(memoryDir, f2), "utf8");
+      const content = readFileSync24(join19(memoryDir, f2), "utf8");
       const fm = readMemoryFileFrontmatter(content);
       insert.run(
         f2,
@@ -20021,7 +20382,7 @@ function memoryUnrender(db, memoryDir, opts = {}) {
   for (const f2 of targets) {
     tombstone(memoryDir, f2, "unrendered", now);
     try {
-      rmSync7(join18(memoryDir, f2));
+      rmSync7(join19(memoryDir, f2));
     } catch {
     }
     db.prepare(`UPDATE memory_files SET tombstoned_at_epoch = ? WHERE rel_path = ? COLLATE NOCASE`).run(
@@ -20029,7 +20390,7 @@ function memoryUnrender(db, memoryDir, opts = {}) {
       f2
     );
   }
-  const indexPath = join18(memoryDir, "MEMORY.md");
+  const indexPath = join19(memoryDir, "MEMORY.md");
   const pre = readMemoryIndex(indexPath);
   if (pre !== void 0) {
     try {
@@ -20104,16 +20465,16 @@ var init_memory_render_candidates = __esm({
 });
 
 // src/capability-advisor.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync13, readFileSync as readFileSync25, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync14, readFileSync as readFileSync25, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname16, join as join19 } from "path";
+import { dirname as dirname17, join as join20 } from "path";
 function advisorStatePath(home = homedir11()) {
-  return join19(home, ".massu", "advisor-state.json");
+  return join20(home, ".massu", "advisor-state.json");
 }
 function readAdvisorState(home) {
   try {
     const p19 = advisorStatePath(home);
-    if (!existsSync31(p19)) return {};
+    if (!existsSync32(p19)) return {};
     return JSON.parse(readFileSync25(p19, "utf-8"));
   } catch {
     return {};
@@ -20122,7 +20483,7 @@ function readAdvisorState(home) {
 function writeAdvisorState(state, home) {
   try {
     const p19 = advisorStatePath(home);
-    mkdirSync13(dirname16(p19), { recursive: true });
+    mkdirSync14(dirname17(p19), { recursive: true });
     writeFileSync8(p19, JSON.stringify(state, null, 2), { mode: 384 });
   } catch {
   }
@@ -20714,8 +21075,8 @@ var init_rule_candidate_hardened = __esm({
 });
 
 // src/rule-candidate-applier.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync9, existsSync as existsSync32, unlinkSync as unlinkSync5, mkdirSync as mkdirSync14 } from "fs";
-import { join as join20, dirname as dirname17, isAbsolute as isAbsolute2 } from "path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync9, existsSync as existsSync33, unlinkSync as unlinkSync5, mkdirSync as mkdirSync15 } from "fs";
+import { join as join21, dirname as dirname18, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir12 } from "os";
 import { createHash as createHash9 } from "crypto";
 function isRuleDestination(value) {
@@ -20725,10 +21086,10 @@ function isTeamShareableDestination(destination) {
   return TEAM_SHAREABLE_DESTINATIONS.includes(destination);
 }
 function resolveMemoryDir(projectRoot = getProjectRoot(), home = homedir12()) {
-  return join20(home, ".claude", "projects", encodeMemoryDirName(projectRoot), "memory");
+  return join21(home, ".claude", "projects", encodeMemoryDirName(projectRoot), "memory");
 }
 function resolveMemoryIndexPath(projectRoot = getProjectRoot(), home = homedir12()) {
-  return join20(resolveMemoryDir(projectRoot, home), "MEMORY.md");
+  return join21(resolveMemoryDir(projectRoot, home), "MEMORY.md");
 }
 function deriveSlug2(prompt) {
   return deriveSlug(prompt);
@@ -20747,17 +21108,17 @@ function writeIndexLineInRegion(indexPath, line) {
 function correctionsMdTargets(slug, projectRoot, home) {
   const dir = resolveMemoryDir(projectRoot, home);
   return {
-    correctionsMd: join20(dir, "corrections.md"),
-    feedbackMd: join20(dir, `feedback_${slug}.md`),
-    memoryIndex: join20(dir, "MEMORY.md")
+    correctionsMd: join21(dir, "corrections.md"),
+    feedbackMd: join21(dir, `feedback_${slug}.md`),
+    memoryIndex: join21(dir, "MEMORY.md")
   };
 }
 function readCandidate(candidateId, projectRoot = getProjectRoot()) {
   if (!CANDIDATE_ID_PATTERN.test(candidateId)) {
     throw new InvalidCandidateIdError(candidateId);
   }
-  const path = join20(projectRoot, ".massu", "rule-candidates", `${candidateId}.json`);
-  if (!existsSync32(path)) throw new CandidateNotFoundError(path);
+  const path = join21(projectRoot, ".massu", "rule-candidates", `${candidateId}.json`);
+  if (!existsSync33(path)) throw new CandidateNotFoundError(path);
   const raw = readFileSync26(path, "utf-8");
   let parsed;
   try {
@@ -20869,7 +21230,7 @@ async function applyRuleCandidate(db, opts) {
     throw new InvalidSlugError(slug);
   }
   const memoryIndex = resolveMemoryIndexPath(projectRoot, home);
-  if (!existsSync32(memoryIndex)) {
+  if (!existsSync33(memoryIndex)) {
     throw new MemoryIndexMissingError(memoryIndex);
   }
   let destTargets;
@@ -20878,7 +21239,7 @@ async function applyRuleCandidate(db, opts) {
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
-  const candidatePath = join20(projectRoot, ".massu", "rule-candidates", `${opts.candidateId}.json`);
+  const candidatePath = join21(projectRoot, ".massu", "rule-candidates", `${opts.candidateId}.json`);
   const snapshot = takeSnapshots([
     ...destTargets.paths,
     memoryIndex
@@ -20925,7 +21286,7 @@ async function applyRuleCandidate(db, opts) {
         throw err;
       }
     }
-    if (existsSync32(candidatePath)) unlinkSync5(candidatePath);
+    if (existsSync33(candidatePath)) unlinkSync5(candidatePath);
     let teamShared = false;
     const localOrigin = candidate.provenance?.origin !== "team" && candidate.provenance?.origin !== "pack";
     const entitledTeam = entitledForTeamSharedPromotion(ent.currentTier);
@@ -20970,15 +21331,15 @@ function computeDestinationTargets(opts, candidate, slug, projectRoot, home) {
     if (opts.patternScannerCheckNumber == null) {
       throw new DestinationConfigError("pattern-scanner destination requires patternScannerCheckNumber");
     }
-    const scannerPath = join20(projectRoot, "scripts", "massu-pattern-scanner.sh");
-    const driftGuardPath = join20(projectRoot, "packages", "core", "src", "__tests__", `${slug}-drift-guard.test.ts`);
+    const scannerPath = join21(projectRoot, "scripts", "massu-pattern-scanner.sh");
+    const driftGuardPath = join21(projectRoot, "packages", "core", "src", "__tests__", `${slug}-drift-guard.test.ts`);
     return { primary: scannerPath, paths: [scannerPath, driftGuardPath] };
   }
   if (opts.destination === "claude-md-cr") {
     if (opts.claudeMdCrNumber == null) {
       throw new DestinationConfigError("claude-md-cr destination requires claudeMdCrNumber");
     }
-    const claudePath = join20(projectRoot, ".claude", "CLAUDE.md");
+    const claudePath = join21(projectRoot, ".claude", "CLAUDE.md");
     return { primary: claudePath, paths: [claudePath] };
   }
   if (opts.destination === "custom-destination") {
@@ -20986,7 +21347,7 @@ function computeDestinationTargets(opts, candidate, slug, projectRoot, home) {
       throw new DestinationConfigError("custom-destination requires customDestination config entry");
     }
     const raw = opts.customDestination.path;
-    const absolute = isAbsolute2(raw) ? raw : join20(projectRoot, raw);
+    const absolute = isAbsolute2(raw) ? raw : join21(projectRoot, raw);
     try {
       assertContainedIn(projectRoot, absolute, { allowNested: true });
     } catch (err) {
@@ -21026,8 +21387,8 @@ function writeCorrectionsMd(opts, candidate, slug, targets, auditRowId) {
       audit_log_id: auditRowId
     }
   });
-  if (!existsSync32(dirname17(correctionsMd))) mkdirSync14(dirname17(correctionsMd), { recursive: true });
-  const correctionsPre = existsSync32(correctionsMd) ? readFileSync26(correctionsMd, "utf-8") : "# Corrections\n";
+  if (!existsSync33(dirname18(correctionsMd))) mkdirSync15(dirname18(correctionsMd), { recursive: true });
+  const correctionsPre = existsSync33(correctionsMd) ? readFileSync26(correctionsMd, "utf-8") : "# Corrections\n";
   writeFileSync9(correctionsMd, correctionsPre + correctionsEntry, "utf-8");
   const body = `${opts.draftText}
 `;
@@ -21053,7 +21414,7 @@ function writeCorrectionsMd(opts, candidate, slug, targets, auditRowId) {
 function writePatternScanner(opts, candidate, slug, targets) {
   const [scannerPath, driftGuardPath] = targets.paths;
   const checkNumber = opts.patternScannerCheckNumber;
-  const scannerPre = existsSync32(scannerPath) ? readFileSync26(scannerPath, "utf-8") : "";
+  const scannerPre = existsSync33(scannerPath) ? readFileSync26(scannerPath, "utf-8") : "";
   if (scannerPre.includes(`${SCANNER_AUTOGEN_MARKER_PREFIX} ${candidate.prompt_hash}`)) {
     throw new DestinationConfigError(
       `scanner already contains a check auto-generated for prompt_hash ${candidate.prompt_hash}`
@@ -21089,13 +21450,13 @@ function writePatternScanner(opts, candidate, slug, targets) {
     `});`,
     ""
   ].join("\n");
-  if (!existsSync32(dirname17(driftGuardPath))) mkdirSync14(dirname17(driftGuardPath), { recursive: true });
+  if (!existsSync33(dirname18(driftGuardPath))) mkdirSync15(dirname18(driftGuardPath), { recursive: true });
   writeFileSync9(driftGuardPath, driftGuard, "utf-8");
 }
 function writeClaudeMdCr(opts, candidate, slug, targets) {
   const [claudePath] = targets.paths;
   const crNumber = opts.claudeMdCrNumber;
-  const pre = existsSync32(claudePath) ? readFileSync26(claudePath, "utf-8") : "";
+  const pre = existsSync33(claudePath) ? readFileSync26(claudePath, "utf-8") : "";
   if (new RegExp(`\\bCR-${crNumber}\\b`).test(pre)) {
     throw new DestinationConfigError(`CLAUDE.md already contains a CR-${crNumber} entry`);
   }
@@ -21137,8 +21498,8 @@ function writeCustomDestination(opts, candidate, slug, targets) {
     destination_name: entry.name
   };
   const rendered = renderTemplate2(entry.template, vars);
-  if (!existsSync32(dirname17(destPath))) mkdirSync14(dirname17(destPath), { recursive: true });
-  const pre = existsSync32(destPath) ? readFileSync26(destPath, "utf-8") : "";
+  if (!existsSync33(dirname18(destPath))) mkdirSync15(dirname18(destPath), { recursive: true });
+  const pre = existsSync33(destPath) ? readFileSync26(destPath, "utf-8") : "";
   const sep3 = pre && !pre.endsWith("\n") ? "\n" : "";
   writeFileSync9(destPath, pre + sep3 + rendered + (rendered.endsWith("\n") ? "" : "\n"), "utf-8");
 }
@@ -21148,7 +21509,7 @@ function dismissRuleCandidate(db, opts) {
   }
   const projectRoot = opts.projectRoot ?? getProjectRoot();
   const candidate = readCandidate(opts.candidateId, projectRoot);
-  const candidatePath = join20(projectRoot, ".massu", "rule-candidates", `${opts.candidateId}.json`);
+  const candidatePath = join21(projectRoot, ".massu", "rule-candidates", `${opts.candidateId}.json`);
   db.exec("BEGIN");
   let auditRowId;
   let blacklistUpdates = 0;
@@ -21190,9 +21551,9 @@ function dismissRuleCandidate(db, opts) {
     };
   }
   try {
-    const dismissedLog = join20(projectRoot, ".massu", "rule-candidates", ".dismissed.jsonl");
-    if (!existsSync32(dirname17(dismissedLog))) mkdirSync14(dirname17(dismissedLog), { recursive: true });
-    const pre = existsSync32(dismissedLog) ? readFileSync26(dismissedLog, "utf-8") : "";
+    const dismissedLog = join21(projectRoot, ".massu", "rule-candidates", ".dismissed.jsonl");
+    if (!existsSync33(dirname18(dismissedLog))) mkdirSync15(dirname18(dismissedLog), { recursive: true });
+    const pre = existsSync33(dismissedLog) ? readFileSync26(dismissedLog, "utf-8") : "";
     const sep3 = pre && !pre.endsWith("\n") ? "\n" : "";
     writeFileSync9(dismissedLog, pre + sep3 + JSON.stringify({
       id: opts.candidateId,
@@ -21203,7 +21564,7 @@ function dismissRuleCandidate(db, opts) {
       audit_log_id: auditRowId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     }) + "\n", "utf-8");
-    if (existsSync32(candidatePath)) unlinkSync5(candidatePath);
+    if (existsSync33(candidatePath)) unlinkSync5(candidatePath);
   } catch (err) {
     appendFailureLog(projectRoot, {
       candidate_id: opts.candidateId,
@@ -21221,10 +21582,10 @@ function dismissRuleCandidate(db, opts) {
 }
 function appendFailureLog(projectRoot, entry) {
   try {
-    const dir = join20(projectRoot, ".massu", "rule-candidates");
-    if (!existsSync32(dir)) mkdirSync14(dir, { recursive: true });
-    const logPath = join20(dir, ".failures.jsonl");
-    const pre = existsSync32(logPath) ? readFileSync26(logPath, "utf-8") : "";
+    const dir = join21(projectRoot, ".massu", "rule-candidates");
+    if (!existsSync33(dir)) mkdirSync15(dir, { recursive: true });
+    const logPath = join21(dir, ".failures.jsonl");
+    const pre = existsSync33(logPath) ? readFileSync26(logPath, "utf-8") : "";
     const sep3 = pre && !pre.endsWith("\n") ? "\n" : "";
     writeFileSync9(logPath, pre + sep3 + JSON.stringify(entry) + "\n", "utf-8");
   } catch {
@@ -21283,7 +21644,7 @@ var init_rule_candidate_applier = __esm({
     ];
     MemoryIndexMissingError = class extends Error {
       constructor(path) {
-        super(`MEMORY.md missing at ${path} \u2014 v0.2 requires the canonical memory index. Create it via \`mkdir -p ${dirname17(path)} && echo '# Memory Index' > ${path}\` or run \`/massu-bearings\``);
+        super(`MEMORY.md missing at ${path} \u2014 v0.2 requires the canonical memory index. Create it via \`mkdir -p ${dirname18(path)} && echo '# Memory Index' > ${path}\` or run \`/massu-bearings\``);
         this.path = path;
         this.name = "MemoryIndexMissingError";
       }
@@ -21307,7 +21668,7 @@ var init_rule_candidate_applier = __esm({
 });
 
 // src/rule-candidate-preview.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync10, existsSync as existsSync33 } from "node:fs";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync10, existsSync as existsSync34 } from "node:fs";
 function renderHardenedPreview(destination, body) {
   const rendered = String(body ?? "");
   const riskFindings = RISK_PATTERNS.filter((p19) => p19.re.test(rendered)).map((p19) => p19.label);
@@ -21335,7 +21696,7 @@ function validateReviewAttestation(att) {
   };
 }
 function recordHardenedReviewAttestation(sidecarPath2, attestation) {
-  if (!existsSync33(sidecarPath2)) {
+  if (!existsSync34(sidecarPath2)) {
     throw new Error(`candidate sidecar not found: ${sidecarPath2}`);
   }
   const validated = validateReviewAttestation(attestation);
@@ -21447,7 +21808,7 @@ var init_rule_candidate_renderer = __esm({
 });
 
 // src/rule-promotion-effectiveness.ts
-import { readFileSync as readFileSync28, existsSync as existsSync34 } from "fs";
+import { readFileSync as readFileSync28, existsSync as existsSync35 } from "fs";
 function evaluateCr53Effectiveness(inputs) {
   const { db, failureLogPath, knownLimitations } = inputs;
   const allowlist = new Set(knownLimitations.map((k3) => k3.promptHash));
@@ -21478,7 +21839,7 @@ function evaluateCr53Effectiveness(inputs) {
     });
   }
   const failureLogViolations = [];
-  if (existsSync34(failureLogPath)) {
+  if (existsSync35(failureLogPath)) {
     try {
       const raw = readFileSync28(failureLogPath, "utf-8");
       const cutoff = Date.now() - SEVEN_DAYS_MS;
@@ -21657,8 +22018,8 @@ var init_rule_pack_schema = __esm({
 });
 
 // src/rule-pack-sync.ts
-import { existsSync as existsSync35, writeFileSync as writeFileSync11, mkdirSync as mkdirSync15 } from "fs";
-import { join as join21, dirname as dirname18 } from "path";
+import { existsSync as existsSync36, writeFileSync as writeFileSync11, mkdirSync as mkdirSync16 } from "fs";
+import { join as join22, dirname as dirname19 } from "path";
 async function pullInstalledPackRules(db, opts = {}) {
   const config = getConfig();
   const cloud = config.cloud;
@@ -21721,7 +22082,7 @@ async function pullInstalledPackRules(db, opts = {}) {
       result.pulled += 1;
       const promptHash = packRulePromptHash(pack.slug, rule);
       const candidatePath = sidecarPath(projectRoot, promptHash);
-      if (existsSync35(candidatePath) || alreadyApplied(db, promptHash)) {
+      if (existsSync36(candidatePath) || alreadyApplied(db, promptHash)) {
         result.skipped += 1;
         continue;
       }
@@ -21759,7 +22120,7 @@ function packRulePromptHash(slug, rule) {
   return createHash15("sha256").update(body, "utf-8").digest("hex").slice(0, 16);
 }
 function sidecarPath(projectRoot, promptHash) {
-  return join21(projectRoot, ".massu", "rule-candidates", `${promptHash}.json`);
+  return join22(projectRoot, ".massu", "rule-candidates", `${promptHash}.json`);
 }
 function alreadyApplied(db, promptHash) {
   try {
@@ -21808,8 +22169,8 @@ function materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack
     destination: rule.destination,
     draft_text: draftText
   };
-  const dir = dirname18(candidatePath);
-  if (!existsSync35(dir)) mkdirSync15(dir, { recursive: true });
+  const dir = dirname19(candidatePath);
+  if (!existsSync36(dir)) mkdirSync16(dir, { recursive: true });
   writeFileSync11(candidatePath, JSON.stringify(sidecar, null, 2), "utf-8");
 }
 function emitDropTelemetry(db, eventType, data) {
@@ -21852,7 +22213,7 @@ var rule_exports = {};
 __export(rule_exports, {
   handleRuleSubcommand: () => handleRuleSubcommand
 });
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function flagValue2(args2, flag) {
   const i = args2.indexOf(flag);
   if (i === -1 || i === args2.length - 1) return void 0;
@@ -21909,7 +22270,7 @@ async function handleRuleSubcommand(args2) {
     case "effectiveness": {
       const db = getMemoryDb();
       try {
-        const failureLogPath = join22(
+        const failureLogPath = join23(
           getProjectRoot(),
           ".massu",
           "rule-candidates",
@@ -22032,7 +22393,7 @@ ${"-".repeat(60)}
           reviewed_at: (/* @__PURE__ */ new Date()).toISOString(),
           note: flagValue2(args2, "--attest-note") ?? ""
         });
-        const sidecar = join22(getProjectRoot(), ".massu", "rule-candidates", `${candidateId}.json`);
+        const sidecar = join23(getProjectRoot(), ".massu", "rule-candidates", `${candidateId}.json`);
         recordHardenedReviewAttestation(sidecar, attestation);
         process.stdout.write(`Attestation recorded by '${operator}'. This candidate may now be approved.
 `);
@@ -22680,8 +23041,8 @@ var init_memory_supersede = __esm({
 
 // src/memory-consolidate.ts
 import { createHash as createHash10 } from "crypto";
-import { existsSync as existsSync36, mkdirSync as mkdirSync16, writeFileSync as writeFileSync12 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync17, writeFileSync as writeFileSync12 } from "fs";
+import { join as join24 } from "path";
 function emptyResult() {
   return {
     deduped: 0,
@@ -22843,7 +23204,7 @@ ${r2.detail ?? ""}`.trim());
     }
     clusters.push(cluster);
   }
-  const candidateDir = join23(projectRoot, ".massu", "rule-candidates");
+  const candidateDir = join24(projectRoot, ".massu", "rule-candidates");
   let promoted = 0;
   for (const cluster of clusters) {
     const occurrences = cluster.reduce((n, c2) => n + (c2.recurrence_count || 1), 0);
@@ -22856,13 +23217,13 @@ ${r2.detail ?? ""}`.trim());
 ${representative.detail}` : ""}`;
     const clusterKey = cluster.map((c2) => c2.title.toLowerCase().replace(/\s+/g, " ").trim()).sort().join("|");
     const promptHash = createHash10("sha256").update(clusterKey).digest("hex").slice(0, 16);
-    const candidatePath = join23(candidateDir, `${promptHash}.json`);
-    if (existsSync36(candidatePath)) continue;
+    const candidatePath = join24(candidateDir, `${promptHash}.json`);
+    if (existsSync37(candidatePath)) continue;
     if (dryRun) {
       promoted++;
       continue;
     }
-    mkdirSync16(candidateDir, { recursive: true });
+    mkdirSync17(candidateDir, { recursive: true });
     writeFileSync12(
       candidatePath,
       JSON.stringify(
@@ -23049,7 +23410,23 @@ async function runConsolidateCommand(args2 = []) {
     return { exitCode: 1 };
   }
   const cfg = resolveConsolidationConfig();
-  const db = getMemoryDb();
+  let db;
+  try {
+    db = getMemoryDb();
+  } catch (err) {
+    if (err instanceof MemoryEngineUnusableError) {
+      if (json) {
+        process.stdout.write(
+          JSON.stringify({ error: "memory-engine-unusable", reason: err.reason, remedy: err.remedy }) + "\n"
+        );
+      } else {
+        process.stderr.write(`massu consolidate: the memory engine is unavailable \u2014 ${err.remedy}
+`);
+      }
+      return { exitCode: 1 };
+    }
+    throw err;
+  }
   try {
     const result = await runConsolidation(db, {
       config: cfg,
@@ -23125,6 +23502,7 @@ var init_consolidate = __esm({
     init_memory_db();
     init_memory_consolidate();
     init_consolidation_config();
+    init_sqlite_loader();
   }
 });
 
@@ -23133,7 +23511,7 @@ var show_template_exports = {};
 __export(show_template_exports, {
   runShowTemplate: () => runShowTemplate
 });
-import { existsSync as existsSync37, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync29 } from "fs";
 import { resolve as resolve17 } from "path";
 function normalizeBaseName(input) {
   return input.endsWith(".md") ? input.slice(0, -".md".length) : input;
@@ -23163,7 +23541,7 @@ async function runShowTemplate(args2) {
   }
   const suffix = choice.kind === "hit" ? choice.suffix : "";
   const file = suffix === "" ? resolve17(sourceDir, `${baseName}.md`) : resolve17(sourceDir, `${baseName}${suffix}.md`);
-  if (!existsSync37(file)) {
+  if (!existsSync38(file)) {
     process.stderr.write(`massu: resolved template "${file}" no longer exists
 `);
     process.exit(1);
@@ -23264,7 +23642,7 @@ __export(config_refresh_exports, {
   mergeRefresh: () => mergeRefresh,
   runConfigRefresh: () => runConfigRefresh
 });
-import { existsSync as existsSync38, readFileSync as readFileSync30, rmSync as rmSync8 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync30, rmSync as rmSync8 } from "fs";
 import { resolve as resolve19 } from "path";
 import { parse as parseYaml5 } from "yaml";
 function flatten(obj, prefix3 = "") {
@@ -23396,7 +23774,7 @@ async function runConfigRefresh(opts = {}) {
   const configPath = resolve19(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
-  if (!existsSync38(configPath)) {
+  if (!existsSync39(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 };
@@ -23477,7 +23855,7 @@ async function runConfigRefresh(opts = {}) {
       const stackResolved = installResult.totalInstalled > 0 || installResult.totalUpdated > 0;
       if (stackResolved) {
         const placeholderPath = resolve19(installResult.claudeDir, "commands", "_massu-needs-stack.md");
-        if (existsSync38(placeholderPath)) {
+        if (existsSync39(placeholderPath)) {
           try {
             rmSync8(placeholderPath, { force: true });
             log("Removed _massu-needs-stack.md (stack now declared).\n");
@@ -23527,7 +23905,7 @@ var init_config_refresh = __esm({
 });
 
 // src/lib/pidLiveness.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 function isPidAlive(pid, opts = {}) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   const platform = opts.platformOverride ?? process.platform;
@@ -23552,7 +23930,7 @@ function checkPosix(pid, killOverride) {
 }
 function checkWindows(pid) {
   try {
-    const res = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/NH"], {
+    const res = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/NH"], {
       encoding: "utf-8",
       windowsHide: true
     });
@@ -23570,9 +23948,9 @@ var init_pidLiveness = __esm({
 });
 
 // src/lib/gitToplevel.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 function gitToplevel(cwd) {
-  const res = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
+  const res = spawnSync3("git", ["rev-parse", "--show-toplevel"], {
     cwd,
     encoding: "utf-8"
   });
@@ -23586,12 +23964,12 @@ var init_gitToplevel = __esm({
 });
 
 // src/watch/lockfile-detector.ts
-import { existsSync as existsSync39, statSync as statSync14 } from "fs";
+import { existsSync as existsSync40, statSync as statSync14 } from "fs";
 import { resolve as resolve20 } from "path";
 function lockfileMidWrite(projectRoot, now = Date.now(), windowMs = LOCKFILE_WINDOW_MS) {
   for (const lf of KNOWN_LOCKFILES) {
     const p19 = resolve20(projectRoot, lf);
-    if (!existsSync39(p19)) continue;
+    if (!existsSync40(p19)) continue;
     try {
       const stat = statSync14(p19);
       const delta = now - stat.mtimeMs;
@@ -23604,7 +23982,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 (existsSync39(resolve20(projectRoot, ".git", s))) return true;
+    if (existsSync40(resolve20(projectRoot, ".git", s))) return true;
   }
   return false;
 }
@@ -23803,8 +24181,8 @@ var init_paths = __esm({
 });
 
 // src/watch/state.ts
-import { closeSync as closeSync4, existsSync as existsSync40, fsyncSync as fsyncSync4, mkdirSync as mkdirSync17, openSync as openSync4, readFileSync as readFileSync31, renameSync as renameSync5, rmSync as rmSync9, writeFileSync as writeFileSync13, writeSync as writeSync3 } from "fs";
-import { dirname as dirname19, resolve as resolve21 } from "path";
+import { closeSync as closeSync4, existsSync as existsSync41, fsyncSync as fsyncSync4, mkdirSync as mkdirSync18, openSync as openSync4, readFileSync as readFileSync31, renameSync as renameSync5, rmSync as rmSync9, writeFileSync as writeFileSync13, writeSync as writeSync3 } from "fs";
+import { dirname as dirname20, resolve as resolve21 } from "path";
 function watchStatePath(projectRoot) {
   return resolve21(projectRoot, ".massu", "watch-state.json");
 }
@@ -23813,7 +24191,7 @@ function backupStatePath(projectRoot) {
 }
 function readState(projectRoot) {
   const path = watchStatePath(projectRoot);
-  if (!existsSync40(path)) return { ...DEFAULT_STATE };
+  if (!existsSync41(path)) return { ...DEFAULT_STATE };
   const content = readFileSync31(path, "utf-8");
   let raw;
   try {
@@ -23856,14 +24234,14 @@ function readState(projectRoot) {
 }
 function archiveCorrupt(projectRoot, content) {
   const bak = backupStatePath(projectRoot);
-  mkdirSync17(dirname19(bak), { recursive: true });
+  mkdirSync18(dirname20(bak), { recursive: true });
   writeFileSync13(bak, content, "utf-8");
 }
 function writeStateAtomic(projectRoot, state) {
   const path = watchStatePath(projectRoot);
   writeStateAtomicCounter = writeStateAtomicCounter + 1 >>> 0;
   const tmp = `${path}.${process.pid}.${writeStateAtomicCounter}.tmp`;
-  mkdirSync17(dirname19(path), { recursive: true });
+  mkdirSync18(dirname20(path), { recursive: true });
   let renamed = false;
   try {
     const fd = openSync4(tmp, "w");
@@ -23877,7 +24255,7 @@ function writeStateAtomic(projectRoot, state) {
     renameSync5(tmp, path);
     renamed = true;
   } finally {
-    if (!renamed && existsSync40(tmp)) {
+    if (!renamed && existsSync41(tmp)) {
       try {
         rmSync9(tmp, { force: true });
       } catch {
@@ -24158,9 +24536,9 @@ __export(watch_exports, {
   runOnQuiescent: () => runOnQuiescent,
   runWatch: () => runWatch
 });
-import { spawnSync as spawnSync3 } from "child_process";
-import { basename as basename8, dirname as dirname20, resolve as resolve22 } from "path";
-import { appendFileSync as appendFileSync3, existsSync as existsSync41, mkdirSync as mkdirSync18, readFileSync as readFileSync32 } from "fs";
+import { spawnSync as spawnSync4 } from "child_process";
+import { basename as basename8, dirname as dirname21, resolve as resolve22 } from "path";
+import { appendFileSync as appendFileSync4, existsSync as existsSync42, mkdirSync as mkdirSync19, readFileSync as readFileSync32 } from "fs";
 function parseFlags(args2) {
   const out = {
     foreground: false,
@@ -24186,8 +24564,8 @@ function parseFlags(args2) {
 function findClaudeBg() {
   const home = process.env.HOME ?? "";
   const fixed = home ? resolve22(home, ".claude", "bin", "claude-bg") : null;
-  if (fixed && existsSync41(fixed)) return fixed;
-  const which = spawnSync3("which", ["claude-bg"], { encoding: "utf-8" });
+  if (fixed && existsSync42(fixed)) return fixed;
+  const which = spawnSync4("which", ["claude-bg"], { encoding: "utf-8" });
   if (which.status === 0 && which.stdout) {
     const p19 = which.stdout.trim();
     if (p19) return p19;
@@ -24229,7 +24607,7 @@ async function runWatch(args2) {
     return { exitCode: 1, message: msg };
   }
   const name = watchName(root);
-  const res = spawnSync3(claudeBg, [
+  const res = spawnSync4(claudeBg, [
     "start",
     "--name",
     name,
@@ -24247,7 +24625,7 @@ async function runWatch(args2) {
 }
 function runStatus(root) {
   const path = watchStatePath(root);
-  if (!existsSync41(path)) {
+  if (!existsSync42(path)) {
     process.stdout.write("massu watch: not running (no state file)\n");
     return { exitCode: 0 };
   }
@@ -24285,7 +24663,7 @@ function runStop(root) {
     process.stderr.write("massu watch --stop: claude-bg not found; cannot kill registered daemon\n");
     return { exitCode: 1 };
   }
-  const res = spawnSync3(claudeBg, ["kill", watchName(root)], { stdio: "inherit" });
+  const res = spawnSync4(claudeBg, ["kill", watchName(root)], { stdio: "inherit" });
   return { exitCode: (res.status ?? 1) === 0 ? 0 : 1 };
 }
 async function runApplyNow(root) {
@@ -24405,14 +24783,14 @@ function refreshLogPath(projectRoot) {
 function appendRefreshLog(projectRoot, event) {
   const path = refreshLogPath(projectRoot);
   try {
-    mkdirSync18(dirname20(path), { recursive: true });
-    appendFileSync3(path, JSON.stringify(event) + "\n", "utf-8");
+    mkdirSync19(dirname21(path), { recursive: true });
+    appendFileSync4(path, JSON.stringify(event) + "\n", "utf-8");
   } catch {
   }
 }
 function readRefreshLog(projectRoot, limit = 10, opts = {}) {
   const path = refreshLogPath(projectRoot);
-  if (!existsSync41(path)) return [];
+  if (!existsSync42(path)) return [];
   const warn = opts.warn ?? ((s) => {
     process.stderr.write(s);
   });
@@ -24487,28 +24865,28 @@ var init_refresh_log = __esm({
 
 // src/security/atomic-write.ts
 import {
-  chmodSync as chmodSync6,
+  chmodSync as chmodSync7,
   closeSync as closeSync5,
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   fsyncSync as fsyncSync5,
-  mkdirSync as mkdirSync19,
+  mkdirSync as mkdirSync20,
   openSync as openSync5,
   renameSync as renameSync6,
   rmSync as rmSync10,
   statSync as statSync15,
   writeSync as writeSync4
 } from "node:fs";
-import { dirname as dirname21 } from "node:path";
+import { dirname as dirname22 } from "node:path";
 function atomicWrite(path, content, opts = {}) {
   const tmpPath = `${path}.tmp`;
-  const parentDir = dirname21(path);
+  const parentDir = dirname22(path);
   try {
-    if (!existsSync42(parentDir)) {
+    if (!existsSync43(parentDir)) {
       const mkdirOpts = { recursive: true };
       if (opts.ensureParentDirMode !== void 0) {
         mkdirOpts.mode = opts.ensureParentDirMode;
       }
-      mkdirSync19(parentDir, mkdirOpts);
+      mkdirSync20(parentDir, mkdirOpts);
     }
     const buf = typeof content === "string" ? Buffer.from(content, "utf-8") : content;
     const openMode = opts.mode ?? 420;
@@ -24520,12 +24898,12 @@ function atomicWrite(path, content, opts = {}) {
       closeSync5(fd);
     }
     if (opts.mode !== void 0) {
-      chmodSync6(tmpPath, opts.mode);
+      chmodSync7(tmpPath, opts.mode);
     }
     renameSync6(tmpPath, path);
     return { written: true };
   } catch (err) {
-    if (existsSync42(tmpPath)) {
+    if (existsSync43(tmpPath)) {
       try {
         rmSync10(tmpPath, { force: true });
       } catch {
@@ -24874,7 +25252,7 @@ var init_fetcher = __esm({
 });
 
 // src/security/manifest-cache.ts
-import { existsSync as existsSync43, readFileSync as readFileSync33, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync44, readFileSync as readFileSync33, statSync as statSync16 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 import { resolve as resolve23 } from "node:path";
 import { z as z5 } from "zod";
@@ -24886,7 +25264,7 @@ function defaultCachePaths() {
   };
 }
 function loadCachedManifest(paths = defaultCachePaths()) {
-  if (!existsSync43(paths.cachePath)) {
+  if (!existsSync44(paths.cachePath)) {
     return { kind: "absent" };
   }
   let raw;
@@ -25080,7 +25458,7 @@ var init_adapter_origin = __esm({
 });
 
 // src/security/local-fingerprint.ts
-import { existsSync as existsSync44, readFileSync as readFileSync34, lstatSync as lstatSync5 } from "node:fs";
+import { existsSync as existsSync45, readFileSync as readFileSync34, lstatSync as lstatSync5 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 import { resolve as resolve24, isAbsolute as isAbsolute3 } from "node:path";
 import { createHash as createHash12 } from "node:crypto";
@@ -25109,7 +25487,7 @@ function computeLocalFingerprint(localPaths, projectRoot) {
   return createHash12("sha256").update(canonical).digest("hex");
 }
 function readFingerprintSentinel(path = FINGERPRINT_PATH) {
-  if (!existsSync44(path)) return null;
+  if (!existsSync45(path)) return null;
   let raw;
   try {
     raw = JSON.parse(readFileSync34(path, "utf-8"));
@@ -25176,15 +25554,15 @@ var init_local_fingerprint = __esm({
 });
 
 // src/security/install-tracking.ts
-import { readFileSync as readFileSync35, readdirSync as readdirSync16, lstatSync as lstatSync6, existsSync as existsSync45 } from "node:fs";
-import { join as join24, relative as relative7, sep as sep2 } from "node:path";
+import { readFileSync as readFileSync35, readdirSync as readdirSync16, lstatSync as lstatSync6, existsSync as existsSync46 } from "node:fs";
+import { join as join25, relative as relative7, sep as sep2 } from "node:path";
 import { homedir as homedir15 } from "node:os";
 import { resolve as resolve25 } from "node:path";
 import { createHash as createHash13 } from "node:crypto";
 import { z as z7 } from "zod";
 function containsHiddenDirs(packageDir) {
   for (const hidden of EXCLUDED_DIR_NAMES) {
-    if (existsSync45(`${packageDir}/${hidden}`)) {
+    if (existsSync46(`${packageDir}/${hidden}`)) {
       return hidden;
     }
   }
@@ -25201,7 +25579,7 @@ function sha256OfDir(dir, opts = {}) {
       return;
     }
     for (const entry of entries.sort()) {
-      const absPath = join24(currentDir, entry);
+      const absPath = join25(currentDir, entry);
       let lst;
       try {
         lst = lstatSync6(absPath);
@@ -25239,7 +25617,7 @@ function sha256OfDir(dir, opts = {}) {
   return top.digest("hex");
 }
 function readInstalledManifest(path = INSTALLED_MANIFEST_PATH) {
-  if (!existsSync45(path)) return {};
+  if (!existsSync46(path)) return {};
   let raw;
   try {
     raw = JSON.parse(readFileSync35(path, "utf-8"));
@@ -25329,12 +25707,12 @@ var init_install_tracking = __esm({
 });
 
 // src/detect/adapters/discover.ts
-import { existsSync as existsSync46, readdirSync as readdirSync17, readFileSync as readFileSync36, lstatSync as lstatSync7 } from "node:fs";
+import { existsSync as existsSync47, readdirSync as readdirSync17, readFileSync as readFileSync36, lstatSync as lstatSync7 } from "node:fs";
 import { resolve as resolve26, isAbsolute as isAbsolute4 } from "node:path";
 import { z as z8 } from "zod";
 function walkNodeModules(projectRoot, warnings) {
   const nodeModulesDir = resolve26(projectRoot, "node_modules");
-  if (!existsSync46(nodeModulesDir)) {
+  if (!existsSync47(nodeModulesDir)) {
     return [];
   }
   const candidates = [];
@@ -25389,7 +25767,7 @@ function walkNodeModules(projectRoot, warnings) {
 }
 function tryReadAdapterPackage(packageDir, warnings) {
   const pkgJsonPath = resolve26(packageDir, "package.json");
-  if (!existsSync46(pkgJsonPath)) return null;
+  if (!existsSync47(pkgJsonPath)) return null;
   let raw;
   try {
     raw = JSON.parse(readFileSync36(pkgJsonPath, "utf-8"));
@@ -25527,7 +25905,7 @@ function discoverAdapters(opts) {
   for (const localPath of opts.configLocalPaths) {
     if (seenIds.has(localPath)) continue;
     const absPath = isAbsolute4(localPath) ? localPath : resolve26(opts.projectRoot, localPath);
-    if (!existsSync46(absPath)) {
+    if (!existsSync47(absPath)) {
       warnings.push(
         `local adapter file not found: ${localPath} (resolved to ${absPath}). Remove via: massu adapters remove-local ${localPath}`
       );
@@ -25609,7 +25987,7 @@ __export(adapters_exports, {
   runAdaptersResyncLocalFingerprint: () => runAdaptersResyncLocalFingerprint,
   runAdaptersSearch: () => runAdaptersSearch
 });
-import { existsSync as existsSync47, readFileSync as readFileSync37 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync37 } from "node:fs";
 import { resolve as resolve27 } from "node:path";
 import { parseDocument } from "yaml";
 async function handleAdaptersSubcommand(args2) {
@@ -25878,7 +26256,7 @@ function mutateLocalArray(mutator, command) {
     return { exitCode: 2 };
   }
   const yamlPath = resolve27(projectRoot, "massu.config.yaml");
-  if (!existsSync47(yamlPath)) {
+  if (!existsSync48(yamlPath)) {
     process.stderr.write(
       `${command}: massu.config.yaml not found at ${yamlPath}. Run \`massu init\` first.
 `
@@ -25978,7 +26356,7 @@ async function runAdaptersInstall(args2) {
     return { exitCode: 1 };
   }
   const packageDir = resolve27(projectRoot, "node_modules", ...packageName.split("/"));
-  if (!existsSync47(packageDir)) {
+  if (!existsSync48(packageDir)) {
     process.stderr.write(
       `install: ${packageName} is not installed in node_modules. Run \`npm install ${packageName}\` first.
 `
@@ -25986,7 +26364,7 @@ async function runAdaptersInstall(args2) {
     return { exitCode: 1 };
   }
   const pkgJsonPath = resolve27(packageDir, "package.json");
-  if (!existsSync47(pkgJsonPath)) {
+  if (!existsSync48(pkgJsonPath)) {
     process.stderr.write(`install: ${packageName} has no package.json at ${pkgJsonPath}
 `);
     return { exitCode: 1 };
@@ -26113,7 +26491,7 @@ async function runAdaptersResign(_args) {
       continue;
     }
     const packageDir = resolve27(projectRoot, "node_modules", ...name.split("/"));
-    if (!existsSync47(packageDir)) {
+    if (!existsSync48(packageDir)) {
       removed++;
       warnings.push(`${name}@${entry.version}: not present in node_modules \u2014 REMOVED from sidecar`);
       removeInstalledManifestEntry(name);
@@ -26199,16 +26577,15 @@ var init_adapters2 = __esm({
 });
 
 // src/preflight.ts
-import Database4 from "better-sqlite3";
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 function assertCodegraphUsable(dbPath) {
   const path = dbPath ?? getResolvedPaths().codegraphDbPath;
-  if (!existsSync48(path)) {
+  if (!existsSync49(path)) {
     throw new CodegraphDbUnusableError(path, "missing");
   }
   let db = null;
   try {
-    db = new Database4(path, { readonly: true });
+    db = openDatabase(path, { readonly: true });
     const row = db.prepare("SELECT COUNT(*) AS c FROM files").get();
     const files = row?.c ?? 0;
     if (files === 0) {
@@ -26232,6 +26609,7 @@ var CodegraphDbNotInitializedError, CodegraphDbUnusableError;
 var init_preflight = __esm({
   "src/preflight.ts"() {
     "use strict";
+    init_sqlite_loader();
     init_config();
     CodegraphDbNotInitializedError = class extends Error {
       dbPath;
@@ -26291,23 +26669,22 @@ var init_sql_table_names = __esm({
 });
 
 // src/db.ts
-import Database5 from "better-sqlite3";
-import { dirname as dirname22, join as join25 } from "path";
-import { existsSync as existsSync49, mkdirSync as mkdirSync20, readdirSync as readdirSync18, statSync as statSync17 } from "fs";
+import { dirname as dirname23, join as join26 } from "path";
+import { existsSync as existsSync50, mkdirSync as mkdirSync21, readdirSync as readdirSync18, statSync as statSync17 } from "fs";
 function getCodeGraphDb() {
   const dbPath = getResolvedPaths().codegraphDbPath;
   assertCodegraphUsable(dbPath);
-  const db = new Database5(dbPath, { readonly: true });
+  const db = openDatabase(dbPath, { readonly: true });
   db.pragma("journal_mode = WAL");
   return db;
 }
 function getDataDb() {
   const dbPath = getResolvedPaths().dataDbPath;
-  const dir = dirname22(dbPath);
-  if (!existsSync49(dir)) {
-    mkdirSync20(dir, { recursive: true });
+  const dir = dirname23(dbPath);
+  if (!existsSync50(dir)) {
+    mkdirSync21(dir, { recursive: true });
   }
-  const db = new Database5(dbPath);
+  const db = openDatabase(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   initDataSchema(db);
@@ -26577,7 +26954,7 @@ function isPythonDataStale(dataDb, pythonRoot) {
     try {
       const entries = readdirSync18(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join25(dir, entry.name);
+        const fullPath = join26(dir, entry.name);
         if (entry.isDirectory()) {
           if (["__pycache__", ".venv", "venv", "node_modules", ".mypy_cache", ".pytest_cache"].includes(entry.name)) continue;
           if (checkDir(fullPath)) return true;
@@ -26597,6 +26974,7 @@ function updatePythonBuildTimestamp(dataDb) {
 var init_db2 = __esm({
   "src/db.ts"() {
     "use strict";
+    init_sqlite_loader();
     init_preflight();
     init_config();
     init_sql_table_names();
@@ -26681,8 +27059,8 @@ var init_rules = __esm({
 });
 
 // src/import-resolver.ts
-import { readFileSync as readFileSync38, existsSync as existsSync50, statSync as statSync18 } from "fs";
-import { resolve as resolve29, dirname as dirname23, join as join26 } from "path";
+import { readFileSync as readFileSync38, existsSync as existsSync51, statSync as statSync18 } from "fs";
+import { resolve as resolve29, dirname as dirname24, join as join27 } from "path";
 function parseImports(source) {
   const imports = [];
   const lines = source.split("\n");
@@ -26740,21 +27118,21 @@ function resolveImportPath(specifier, fromFile) {
     const paths = getResolvedPaths();
     basePath = resolve29(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
   } else {
-    basePath = resolve29(dirname23(fromFile), specifier);
+    basePath = resolve29(dirname24(fromFile), specifier);
   }
-  if (existsSync50(basePath) && !isDirectory(basePath)) {
+  if (existsSync51(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
   }
   const resolvedPaths = getResolvedPaths();
   for (const ext of resolvedPaths.extensions) {
     const withExt = basePath + ext;
-    if (existsSync50(withExt)) {
+    if (existsSync51(withExt)) {
       return toRelative(withExt);
     }
   }
   for (const indexFile of resolvedPaths.indexFiles) {
-    const indexPath = join26(basePath, indexFile);
-    if (existsSync50(indexPath)) {
+    const indexPath = join27(basePath, indexFile);
+    if (existsSync51(indexPath)) {
       return toRelative(indexPath);
     }
   }
@@ -26791,7 +27169,7 @@ function buildImportIndex(dataDb, codegraphDb) {
   let batch = [];
   for (const file of files) {
     const absPath = ensureWithinRoot(resolve29(projectRoot, file.path), projectRoot);
-    if (!existsSync50(absPath)) continue;
+    if (!existsSync51(absPath)) continue;
     let source;
     try {
       source = readFileSync38(absPath, "utf-8");
@@ -26831,12 +27209,12 @@ var init_import_resolver = __esm({
 });
 
 // src/trpc-index.ts
-import { readFileSync as readFileSync39, existsSync as existsSync51, readdirSync as readdirSync19 } from "fs";
-import { resolve as resolve30, join as join27 } from "path";
+import { readFileSync as readFileSync39, existsSync as existsSync52, readdirSync as readdirSync19 } from "fs";
+import { resolve as resolve30, join as join28 } from "path";
 function parseRootRouter() {
   const paths = getResolvedPaths();
   const rootPath = paths.rootRouterPath;
-  if (!existsSync51(rootPath)) {
+  if (!existsSync52(rootPath)) {
     throw new Error(`Root router not found at ${rootPath}`);
   }
   const source = readFileSync39(rootPath, "utf-8");
@@ -26851,12 +27229,12 @@ function parseRootRouter() {
     for (const ext of [".ts", ".tsx", ""]) {
       const candidate = fullPath + ext;
       const routersRelPath = getConfig().paths.routers ?? "src/server/api/routers";
-      if (existsSync51(candidate)) {
+      if (existsSync52(candidate)) {
         filePath = routersRelPath + "/" + filePath + ext;
         break;
       }
-      const indexCandidate = join27(fullPath, "index.ts");
-      if (existsSync51(indexCandidate)) {
+      const indexCandidate = join28(fullPath, "index.ts");
+      if (existsSync52(indexCandidate)) {
         filePath = routersRelPath + "/" + filePath + "/index.ts";
         break;
       }
@@ -26876,7 +27254,7 @@ function parseRootRouter() {
 }
 function extractProcedures(routerFilePath) {
   const absPath = resolve30(getProjectRoot(), routerFilePath);
-  if (!existsSync51(absPath)) return [];
+  if (!existsSync52(absPath)) return [];
   const source = readFileSync39(absPath, "utf-8");
   const procedures = [];
   const seen = /* @__PURE__ */ new Set();
@@ -26906,7 +27284,7 @@ function findUICallSites(routerKey, procedureName) {
   ];
   const searchPattern = `api.${routerKey}.${procedureName}`;
   for (const dir of searchDirs) {
-    if (!existsSync51(dir)) continue;
+    if (!existsSync52(dir)) continue;
     searchDirectory(dir, searchPattern, callSites);
   }
   return callSites;
@@ -26914,7 +27292,7 @@ function findUICallSites(routerKey, procedureName) {
 function searchDirectory(dir, pattern, results) {
   const entries = readdirSync19(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join27(dir, entry.name);
+    const fullPath = join28(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".next") continue;
       searchDirectory(fullPath, pattern, results);
@@ -26984,7 +27362,7 @@ var init_trpc_index = __esm({
 });
 
 // src/page-deps.ts
-import { readFileSync as readFileSync40, existsSync as existsSync52 } from "fs";
+import { readFileSync as readFileSync40, existsSync as existsSync53 } from "fs";
 import { resolve as resolve31 } from "path";
 function deriveRoute(pageFile) {
   let route = pageFile.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "").replace(/\/page\.jsx?$/, "");
@@ -27024,7 +27402,7 @@ function findRouterCalls(files) {
   const projectRoot = getProjectRoot();
   for (const file of files) {
     const absPath = ensureWithinRoot(resolve31(projectRoot, file), projectRoot);
-    if (!existsSync52(absPath)) continue;
+    if (!existsSync53(absPath)) continue;
     try {
       const source = readFileSync40(absPath, "utf-8");
       const apiCallRegex = /api\.(\w+)\.\w+/g;
@@ -27045,7 +27423,7 @@ function findTablesFromRouters(routerNames, dataDb) {
     ).all(routerName);
     for (const proc of procs) {
       const absPath = ensureWithinRoot(resolve31(getProjectRoot(), proc.router_file), getProjectRoot());
-      if (!existsSync52(absPath)) continue;
+      if (!existsSync53(absPath)) continue;
       try {
         const source = readFileSync40(absPath, "utf-8");
         const dbPattern = getConfig().dbAccessPattern ?? "ctx.db.{table}";
@@ -27319,11 +27697,11 @@ var init_domains = __esm({
 });
 
 // src/schema-mapper.ts
-import { readFileSync as readFileSync41, existsSync as existsSync53, readdirSync as readdirSync20 } from "fs";
-import { join as join28 } from "path";
+import { readFileSync as readFileSync41, existsSync as existsSync54, readdirSync as readdirSync20 } from "fs";
+import { join as join29 } from "path";
 function parsePrismaSchema() {
   const schemaPath = getResolvedPaths().prismaSchemaPath;
-  if (!existsSync53(schemaPath)) {
+  if (!existsSync54(schemaPath)) {
     throw new Error(`Prisma schema not found at ${schemaPath}`);
   }
   const source = readFileSync41(schemaPath, "utf-8");
@@ -27384,14 +27762,14 @@ function toSnakeCase(str) {
 function findColumnUsageInRouters(tableName) {
   const usage2 = /* @__PURE__ */ new Map();
   const routersDir = getResolvedPaths().routersDir;
-  if (!existsSync53(routersDir)) return usage2;
+  if (!existsSync54(routersDir)) return usage2;
   scanDirectory(routersDir, tableName, usage2);
   return usage2;
 }
 function scanDirectory(dir, tableName, usage2) {
   const entries = readdirSync20(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join28(dir, entry.name);
+    const fullPath = join29(dir, entry.name);
     if (entry.isDirectory()) {
       scanDirectory(fullPath, tableName, usage2);
     } else if (entry.name.endsWith(".ts")) {
@@ -27446,10 +27824,10 @@ function detectMismatches(models) {
 }
 function findFilesUsingColumn(dir, column, tableName) {
   const result = [];
-  if (!existsSync53(dir)) return result;
+  if (!existsSync54(dir)) return result;
   const entries = readdirSync20(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join28(dir, entry.name);
+    const fullPath = join29(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...findFilesUsingColumn(fullPath, column, tableName));
     } else if (entry.name.endsWith(".ts")) {
@@ -27599,34 +27977,34 @@ var init_import_parser = __esm({
 });
 
 // src/python/import-resolver.ts
-import { readFileSync as readFileSync42, existsSync as existsSync54, readdirSync as readdirSync21 } from "fs";
-import { resolve as resolve33, join as join29, relative as relative8, dirname as dirname24 } from "path";
+import { readFileSync as readFileSync42, existsSync as existsSync55, readdirSync as readdirSync21 } from "fs";
+import { resolve as resolve33, join as join30, relative as relative8, dirname as dirname25 } from "path";
 function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
   const projectRoot = getProjectRoot();
   if (level > 0) {
-    let baseDir = dirname24(resolve33(projectRoot, fromFile));
+    let baseDir = dirname25(resolve33(projectRoot, fromFile));
     for (let i = 1; i < level; i++) {
-      baseDir = dirname24(baseDir);
+      baseDir = dirname25(baseDir);
     }
     const modulePart = module.replace(/^\.+/, "");
     if (modulePart) {
       const parts2 = modulePart.split(".");
-      return tryResolvePythonPath(join29(baseDir, ...parts2), projectRoot);
+      return tryResolvePythonPath(join30(baseDir, ...parts2), projectRoot);
     }
     return tryResolvePythonPath(baseDir, projectRoot);
   }
   const parts = module.split(".");
-  const candidate = join29(resolve33(projectRoot, pythonRoot), ...parts);
+  const candidate = join30(resolve33(projectRoot, pythonRoot), ...parts);
   return tryResolvePythonPath(candidate, projectRoot);
 }
 function tryResolvePythonPath(basePath, projectRoot) {
-  if (existsSync54(basePath + ".py")) {
+  if (existsSync55(basePath + ".py")) {
     return relative8(projectRoot, basePath + ".py");
   }
-  if (existsSync54(join29(basePath, "__init__.py"))) {
-    return relative8(projectRoot, join29(basePath, "__init__.py"));
+  if (existsSync55(join30(basePath, "__init__.py"))) {
+    return relative8(projectRoot, join30(basePath, "__init__.py"));
   }
-  if (basePath.endsWith(".py") && existsSync54(basePath)) {
+  if (basePath.endsWith(".py") && existsSync55(basePath)) {
     return relative8(projectRoot, basePath);
   }
   return null;
@@ -27638,9 +28016,9 @@ function walkPythonFiles(dir, excludeDirs) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
-        files.push(...walkPythonFiles(join29(dir, entry.name), excludeDirs));
+        files.push(...walkPythonFiles(join30(dir, entry.name), excludeDirs));
       } else if (entry.name.endsWith(".py")) {
-        files.push(join29(dir, entry.name));
+        files.push(join30(dir, entry.name));
       }
     }
   } catch {
@@ -27934,7 +28312,7 @@ var init_route_parser = __esm({
 
 // src/python/route-indexer.ts
 import { readFileSync as readFileSync43, readdirSync as readdirSync22 } from "fs";
-import { join as join30, relative as relative9 } from "path";
+import { join as join31, relative as relative9 } from "path";
 function walkPyFiles(dir, excludeDirs) {
   const files = [];
   try {
@@ -27942,9 +28320,9 @@ function walkPyFiles(dir, excludeDirs) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
-        files.push(...walkPyFiles(join30(dir, entry.name), excludeDirs));
+        files.push(...walkPyFiles(join31(dir, entry.name), excludeDirs));
       } else if (entry.name.endsWith(".py")) {
-        files.push(join30(dir, entry.name));
+        files.push(join31(dir, entry.name));
       }
     }
   } catch {
@@ -27953,7 +28331,7 @@ function walkPyFiles(dir, excludeDirs) {
 }
 function buildPythonRouteIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = join30(projectRoot, pythonRoot);
+  const absRoot = join31(projectRoot, pythonRoot);
   dataDb.exec(`DELETE FROM ${t("py_routes")}`);
   dataDb.exec(`DELETE FROM ${t("py_route_callers")}`);
   const insertStmt = dataDb.prepare(
@@ -28179,7 +28557,7 @@ var init_model_parser = __esm({
 
 // src/python/model-indexer.ts
 import { readFileSync as readFileSync44, readdirSync as readdirSync23 } from "fs";
-import { join as join31, relative as relative10 } from "path";
+import { join as join32, relative as relative10 } from "path";
 function walkPyFiles2(dir, excludeDirs) {
   const files = [];
   try {
@@ -28187,9 +28565,9 @@ function walkPyFiles2(dir, excludeDirs) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
-        files.push(...walkPyFiles2(join31(dir, entry.name), excludeDirs));
+        files.push(...walkPyFiles2(join32(dir, entry.name), excludeDirs));
       } else if (entry.name.endsWith(".py")) {
-        files.push(join31(dir, entry.name));
+        files.push(join32(dir, entry.name));
       }
     }
   } catch {
@@ -28198,7 +28576,7 @@ function walkPyFiles2(dir, excludeDirs) {
 }
 function buildPythonModelIndex(dataDb, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = join31(projectRoot, pythonRoot);
+  const absRoot = join32(projectRoot, pythonRoot);
   dataDb.exec(`DELETE FROM ${t("py_models")}`);
   dataDb.exec(`DELETE FROM ${t("py_fk_edges")}`);
   const insertModel = dataDb.prepare(
@@ -28476,18 +28854,18 @@ var init_migration_parser = __esm({
 
 // src/python/migration-indexer.ts
 import { readFileSync as readFileSync45, readdirSync as readdirSync24 } from "fs";
-import { join as join32, relative as relative11 } from "path";
+import { join as join33, relative as relative11 } from "path";
 function buildPythonMigrationIndex(dataDb, alembicDir) {
   const projectRoot = getProjectRoot();
-  const absDir = join32(projectRoot, alembicDir);
+  const absDir = join33(projectRoot, alembicDir);
   dataDb.exec(`DELETE FROM ${t("py_migrations")}`);
-  const versionsDir = join32(absDir, "versions");
+  const versionsDir = join33(absDir, "versions");
   let files = [];
   try {
-    files = readdirSync24(versionsDir).filter((f2) => f2.endsWith(".py")).map((f2) => join32(versionsDir, f2));
+    files = readdirSync24(versionsDir).filter((f2) => f2.endsWith(".py")).map((f2) => join33(versionsDir, f2));
   } catch {
     try {
-      files = readdirSync24(absDir).filter((f2) => f2.endsWith(".py") && f2 !== "env.py").map((f2) => join32(absDir, f2));
+      files = readdirSync24(absDir).filter((f2) => f2.endsWith(".py") && f2 !== "env.py").map((f2) => join33(absDir, f2));
     } catch {
     }
   }
@@ -28537,11 +28915,11 @@ var init_migration_indexer = __esm({
 
 // src/python/coupling-detector.ts
 import { readFileSync as readFileSync46, readdirSync as readdirSync25 } from "fs";
-import { join as join33, relative as relative12 } from "path";
+import { join as join34, relative as relative12 } from "path";
 function buildPythonCouplingIndex(dataDb) {
   const projectRoot = getProjectRoot();
   const config = getConfig();
-  const srcDir = join33(projectRoot, config.paths.source);
+  const srcDir = join34(projectRoot, config.paths.source);
   const routes = dataDb.prepare(`SELECT id, method, path FROM ${t("py_routes")}`).all();
   if (routes.length === 0) return 0;
   dataDb.exec(`DELETE FROM ${t("py_route_callers")}`);
@@ -28605,9 +28983,9 @@ function walkFrontendFiles(dir) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (exclude.includes(entry.name)) continue;
-        files.push(...walkFrontendFiles(join33(dir, entry.name)));
+        files.push(...walkFrontendFiles(join34(dir, entry.name)));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
-        files.push(join33(dir, entry.name));
+        files.push(join34(dir, entry.name));
       }
     }
   } catch {
@@ -28979,7 +29357,7 @@ var init_memory_tools = __esm({
 });
 
 // src/docs-tools.ts
-import { readFileSync as readFileSync47, existsSync as existsSync55 } from "fs";
+import { readFileSync as readFileSync47, existsSync as existsSync56 } from "fs";
 import { resolve as resolve34, basename as basename9 } from "path";
 function p4(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
@@ -29035,7 +29413,7 @@ function handleDocsToolCall(name, args2) {
 }
 function loadDocsMap() {
   const mapPath = getResolvedPaths().docsMapPath;
-  if (!existsSync55(mapPath)) {
+  if (!existsSync56(mapPath)) {
     throw new Error(`docs-map.json not found at ${mapPath}`);
   }
   return JSON.parse(readFileSync47(mapPath, "utf-8"));
@@ -29109,9 +29487,9 @@ function extractFrontmatter(content) {
 function extractProcedureNames(routerPath) {
   const root = getProjectRoot();
   const absPath = ensureWithinRoot(resolve34(getResolvedPaths().srcDir, "..", routerPath), root);
-  if (!existsSync55(absPath)) {
+  if (!existsSync56(absPath)) {
     const altPath = ensureWithinRoot(resolve34(getResolvedPaths().srcDir, "../server/api/routers", basename9(routerPath)), root);
-    if (!existsSync55(altPath)) return [];
+    if (!existsSync56(altPath)) return [];
     return extractProcedureNamesFromContent(readFileSync47(altPath, "utf-8"));
   }
   return extractProcedureNamesFromContent(readFileSync47(absPath, "utf-8"));
@@ -29155,7 +29533,7 @@ function handleDocsAudit(args2) {
     const mapping = docsMap.mappings.find((m3) => m3.id === mappingId);
     if (!mapping) continue;
     const helpPagePath = ensureWithinRoot(resolve34(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    if (!existsSync55(helpPagePath)) {
+    if (!existsSync56(helpPagePath)) {
       results.push({
         helpPage: mapping.helpPage,
         mappingId,
@@ -29208,7 +29586,7 @@ function handleDocsAudit(args2) {
     for (const [guideName, parentId] of Object.entries(docsMap.userGuideInheritance.examples)) {
       if (parentId === mappingId) {
         const guidePath = ensureWithinRoot(resolve34(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
-        if (existsSync55(guidePath)) {
+        if (existsSync56(guidePath)) {
           const guideContent = readFileSync47(guidePath, "utf-8");
           const guideFrontmatter = extractFrontmatter(guideContent);
           if (!guideFrontmatter?.lastVerified || status === "STALE") {
@@ -29243,7 +29621,7 @@ function handleDocsCoverage(args2) {
   const mappings = filterDomain ? docsMap.mappings.filter((m3) => m3.id === filterDomain) : docsMap.mappings;
   for (const mapping of mappings) {
     const helpPagePath = ensureWithinRoot(resolve34(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    const exists = existsSync55(helpPagePath);
+    const exists = existsSync56(helpPagePath);
     let hasContent = false;
     let lineCount = 0;
     let lastVerified = null;
@@ -29590,7 +29968,7 @@ var init_observability_tools = __esm({
 });
 
 // src/sentinel-db.ts
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import { resolve as resolve35 } from "path";
 function parsePortalScope(raw) {
   if (!raw) return [];
@@ -29828,22 +30206,22 @@ function validateFeatures(db, domainFilter) {
     const missingPages = [];
     for (const comp of components) {
       const absPath = resolve35(PROJECT_ROOT, comp.component_file);
-      if (!existsSync56(absPath)) {
+      if (!existsSync57(absPath)) {
         missingComponents.push(comp.component_file);
       }
     }
     for (const proc of procedures) {
       const routerPath = resolve35(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
-      if (!existsSync56(routerPath)) {
+      if (!existsSync57(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 = resolve35(PROJECT_ROOT, routeToPath);
-      if (page.page_route.startsWith("/") && !existsSync56(absPath)) {
+      if (page.page_route.startsWith("/") && !existsSync57(absPath)) {
         const altPath = resolve35(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
-        if (!existsSync56(altPath)) {
+        if (!existsSync57(altPath)) {
           missingPages.push(page.page_route);
         }
       }
@@ -30369,8 +30747,8 @@ var init_sentinel_tools = __esm({
 });
 
 // src/sentinel-scanner.ts
-import { readFileSync as readFileSync48, existsSync as existsSync57, readdirSync as readdirSync26, statSync as statSync19 } from "fs";
-import { resolve as resolve36, join as join34, basename as basename10, dirname as dirname25, relative as relative13 } from "path";
+import { readFileSync as readFileSync48, existsSync as existsSync58, readdirSync as readdirSync26, statSync as statSync19 } from "fs";
+import { resolve as resolve36, join as join35, basename as basename10, dirname as dirname26, relative as relative13 } from "path";
 function inferDomain(filePath) {
   const domains = getConfig().domains;
   const path = filePath.toLowerCase();
@@ -30502,7 +30880,7 @@ function scanComponentExports(dataDb) {
   const componentsBase = config.paths.components ?? config.paths.source + "/components";
   const componentDirs = [];
   const basePath = resolve36(projectRoot, componentsBase);
-  if (existsSync57(basePath)) {
+  if (existsSync58(basePath)) {
     try {
       const entries = readdirSync26(basePath, { withFileTypes: true });
       for (const entry of entries) {
@@ -30515,7 +30893,7 @@ function scanComponentExports(dataDb) {
   }
   for (const dir of componentDirs) {
     const absDir = resolve36(projectRoot, dir);
-    if (!existsSync57(absDir)) continue;
+    if (!existsSync58(absDir)) continue;
     const files = walkDir2(absDir).filter((f2) => f2.endsWith(".tsx") || f2.endsWith(".ts"));
     for (const file of files) {
       const relPath = relative13(projectRoot, file);
@@ -30545,7 +30923,7 @@ function scanComponentExports(dataDb) {
       if (hasHandlers && exportMatch) {
         const componentName = exportMatch[1];
         const domain = inferDomain(relPath);
-        const subdomain = basename10(dirname25(relPath));
+        const subdomain = basename10(dirname26(relPath));
         const featureKey = `component.${subdomain}.${componentName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "")}`;
         if (!annotations.some((a2) => a2.featureKey === featureKey)) {
           features.push({
@@ -30570,7 +30948,7 @@ function walkDir2(dir) {
   try {
     const entries = readdirSync26(dir);
     for (const entry of entries) {
-      const fullPath = join34(dir, entry);
+      const fullPath = join35(dir, entry);
       try {
         const stat = statSync19(fullPath);
         if (stat.isDirectory()) {
@@ -31280,7 +31658,7 @@ var init_prompt_analyzer = __esm({
 });
 
 // src/validation-engine.ts
-import { existsSync as existsSync58, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync59, readFileSync as readFileSync49 } from "fs";
 function p10(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -31311,7 +31689,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  if (!existsSync58(absPath)) {
+  if (!existsSync59(absPath)) {
     checks.push({
       name: "file_exists",
       severity: "error",
@@ -31779,7 +32157,7 @@ var init_adr_generator = __esm({
 });
 
 // src/security-scorer.ts
-import { existsSync as existsSync59, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync60, readFileSync as readFileSync50 } from "fs";
 function p12(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -31803,7 +32181,7 @@ function scoreFileSecurity(filePath, projectRoot) {
       }]
     };
   }
-  if (!existsSync59(absPath)) {
+  if (!existsSync60(absPath)) {
     return { riskScore: 0, findings: [] };
   }
   let source;
@@ -32098,7 +32476,7 @@ var init_security_scorer = __esm({
 });
 
 // src/dependency-scorer.ts
-import { existsSync as existsSync60, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync61, readFileSync as readFileSync51 } from "fs";
 import { resolve as resolve37 } from "path";
 function p13(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
@@ -32132,7 +32510,7 @@ function calculateDepRisk(factors) {
 }
 function getInstalledPackages(projectRoot) {
   const pkgPath = resolve37(projectRoot, "package.json");
-  if (!existsSync60(pkgPath)) return /* @__PURE__ */ new Map();
+  if (!existsSync61(pkgPath)) return /* @__PURE__ */ new Map();
   try {
     const pkg = JSON.parse(readFileSync51(pkgPath, "utf-8"));
     const packages = /* @__PURE__ */ new Map();
@@ -32740,7 +33118,7 @@ var init_regression_detector = __esm({
 
 // src/knowledge-indexer.ts
 import { createHash as createHash14 } from "crypto";
-import { readFileSync as readFileSync52, readdirSync as readdirSync27, statSync as statSync20, existsSync as existsSync61 } from "fs";
+import { readFileSync as readFileSync52, readdirSync as readdirSync27, statSync as statSync20, existsSync as existsSync62 } from "fs";
 import { resolve as resolve38, relative as relative14, basename as basename11, extname as extname2 } from "path";
 function getKnowledgePaths() {
   const resolved = getResolvedPaths();
@@ -33048,11 +33426,11 @@ function indexAllKnowledge(db) {
     files.push(...memFiles);
   } catch {
   }
-  if (existsSync61(paths.plansDir)) {
+  if (existsSync62(paths.plansDir)) {
     const planFiles = discoverMarkdownFiles(paths.plansDir);
     files.push(...planFiles);
   }
-  if (existsSync61(paths.docsDir)) {
+  if (existsSync62(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);
@@ -33095,7 +33473,7 @@ function indexAllKnowledge(db) {
     } catch {
     }
     for (const filePath of files) {
-      if (!existsSync61(filePath)) continue;
+      if (!existsSync62(filePath)) continue;
       const content = readFileSync52(filePath, "utf-8");
       const hash = hashContent2(content);
       const relPath = filePath.startsWith(paths.claudeDir) ? relative14(paths.claudeDir, filePath) : filePath.startsWith(paths.plansDir) ? "plans/" + relative14(paths.plansDir, filePath) : filePath.startsWith(paths.docsDir) ? "docs/" + relative14(paths.docsDir, filePath) : filePath.startsWith(paths.memoryDir) ? `memory/${relative14(paths.memoryDir, filePath)}` : basename11(filePath);
@@ -33231,10 +33609,10 @@ function isKnowledgeStale(db) {
     files.push(...discoverMarkdownFiles(paths.memoryDir));
   } catch {
   }
-  if (existsSync61(paths.plansDir)) {
+  if (existsSync62(paths.plansDir)) {
     files.push(...discoverMarkdownFiles(paths.plansDir));
   }
-  if (existsSync61(paths.docsDir)) {
+  if (existsSync62(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);
@@ -33263,7 +33641,7 @@ var init_knowledge_indexer = __esm({
 });
 
 // src/knowledge-tools.ts
-import { readFileSync as readFileSync53, writeFileSync as writeFileSync14, appendFileSync as appendFileSync4, readdirSync as readdirSync28 } from "fs";
+import { readFileSync as readFileSync53, writeFileSync as writeFileSync14, appendFileSync as appendFileSync5, readdirSync as readdirSync28 } from "fs";
 import { resolve as resolve39, basename as basename12 } from "path";
 function p16(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
@@ -34025,7 +34403,7 @@ function handleCorrect(db, args2) {
     const after = existing.slice(archiveIdx);
     writeFileSync14(correctionsPath, before + entry + after);
   } else {
-    appendFileSync4(correctionsPath, entry);
+    appendFileSync5(correctionsPath, entry);
   }
   const doc = db.prepare("SELECT id FROM knowledge_documents WHERE file_path LIKE ?").get("%corrections.md");
   if (doc) {
@@ -34972,7 +35350,7 @@ var init_framework_supports = __esm({
 });
 
 // src/tools.ts
-import { readFileSync as readFileSync54, existsSync as existsSync63 } from "fs";
+import { readFileSync as readFileSync54, existsSync as existsSync64 } from "fs";
 import { resolve as resolve40, basename as basename13 } from "path";
 function prefix2() {
   return getConfig().toolPrefix;
@@ -35392,7 +35770,7 @@ function handleContext(file, dataDb, codegraphDb) {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
           const absFilePath = ensureWithinRoot(resolve40(resolvedPaths.srcDir, "..", file), root);
-          if (existsSync63(absFilePath)) {
+          if (existsSync64(absFilePath)) {
             const fileContent = readFileSync54(absFilePath, "utf-8").slice(0, 3e3);
             const keywords = [];
             if (fileContent.includes("ctx.db")) keywords.push("database", "schema");
@@ -35831,7 +36209,7 @@ function handleSchema(args2) {
     lines.push("");
     const projectRoot = getProjectRoot();
     const absPath = ensureWithinRoot(resolve40(projectRoot, file), projectRoot);
-    if (!existsSync63(absPath)) {
+    if (!existsSync64(absPath)) {
       return text17(`File not found: ${file}`);
     }
     const source = readFileSync54(absPath, "utf-8");
@@ -36267,7 +36645,7 @@ var init_startup_health = __esm({
 // src/server.ts
 var server_exports = {};
 import { readFileSync as readFileSync55 } from "fs";
-import { resolve as resolve41, dirname as dirname26 } from "path";
+import { resolve as resolve41, dirname as dirname27 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function pruneMemoryOnStartup() {
   try {
@@ -36310,7 +36688,9 @@ var init_server = __esm({
     init_license();
     init_server_dispatch();
     init_startup_health();
-    __dirname5 = dirname26(fileURLToPath6(import.meta.url));
+    init_sqlite_loader();
+    init_config();
+    __dirname5 = dirname27(fileURLToPath6(import.meta.url));
     PKG_VERSION = (() => {
       try {
         const pkg = JSON.parse(readFileSync55(resolve41(__dirname5, "..", "package.json"), "utf-8"));
@@ -36321,7 +36701,14 @@ var init_server = __esm({
     })();
     dispatcher = createDispatcher({ serverInfoVersion: PKG_VERSION });
     try {
-      assertMemoryEngineHealthy(getMemoryDb);
+      const memoryDbPath = getResolvedPaths().memoryDbPath;
+      const verdict = probeMemoryDbUsable({ dbPath: memoryDbPath, selfHeal: true });
+      if (!verdict.ok) {
+        throw new FatalStartupError(
+          `the memory database engine is unusable (reason: ${verdict.reason}). ${verdict.detail ? verdict.detail.trim() + " " : ""}${NATIVE_DB_REMEDY}`
+        );
+      }
+      assertMemoryEngineHealthy(() => openDatabase(memoryDbPath));
     } catch (error) {
       if (error instanceof FatalStartupError) {
         process.stderr.write(`massu: FATAL \u2014 ${error.message}
@@ -36609,7 +36996,7 @@ var config_upgrade_exports = {};
 __export(config_upgrade_exports, {
   runConfigUpgrade: () => runConfigUpgrade
 });
-import { existsSync as existsSync64, readFileSync as readFileSync56, writeFileSync as writeFileSync15, copyFileSync as copyFileSync3, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync65, readFileSync as readFileSync56, writeFileSync as writeFileSync15, copyFileSync as copyFileSync3, unlinkSync as unlinkSync6 } from "fs";
 import { resolve as resolve42 } from "path";
 import { parse as parseYaml6 } from "yaml";
 async function runConfigUpgrade(opts = {}) {
@@ -36621,7 +37008,7 @@ async function runConfigUpgrade(opts = {}) {
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
   if (opts.rollback) {
-    if (!existsSync64(bakPath)) {
+    if (!existsSync65(bakPath)) {
       const message = `No backup found at ${bakPath}`;
       err(message + "\n");
       return { exitCode: 1, action: "none", message };
@@ -36637,7 +37024,7 @@ async function runConfigUpgrade(opts = {}) {
       return { exitCode: 2, action: "none", message };
     }
   }
-  if (!existsSync64(configPath)) {
+  if (!existsSync65(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return { exitCode: 1, action: "none", message };
@@ -36701,7 +37088,7 @@ var config_check_drift_exports = {};
 __export(config_check_drift_exports, {
   runConfigCheckDrift: () => runConfigCheckDrift
 });
-import { existsSync as existsSync65, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync66, readFileSync as readFileSync57 } from "fs";
 import { resolve as resolve43 } from "path";
 import { parse as parseYaml7 } from "yaml";
 function renderChanges(changes) {
@@ -36715,7 +37102,7 @@ async function runConfigCheckDrift(opts = {}) {
   } : (s) => process.stdout.write(s);
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
-  if (!existsSync65(configPath)) {
+  if (!existsSync66(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return {
@@ -36797,10 +37184,10 @@ var init_config_check_drift = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync58 } from "fs";
-import { resolve as resolve44, dirname as dirname27 } from "path";
+import { resolve as resolve44, dirname as dirname28 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 var __filename5 = fileURLToPath7(import.meta.url);
-var __dirname6 = dirname27(__filename5);
+var __dirname6 = dirname28(__filename5);
 var args = process.argv.slice(2);
 var subcommand = args[0];
 async function main() {
@@ -36820,6 +37207,12 @@ async function main() {
       await runLogin2(args.slice(1));
       break;
     }
+    case "heal": {
+      const { runHeal: runHeal2 } = await Promise.resolve().then(() => (init_heal(), heal_exports));
+      const result = await runHeal2(args.slice(1));
+      process.exit(result.exitCode);
+      return;
+    }
     case "logout": {
       const { runLogout: runLogout2 } = await Promise.resolve().then(() => (init_login(), login_exports));
       await runLogout2();