@massu/core 2.3.1 → 2.5.0

package/CHANGELOG.md

@@ -10,6 +10,137 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 > redistributed under the **Apache License 2.0**. Full license + NOTICE:
 > `packages/core/assets/embedder/MODEL-LICENSE`.
 
+## [2.5.0] - 2026-08-01
+
+### Fixed
+
+- **`install-hooks` ADDED a hook registration instead of REPLACING it, so every version bump
+  doubled the hooks — and that defect BLOCKED ITS OWN REMEDY.** `mergeHookEntries` deduped by
+  EXACT COMMAND STRING, and the emitted command embeds the version, so
+  `npx -y @massu/core@1.16.2 hook-runner user-prompt` and the `@2.4.0` form were two different
+  strings, two different hooks, BOTH kept. The command was simultaneously the payload and the
+  identity, so any payload change forged a new identity.
+
+  Measured, not theoretical: one workspace carried `1.15.5` x16 **and** `1.15.2` x15 at once,
+  with 15 hook names firing TWICE per event and writing double telemetry indefinitely. Worse,
+  because upgrading duplicated, nobody upgraded — 9 of 10 workspaces on this machine sat on a
+  pre-2.0.0 version whose `better-sqlite3` ABI did not match the running Node, and one had
+  **26,119 `NODE_MODULE_VERSION` hook failures**: a total massu outage. It stayed invisible
+  because a crashing hook still **exits 0**.
+
+  Registration identity is now the `hook-runner` subcommand — a stable CLI contract (`cli.ts`
+  dispatches on exactly that token), invariant under both a version bump and a launch-mechanism
+  change. Non-massu entries keep the historical exact-command semantics, so a customer's own
+  hooks are never touched or collapsed.
+
+  Proof it can fail (CR-72, planted in the real tree, restored byte-identical by sha256):
+  reverting the identity branch to exact-command dedup turns
+  `installer-registration-identity-drift-guard.test.ts` RED — that guard drives the REAL
+  `installHooks()` over a real temp project seeded with an older-version block, a node-direct
+  block and a customer hook.
+
+### Added
+
+- **A version-stable launcher shim, cutting ~0.86s of npm bootstrap off each hook fire.**
+  `npx -y @massu/core@<v> …` spends ~0.86s starting npm before any massu code runs. Measured
+  interleaved, min-of-5: `npx` 0.97s, `npx --offline` 0.88s, `node <cli.js>` 0.11s — so the
+  cost is npm's own startup, NOT the registry, and no npx flag addresses it.
+
+  `install-hooks` now writes `~/.massu/bin/massu-hook` and emits
+  `"~/.massu/bin/massu-hook" <version> hook-runner <name>`. That path is VERSION-STABLE, and
+  the shim re-resolves the runtime AT FIRE TIME, exec'ing npx when it is absent.
+
+  This deliberately does NOT bake a versioned absolute path, which would reintroduce the class
+  P-003 (v1.9.4) eliminated: such a path is "invalidated by cache clears, global-install
+  relocations, or npx upgrades — silently 404-ing the hooks". Probing at emit time says nothing
+  about invalidation after emit. Three fail-safe layers instead — shim missing at emit emits
+  npx; runtime missing at fire execs npx; both present takes the fast path — so no single
+  missing artifact is fatal and a stale registration self-heals.
+
+  Measured after: fast path **0.11s vs npx 1.07s (9.7x)**. The fallback is mutation-proven — a
+  shim with its npx branch removed FAILS the same no-runtime case (exit 27), so the test is not
+  vacuous. `exec` in both branches preserves stdin, stdout and the exit code.
+
+  Semver MINOR: `massuHookIdentity`, `massuShimPath`, `massuShimBody`, `installMassuShim`,
+  `resolveMassuShim`, `massuRuntimeDir`, `massuRuntimeCliPath`, `resolveMassuRuntimeCli` and
+  `materializeMassuRuntime` are new exports. `MASSU_NO_NODE_DIRECT=1` forces the npx form.
+
+### Changed
+
+- **CR-70 Layer 3 amended: installer symmetry is no longer npx-specific.** Both emitters read
+  one resolver and agree on mechanism AND pinned version. The drift-guard previously asserted
+  the literal `'npx'`, which pinned an implementation detail rather than the property — it
+  would go RED on a correct mechanism change and GREEN on a wrong one that used npx on both
+  sides. Three assertions were amended on the same grounds
+  (`init-hook-paths-no-absolute`, `init-mcp-json-pin`, `cli.test.ts`); each keeps its original
+  protection of a visible pinned version and a known launch mechanism.
+
+## [2.4.0] - 2026-07-31
+
+### Fixed
+
+- **Hooks silently lost telemetry whenever two sessions wrote at once — `db-driver.ts` never
+  armed `PRAGMA busy_timeout`, so SQLite's default of 0ms made a blocked writer fail
+  INSTANTLY.** Both engine paths (`openNodeSqlite`, `openBetterSqlite3`) opened a connection
+  and handed it out without a busy-timeout, so a writer that met a competing writer's lock
+  got `SQLITE_BUSY` ("database is locked") with no wait at all. Every hook catches that,
+  appends to `.massu/hook-failures.jsonl`, and **exits 0** — so the observation, cost, or
+  session row was gone with no failing signal anywhere. Measured before the fix across two
+  active workspaces: **2,169 lost rows in one and 156 in the other**, still accruing. In one
+  of them the throw landed in `session-start`'s `createSession`, which also skipped
+  `pullTeamPromotions` further down the same `try` — so team/enterprise promotions silently
+  stopped pulling on any session that lost the race. Concurrency is the NORMAL state whenever
+  more than one agent session shares a repo, not an edge case.
+
+  `PRAGMA busy_timeout` is set — rather than the ctor `timeout` option — because it is
+  engine-agnostic across `node:sqlite` and better-sqlite3, connection-local, and needs no
+  lock of its own. It is applied in `db-driver.ts`, the CR-69 sole open chokepoint, so
+  **every** opener (hooks, MCP server, CLI) inherits it. Default **5000ms**, overridable via
+  `MASSU_DB_BUSY_TIMEOUT_MS`; `0` is legal and restores the old fail-instantly behaviour,
+  which is how the tests prove they can still go RED. A malformed value falls back to the
+  default rather than disabling the wait (fail-safe, not fail-open).
+
+  Semver MINOR, not PATCH: `resolveBusyTimeoutMs()`, `DEFAULT_BUSY_TIMEOUT_MS` and
+  `DB_BUSY_TIMEOUT_ENV` are new exports. This release also carries the unpublished 2.3.2.
+
+  Proof it can fail (CR-72, planted in the real tree, restored byte-identical by sha256):
+  removing the pragma from `openNodeSqlite` turns the behavioural test RED
+  (`db-busy-timeout.test.ts` — a `worker_threads` lock-holder, because the plan audit proved
+  a same-thread holder is impossible: SQLite's busy-wait blocks the event loop, so the
+  release timer never fires); removing it from `openBetterSqlite3` turns drift-guard clause
+  (e) RED; hard-coding the value turns clause (e2) RED.
+  New gate registered in `scripts/lib/gate-registry.json` (416 → 417).
+  Incident: `docs/incidents/2026-07-23-hook-db-busy-timeout-silent-loss.md`.
+  (plan-2026-07-23-hook-latency-silent-loss-fixes, P1)
+
+## [2.3.2] - 2026-07-24
+
+### Fixed
+
+- **`sync-public.sh` self-exempts its bulk `git rm -rf .` / `git clean -fd` from the machine
+  deletion circuit breaker.** The public-mirror sync wipes the mirror with `git rm -rf .` +
+  `git clean -fd` — hundreds of unlinks under `$HOME`, whose bulk-delete signature the breaker
+  SIGSTOPs — freezing the git child mid-sync on every run. Both bulk deletes now route through a
+  `cb_exempt_git` helper that registers each git child pid plus a start-time identity token in
+  `~/.claude/cb-exempt-pids.txt` for the duration of that one command, scoped to only the pids this
+  script adds, fail-open (the sync never depends on the breaker), with an `EXIT`/`INT`/`TERM`
+  cleanup trap that de-registers them even on interrupt. The start-time token pairs with the
+  breaker's identity-verifying exempt list so a reused pid cannot inherit a stale exemption.
+  Drift-guarded (`sync-public-cb-exempt-drift-guard.test.ts`, registered as a DEFEAT-proven G-6
+  anti-vacuity guard).
+
+### Changed
+
+- **Synced `packages/core/CHANGELOG.md` with the previously-missing `[2.3.1]` entry.** The 2.3.1
+  release added `[2.3.1]` to the root and website CHANGELOGs but omitted
+  `packages/core/CHANGELOG.md`, leaving the three copies out of sync. Parity restored.
+- **Trimmed `CLAUDE.md` back under its size budget**, relocating the removed detail into
+  `.claude/reference/patterns-quickref.md` so `.claude/CLAUDE.md` stays under its 55,000-character
+  cap.
+
+No runtime behaviour of `@massu/core` changes in this release; it is repo-tooling and documentation
+only. Published because CR-64 forbids commits sitting on top of a published, tagged release.
+
 ## [2.3.1] - 2026-07-23
 
 ### Fixed

package/dist/cli.js

@@ -560,6 +560,12 @@ import { join as join2 } from "path";
 function resolveDbEngine() {
   return process.env[DB_ENGINE_ENV] === "better-sqlite3" ? "better-sqlite3" : DEFAULT_DB_ENGINE;
 }
+function resolveBusyTimeoutMs() {
+  const raw = process.env[DB_BUSY_TIMEOUT_ENV];
+  if (raw === void 0 || raw === "") return DEFAULT_BUSY_TIMEOUT_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : DEFAULT_BUSY_TIMEOUT_MS;
+}
 function nodeSqliteCtor() {
   if (!_nodeCtor) _nodeCtor = req2("node:sqlite").DatabaseSync;
   return _nodeCtor;
@@ -581,6 +587,7 @@ function openNodeSqlite(dbPath, opts) {
     enableForeignKeyConstraints: true,
     allowExtension: false
   });
+  raw.exec(`PRAGMA busy_timeout = ${resolveBusyTimeoutMs()}`);
   let savepointSeq = 0;
   const wrapStmt = (sql) => {
     const st = raw.prepare(sql);
@@ -664,7 +671,9 @@ function openNodeSqlite(dbPath, opts) {
   return handle;
 }
 function openBetterSqlite3(dbPath, opts) {
-  return openDatabase(dbPath, opts);
+  const db = openDatabase(dbPath, opts);
+  db.exec(`PRAGMA busy_timeout = ${resolveBusyTimeoutMs()}`);
+  return db;
 }
 function openDatabase2(dbPath, opts = {}) {
   return resolveDbEngine() === "better-sqlite3" ? openBetterSqlite3(dbPath, opts) : openNodeSqlite(dbPath, opts);
@@ -708,7 +717,7 @@ function probeMemoryDbUsable2(opts = {}) {
   }
   return { ok: true };
 }
-var req2, DEFAULT_DB_ENGINE, DB_ENGINE_ENV, _nodeCtor, NODE_SQLITE_REMEDY;
+var req2, DEFAULT_DB_ENGINE, DB_ENGINE_ENV, DEFAULT_BUSY_TIMEOUT_MS, DB_BUSY_TIMEOUT_ENV, _nodeCtor, NODE_SQLITE_REMEDY;
 var init_db_driver = __esm({
   "src/db-driver.ts"() {
     "use strict";
@@ -717,6 +726,8 @@ var init_db_driver = __esm({
     req2 = createRequire2(import.meta.url);
     DEFAULT_DB_ENGINE = "node-sqlite";
     DB_ENGINE_ENV = "MASSU_DB_ENGINE";
+    DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+    DB_BUSY_TIMEOUT_ENV = "MASSU_DB_BUSY_TIMEOUT_MS";
     _nodeCtor = null;
     NODE_SQLITE_REMEDY = "Node's built-in node:sqlite failed to open the database. Ensure Node >= 22.16.0 (`node --version`) and that this Node build includes SQLite, then restart your MCP client / Claude Code.";
   }
@@ -12946,23 +12957,23 @@ function introspectPython(detection, projectRoot) {
   for (const path of candidates) {
     const body = readSafe(path);
     if (body === null) continue;
-    const authRegex = /\bDepends\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/gu;
+    const authRegex = new RegExp(PY_AUTH_DEP_PATTERN, "gu");
     forEachMatch(authRegex, body, (m3) => {
       const name = m3[1];
       if (!authDeps.has(name)) authDeps.set(name, path);
     });
-    const djangoAuthRegex = /^@\s*([a-z_][a-z0-9_]*(?:_required|_login))\b/gmu;
+    const djangoAuthRegex = new RegExp(PY_DJANGO_AUTH_PATTERN, "gmu");
     forEachMatch(djangoAuthRegex, body, (m3) => {
       const name = m3[1];
       if (!authDeps.has(name)) authDeps.set(name, path);
     });
-    const prefixRegex = /\bAPIRouter\s*\(\s*[^)]*?prefix\s*=\s*["']([^"']+)["']/gu;
+    const prefixRegex = new RegExp(PY_API_PREFIX_PATTERN, "gu");
     forEachMatch(prefixRegex, body, (m3) => {
       const fullPrefix = m3[1];
       const base = extractPrefixBase(fullPrefix);
       if (base && !prefixBases.has(base)) prefixBases.set(base, path);
     });
-    const asyncRegex = /^(@pytest\.mark\.asyncio(?:\s*\([^)]*\))?)/gmu;
+    const asyncRegex = new RegExp(PY_TEST_ASYNC_PATTERN, "gmu");
     forEachMatch(asyncRegex, body, (m3) => {
       const pat = m3[1].trim();
       if (!testAsyncPatterns.has(pat)) testAsyncPatterns.set(pat, path);
@@ -13167,10 +13178,14 @@ function relativeTo(projectRoot, absPath) {
   }
   return basename4(absPath);
 }
-var MAX_FILE_BYTES, MAX_SAMPLES_PER_ADAPTER, MAX_DIR_DEPTH;
+var PY_AUTH_DEP_PATTERN, PY_DJANGO_AUTH_PATTERN, PY_API_PREFIX_PATTERN, PY_TEST_ASYNC_PATTERN, MAX_FILE_BYTES, MAX_SAMPLES_PER_ADAPTER, MAX_DIR_DEPTH;
 var init_regex_fallback = __esm({
   "src/detect/regex-fallback.ts"() {
     "use strict";
+    PY_AUTH_DEP_PATTERN = String.raw`\bDepends\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)`;
+    PY_DJANGO_AUTH_PATTERN = String.raw`^@\s*([a-z_][a-z0-9_]*(?:_required|_login))\b`;
+    PY_API_PREFIX_PATTERN = String.raw`\bAPIRouter\s*\(\s*[^)]*?prefix\s*=\s*["']([^"']+)["']`;
+    PY_TEST_ASYNC_PATTERN = String.raw`^(@pytest\.mark\.asyncio(?:\s*\([^)]*\))?)`;
     MAX_FILE_BYTES = 256 * 1024;
     MAX_SAMPLES_PER_ADAPTER = 3;
     MAX_DIR_DEPTH = 6;
@@ -15965,14 +15980,23 @@ __export(init_exports, {
   getInstallerVersion: () => getInstallerVersion,
   initMemoryDir: () => initMemoryDir,
   installHooks: () => installHooks,
+  installMassuShim: () => installMassuShim,
   isTemplateName: () => isTemplateName,
   listTemplates: () => listTemplates,
+  massuHookIdentity: () => massuHookIdentity,
+  massuRuntimeCliPath: () => massuRuntimeCliPath,
+  massuRuntimeDir: () => massuRuntimeDir,
+  massuShimBody: () => massuShimBody,
+  massuShimPath: () => massuShimPath,
+  materializeMassuRuntime: () => materializeMassuRuntime,
   mergeHooksConfig: () => mergeHooksConfig,
   parseInitArgs: () => parseInitArgs,
   printInitHelp: () => printInitHelp,
   registerMcpServer: () => registerMcpServer,
   renderConfigYaml: () => renderConfigYaml,
   resolveHooksDir: () => resolveHooksDir,
+  resolveMassuRuntimeCli: () => resolveMassuRuntimeCli,
+  resolveMassuShim: () => resolveMassuShim,
   resolveTemplatesDir: () => resolveTemplatesDir,
   runInit: () => runInit,
   validateWrittenConfig: () => validateWrittenConfig,
@@ -15982,6 +16006,7 @@ import { closeSync as closeSync4, existsSync as existsSync19, fsyncSync as fsync
 import { resolve as resolve9, basename as basename6, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { homedir as homedir7 } from "os";
+import { execFileSync as execFileSync2 } from "child_process";
 import { stringify as yamlStringify, parse as yamlParse } from "yaml";
 function detectFramework(projectRoot) {
   const result = {
@@ -16555,11 +16580,8 @@ function registerMcpServer(projectRoot) {
     return false;
   }
   const version = getInstallerVersion();
-  servers.massu = {
-    type: "stdio",
-    command: "npx",
-    args: ["-y", `@massu/core@${version}`]
-  };
+  const shim = resolveMassuShim();
+  servers.massu = shim !== null ? { type: "stdio", command: shim, args: [version] } : { type: "stdio", command: "npx", args: ["-y", `@massu/core@${version}`] };
   existing.mcpServers = servers;
   writeFileSync5(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
   return true;
@@ -16576,7 +16598,98 @@ function resolveHooksDir() {
   }
   return "node_modules/@massu/core/dist/hooks";
 }
-function hookCmd(version, hookName) {
+function massuRuntimeDir(version) {
+  return resolve9(homedir7(), ".massu", "runtime", version);
+}
+function massuRuntimeCliPath(version) {
+  return resolve9(massuRuntimeDir(version), "node_modules", "@massu", "core", "dist", "cli.js");
+}
+function resolveMassuRuntimeCli(version) {
+  if (process.env.MASSU_NO_NODE_DIRECT === "1") return null;
+  const cli = massuRuntimeCliPath(version);
+  if (!existsSync19(cli)) return null;
+  try {
+    execFileSync2(process.execPath, [cli, "--version"], { stdio: "ignore", timeout: 2e4 });
+    return cli;
+  } catch {
+    return null;
+  }
+}
+function materializeMassuRuntime(version) {
+  if (process.env.MASSU_NO_NODE_DIRECT === "1") return false;
+  if (resolveMassuRuntimeCli(version) !== null) return true;
+  const dir = massuRuntimeDir(version);
+  try {
+    mkdirSync10(dir, { recursive: true });
+    execFileSync2(
+      "npm",
+      ["install", "--prefix", dir, `@massu/core@${version}`, "--no-audit", "--no-fund", "--loglevel=error"],
+      { stdio: "ignore", timeout: 3e5 }
+    );
+  } catch {
+    return false;
+  }
+  return resolveMassuRuntimeCli(version) !== null;
+}
+function massuShimPath() {
+  return resolve9(homedir7(), ".massu", "bin", "massu-hook");
+}
+function massuShimBody() {
+  return `#!/bin/sh
+# massu launcher shim \u2014 GENERATED, do not edit. Recreated by \`massu install-hooks\`.
+#
+# usage: massu-hook <version> <subcommand...>
+#
+# Resolves the massu runtime AT FIRE TIME so a deleted/moved runtime degrades to npx
+# instead of silently 404-ing the hook (the P-003 failure class). exec preserves stdin,
+# stdout, stderr and the exit code.
+set -u
+if [ "$#" -lt 1 ]; then
+  echo "massu-hook: missing <version> argument" >&2
+  exit 2
+fi
+MASSU_VERSION="$1"
+shift
+MASSU_CLI="\${HOME}/.massu/runtime/\${MASSU_VERSION}/node_modules/@massu/core/dist/cli.js"
+if [ -f "$MASSU_CLI" ]; then
+  exec node "$MASSU_CLI" "$@"
+fi
+exec npx -y "@massu/core@\${MASSU_VERSION}" "$@"
+`;
+}
+function installMassuShim() {
+  if (process.env.MASSU_NO_NODE_DIRECT === "1") return false;
+  if (process.platform === "win32") return false;
+  const shim = massuShimPath();
+  try {
+    mkdirSync10(dirname12(shim), { recursive: true });
+    writeFileSync5(shim, massuShimBody(), "utf-8");
+    chmodSync5(shim, 493);
+  } catch {
+    return false;
+  }
+  try {
+    execFileSync2(shim, [], { stdio: "ignore", timeout: 1e4 });
+    return false;
+  } catch (e2) {
+    const status = e2.status;
+    return status === 2;
+  }
+}
+function resolveMassuShim() {
+  if (process.env.MASSU_NO_NODE_DIRECT === "1") return null;
+  if (process.platform === "win32") return null;
+  const shim = massuShimPath();
+  if (!existsSync19(shim)) return null;
+  try {
+    execFileSync2(shim, [], { stdio: "ignore", timeout: 1e4 });
+    return null;
+  } catch (e2) {
+    return e2.status === 2 ? shim : null;
+  }
+}
+function hookCmd(version, hookName, shim) {
+  if (shim !== null) return `"${shim}" ${version} hook-runner ${hookName}`;
   return `npx -y @massu/core@${version} hook-runner ${hookName}`;
 }
 function getHookTimeout(name) {
@@ -16584,11 +16697,12 @@ function getHookTimeout(name) {
 }
 function buildHooksConfig(_hooksDir) {
   const version = getInstallerVersion();
+  const shim = resolveMassuShim();
   return {
     SessionStart: [
       {
         hooks: [
-          { type: "command", command: hookCmd(version, "session-start"), timeout: getHookTimeout("session-start") }
+          { type: "command", command: hookCmd(version, "session-start", shim), timeout: getHookTimeout("session-start") }
         ]
       }
     ],
@@ -16603,26 +16717,26 @@ function buildHooksConfig(_hooksDir) {
       {
         matcher: "Bash|Write|Edit",
         hooks: [
-          { type: "command", command: hookCmd(version, "pre-tool-use-gate"), timeout: getHookTimeout("pre-tool-use-gate") }
+          { type: "command", command: hookCmd(version, "pre-tool-use-gate", shim), timeout: getHookTimeout("pre-tool-use-gate") }
         ]
       }
     ],
     PostToolUse: [
       {
         hooks: [
-          { type: "command", command: hookCmd(version, "post-tool-use"), timeout: getHookTimeout("post-tool-use") },
-          { type: "command", command: hookCmd(version, "quality-event"), timeout: getHookTimeout("quality-event") },
-          { type: "command", command: hookCmd(version, "cost-tracker"), timeout: getHookTimeout("cost-tracker") }
+          { type: "command", command: hookCmd(version, "post-tool-use", shim), timeout: getHookTimeout("post-tool-use") },
+          { type: "command", command: hookCmd(version, "quality-event", shim), timeout: getHookTimeout("quality-event") },
+          { type: "command", command: hookCmd(version, "cost-tracker", shim), timeout: getHookTimeout("cost-tracker") }
         ]
       },
       {
         matcher: "Edit|Write",
         hooks: [
-          { type: "command", command: hookCmd(version, "post-edit-context"), timeout: getHookTimeout("post-edit-context") },
+          { type: "command", command: hookCmd(version, "post-edit-context", shim), timeout: getHookTimeout("post-edit-context") },
           // Auto-learning pipeline — classifies failures and detects fixes on
           // file changes. See Phase 5-6 of the autodetect plan.
-          { type: "command", command: hookCmd(version, "fix-detector"), timeout: getHookTimeout("fix-detector") },
-          { type: "command", command: hookCmd(version, "classify-failure"), timeout: getHookTimeout("classify-failure") }
+          { type: "command", command: hookCmd(version, "fix-detector", shim), timeout: getHookTimeout("fix-detector") },
+          { type: "command", command: hookCmd(version, "classify-failure", shim), timeout: getHookTimeout("classify-failure") }
         ]
       },
       {
@@ -16630,35 +16744,35 @@ function buildHooksConfig(_hooksDir) {
         hooks: [
           // Incident + rule enforcement pipelines fire on Write-only (incidents
           // are authored as .md files; rules are enforced after new-file drops).
-          { type: "command", command: hookCmd(version, "incident-pipeline"), timeout: getHookTimeout("incident-pipeline") },
-          { type: "command", command: hookCmd(version, "rule-enforcement-pipeline"), timeout: getHookTimeout("rule-enforcement-pipeline") }
+          { type: "command", command: hookCmd(version, "incident-pipeline", shim), timeout: getHookTimeout("incident-pipeline") },
+          { type: "command", command: hookCmd(version, "rule-enforcement-pipeline", shim), timeout: getHookTimeout("rule-enforcement-pipeline") }
         ]
       }
     ],
     Stop: [
       {
         hooks: [
-          { type: "command", command: hookCmd(version, "session-end"), timeout: getHookTimeout("session-end") },
+          { type: "command", command: hookCmd(version, "session-end", shim), timeout: getHookTimeout("session-end") },
           // Session-end auto-learning aggregation (failure-class roll-up).
-          { type: "command", command: hookCmd(version, "auto-learning-pipeline"), timeout: getHookTimeout("auto-learning-pipeline") }
+          { type: "command", command: hookCmd(version, "auto-learning-pipeline", shim), timeout: getHookTimeout("auto-learning-pipeline") }
         ]
       }
     ],
     PreCompact: [
       {
         hooks: [
-          { type: "command", command: hookCmd(version, "pre-compact"), timeout: getHookTimeout("pre-compact") }
+          { type: "command", command: hookCmd(version, "pre-compact", shim), timeout: getHookTimeout("pre-compact") }
         ]
       }
     ],
     UserPromptSubmit: [
       {
         hooks: [
-          { type: "command", command: hookCmd(version, "user-prompt"), timeout: getHookTimeout("user-prompt") },
-          { type: "command", command: hookCmd(version, "intent-suggester"), timeout: getHookTimeout("intent-suggester") },
+          { type: "command", command: hookCmd(version, "user-prompt", shim), timeout: getHookTimeout("user-prompt") },
+          { type: "command", command: hookCmd(version, "intent-suggester", shim), timeout: getHookTimeout("intent-suggester") },
           // plan-living-memory-slice-1 P3-002: automatic relevant-recall.
           // Injects a compact "🧠 Relevant memory" block; fails open (empty).
-          { type: "command", command: hookCmd(version, "memory-recall"), timeout: getHookTimeout("memory-recall") }
+          { type: "command", command: hookCmd(version, "memory-recall", shim), timeout: getHookTimeout("memory-recall") }
         ]
       }
     ]
@@ -16696,21 +16810,31 @@ function mergeHooksConfig(existing, additions) {
   }
   return merged;
 }
+function massuHookIdentity(command) {
+  if (!/@massu\/core|[/\\]\.?massu[/\\]/.test(command)) return null;
+  const m3 = /\bhook-runner\s+([A-Za-z0-9._-]+)/.exec(command);
+  return m3 ? m3[1] : null;
+}
 function mergeHookEntries(existing, additions) {
-  const seen = /* @__PURE__ */ new Set();
+  const seenCommands = /* @__PURE__ */ new Set();
+  const seenIdentities = /* @__PURE__ */ new Set();
   const result = [];
-  for (const entry of additions ?? []) {
-    if (!entry || typeof entry.command !== "string") continue;
-    if (seen.has(entry.command)) continue;
-    seen.add(entry.command);
-    result.push(entry);
-  }
-  for (const entry of existing ?? []) {
-    if (!entry || typeof entry.command !== "string") continue;
-    if (seen.has(entry.command)) continue;
-    seen.add(entry.command);
+  const take = (entry) => {
+    if (!entry || typeof entry.command !== "string") return;
+    const identity = massuHookIdentity(entry.command);
+    if (identity !== null) {
+      if (seenIdentities.has(identity)) return;
+      seenIdentities.add(identity);
+      seenCommands.add(entry.command);
+      result.push(entry);
+      return;
+    }
+    if (seenCommands.has(entry.command)) return;
+    seenCommands.add(entry.command);
     result.push(entry);
-  }
+  };
+  for (const entry of additions ?? []) take(entry);
+  for (const entry of existing ?? []) take(entry);
   return result;
 }
 function installHooks(projectRoot) {
@@ -18701,6 +18825,16 @@ async function runInstallHooks() {
   console.log("Massu AI - Hook Installation");
   console.log("============================");
   console.log("");
+  const version = getInstallerVersion();
+  const shimOk = installMassuShim();
+  const runtimeOk = materializeMassuRuntime(version);
+  if (shimOk && runtimeOk) {
+    console.log("  Launcher: shim + runtime ready (fast path, ~9x cheaper per hook)");
+  } else if (shimOk) {
+    console.log("  Launcher: shim ready, runtime unavailable \u2014 shim will fall back to npx at fire time");
+  } else {
+    console.log("  Launcher: npx (shim unavailable \u2014 works, ~0.9s slower per hook)");
+  }
   const { count } = installHooks(projectRoot);
   console.log(`  Installed ${count} hooks in .claude/settings.local.json`);
   console.log("");

package/dist/hooks/auto-learning-pipeline.js

@@ -1187,6 +1187,12 @@ import { join as join2 } from "path";
 function resolveDbEngine() {
   return process.env[DB_ENGINE_ENV] === "better-sqlite3" ? "better-sqlite3" : DEFAULT_DB_ENGINE;
 }
+function resolveBusyTimeoutMs() {
+  const raw = process.env[DB_BUSY_TIMEOUT_ENV];
+  if (raw === void 0 || raw === "") return DEFAULT_BUSY_TIMEOUT_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : DEFAULT_BUSY_TIMEOUT_MS;
+}
 function nodeSqliteCtor() {
   if (!_nodeCtor) _nodeCtor = req2("node:sqlite").DatabaseSync;
   return _nodeCtor;
@@ -1208,6 +1214,7 @@ function openNodeSqlite(dbPath, opts) {
     enableForeignKeyConstraints: true,
     allowExtension: false
   });
+  raw.exec(`PRAGMA busy_timeout = ${resolveBusyTimeoutMs()}`);
   let savepointSeq = 0;
   const wrapStmt = (sql) => {
     const st = raw.prepare(sql);
@@ -1291,12 +1298,14 @@ function openNodeSqlite(dbPath, opts) {
   return handle;
 }
 function openBetterSqlite3(dbPath, opts) {
-  return openDatabase(dbPath, opts);
+  const db = openDatabase(dbPath, opts);
+  db.exec(`PRAGMA busy_timeout = ${resolveBusyTimeoutMs()}`);
+  return db;
 }
 function openDatabase2(dbPath, opts = {}) {
   return resolveDbEngine() === "better-sqlite3" ? openBetterSqlite3(dbPath, opts) : openNodeSqlite(dbPath, opts);
 }
-var req2, DEFAULT_DB_ENGINE, DB_ENGINE_ENV, _nodeCtor;
+var req2, DEFAULT_DB_ENGINE, DB_ENGINE_ENV, DEFAULT_BUSY_TIMEOUT_MS, DB_BUSY_TIMEOUT_ENV, _nodeCtor;
 var init_db_driver = __esm({
   "src/db-driver.ts"() {
     "use strict";
@@ -1305,6 +1314,8 @@ var init_db_driver = __esm({
     req2 = createRequire2(import.meta.url);
     DEFAULT_DB_ENGINE = "node-sqlite";
     DB_ENGINE_ENV = "MASSU_DB_ENGINE";
+    DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+    DB_BUSY_TIMEOUT_ENV = "MASSU_DB_BUSY_TIMEOUT_MS";
     _nodeCtor = null;
   }
 });
@@ -4132,3 +4143,6 @@ function readStdin() {
   });
 }
 main();
+export {
+  MAX_FULL_DIFF_BYTES
+};

package/dist/hooks/classify-failure.js

@@ -1187,6 +1187,12 @@ import { join as join2 } from "path";
 function resolveDbEngine() {
   return process.env[DB_ENGINE_ENV] === "better-sqlite3" ? "better-sqlite3" : DEFAULT_DB_ENGINE;
 }
+function resolveBusyTimeoutMs() {
+  const raw = process.env[DB_BUSY_TIMEOUT_ENV];
+  if (raw === void 0 || raw === "") return DEFAULT_BUSY_TIMEOUT_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : DEFAULT_BUSY_TIMEOUT_MS;
+}
 function nodeSqliteCtor() {
   if (!_nodeCtor) _nodeCtor = req2("node:sqlite").DatabaseSync;
   return _nodeCtor;
@@ -1208,6 +1214,7 @@ function openNodeSqlite(dbPath, opts) {
     enableForeignKeyConstraints: true,
     allowExtension: false
   });
+  raw.exec(`PRAGMA busy_timeout = ${resolveBusyTimeoutMs()}`);
   let savepointSeq = 0;
   const wrapStmt = (sql) => {
     const st = raw.prepare(sql);
@@ -1291,12 +1298,14 @@ function openNodeSqlite(dbPath, opts) {
   return handle;
 }
 function openBetterSqlite3(dbPath, opts) {
-  return openDatabase(dbPath, opts);
+  const db = openDatabase(dbPath, opts);
+  db.exec(`PRAGMA busy_timeout = ${resolveBusyTimeoutMs()}`);
+  return db;
 }
 function openDatabase2(dbPath, opts = {}) {
   return resolveDbEngine() === "better-sqlite3" ? openBetterSqlite3(dbPath, opts) : openNodeSqlite(dbPath, opts);
 }
-var req2, DEFAULT_DB_ENGINE, DB_ENGINE_ENV, _nodeCtor;
+var req2, DEFAULT_DB_ENGINE, DB_ENGINE_ENV, DEFAULT_BUSY_TIMEOUT_MS, DB_BUSY_TIMEOUT_ENV, _nodeCtor;
 var init_db_driver = __esm({
   "src/db-driver.ts"() {
     "use strict";
@@ -1305,6 +1314,8 @@ var init_db_driver = __esm({
     req2 = createRequire2(import.meta.url);
     DEFAULT_DB_ENGINE = "node-sqlite";
     DB_ENGINE_ENV = "MASSU_DB_ENGINE";
+    DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+    DB_BUSY_TIMEOUT_ENV = "MASSU_DB_BUSY_TIMEOUT_MS";
     _nodeCtor = null;
   }
 });