@pcircle/memesh 4.9.4 → 4.10.1

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

@@ -26,6 +26,9 @@ import {
   matchingGuards,
   guardWarningLines,
   recordGuardFires,
+  hookErrorReason,
+  SKIP_REASONS,
+  recordHookOutcome,
 } from './_shared.js';
 import { MemeshDatabase } from './_generated/sqlite.js';
 
@@ -35,15 +38,23 @@ const THROTTLE_FILE = join(memeshDir, 'session-recalled-files.json');
 const MAX_RESULTS = 3;
 
 let input = '';
+// See post-commit.js for why every exit path leaves a record (#327).
+let payload = null;
+function record(outcome, reason, entity) {
+  recordHookOutcome(process.env, { hook: 'pre-edit-recall', outcome, reason, entity, payload });
+}
+
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { input += chunk; });
 process.stdin.on('end', () => {
   try {
     const data = JSON.parse(input);
+    payload = data;
     if (!data.tool_input) {
       // Schema-flip signal — Claude Code has renamed `tool_input` for
       // transcript blocks before. Trace so the rename surfaces day-1.
       try { process.stderr.write(`[memesh pre-edit-recall] tool_input absent (keys: ${Object.keys(data).join(',')}); skipping\n`); } catch {}
+      record('skipped', SKIP_REASONS.toolInputAbsent);
       return pass();
     }
     const toolInput = data.tool_input;
@@ -51,6 +62,7 @@ process.stdin.on('end', () => {
 
     // Only process if we have a file path
     if (!filePath || typeof filePath !== 'string') {
+      record('skipped', SKIP_REASONS.noFilePath);
       return pass();
     }
 
@@ -69,7 +81,10 @@ process.stdin.on('end', () => {
     }
     const throttled = seenFiles.includes(fileKey);
 
-    if (!existsSync(dbPath)) return pass();
+    if (!existsSync(dbPath)) {
+      record('skipped', SKIP_REASONS.noDatabaseForRecall);
+      return pass();
+    }
 
     // Get project name from cwd for project-scoped RECALL filtering — this
     // spawns 1-2 git subprocesses, and the throttled path (every repeat
@@ -102,6 +117,7 @@ process.stdin.on('end', () => {
       db.prepare('SELECT 1').get();
     } catch {
       db.close();
+      record('error', 'the database stayed locked past the hook busy timeout');
       return pass();
     }
     let guardMatches = [];
@@ -236,6 +252,7 @@ process.stdin.on('end', () => {
     }
 
     if (guardMatches.length === 0 && recallLines.length === 0) {
+      record('skipped', SKIP_REASONS.nothingToRecall);
       return pass();
     }
 
@@ -257,6 +274,19 @@ process.stdin.on('end', () => {
         additionalContext: buildReferenceContext(lines),
       },
     }));
+    // A recall hook produces an INJECTION, so it records `notified`, not
+    // `wrote`: doctor's `writes` answers "is memory capture still alive",
+    // and recalling a memory is not storing one.
+    //
+    // Not "this hook writes nothing" — it does, and the distinction is the
+    // whole point of the outcome. `recordGuardFires` above issues an
+    // `UPDATE entities SET metadata = json_set(… '$.guard.fires' …)`
+    // (_shared.js), bumping a counter on a memory that already exists. That
+    // is a write to the database and NOT a write of a memory, which is what
+    // `writes` counts. guard-check.js does the same thing for the same
+    // reason. A run of skips here is normal; a long run of them on a machine
+    // that edits files daily is not (#327).
+    record('notified', undefined, `injected:${guardMatches.length}g+${recallLines.length}r`);
   } catch (err) {
     // Never crash Claude Code, but trace — peer hooks (post-commit,
     // pre-compact, session-summary) all stderr-trace their outer
@@ -264,6 +294,7 @@ process.stdin.on('end', () => {
     // would silently break continuous recall on every Edit/Write
     // tool call indefinitely.
     try { process.stderr.write(`[memesh pre-edit-recall] ${err?.message || err}\n`); } catch {}
+    record('error', hookErrorReason(err));
     pass();
   }
 });