@monoes/monomindcli 2.16.0 → 2.16.2

package/.claude/helpers/handlers/edit-handler.cjs

@@ -5,7 +5,7 @@
 
 const path = require('path');
 const fs = require('fs');
-const { claimLock } = require('../utils/fs-helpers.cjs');
+const { claimRebuildLock, startRebuild } = require('../utils/monograph-resolve.cjs');
 
 module.exports = {
   handle: async function(hCtx) {
@@ -102,18 +102,20 @@ module.exports = {
         // check and spawns its own rebuild + ua-enrich child (see the
         // 896-orphan-process incident fixed in control-start.cjs). claimLock
         // mirrors that same TOCTOU-safe stale-lock-breaking pattern.
-        if (claimLock(lockFile, COOLDOWN_MS)) {
+        // #328: the rebuild child now owns the lock (its PID replaces ours)
+        // and removes it when done, so a running rebuild blocks a second one
+        // and a lock left by an exited process is stale after the cooldown.
+        if (claimRebuildLock(lockFile, COOLDOWN_MS, 10 * 60 * 1000)) {
           var { spawn: spawnRebuild } = require('child_process');
-          var rebuildScript = "import { buildAsync } from '@monoes/monograph'; await buildAsync(" + JSON.stringify(CWD) + ");";
-          var graphDir = path.join(CWD, '.monomind', 'graph');
-          var logPath = path.join(graphDir, 'build.log');
-          var logFd;
-          try { logFd = fs.openSync(logPath, 'a'); } catch(e) { logFd = 'ignore'; }
-          var child = spawnRebuild(process.execPath, ['--input-type=module', '--eval', rebuildScript], {
-            detached: true, stdio: ['ignore', logFd, logFd], cwd: CWD,
-          });
-          child.unref();
-          console.log('[MONOGRAPH] Incremental rebuild triggered for ' + path.basename(editedFile2));
+          // Resolves @monoes/monograph to an absolute path (project, global
+          // npm, npx cache) and imports it by file URL — a bare-specifier
+          // import only finds a project-local install. Falls back to
+          // `monomind monograph build`; with neither, it records one deduped
+          // failure line instead of an ERR_MODULE_NOT_FOUND per edit.
+          var rebuild = startRebuild(CWD, { lockPath: lockFile });
+          if (rebuild.mode !== 'none') {
+            console.log('[MONOGRAPH] Incremental rebuild triggered for ' + path.basename(editedFile2));
+          }
 
           // Option C: fire ua-enrich.mjs in background after monograph rebuild
           var uaEnrichScript = path.join(CWD, 'scripts', 'ua-enrich.mjs');

package/.claude/helpers/handlers/route-handler.cjs

@@ -77,6 +77,17 @@ function _loadJevPicker() {
   return _jevPicker;
 }
 
+// hook-handler.cjs force-exits every hook at this deadline. A configured Jev
+// may hold the route hook for its whole window, so that hook gets the window
+// plus 1.5 s to persist its route; without Jev it keeps the 5 s exit.
+var HOOK_EXIT_MS = 5000;
+function routeDeadlineMs(env) {
+  env = env || process.env;
+  var jp = _loadJevPicker();
+  if (!jp || jp.resolveProviders(env).length === 0) return HOOK_EXIT_MS;
+  return Math.max(HOOK_EXIT_MS, jp.resolveHookTimeoutMs(env) + 1500);
+}
+
 var JEV_BREAKER_MS = 5 * 60 * 1000;
 function _jevBreakerPath(CWD) { return path.join(CWD, '.monomind', 'jev-breaker.json'); }
 function _jevBreakerOpen(CWD) {
@@ -136,6 +147,7 @@ function _applyJevPick(result, jev) {
 
 
 module.exports = {
+  routeDeadlineMs: routeDeadlineMs,
   handle: async function(hCtx) {
     var hookStart = Date.now();
     var prompt = hCtx.prompt;
@@ -283,9 +295,10 @@ module.exports = {
       // This ENHANCES the keyword route — it only overrides when the
       // embedding match is meaningfully more confident, and never blocks or
       // delays routing beyond a 2s budget (fails silently otherwise).
-      // A slow or failed Jev attempt may already have spent most of the 5 s
-      // hook exit, so the budget shrinks to keep the route persist below in time.
-      var intelBudgetMs = Math.min(2000, Math.max(0, 4500 - (Date.now() - hookStart)));
+      // A slow or failed Jev attempt may already have spent most of the time
+      // before the hook exit, so the budget shrinks to keep the route persist
+      // below in time (500 ms before routeDeadlineMs).
+      var intelBudgetMs = Math.min(2000, Math.max(0, routeDeadlineMs(process.env) - 500 - (Date.now() - hookStart)));
       if (result.routingMethod !== 'jev' && intelBudgetMs > 0) try {
         var intelResult = await Promise.race([
           (async function() {
@@ -965,6 +978,12 @@ module.exports = {
             advisoryLog('[MONOGRAPH] ' + nodeCount + ' nodes. Call mcp__monomind__monograph_suggest to find relevant files.');
             hCtx._recordGraphTelemetry('preresolve_miss');
           }
+        } else if (!hintDb || nodeCount > 100) {
+          // #328: the gate and these hints switch off when the hooks can't
+          // open the graph or it is past the 50-commit limit. Say so once per
+          // cause (not per prompt), even under MONOMIND_HOOK_QUIET.
+          var offNotice = require('../utils/monograph-resolve.cjs').graphOffNoticeOnce(CWD, hintDb || null);
+          if (offNotice) console.log(offNotice);
         }
       } catch(e) {}
 

package/.claude/helpers/hook-handler.cjs

@@ -239,10 +239,23 @@ async function readStdin() {
   });
 }
 
+// Every hook force-exits after 5 s, except the route hook while a Jev decision
+// model is configured: it may wait out the Jev window (route-handler.cjs
+// routeDeadlineMs). The security gates never load the route handler.
+function safetyTimeoutMs(cmd, env) {
+  if (cmd !== 'route') return 5000;
+  try {
+    return require('./handlers/route-handler.cjs').routeDeadlineMs(env || process.env);
+  } catch (e) {
+    return 5000;
+  }
+}
+
 async function main() {
   // Global safety timeout: hooks must NEVER hang (#1530, #1531)
+  var safetyMs = safetyTimeoutMs(command);
   var safetyTimer = setTimeout(function() {
-    process.stderr.write("[WARN] Hook handler global timeout (5s), forcing exit\n");
+    process.stderr.write("[WARN] Hook handler global timeout (" + (safetyMs / 1000) + "s), forcing exit\n");
     // If a security gate was still pending when the timer fired, the operation
     // was never evaluated — fail CLOSED rather than letting a hang act as an
     // allow. (`_securityGateCompleted` is `var`-hoisted, so it reads as
@@ -256,7 +269,7 @@ async function main() {
       process.exit(2);
     }
     process.exit(0);
-  }, 5000);
+  }, safetyMs);
   safetyTimer.unref();
 
   let stdinData = '';
@@ -940,6 +953,8 @@ if (command && handlers[command]) {
   }
 }
 
+module.exports = { safetyTimeoutMs: safetyTimeoutMs };
+
 // Only run when executed directly (every real hook event spawns this file as a
 // process). A require() — e.g. from tests verifying it loads — must not exit.
 if (require.main === module) {

package/.claude/helpers/jev-picker.cjs

@@ -33,7 +33,7 @@ var NONE_ID = '__none__';
 var OFF_VALUES = ['0', 'off', 'false', 'no'];
 var ON_VALUES = ['1', 'on', 'true', 'yes'];
 var DEFAULT_HOOK_TIMEOUT_MS = 1500;
-var MAX_HOOK_TIMEOUT_MS = 4000;
+var MAX_HOOK_TIMEOUT_MS = 10000;
 
 class JevError extends Error {
   constructor(message, provider, status) {

package/.claude/helpers/monograph-freshen.cjs

@@ -5,91 +5,38 @@
 if (String(process.env.MONOMIND_SDK_AGENT || '') === '1') process.exit(0);
 const path = require('path');
 const fs = require('fs');
-const { spawn } = require('child_process');
-const { pathToFileURL } = require('url');
-const { claimLock } = require('./utils/fs-helpers.cjs');
+const mg = require('./utils/monograph-resolve.cjs');
 
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const graphDir = path.join(projectDir, '.monomind', 'graph');
 fs.mkdirSync(graphDir, { recursive: true });
+const quiet = String(process.env.MONOMIND_HOOK_QUIET || '') === '1';
 
-const logPath = path.join(graphDir, 'build.log');
-let logFd;
-try { logFd = fs.openSync(logPath, 'a'); } catch { logFd = 'ignore'; }
-
-// Resolve the monograph entry point — searches several common layouts
-function resolveMonographEntry(dir) {
-  // pnpm virtual store — the reliable pre-built copy not affected by workspace symlinks
-  const pnpmStore = (() => {
-    try {
-      const storeBase = path.join(dir, 'node_modules', '.pnpm');
-      if (!fs.existsSync(storeBase)) return null;
-      const entries = fs.readdirSync(storeBase).filter(e => e.startsWith('@monoes+monograph@'));
-      for (const e of entries.sort().reverse()) { // newest version first
-        const p = path.join(storeBase, e, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js');
-        if (fs.existsSync(p)) return p;
-      }
-    } catch {}
-    return null;
-  })();
-
-  const candidates = [
-    // Monorepo workspace build FIRST — it carries unpublished fixes; the pnpm store
-    // holds registry tarballs that can lag behind the workspace source.
-    path.join(dir, 'packages', '@monomind', 'monograph', 'dist', 'src', 'index.js'),
-    // Installed as a flat dependency (follows workspace symlinks when linked)
-    path.join(dir, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js'),
-    path.join(dir, 'node_modules', '@monomind', 'monograph', 'dist', 'src', 'index.js'),
-    // Monorepo: monomind root is the monograph package
-    path.join(dir, 'dist', 'src', 'index.js'),
-    // pnpm store registry copy
-    pnpmStore,
-  ].filter(Boolean);
-  for (const c of candidates) {
-    if (fs.existsSync(c)) return c;
+// Same resolution as the post-edit rebuild and every other hook consumer:
+// project install, global npm root, then the copy bundled with the monomind
+// CLI in the npx cache (#328).
+const resolved = mg.resolveMonographEntry(projectDir);
+const native = resolved ? mg.checkNative(resolved, projectDir) : null;
+const canRebuild = resolved ? native.ok : !!mg.findMonomindBin(projectDir);
+if (!canRebuild) {
+  if (!resolved) {
+    mg.recordRebuildFailure(projectDir, 'unresolvable',
+      '@monoes/monograph not found in the project, the global npm root or the npx cache', mg.GLOBAL_FIX);
+  } else {
+    mg.recordRebuildFailure(projectDir, 'native', 'better-sqlite3 failed to load: ' + native.error, native.fix);
   }
-
-  // Global npm / homebrew install of @monomind/cli (most common for npx/global users).
-  // Resolved lazily — shells out to `npm root -g` (~65ms) — so that cost is only paid
-  // when none of the faster candidates above matched.
-  try {
-    const { execSync } = require('child_process');
-    const globalRoot = execSync('npm root -g', { encoding: 'utf-8', timeout: 5000 }).trim();
-    const p = path.join(globalRoot, '@monoes', 'monograph', 'dist', 'src', 'index.js');
-    if (fs.existsSync(p)) return p;
-  } catch {}
-
-  return null;
-}
-
-const entryPoint = resolveMonographEntry(projectDir);
-if (!entryPoint) {
-  console.error('[graph] @monoes/monograph not found — skipping build');
+  // SessionStart stdout reaches the session; stderr of this hook does not.
+  const warning = mg.sessionWarning(mg.diagnose(projectDir));
+  if (warning) console.log(warning);
+  else if (!resolved) console.error('[graph] @monoes/monograph not found — skipping build');
   process.exit(0);
 }
 
 // Skip if index is already fresh — don't waste CPU on every session start
 const dbPath = path.join(projectDir, '.monomind', 'monograph.db');
-if (fs.existsSync(dbPath)) {
-  try {
-    const Database = require(require.resolve('better-sqlite3', { paths: [path.dirname(entryPoint)] }));
-    const db = new Database(dbPath, { readonly: true, timeout: 5000 });
-    try {
-      const row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get();
-      if (row && row.value && /^[0-9a-f]{7,40}$/i.test(row.value)) {
-        const { execFileSync } = require('child_process');
-        const out = execFileSync('git', ['rev-list', '--count', row.value + '..HEAD'], {
-          cwd: projectDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-        const behind = parseInt(out, 10);
-        if (behind === 0) {
-          if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[graph] index is fresh — skipping rebuild');
-          db.close();
-          process.exit(0);
-        }
-      }
-    } finally { try { db.close(); } catch {} }
-  } catch { /* can't check — proceed with build */ }
+if (fs.existsSync(dbPath) && mg.commitsBehind(projectDir, mg.readIndexedCommit(dbPath)) === 0) {
+  if (!quiet) console.log('[graph] index is fresh — skipping rebuild');
+  process.exit(0);
 }
 
 // Skip if another build is already in progress (avoids SQLite BUSY on concurrent init + session-start)
@@ -99,51 +46,22 @@ if (fs.existsSync(dbPath)) {
 // both pass the check and both spawn a detached rebuild child. claimLock
 // uses the same TOCTOU-safe stale-lock-break (atomic rename-to-claim) as
 // control-start.cjs's spawn lock (see P2-25) — a lock older than 5 minutes
-// is treated as abandoned and safely reclaimed.
+// is treated as abandoned and safely reclaimed, and so is one whose build
+// process has exited.
 const lockPath = path.join(graphDir, 'build.lock');
-if (!claimLock(lockPath, 5 * 60 * 1000)) {
-  if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[graph] build already in progress — skipping');
+if (!mg.claimRebuildLock(lockPath, 0, 5 * 60 * 1000)) {
+  if (!quiet) console.log('[graph] build already in progress — skipping');
   process.exit(0);
 }
 
-// Spawn a detached node process to run buildAsync from @monoes/monograph (ESM).
-// After the build, VACUUM the DB if it has >50% bloat (reclaim space from
-// delete/insert churn; opens are ~5x faster on a tight DB).
-const dbPathStr = JSON.stringify(path.join(projectDir, '.monomind', 'monograph.db'));
-const script = `
-import { buildAsync } from ${JSON.stringify(pathToFileURL(entryPoint).href)};
-import { unlinkSync, statSync } from 'fs';
-import { execFileSync } from 'child_process';
-try {
-  await buildAsync(${JSON.stringify(projectDir)});
-  // Vacuum if bloat ratio is high — keeps openDb fast over time.
-  try {
-    const dbPath = ${dbPathStr};
-    const fileMB = statSync(dbPath).size / 1024 / 1024;
-    // execFileSync with array argv — no shell involved, so a project
-    // directory name containing '"' or '$(...)' cannot break out and
-    // execute arbitrary commands (P3-8).
-    const liveMB = parseInt(
-      execFileSync('sqlite3', [dbPath, 'SELECT SUM(pgsize)/1024/1024 FROM dbstat;'],
-        { encoding: 'utf-8', timeout: 30000 }).trim(), 10);
-    if (fileMB > 100 && liveMB / fileMB < 0.5) {
-      execFileSync('sqlite3', [dbPath, 'VACUUM;'], { timeout: 120000 });
-    }
-  } catch (_) {}
-} finally {
-  try { unlinkSync(${JSON.stringify(lockPath)}); } catch {}
-  try { unlinkSync(${JSON.stringify(path.join(graphDir, 'build.pid'))}); } catch {}
-}`;
-const child = spawn(process.execPath, ['--input-type=module', '--eval', script], {
-  detached: true,
-  stdio: ['ignore', logFd, logFd],
-  cwd: projectDir,
-});
-child.unref();
+// Detached rebuild; after the build, VACUUM the DB if it has >50% bloat
+// (reclaim space from delete/insert churn; opens are ~5x faster on a tight DB).
+const pidPath = path.join(graphDir, 'build.pid');
+const started = mg.startRebuild(projectDir, { resolved, lockPath, cleanup: [pidPath], vacuum: true });
 
 // Track PID so control-stop.cjs can kill it on session exit
 try {
-  fs.writeFileSync(path.join(graphDir, 'build.pid'), String(child.pid), 'utf-8');
+  if (started.pid) fs.writeFileSync(pidPath, String(started.pid), 'utf-8');
 } catch { /* best-effort */ }
 
-if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[graph] background build started for ' + projectDir);
+if (!quiet) console.log('[graph] background build started for ' + projectDir);