linksee-memory 0.7.2 → 0.10.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/migrate.js

@@ -33,11 +33,11 @@ export function runMigrations(db) {
     // v3 → v4: rebuild memories_fts with trigram tokenizer for JP/CJK support.
     // Only runs when upgrading an existing DB from schema v1-3.
     if (currentVersion > 0 && currentVersion < 4) {
-        db.exec(`
-      DROP TRIGGER IF EXISTS trg_memories_fts_ai;
-      DROP TRIGGER IF EXISTS trg_memories_fts_ad;
-      DROP TRIGGER IF EXISTS trg_memories_fts_au;
-      DROP TABLE IF EXISTS memories_fts;
+        db.exec(`
+      DROP TRIGGER IF EXISTS trg_memories_fts_ai;
+      DROP TRIGGER IF EXISTS trg_memories_fts_ad;
+      DROP TRIGGER IF EXISTS trg_memories_fts_au;
+      DROP TABLE IF EXISTS memories_fts;
     `);
     }
     // v4 → v5: add normalized_name column BEFORE schema.sql runs,
@@ -81,11 +81,35 @@ export function runMigrations(db) {
             db.exec('ALTER TABLE memories ADD COLUMN thread_id TEXT');
         }
         // Backfill thread_id from content JSON session_id for existing memories
-        db.exec(`
-      UPDATE memories SET thread_id = json_extract(content, '$.session_id')
-      WHERE thread_id IS NULL AND json_valid(content) AND json_extract(content, '$.session_id') IS NOT NULL
+        db.exec(`
+      UPDATE memories SET thread_id = json_extract(content, '$.session_id')
+      WHERE thread_id IS NULL AND json_valid(content) AND json_extract(content, '$.session_id') IS NOT NULL
     `);
     }
+    // v8 → v9: ProjectCoreNode — extend drift_anchors into the Current Truth Map node.
+    // ADDITIVE columns only (ADD COLUMN with safe defaults) — NO CHECK rebuild, so the existing
+    // detector/dashboard (which read the original columns + status active/retired) are unaffected.
+    // `lifecycle` carries the rich state; `status` stays the coarse scan-gate. New tables
+    // (reality_events, memory_write_candidates) are created by db.exec(sql) below (CREATE IF NOT EXISTS).
+    if (currentVersion > 0 && currentVersion < 9) {
+        const have = new Set(db.prepare('PRAGMA table_info(drift_anchors)').all().map((c) => c.name));
+        const addCol = (name, ddl) => {
+            if (!have.has(name))
+                db.exec(`ALTER TABLE drift_anchors ADD COLUMN ${ddl}`);
+        };
+        addCol('node_type', 'node_type TEXT');
+        addCol('domain', 'domain TEXT');
+        addCol('decision_mode', 'decision_mode TEXT');
+        addCol('confidence', 'confidence REAL NOT NULL DEFAULT 0.8');
+        addCol('lifecycle', "lifecycle TEXT NOT NULL DEFAULT 'active'");
+        addCol('validity_scope', "validity_scope TEXT NOT NULL DEFAULT '{}'");
+        addCol('card_policy', "card_policy TEXT NOT NULL DEFAULT '{}'");
+        addCol('reality_manifestations', "reality_manifestations TEXT NOT NULL DEFAULT '[]'");
+        addCol('evidence_refs', "evidence_refs TEXT NOT NULL DEFAULT '[]'");
+        addCol('review_after', 'review_after INTEGER');
+        addCol('last_confirmed_at', 'last_confirmed_at INTEGER');
+        addCol('owner', 'owner TEXT');
+    }
     db.exec(sql);
     if (currentVersion > 0 && currentVersion < 4) {
         db.exec(`INSERT INTO memories_fts(rowid, content) SELECT id, content FROM memories;`);
@@ -124,12 +148,12 @@ function migrateV5EntityNormalization(db) {
         }
     })();
     // 4. Auto-merge duplicate entities (same kind + normalized_name)
-    const dupes = db.prepare(`
-    SELECT kind, normalized_name, GROUP_CONCAT(id) as ids
-    FROM entities
-    WHERE normalized_name IS NOT NULL
-    GROUP BY kind, normalized_name
-    HAVING COUNT(*) > 1
+    const dupes = db.prepare(`
+    SELECT kind, normalized_name, GROUP_CONCAT(id) as ids
+    FROM entities
+    WHERE normalized_name IS NOT NULL
+    GROUP BY kind, normalized_name
+    HAVING COUNT(*) > 1
   `).all();
     if (dupes.length > 0) {
         console.log(`[linksee-memory] v5 migration: merging ${dupes.length} duplicate entity clusters`);
@@ -150,12 +174,12 @@ function mergeEntityCluster(db, ids) {
     if (ids.length < 2)
         return;
     // Score each entity: prefer most memories, then has canonical_key, then lowest id
-    const rows = db.prepare(`
-    SELECT e.id, e.name, e.canonical_key, COUNT(m.id) as mem_count
-    FROM entities e LEFT JOIN memories m ON m.entity_id = e.id
-    WHERE e.id IN (${ids.map(() => '?').join(',')})
-    GROUP BY e.id
-    ORDER BY mem_count DESC, (e.canonical_key IS NOT NULL) DESC, e.id ASC
+    const rows = db.prepare(`
+    SELECT e.id, e.name, e.canonical_key, COUNT(m.id) as mem_count
+    FROM entities e LEFT JOIN memories m ON m.entity_id = e.id
+    WHERE e.id IN (${ids.map(() => '?').join(',')})
+    GROUP BY e.id
+    ORDER BY mem_count DESC, (e.canonical_key IS NOT NULL) DESC, e.id ASC
   `).all(...ids);
     const keep = rows[0];
     const mergeIds = rows.slice(1).map(r => r.id);
@@ -176,16 +200,16 @@ function mergeEntityCluster(db, ids) {
         db.prepare('UPDATE events SET entity_id = ? WHERE entity_id = ?').run(keep.id, mid);
         // Reassign edges (both directions)
         // Handle UNIQUE constraint: delete duplicates first
-        db.prepare(`
-      DELETE FROM edges WHERE from_id = ? AND EXISTS (
-        SELECT 1 FROM edges e2 WHERE e2.from_id = ? AND e2.to_id = edges.to_id AND e2.relation = edges.relation
-      )
+        db.prepare(`
+      DELETE FROM edges WHERE from_id = ? AND EXISTS (
+        SELECT 1 FROM edges e2 WHERE e2.from_id = ? AND e2.to_id = edges.to_id AND e2.relation = edges.relation
+      )
     `).run(mid, keep.id);
         db.prepare('UPDATE edges SET from_id = ? WHERE from_id = ?').run(keep.id, mid);
-        db.prepare(`
-      DELETE FROM edges WHERE to_id = ? AND EXISTS (
-        SELECT 1 FROM edges e2 WHERE e2.to_id = ? AND e2.from_id = edges.from_id AND e2.relation = edges.relation
-      )
+        db.prepare(`
+      DELETE FROM edges WHERE to_id = ? AND EXISTS (
+        SELECT 1 FROM edges e2 WHERE e2.to_id = ? AND e2.from_id = edges.from_id AND e2.relation = edges.relation
+      )
     `).run(mid, keep.id);
         db.prepare('UPDATE edges SET to_id = ? WHERE to_id = ?').run(keep.id, mid);
         // Reassign consolidations