@pcircle/memesh 4.5.0 → 4.5.1

package/scripts/hooks/post-commit.js

@@ -1,13 +1,19 @@
 #!/usr/bin/env node
 
 import { execFileSync } from 'child_process';
-import { captureEntity, getProjectName, openHookDb } from './_shared.js';
+import { AUTO_CAPTURE_TAG, captureEntity, getProjectName, isAutoCaptureEnabled, openHookDb, recordHookRun } from './_shared.js';
 
 let input = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { input += chunk; });
 process.stdin.on('end', () => {
   try {
+    // Opt-out check (env > config > default-on). This hook skipped it for
+    // years while its two siblings honoured it — with capture disabled it
+    // kept writing commit entities AND stamping the heartbeat, which made
+    // doctor's "capture is off, hook silence is expected" message false.
+    if (!isAutoCaptureEnabled(process.env)) return exit0();
+
     const data = JSON.parse(input);
 
     // tool_name absent is a schema-flip signal (Claude Code has done
@@ -50,6 +56,20 @@ process.stdin.on('end', () => {
     const commitMatch = toolOutput.match(/\[[\w/.-]+(?: \([\w -]+\))? ([a-f0-9]{7,})\] (.+)/);
     if (!commitMatch) return exit0();
 
+    // The OUTPUT looking like a commit is not evidence that a commit happened.
+    // This hook stopped at the regex above, so any Bash output containing a
+    // commit-shaped line produced a permanent memory. Measured: a payload whose
+    // command was `cat docs/release-notes.md` wrote entity `commit-9f3c2a1`
+    // for a hash `git cat-file -t` rejects as "Not a valid object name".
+    // Reading a changelog, tailing a build log, or quoting a commit line was
+    // enough — and the fake then surfaced through session-start and
+    // pre-edit-recall as if it had happened.
+    const issuedCommand = typeof data.tool_input?.command === 'string' ? data.tool_input.command : '';
+    if (!/\bgit\b[^|;&]*\bcommit\b/.test(issuedCommand)) {
+      try { process.stderr.write(`[memesh post-commit] output looks like a commit but the command was not a git commit; skipping ${commitMatch[1]}\n`); } catch {}
+      return exit0();
+    }
+
     const branchMatch = commitMatch[0].match(/^\[([^\s]+)\s/);
     const branch = branchMatch ? branchMatch[1] : 'unknown';
 
@@ -66,17 +86,28 @@ process.stdin.on('end', () => {
       try { process.stderr.write(`[memesh post-commit] data.cwd absent — cannot resolve project / repo; skipping commit ${commitHash}\n`); } catch {}
       return exit0();
     }
+    // And the commit has to actually be in THIS repository.
+    //
+    // `cat-file -e <hash>^{commit}` answers exactly one question — does this
+    // resolve to a commit object here — in milliseconds, before anything is
+    // written. Deliberately separate from the `git show` below, whose failure
+    // (git absent, timeout on a huge diff) says nothing about the commit and
+    // must NOT veto.
+    try {
+      execFileSync('git', ['-C', data.cwd, 'cat-file', '-e', `${commitHash}^{commit}`], {
+        timeout: 5000,
+        stdio: ['ignore', 'ignore', 'pipe'],
+      });
+    } catch {
+      try { process.stderr.write(`[memesh post-commit] ${commitHash} is not a commit in ${data.cwd}; nothing written\n`); } catch {}
+      return exit0();
+    }
+
     const projectName = getProjectName(data.cwd);
 
     // Open DB via shared helper — applies SCHEMA_SQL + status migration.
     // Pass fts:true so the FTS5 entity-search index is also available.
-    // Returns null when the better-sqlite3 native module is unavailable
-    // (e.g. plugin-marketplace cache install with no node_modules); in
-    // that case silently skip — a sibling registered hook copy with
-    // proper deps still records the commit.
-    const handle = openHookDb(process.env, { fts: true });
-    if (!handle) return;
-    const { db } = handle;
+    const { db } = openHookDb(process.env, { fts: true });
     try {
       const entityName = `commit-${commitHash}`;
 
@@ -103,12 +134,23 @@ process.stdin.on('end', () => {
       }
 
       // Shared write dance — upsert entity + observations + tags AND reindex FTS.
-      captureEntity(db, {
+      //
+      // `source:auto-capture` is the provenance marker every capture hook
+      // writes (session-summary, pre-compact and the extractor already did;
+      // this one did not). `memesh doctor` counts it to answer "is the
+      // auto-capture loop alive" — a question it used to answer from entity
+      // TYPE, which a hand-typed `memesh learn` satisfied all by itself.
+      const written = captureEntity(db, {
         name: entityName,
         type: 'commit',
         observations,
-        tags: [`project:${projectName}`],
+        tags: [AUTO_CAPTURE_TAG, `project:${projectName}`],
       });
+
+      // Heartbeat AFTER capture, so the stamp certifies "the capture loop
+      // completed", not "a database handle existed". A throw above skips it,
+      // and so does a null return (the write did not land).
+      if (written) recordHookRun(db, 'post-commit');
     } finally {
       db.close();
     }

package/scripts/hooks/pre-compact.js

@@ -2,7 +2,7 @@
 
 import { basename } from 'path';
 import { existsSync, readFileSync } from 'fs';
-import { captureEntity, getProjectName, isAutoCaptureEnabled, openHookDb } from './_shared.js';
+import { AUTO_CAPTURE_TAG, captureEntity, getProjectName, isAutoCaptureEnabled, openHookDb, recordHookRun } from './_shared.js';
 
 // Timeout guard: always exit within 10 seconds
 const TIMEOUT_MS = 10000;
@@ -101,11 +101,7 @@ process.stdin.on('end', () => {
 
     // Open DB via shared helper — applies SCHEMA_SQL + status migration.
     // FTS5 needed for the entity-search index updates below.
-    // Returns null on plugin-marketplace cache installs without node_modules;
-    // silently skip in that case (sibling registered copy handles it).
-    const handle = openHookDb(process.env, { fts: true });
-    if (!handle) return;
-    const { db } = handle;
+    const { db } = openHookDb(process.env, { fts: true });
     let written = null;
     try {
       // Shared write dance — upsert entity + observations + tags AND reindex FTS
@@ -114,8 +110,15 @@ process.stdin.on('end', () => {
         name: entityName,
         type: 'session-summary',
         observations: obsLines,
-        tags: ['source:auto-capture', 'urgency:pre-compact', `project:${projectName}`],
+        tags: [AUTO_CAPTURE_TAG, 'urgency:pre-compact', `project:${projectName}`],
       });
+
+      // Heartbeat AFTER capture, so the stamp certifies "the capture loop
+      // completed", not "a database handle existed". A throw above skips it,
+      // and so does a null return — captureEntity's null means the write did
+      // not land, and this very hook tells the user "could not save" below;
+      // stamping would say "alive" to doctor about the same failed run.
+      if (written) recordHookRun(db, 'pre-compact');
     } finally {
       db.close();
     }

package/scripts/hooks/pre-edit-recall.js

@@ -13,10 +13,10 @@ import {
   getMemeshDirFromDbPath,
   getProjectName,
   isTrustedForAutoContext,
-  tryRequireBetterSqlite,
   writePrivateJson,
   hookMatchExpression,
 } from './_shared.js';
+import { MemeshDatabase } from './_generated/sqlite.js';
 
 const dbPath = getDbPath();
 const memeshDir = getMemeshDirFromDbPath();
@@ -64,13 +64,9 @@ process.stdin.on('end', () => {
 
     if (!existsSync(dbPath)) return pass();
 
-    // tryRequireBetterSqlite() returns null on plugin-marketplace cache
-    // installs that ship without node_modules; pass-through silently in
-    // that case so a sibling registered hook copy can still inject
-    // recall context.
-    const Database = tryRequireBetterSqlite();
-    if (!Database) return pass();
-    const db = new Database(dbPath, { readonly: true });
+    // `readOnly`, not `readonly`: node:sqlite ignores the lowercase spelling
+    // and hands back a WRITABLE handle. This hook only reads.
+    const db = new MemeshDatabase(dbPath, { readOnly: true });
     try {
 
       // Check if entities table exists

package/scripts/hooks/session-start.js

@@ -5,7 +5,7 @@ import { spawn } from 'child_process';
 import { homedir } from 'os';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { existsSync, readFileSync, unlinkSync, rmSync, appendFileSync, chmodSync } from 'fs';
+import { existsSync, readFileSync, unlinkSync, mkdirSync, accessSync, constants as fsConstants } from 'fs';
 import {
   buildReferenceContext,
   ensurePrivateDir,
@@ -13,14 +13,13 @@ import {
   getMemeshDirFromDbPath,
   getProjectName,
   importFromPluginRoot,
-  isAgenticOrchestrationEnabled,
   isTrustedForAutoContext,
   readUpdateCheckCache,
   resolvePluginRoot,
   resolveSessionLimit,
-  tryRequireBetterSqlite,
   writePrivateJson,
 } from './_shared.js';
+import { MemeshDatabase } from './_generated/sqlite.js';
 
 const require = createRequire(import.meta.url);
 
@@ -44,7 +43,6 @@ try {
 const dbPath = getDbPath();
 const memeshDir = getMemeshDirFromDbPath();
 const throttlePath = join(memeshDir, 'session-recalled-files.json');
-const nudgeFlagsDir = join(memeshDir, 'agent-nudge-flags');
 
 /**
  * Build the strong deprecation warning lines to prepend to the
@@ -430,6 +428,48 @@ function runPostBannerUpdateTasks() {
   }
 }
 
+/**
+ * Can the capture hooks actually write? Returns the offending path, or null.
+ *
+ * Probes the two things a capture hook needs and nothing else: the memesh
+ * directory has to exist and be writable, and where the database file already
+ * exists, that file has to be writable too. The second half matters on its
+ * own — a writable directory holding a read-only database is a state the old
+ * mkdir-only probe called healthy, and it is exactly what a botched `sudo`
+ * leaves behind.
+ *
+ * `accessSync(W_OK)` rather than opening a handle: this is the SessionStart
+ * hot path, and a read-write open would run the whole migration chain here
+ * just to answer a permissions question. It is one syscall and it fails in
+ * the same cases EACCES would.
+ *
+ * Deliberately not detected: a full disk. No cheap probe finds it, and
+ * claiming otherwise would be worse than the honest gap.
+ */
+function captureTargetUnwritable() {
+  try {
+    mkdirSync(memeshDir, { recursive: true });
+    accessSync(memeshDir, fsConstants.W_OK);
+  } catch {
+    return memeshDir;
+  }
+  // The WAL/SHM sidecars are probed too: an interrupted `sudo` run leaves a
+  // user-owned database next to root-owned `-wal`/`-shm` files, and SQLite
+  // then fails every write with EACCES while the db file itself probes
+  // writable — the most common botched-sudo residue, and exactly the state
+  // the db-file probe alone called healthy.
+  for (const suffix of ['', '-wal', '-shm']) {
+    const p = `${dbPath}${suffix}`;
+    if (!existsSync(p)) continue;
+    try {
+      accessSync(p, fsConstants.W_OK);
+    } catch {
+      return p;
+    }
+  }
+  return null;
+}
+
 /**
  * Build a "base message + optional deprecation banner" combined
  * single-line systemMessage payload. Keeps stdout a single JSON
@@ -466,6 +506,14 @@ let input = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { input += chunk; });
 process.stdin.on('end', async () => {
+  // Hoisted above both try blocks: the recall-failure catch below must be
+  // able to lead with this warning too, or a capture-dead session that ALSO
+  // hits a recall error silently drops the more important half of the story.
+  let captureWarning = null;
+  const withCaptureWarning = (msg) => {
+    if (!captureWarning) return msg;
+    return `${captureWarning}\n${msg.replace(/^◉ MeMesh ready · /, '◉ MeMesh · ')}`;
+  };
   try {
     try {
     const data = JSON.parse(input);
@@ -479,38 +527,57 @@ process.stdin.on('end', async () => {
     } catch {
       // Non-critical
     }
-    try {
-      if (existsSync(nudgeFlagsDir)) {
-        rmSync(nudgeFlagsDir, { recursive: true, force: true });
-      }
-    } catch {
-      // Non-critical
-    }
+
+    // Every banner below this line is a PROMISE that memories will be saved,
+    // so check that it can be kept before making any of them.
+    //
+    // This probe used to live INSIDE the `!existsSync(dbPath)` branch below,
+    // which meant it only ever ran before the database existed — while the
+    // failure it detects has nothing to do with first runs. A `~/.memesh` that
+    // became unwritable later (permissions changed, a read-only mount, a
+    // directory that changed owner) produced the cheerful green count banner
+    // on every session, forever, while every capture hook failed with EACCES.
+    // Fixing the first-run case and leaving the steady-state case is how a
+    // detector ends up covering the one day the bug is least likely to happen.
+    // The warning does NOT return: this hook's other job is recall, which
+    // opens the database read-only and works fine on an unwritable target.
+    // Returning here turned "capture is off" into "your memory is gone" —
+    // every existing memory silently withheld exactly when the user needs
+    // the context to notice something is wrong. Warn, then keep reading.
+    const unwritable = captureTargetUnwritable();
+    // "ready" is a promise about capture — when the warning is present,
+    // withCaptureWarning (hoisted above) demotes it instead of contradicting
+    // it one line later.
+    captureWarning = unwritable
+      ? `◉ MeMesh cannot write to ${unwritable} — memories will NOT be saved this session (recall still works). Run 'memesh doctor'.`
+      : null;
 
     if (!existsSync(dbPath)) {
       // Combine deprecation banner (if any) into the same
       // systemMessage so stdout stays a single JSON document. Outer
       // finally runs runPostBannerUpdateTasks().
-      output(combineWithBanner('◉ MeMesh ready · no database yet, memories will be created as you work'));
+      // With no database there is nothing to recall either — the warning IS
+      // the whole truth, and "memories will be created as you work" would
+      // contradict it one line later.
+      output(combineWithBanner(captureWarning ?? '◉ MeMesh ready · no database yet, memories will be created as you work'));
       return;
     }
 
-    // Native module unavailable (typical for plugin-marketplace cache
-    // installs that ship without node_modules). Silently skip — the
-    // plugin's own MCP server runs via npx and a sibling registered
-    // copy of this hook (npm-global / dev path) supplies the summary.
-    const Database = tryRequireBetterSqlite();
-    if (!Database) return;
-    const db = new Database(dbPath, { readonly: true });
+    // `readOnly`, not `readonly`: node:sqlite ignores the lowercase spelling
+    // and hands back a WRITABLE handle. This hook only reads.
+    //
+    // No `journal_mode = WAL` here. Setting it is a write, so a read-only
+    // connection refuses it — and it was never doing anything: the mode is a
+    // property of the database file that the writing side already set, and a
+    // reader opens a WAL database perfectly well without asking for it.
+    const db = new MemeshDatabase(dbPath, { readOnly: true });
     try {
-      db.pragma('journal_mode = WAL');
-
       // Check if tables exist (db may exist but be empty)
       const tableCheck = db.prepare(
         "SELECT name FROM sqlite_master WHERE type='table' AND name='entities'"
       ).get();
       if (!tableCheck) {
-        output(combineWithBanner('◉ MeMesh ready · database initialised but no memories stored yet'));
+        output(combineWithBanner(captureWarning ?? '◉ MeMesh ready · database initialised but no memories stored yet'));
         return;
       }
 
@@ -545,11 +612,10 @@ process.stdin.on('end', async () => {
       // Functions:
       //   - frequency: log(c+1) / log(max(maxAccess,1) + 1)  (matches frequencyScore)
       //   - recency:   exp(-(now - lastAccessed_days) / 30)  (matches recencyScore)
-      // SQLite >= 3.35 with -DSQLITE_ENABLE_MATH_FUNCTIONS provides exp/log;
-      // better-sqlite3 v8+ ships with this flag enabled by default. We probe
-      // once per process and fall back to the legacy linear/rational forms
-      // if a stripped-down build is detected, so ranking degrades gracefully
-      // rather than throwing.
+      // SQLite >= 3.35 with -DSQLITE_ENABLE_MATH_FUNCTIONS provides exp/log,
+      // which Node's bundled SQLite has. We probe once per process and fall
+      // back to the legacy linear/rational forms if a stripped-down build is
+      // detected, so ranking degrades gracefully rather than throwing.
       // Test-only seam: force the legacy linear/rational fallback so the
       // pre-math-functions code path is reachable in CI on builds where
       // exp/log ARE available. Production callers never set this.
@@ -842,24 +908,6 @@ process.stdin.on('end', async () => {
         try { process.stderr.write(`[memesh session-start] sessions-write: ${err?.message || err}\n`); } catch {}
       }
 
-      // --- Agentic-orchestration mode (opt-in) ---
-      // Banner kept short. Telemetry write preserved for protocol validation.
-      if (isAgenticOrchestrationEnabled(process.env)) {
-        summary += '\n[AO opt-in: dispatch verifiable work as background agent · skill: agentic-orchestration]';
-        try {
-          const usagePath = join(homedir(), '.memesh', 'skill-usage.jsonl');
-          // Only { ts, event } — an earlier `payload: { cwd_hashed }` was never
-          // read by summariseSkillUsage (counts by event name only), so it was
-          // write-only privacy-adjacent data. Removed.
-          const line = JSON.stringify({
-            ts: new Date().toISOString(),
-            event: 'agentic_orchestration_banner_injected',
-          }) + '\n';
-          appendFileSync(usagePath, line);
-          try { chmodSync(usagePath, 0o600); } catch { /* non-POSIX */ }
-        } catch { /* swallow — telemetry must not break session-start */ }
-      }
-
       // Deprecation banner (security advisory) — surfaced even with the
       // short summary so flagged installs still warn on every session.
       let installedVersion = null;
@@ -889,7 +937,7 @@ process.stdin.on('end', async () => {
         ? [...bannerLines.filter(l => l.length > 0), '', summary].join('\n')
         : summary;
 
-      output(finalMessage, memoryContext);
+      output(withCaptureWarning(finalMessage), memoryContext);
     } finally {
       db.close();
     }
@@ -921,7 +969,7 @@ process.stdin.on('end', async () => {
       // Hooks must never crash Claude Code — but report honestly.
       // Inner catch so the outer finally can still run the post-
       // banner update tasks even when the recall flow blew up.
-      console.log(JSON.stringify({ systemMessage: `MeMesh: memories not loaded this session (${err?.message || 'unknown error'}) — everything else works; run \`memesh doctor\` if this repeats.` }));
+      console.log(JSON.stringify({ systemMessage: withCaptureWarning(`MeMesh: memories not loaded this session (${err?.message || 'unknown error'}) — everything else works; run \`memesh doctor\` if this repeats.`) }));
     }
   } finally {
     // ── Auto-update + cache refresh ──────────────────────────────