linksee-memory 0.8.0 → 0.10.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

@@ -16,10 +16,10 @@ import { extractSession } from '../lib/session-extractor.js';
 import { normalizeEntityName } from '../lib/normalize.js';
 const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
 function usage() {
-    console.log(`Usage:
-  node dist/bin/import-sessions.js [--dry-run] [--all | <projectDir> [<projectDir> ...]]
-    --all         : scan every project under ~/.claude/projects/*
-    --dry-run     : parse + extract but do not write to DB
+    console.log(`Usage:
+  node dist/bin/import-sessions.js [--dry-run] [--all | <projectDir> [<projectDir> ...]]
+    --all         : scan every project under ~/.claude/projects/*
+    --dry-run     : parse + extract but do not write to DB
     projectDir    : absolute path to a project dir (must contain *.jsonl files)`);
 }
 function collectJsonlFiles(projectDir) {
@@ -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/install-skill.js

@@ -21,20 +21,20 @@ const force = args.includes('--force') || args.includes('-f');
 const dryRun = args.includes('--dry-run');
 const showHelp = args.includes('--help') || args.includes('-h');
 if (showHelp) {
-    console.log(`linksee-memory-install-skill
-
-Install the linksee-memory Claude Code skill into ~/.claude/skills/linksee-memory/.
-
-Options:
-  --force, -f    Overwrite an existing skill file
-  --dry-run      Show what would happen without writing
-  --help, -h     This message
-
-After installation, ensure the MCP server is registered in Claude Code:
-  claude mcp add -s user linksee -- npx -y linksee-memory
-
-The skill expects tool names of the form mcp__linksee__*. If you register the
-server under a different name (e.g. "linksee-memory"), edit the skill file
+    console.log(`linksee-memory-install-skill
+
+Install the linksee-memory Claude Code skill into ~/.claude/skills/linksee-memory/.
+
+Options:
+  --force, -f    Overwrite an existing skill file
+  --dry-run      Show what would happen without writing
+  --help, -h     This message
+
+After installation, ensure the MCP server is registered in Claude Code:
+  claude mcp add -s user linksee -- npx -y linksee-memory
+
+The skill expects tool names of the form mcp__linksee__*. If you register the
+server under a different name (e.g. "linksee-memory"), edit the skill file
 afterwards.`);
     process.exit(0);
 }

package/dist/bin/setup.js

@@ -6,14 +6,16 @@
 //   npx linksee-memory-setup --yes    (accept all defaults, no prompts)
 //   npx linksee-memory-setup --dry-run
 //
-// Does three things:
+// Does four things:
 //   1. Registers the MCP server with Claude Code
 //   2. Installs the SKILL.md (agent trigger phrases)
-//   3. Configures the Stop hook (auto-capture sessions)
+//   3. Configures the Stop hook (auto-capture sessions) — user-global
+//   4. Offers to wire the re-injection guard into THIS project's .claude/settings.json
 //
 // After setup, every Claude Code session:
 //   - Auto-captures decisions, learnings, caveats to local memory
 //   - Agent auto-recalls past context at task start (via SKILL.md triggers)
+//   - (if guard enabled) accepted decisions are re-injected before edits + on session start
 //   - "Use Linksee" in any prompt forces a recall
 //
 // Why: Competing memory tools (claude-mem, etc.) are one-install-and-done.
@@ -24,24 +26,26 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline';
 const args = process.argv.slice(2);
 const dryRun = args.includes('--dry-run');
 const autoYes = args.includes('--yes') || args.includes('-y');
 const showHelp = args.includes('--help') || args.includes('-h');
 if (showHelp) {
-    console.log(`linksee-memory-setup — One-command setup for Linksee Memory
-
-Usage:
-  npx linksee-memory-setup          Interactive setup
-  npx linksee-memory-setup --yes    Accept all defaults, no prompts
-  npx linksee-memory-setup --dry-run Show what would happen
-
-What it does:
-  1. Registers linksee-memory MCP server with Claude Code
-  2. Installs SKILL.md (teaches the agent when to recall/remember)
-  3. Configures Stop hook (auto-captures every session)
-
-After setup, just chat with Claude Code normally.
+    console.log(`linksee-memory-setup — One-command setup for Linksee Memory
+
+Usage:
+  npx linksee-memory-setup          Interactive setup
+  npx linksee-memory-setup --yes    Accept all defaults, no prompts
+  npx linksee-memory-setup --dry-run Show what would happen
+
+What it does:
+  1. Registers linksee-memory MCP server with Claude Code
+  2. Installs SKILL.md (teaches the agent when to recall/remember)
+  3. Configures Stop hook (auto-captures every session)
+  4. Offers to wire the re-injection guard into THIS project's .claude/settings.json
+
+After setup, just chat with Claude Code normally.
 Add "Use Linksee" to any prompt to trigger memory recall.`);
     process.exit(0);
 }
@@ -56,6 +60,14 @@ const SKILL_SRC = join(dirname(__filename), '..', 'skill', 'SKILL.md');
 const SERVER_NAME = 'linksee';
 const MCP_COMMAND = `claude mcp add -s user ${SERVER_NAME} -- npx -y linksee-memory`;
 const HOOK_COMMAND = 'npx -y linksee-memory-sync';
+// Re-injection guard — wired into the PROJECT (not user-global) settings, because it enforces THIS
+// project's accepted decisions. Mirrors the dogfood wiring's ${CLAUDE_PROJECT_DIR}/dist/bin path, but
+// points at the globally-installed `linksee-memory-guard` bin so it ships without a build step. Shell
+// form (resolved at run time) survives npx-cache eviction; a baked dist path would not.
+const GUARD_COMMAND = 'npx -y linksee-memory-guard';
+const PROJECT_DIR = process.cwd();
+const PROJECT_CLAUDE_DIR = join(PROJECT_DIR, '.claude');
+const PROJECT_SETTINGS_PATH = join(PROJECT_CLAUDE_DIR, 'settings.json');
 const CHECK = '\x1b[32m✓\x1b[0m';
 const SKIP = '\x1b[33m○\x1b[0m';
 const FAIL = '\x1b[31m✗\x1b[0m';
@@ -67,7 +79,7 @@ console.log(`${BOLD}Linksee Memory Setup${RESET}`);
 console.log(`${DIM}Local-first cross-LLM memory · precision recall${RESET}`);
 console.log('');
 // ── Step 1: Register MCP server ──────────────────────────
-console.log(`${BOLD}[1/3]${RESET} Registering MCP server...`);
+console.log(`${BOLD}[1/4]${RESET} Registering MCP server...`);
 let mcpAlreadyRegistered = false;
 try {
     // Check if already registered by looking at settings.json or .claude.json
@@ -132,7 +144,7 @@ else {
 }
 console.log('');
 // ── Step 2: Install SKILL.md ─────────────────────────────
-console.log(`${BOLD}[2/3]${RESET} Installing agent skill...`);
+console.log(`${BOLD}[2/4]${RESET} Installing agent skill...`);
 if (!existsSync(SKILL_SRC)) {
     console.log(`  ${FAIL} Bundled SKILL.md not found (packaging bug)`);
     console.log(`  ${DIM}Expected at: ${SKILL_SRC}${RESET}`);
@@ -165,7 +177,7 @@ else {
 }
 console.log('');
 // ── Step 3: Configure Stop hook ──────────────────────────
-console.log(`${BOLD}[3/3]${RESET} Configuring auto-capture hook...`);
+console.log(`${BOLD}[3/4]${RESET} Configuring auto-capture hook...`);
 let settings = {};
 if (existsSync(SETTINGS_PATH)) {
     try {
@@ -200,6 +212,80 @@ else {
     console.log(`  ${CHECK} Stop hook added → ${SETTINGS_PATH}`);
 }
 console.log('');
+const GUARD_EVENTS = ['SessionStart', 'PreToolUse'];
+const GUARD_HOOKS = {
+    // matchers + timeouts mirror the dogfood .claude/settings.json
+    SessionStart: { matcher: 'startup|resume|compact', hooks: [{ type: 'command', command: GUARD_COMMAND, timeout: 15 }] },
+    PreToolUse: { matcher: 'Edit|Write|Bash', hooks: [{ type: 'command', command: GUARD_COMMAND, timeout: 8 }] },
+};
+// Idempotency probe: is OUR guard already wired for this event? (Match by bin name so a manually-added
+// or previously-installed entry isn't duplicated, and other people's hooks are never touched.)
+function guardWiredFor(s, ev) {
+    return (s.hooks?.[ev] ?? []).some((entry) => entry?.hooks?.some((h) => typeof h?.command === 'string' && h.command.includes('linksee-memory-guard')));
+}
+function askYesNo(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${question} [Y/n] `, (ans) => {
+            rl.close();
+            const a = ans.trim().toLowerCase();
+            resolve(a === '' || a === 'y' || a === 'yes'); // default = yes
+        });
+    });
+}
+async function configureGuard() {
+    console.log(`${BOLD}[4/4]${RESET} Configuring re-injection guard (this project)...`);
+    let project = {};
+    if (existsSync(PROJECT_SETTINGS_PATH)) {
+        try {
+            // Strip a leading BOM (U+FEFF) — Windows editors (Notepad) emit UTF-8+BOM, which JSON.parse rejects.
+            const raw = readFileSync(PROJECT_SETTINGS_PATH, 'utf8');
+            project = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw);
+        }
+        catch {
+            // Never clobber a file we can't parse — the user may have hand-authored it.
+            console.log(`  ${FAIL} Could not parse ${PROJECT_SETTINGS_PATH} — left untouched`);
+            console.log(`  ${DIM}Add the guard block by hand (see README → Re-injection Guard).${RESET}`);
+            return false;
+        }
+    }
+    if (GUARD_EVENTS.every((ev) => guardWiredFor(project, ev))) {
+        console.log(`  ${SKIP} Guard already wired in ${PROJECT_SETTINGS_PATH}`);
+        return true;
+    }
+    if (dryRun) {
+        console.log(`  ${DIM}[dry-run] Would merge SessionStart + PreToolUse guard hooks into ${PROJECT_SETTINGS_PATH}${RESET}`);
+        return false;
+    }
+    // "Offer" — opt-in, because the guard can deny tool calls on a 'hard' contradiction.
+    if (!autoYes) {
+        if (!process.stdin.isTTY) {
+            console.log(`  ${SKIP} Skipped (non-interactive shell). Re-run with --yes, or paste the README block.`);
+            return false;
+        }
+        console.log(`  ${DIM}Re-injects your accepted decisions before Edit/Write/Bash and on session start.`);
+        console.log(`  Fail-open — only an action that contradicts a 'hard' anchor is ever blocked.${RESET}`);
+        const ok = await askYesNo(`  Wire it into ${PROJECT_SETTINGS_PATH}?`);
+        if (!ok) {
+            console.log(`  ${SKIP} Skipped. Enable later via the README → Re-injection Guard.`);
+            return false;
+        }
+    }
+    // Merge, don't replace: append only the events we don't already own; leave foreign hooks intact.
+    const hooks = project.hooks ?? (project.hooks = {});
+    for (const ev of GUARD_EVENTS) {
+        if (!Array.isArray(hooks[ev]))
+            hooks[ev] = [];
+        if (!guardWiredFor(project, ev))
+            hooks[ev].push(GUARD_HOOKS[ev]);
+    }
+    mkdirSync(PROJECT_CLAUDE_DIR, { recursive: true });
+    writeFileSync(PROJECT_SETTINGS_PATH, JSON.stringify(project, null, 2), 'utf8');
+    console.log(`  ${CHECK} Guard wired → ${PROJECT_SETTINGS_PATH}`);
+    return true;
+}
+const guardConfigured = await configureGuard();
+console.log('');
 // ── Summary ──────────────────────────────────────────────
 console.log(`${BOLD}Setup complete!${RESET}`);
 console.log('');
@@ -208,6 +294,9 @@ console.log(`  ${DIM}• Every session is auto-captured (decisions, caveats, lea
 console.log(`  ${DIM}• Agent auto-recalls past context when starting a task${RESET}`);
 console.log(`  ${DIM}• Memory is local-first (nothing leaves your machine)${RESET}`);
 console.log(`  ${DIM}• Works across Claude Code, Cursor, ChatGPT (cross-LLM)${RESET}`);
+if (guardConfigured) {
+    console.log(`  ${DIM}• Re-injection guard re-surfaces this project's accepted decisions before edits${RESET}`);
+}
 console.log('');
 console.log('Test by asking:');
 console.log(`  ${BOLD}"How did we solve this before?"${RESET}`);

package/dist/bin/stats.js

@@ -53,11 +53,11 @@ function humanAge(unix) {
 function main() {
     const args = parseArgs();
     if (args.help) {
-        console.log(`linksee-memory-stats — summary of the local memory DB
-
-  --json             Output machine-readable JSON
-  --per-entity N     Show top N entities (default 5, 0 to skip)
-  -h, --help         This message
+        console.log(`linksee-memory-stats — summary of the local memory DB
+
+  --json             Output machine-readable JSON
+  --per-entity N     Show top N entities (default 5, 0 to skip)
+  -h, --help         This message
 `);
         return;
     }
@@ -88,23 +88,23 @@ function main() {
     const oldest = db.prepare('SELECT MIN(created_at) as t FROM memories').get().t;
     const newest = db.prepare('SELECT MAX(created_at) as t FROM memories').get().t;
     const topEntities = args.perEntity > 0
-        ? db.prepare(`
-        SELECT e.name, e.kind, e.momentum_score, COUNT(m.id) as memory_count,
-               MAX(m.last_accessed_at) as last_access
-        FROM entities e
-        LEFT JOIN memories m ON m.entity_id = e.id
-        GROUP BY e.id
-        ORDER BY memory_count DESC, e.momentum_score DESC
-        LIMIT ?
+        ? db.prepare(`
+        SELECT e.name, e.kind, e.momentum_score, COUNT(m.id) as memory_count,
+               MAX(m.last_accessed_at) as last_access
+        FROM entities e
+        LEFT JOIN memories m ON m.entity_id = e.id
+        GROUP BY e.id
+        ORDER BY memory_count DESC, e.momentum_score DESC
+        LIMIT ?
       `).all(args.perEntity)
         : [];
-    const topFiles = db.prepare(`
-    SELECT file_path, COUNT(*) as edits, COUNT(DISTINCT session_id) as in_sessions
-    FROM session_file_edits
-    WHERE operation IN ('edit', 'write')
-    GROUP BY file_path
-    ORDER BY edits DESC
-    LIMIT 5
+    const topFiles = db.prepare(`
+    SELECT file_path, COUNT(*) as edits, COUNT(DISTINCT session_id) as in_sessions
+    FROM session_file_edits
+    WHERE operation IN ('edit', 'write')
+    GROUP BY file_path
+    ORDER BY edits DESC
+    LIMIT 5
   `).all();
     const result = {
         db_path: dbPath,

package/dist/db/schema.sql

@@ -335,6 +335,29 @@ CREATE TABLE IF NOT EXISTS memory_write_candidates (
 CREATE INDEX IF NOT EXISTS idx_mwc_status ON memory_write_candidates(status);
 CREATE INDEX IF NOT EXISTS idx_mwc_scope  ON memory_write_candidates(scope);
 
+-- ============================================================
+-- v10: Re-injection log — the ACTIVE-observability stream (pre-action gate hits).
+-- Separate from drift_edges (POST-action reality): the gate (guard.ts, fired by a Claude Code
+-- PreToolUse hook) writes here when an accepted anchor is re-surfaced into context BEFORE an action.
+-- Feeds `dream` — "re-injected N times, still contradicted (heeded=0)" is the machine evidence behind
+-- #15443. trigger: boot=SessionStart · cue=prompt · gate=PreToolUse.
+-- ============================================================
+CREATE TABLE IF NOT EXISTS injection_log (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  anchor_id   INTEGER REFERENCES drift_anchors(id) ON DELETE CASCADE,
+  session_id  TEXT,
+  trigger     TEXT NOT NULL CHECK (trigger IN ('boot', 'cue', 'gate')),
+  surface     TEXT NOT NULL CHECK (surface IN ('inform', 'warn', 'block', 'allow')),
+  tool_name   TEXT,
+  action_snip TEXT,                                   -- first ~120 chars of the attempted action
+  verdict     TEXT,                                   -- contradicts | in_scope | none
+  heeded      INTEGER,                                -- NULL=unknown / 1=followed / 0=ignored (dream backfills)
+  occurred_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_injlog_anchor  ON injection_log(anchor_id, occurred_at);
+CREATE INDEX IF NOT EXISTS idx_injlog_session ON injection_log(session_id, occurred_at);
+
 -- ============================================================
 -- Meta — schema version tracking
 -- ============================================================
@@ -343,6 +366,6 @@ CREATE TABLE IF NOT EXISTS meta (
   value         TEXT NOT NULL
 );
 
-INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '9');
+INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '10');
 INSERT OR IGNORE INTO meta (key, value) VALUES ('created_at', CAST(unixepoch() AS TEXT));
-UPDATE meta SET value = '9' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6', '7', '8');
+UPDATE meta SET value = '10' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6', '7', '8', '9');

package/dist/lib/consolidate.js

@@ -25,17 +25,17 @@ export function consolidate(db, opts = {}) {
     // table is actually populated by the MCP server).
     const layerPlaceholders = CLUSTER_LAYERS.map(() => '?').join(',');
     const rows = db
-        .prepare(`
-      SELECT m.id, m.entity_id, m.layer, m.content, m.importance,
-             m.last_accessed_at, m.access_count, m.created_at, m.protected,
-             m.altitude,
-             e.name as entity_name
-      FROM memories m
-      JOIN entities e ON e.id = m.entity_id
-      WHERE m.protected = 0
-        AND m.layer IN (${layerPlaceholders})
-        AND m.created_at <= ?
-      ORDER BY m.entity_id, m.layer, m.created_at
+        .prepare(`
+      SELECT m.id, m.entity_id, m.layer, m.content, m.importance,
+             m.last_accessed_at, m.access_count, m.created_at, m.protected,
+             m.altitude,
+             e.name as entity_name
+      FROM memories m
+      JOIN entities e ON e.id = m.entity_id
+      WHERE m.protected = 0
+        AND m.layer IN (${layerPlaceholders})
+        AND m.created_at <= ?
+      ORDER BY m.entity_id, m.layer, m.created_at
       `)
         .all(...CLUSTER_LAYERS, ageCutoff);
     // Filter to cold-heat memories
@@ -68,10 +68,10 @@ export function consolidate(db, opts = {}) {
         memoryEdgesCreated: 0,
         decisionsSuperseded: 0,
     };
-    const insertLearning = db.prepare(`INSERT INTO memories (entity_id, layer, content, importance, protected, source)
+    const insertLearning = db.prepare(`INSERT INTO memories (entity_id, layer, content, importance, protected, source)
      VALUES (?, 'learning', ?, ?, 1, ?)`);
     const deleteMemory = db.prepare('DELETE FROM memories WHERE id = ?');
-    const insertAudit = db.prepare(`INSERT INTO consolidations (learning_id, replaced_ids, replaced_count, entity_id, original_layer)
+    const insertAudit = db.prepare(`INSERT INTO consolidations (learning_id, replaced_ids, replaced_count, entity_id, original_layer)
      VALUES (?, ?, ?, ?, ?)`);
     const insertEvent = db.prepare('INSERT INTO events (entity_id, kind, payload) VALUES (?, ?, ?)');
     const tx = db.transaction(() => {
@@ -137,12 +137,12 @@ export function consolidate(db, opts = {}) {
     // Uses json_set() to update the state field in content JSON atomically.
     const STALLED_THRESHOLD_DAYS = 30;
     const stalledCutoff = now - STALLED_THRESHOLD_DAYS * 86400;
-    const stalledResult = db.prepare(`
-    UPDATE memories SET content = json_set(content, '$.state', 'stalled')
-    WHERE json_valid(content)
-      AND json_extract(content, '$.state') = 'in_progress'
-      AND last_accessed_at < ?
-      AND protected = 0
+    const stalledResult = db.prepare(`
+    UPDATE memories SET content = json_set(content, '$.state', 'stalled')
+    WHERE json_valid(content)
+      AND json_extract(content, '$.state') = 'in_progress'
+      AND last_accessed_at < ?
+      AND protected = 0
   `).run(stalledCutoff);
     result.stalledTransitions = stalledResult.changes;
     // Memory→memory edge detection: link superseding/contradicting decisions so the

package/dist/lib/edge-detection.js

@@ -71,11 +71,11 @@ export function detectMemoryEdges(db, opts = {}) {
     const res = {
         decisionsScanned: 0, edgesCreated: 0, supersedes: 0, contradicts: 0, extends: 0, supersededMarked: 0, samples: [],
     };
-    const rows = db.prepare(`
-    SELECT id, entity_id, content, created_at
-    FROM memories
-    WHERE mem_type = 'decision' AND json_valid(content)
-    ORDER BY entity_id ASC, created_at ASC, id ASC
+    const rows = db.prepare(`
+    SELECT id, entity_id, content, created_at
+    FROM memories
+    WHERE mem_type = 'decision' AND json_valid(content)
+    ORDER BY entity_id ASC, created_at ASC, id ASC
   `).all();
     res.decisionsScanned = rows.length;
     if (rows.length < 2)
@@ -91,9 +91,9 @@ export function detectMemoryEdges(db, opts = {}) {
     // Prepare write statements only when actually writing — keeps dryRun safe on a
     // readonly connection (preview / verification path).
     const insEdge = opts.dryRun ? null : db.prepare(`INSERT OR IGNORE INTO memory_edges (from_memory_id, to_memory_id, relation) VALUES (?, ?, ?)`);
-    const markSuperseded = opts.dryRun ? null : db.prepare(`
-    UPDATE memories SET content = json_set(content, '$.state', 'superseded')
-    WHERE id = ? AND json_valid(content) AND json_extract(content, '$.state') <> 'superseded'
+    const markSuperseded = opts.dryRun ? null : db.prepare(`
+    UPDATE memories SET content = json_set(content, '$.state', 'superseded')
+    WHERE id = ? AND json_valid(content) AND json_extract(content, '$.state') <> 'superseded'
   `);
     const apply = () => {
         for (const decisions of byEntity.values()) {