linksee-memory 0.8.0 → 0.11.0

package/dist/bin/guard-hook.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/guard-hook.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// linksee-memory-guard — Claude Code hook adapter for the re-injection layer.
+//
+// Reads a hook event JSON from stdin and emits hook-control JSON to stdout:
+//   • PreToolUse  (matcher Edit|Write|Bash) → gateAction → block (hard) / soft-inject (warn|inform)
+//   • SessionStart (startup|resume|compact)  → buildBootDigest → additionalContext
+//
+// FAIL-OPEN by construction: any parse/DB/logic error → NO output, exit 0 → the tool/session proceeds
+// unblocked. The ONLY thing that ever blocks is an explicit `gate_mode:'hard'` contradiction. This is
+// intentional — a guard that breaks the user's workflow on its own bug is a footgun.
+//
+// Wire it (project or ~/.claude/settings.json), exec form so Windows .cmd shims are bypassed:
+//   { "hooks": { "PreToolUse": [ { "matcher": "Edit|Write|Bash",
+//       "hooks": [ { "type": "command", "command": "node",
+//                    "args": ["${CLAUDE_PROJECT_DIR}/dist/bin/guard-hook.js"], "timeout": 8 } ] } ] } }
+import { pathToFileURL } from 'node:url';
+import { openDb, runMigrations } from '../db/migrate.js';
+import { gateAction, buildBootDigest } from '../lib/guard.js';
+function readStdin() {
+    return new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on('data', (c) => chunks.push(c));
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        process.stdin.on('error', () => resolve(''));
+    });
+}
+function emit(obj) {
+    process.stdout.write(JSON.stringify(obj));
+}
+async function main() {
+    let ev;
+    try {
+        ev = JSON.parse(await readStdin());
+    }
+    catch {
+        process.exit(0); // unparseable stdin → fail-open
+    }
+    if (!ev || typeof ev !== 'object')
+        process.exit(0);
+    let db;
+    try {
+        db = openDb();
+        db.pragma('busy_timeout = 2000'); // MCP server may hold a write lock; wait briefly, else fail-open
+        runMigrations(db); // ensures injection_log exists even when run standalone
+    }
+    catch {
+        process.exit(0); // can't open DB → never block
+    }
+    try {
+        if (ev.hook_event_name === 'PreToolUse') {
+            const ti = (ev.tool_input ?? {});
+            const r = gateAction(db, {
+                tool: ev.tool_name,
+                file_path: ti.file_path,
+                command: ti.command,
+                content: ti.content,
+                diff: ti.new_string ?? ti.diff, // Edit passes new_string; some tools pass diff
+            }, { sessionId: ev.session_id });
+            if (r.gate === 'block') {
+                emit({
+                    hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        permissionDecision: 'deny',
+                        permissionDecisionReason: r.reinject,
+                    },
+                });
+            }
+            else if (r.gate === 'warn' || r.gate === 'inform') {
+                emit({
+                    hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: r.reinject },
+                });
+            }
+            // 'allow' → emit nothing
+        }
+        else if (ev.hook_event_name === 'SessionStart') {
+            const d = buildBootDigest(db);
+            if (d.text) {
+                emit({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: d.text } });
+            }
+        }
+    }
+    catch {
+        /* fail-open: surface nothing rather than risk blocking on a guard bug */
+    }
+    try {
+        db.close();
+    }
+    catch {
+        /* ignore */
+    }
+    process.exit(0);
+}
+const invoked = !!process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invoked)
+    main();
+//# sourceMappingURL=guard-hook.js.map

package/dist/bin/import-sessions.js

@@ -42,13 +42,33 @@ function collectJsonlFiles(projectDir) {
 }
 // Idempotent wipe: remove all rows tied to a given session_id BEFORE re-inserting.
 // Uses LIKE matching on the JSON-encoded source field for memories/events.
+// DISTILLED memories survive the wipe: a session stays ACTIVE while its raw extractions
+// get distilled (dream → remember(memory_id) rewrite), and the next Stop-hook re-import
+// must not destroy that human/agent-curated rewrite and resurrect the raw utterance.
 function wipeSession(db, sessionId) {
     const sidNeedle = `%"session_id":"${sessionId}"%`;
     const editDel = db.prepare('DELETE FROM session_file_edits WHERE session_id = ?').run(sessionId);
-    const memDel = db.prepare('DELETE FROM memories WHERE source LIKE ?').run(sidNeedle);
+    const memDel = db.prepare(`DELETE FROM memories WHERE source LIKE ?
+       AND (NOT json_valid(content) OR COALESCE(json_extract(content, '$.distilled'), 0) != 1)`).run(sidNeedle);
     const evtDel = db.prepare('DELETE FROM events WHERE payload LIKE ?').run(sidNeedle);
     return { memories: memDel.changes, edits: editDel.changes, events: evtDel.changes };
 }
+// A re-extracted memory must NOT be re-inserted if its source turn already has a surviving
+// distilled rewrite (matched by turn_uuid — the stable key shared by raw and rewrite).
+function makeDistilledTurnSet(db, sessionId) {
+    const rows = db.prepare(`SELECT source FROM memories
+      WHERE source LIKE ? AND json_valid(content) AND json_extract(content, '$.distilled') = 1`).all(`%"session_id":"${sessionId}"%`);
+    const set = new Set();
+    for (const r of rows) {
+        try {
+            const uuid = JSON.parse(r.source)?.turn_uuid;
+            if (uuid)
+                set.add(String(uuid));
+        }
+        catch { /* ignore malformed source */ }
+    }
+    return set;
+}
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes('-h') || args.includes('--help')) {
@@ -86,7 +106,10 @@ async function main() {
         if (!db)
             return;
         // Idempotent: wipe any prior data for THIS session before re-inserting
+        // (distilled rewrites survive — see wipeSession), then skip re-extracting
+        // any turn that already has a distilled rewrite.
         const wiped = wipeSession(db, result.session_id);
+        const distilledTurns = makeDistilledTurnSet(db, result.session_id);
         // Resolve project entity (canonical_key = project:<name>, so same project across
         // different sessions/cwds collapses to one entity)
         let projectEntityId;
@@ -102,14 +125,19 @@ async function main() {
             const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
             projectEntityId = Number(ins.lastInsertRowid);
         }
-        const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id) VALUES (?, ?, ?, ?, ?, ?)');
+        // created_at = the source turn's true timestamp. The Stop hook re-imports the growing
+        // transcript every turn (wipe+reinsert), and DEFAULT unixepoch() restamped days-old
+        // content as "now" — inflating every time-windowed view ("today" showed last week).
+        const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
         const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
         const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
         let inserted = { memories: 0, edits: 0 };
         db.transaction(() => {
             const memContentToId = new Map();
             for (const m of result.memories) {
-                const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, JSON.stringify(m.source), m.thread_id ?? null);
+                if (m.source.turn_uuid && distilledTurns.has(m.source.turn_uuid))
+                    continue; // distilled rewrite wins
+                const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, JSON.stringify(m.source), m.thread_id ?? null, m.occurred_at ?? Math.floor(Date.now() / 1000));
                 memContentToId.set(m.content, Number(res.lastInsertRowid));
                 inserted.memories++;
             }
@@ -221,17 +249,22 @@ async function main() {
                 const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
                 projectEntityId = Number(ins.lastInsertRowid);
             }
-            // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B)
+            // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B).
+            // Distilled rewrites survive the wipe and suppress re-insertion of their raw turn.
             wipeSession(db, result.session_id);
-            // Insert memories + file_edits in a single transaction per session
-            const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id) VALUES (?, ?, ?, ?, ?, ?)');
+            const distilledTurns = makeDistilledTurnSet(db, result.session_id);
+            // Insert memories + file_edits in a single transaction per session.
+            // created_at = source-turn timestamp (see single-file mode above for why).
+            const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
             const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
             const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
             const tx = db.transaction(() => {
                 const memContentToId = new Map();
                 for (const m of result.memories) {
+                    if (m.source.turn_uuid && distilledTurns.has(m.source.turn_uuid))
+                        continue; // distilled rewrite wins
                     const srcJson = JSON.stringify(m.source);
-                    const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, srcJson, m.thread_id ?? null);
+                    const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, srcJson, m.thread_id ?? null, m.occurred_at ?? Math.floor(Date.now() / 1000));
                     memContentToId.set(m.content, Number(res.lastInsertRowid));
                     agg.memories_inserted++;
                 }

package/dist/bin/map-import.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};