linksee-memory 0.7.2 → 0.8.0

package/README.md

@@ -1,8 +1,10 @@
 # linksee-memory
 
-> **Your agent forgets everything when a session ends. Linksee Memory is the fix.**
+> **Your agent forgets everything when a session ends. Worse — it silently drifts from what you decided last week.**
 >
-> Local-first cross-LLM memory MCP — one SQLite file that **Claude Code, Cursor, Windsurf, OpenAI Codex, and Gemini CLI** all read from. Not just "what happened" but **WHY** it happened: 6-layer structured memory with precision recall that surfaces the right context at the right moment.
+> Local-first cross-LLM memory MCP — one SQLite file that **Claude Code, Cursor, Windsurf, OpenAI Codex, and Gemini CLI** all read from. Not just "what happened" but **WHY** it happened: 6-layer structured memory with precision recall, **plus drift detection that catches when reality diverges from your decisions**.
+>
+> Memory is the entry point. Drift detection is the real value.
 >
 > `npx linksee-memory-setup` — one command, done.
 
@@ -87,21 +89,69 @@ Every memory is tagged with **exactly one layer**. `caveat`-layer entries are pr
 
 Most "agent memory" services (Mem0, Letta, Zep) save a flat list of facts. Then the agent looks at "edited file X 30 times" and has no idea why. **linksee-memory keeps the WHY.**
 
-It is a Model Context Protocol (MCP) server with **3 tools** that gives any AI agent structured memory:
+It is a Model Context Protocol (MCP) server with **7 tools** that gives any AI agent structured memory + drift detection:
 
 | | Mem0 / Letta / Zep | Claude Code auto-memory | linksee-memory |
 |---|---|---|---|
 | Cross-agent | △ (cloud) | ❌ Claude only | ✅ single SQLite file |
 | 6-layer WHY structure | ❌ flat | ❌ flat markdown | ✅ goal / context / emotion / impl / caveat / learning |
+| **Drift detection** | ❌ | ❌ | ✅ intent ↔ reality divergence tracking |
 | File diff cache | ❌ | ❌ | ✅ AST-aware, 50-99% token savings on re-reads |
 | Active forgetting | △ | ❌ | ✅ Ebbinghaus curve, caveat layer protected |
 | Local-first / private | ❌ | ✅ | ✅ |
 
-## Three pillars
+## Four pillars
 
 1. **Token savings** via `read_smart` — sha256 + AST/heading/indent chunking. Re-reads return only diffs. **Measured 86% saved on a typical TS file edit, 99% saved on unchanged re-reads.**
 2. **Cross-agent portability** — single SQLite file at `~/.linksee-memory/memory.db`. Same brain for Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI.
 3. **WHY-first structured memory** — six explicit layers (`goal` / `context` / `emotion` / `implementation` / `caveat` / `learning`). Solves "flat fact memory is useless without goals".
+4. **Drift detection** — declare decisions as anchors, then the engine automatically detects when committed reality diverges from stated intent. Think "Datadog for product decisions" — unaccounted divergences surface as drift, intentional evolution (recorded as supersede/fix) stays quiet.
+
+## 🔍 Drift Detection — "Intent Datadog"
+
+Most teams make decisions, then forget them. The agent from last week decided "we'll use FTS5 instead of vector search" — but this week a new session installs `pgvector` without knowing why that was rejected. **That's drift.** Not a bug. Not malice. Just forgotten context.
+
+Linksee Memory's drift detection catches this:
+
+```
+You:    What's drifting right now?
+Agent:  [calls drift_status]
+
+        28 anchors: ⚪ 1 held · 🔵 27 aligned
+
+        Needs attention:
+        ⚪ HELD — "Focus on 4 areas: Recipe layer, agent-native API,
+           Japanese market, Agent Insights"
+           ↻ Reopens 2026-07-04
+
+        Everything else is aligned — no unaccounted divergence.
+```
+
+### How it works
+
+1. **Declare** decisions as anchors: `declare_anchor({ kind: "decision", statement: "We use FTS5, not vector search", violation_signal: ["pgvector", "embedding"] })`
+2. **The engine detects** when committed code reality diverges from these anchors
+3. **State derivation** classifies each anchor:
+   - 🔴 **Drift** — reality diverges with no recorded resolution
+   - 🟡 **Review** — a soft signal awaits your decision
+   - ⚪ **Held** — you acknowledged the gap, parked it with a review date
+   - 🔵 **Aligned** — reality matches intent, or a recorded resolution explains the change
+4. **Resolve** with `fix`, `supersede`, `acknowledge`, or `dismiss`
+
+The **make-or-break rule**: a divergence accounted for by a recorded resolution (supersede/fix/acknowledge) is NOT drift. Only unaccounted gaps are flagged. This means intentional evolution stays quiet while silent abandonment gets caught.
+
+### 4-species taxonomy
+
+Anchors are classified into four species with different display formats:
+
+| Species | Icon | Display Format | Example |
+|---|---|---|---|
+| Hypothesis | 🧪 | Decision Card (journal format) | "We'll launch English-first on HN" |
+| Constraint | 🔒 | Rule (pass/fail checklist) | "All writes go through remember()" |
+| Commitment | 🔁 | Heartbeat (alive/dead) | "Ship a new version every week" |
+| Source of Truth | 📍 | Reference (stable anchor) | "MCP server runs on stdio, single SQLite" |
+
+---
 
 ## Quick Start — One Command
 
@@ -248,7 +298,17 @@ All editors share the same `~/.linksee-memory/memory.db`. A decision made in Cla
 
 Default: `~/.linksee-memory/memory.db`. Override with `LINKSEE_MEMORY_DIR` env var.
 
-## What's new in v0.7
+## What's new in v0.8
+
+| Feature | Detail |
+|---|---|
+| **4 drift detection tools** | `drift_status`, `check_decision`, `declare_anchor`, `resolve_drift` — agents can now query and act on intent ↔ reality divergence. The biggest gap in agent memory (decisions are forgotten across sessions) is now closed. |
+| **Truth engine** | State derivation logic (drift/review/held/aligned) now lives in the MCP engine, not just the dashboard. Any MCP client can query drift status. |
+| **4-species taxonomy** | Anchors classified as hypothesis/constraint/commitment/source_of_truth with species-appropriate display formats. |
+| **Resolution priority** | When multiple resolutions exist for an anchor, the most recent one wins (prevents stale acknowledge from shadowing a newer fix). |
+
+<details>
+<summary>What's new in v0.7</summary>
 
 | Feature | Detail |
 |---|---|
@@ -258,6 +318,8 @@ Default: `~/.linksee-memory/memory.db`. Override with `LINKSEE_MEMORY_DIR` env v
 | **"Use Linksee Memory" trigger** | Add "Use Linksee Memory" to any prompt to force memory recall — same adoption pattern as Context7. |
 | **Claude Code Plugin** | `claude plugin add -- linksee-memory` — ships MCP server + auto-invocation skill in one install. |
 
+</details>
+
 <details>
 <summary>What's new in v0.4</summary>
 
@@ -270,7 +332,9 @@ Default: `~/.linksee-memory/memory.db`. Override with `LINKSEE_MEMORY_DIR` env v
 
 </details>
 
-## 3 Tools (v0.7)
+## 7 Tools (v0.8)
+
+### Memory tools
 
 | Tool | What it does |
 |---|---|
@@ -278,7 +342,16 @@ Default: `~/.linksee-memory/memory.db`. Override with `LINKSEE_MEMORY_DIR` env v
 | `recall` | **Search / file history / overview.** Modes: search (`query`), file history (`path`), entity overview (no params). FTS5 + heat × momentum ranking with `match_reasons`. |
 | `read_smart` | **Token-saving file reader** with AST diff caching. First read = full content. Re-read unchanged = ~50 tokens. Re-read modified = changed chunks only. |
 
-Previous versions exposed 8 tools — v0.7.0 unified them into 3 for cross-LLM consistency. The server handles routing internally. Old tool names return migration guidance.
+### Drift tools (v0.8.0)
+
+| Tool | What it does |
+|---|---|
+| `drift_status` | **"What's drifting right now?"** Returns the truth map with 4-species classification (hypothesis/constraint/commitment/source_of_truth) and per-node state (🔴 drift / 🟡 review / ⚪ held / 🔵 aligned). |
+| `check_decision` | **Deep-dive into a specific decision.** Returns the full context: what was decided, why, what reality says, pending candidates, and drift edges. |
+| `declare_anchor` | **Record a decision as a truth-map anchor.** The drift detector checks these against committed reality. Supports v9 fields (domain, confidence, lifecycle, review_after). |
+| `resolve_drift` | **Close the loop.** Record a resolution: `fix` (reality now matches), `supersede` (intent evolved), `acknowledge` (parking with review date), or `dismiss` (false positive). |
+
+Previous versions exposed 3 tools — v0.8.0 added 4 drift tools that let agents query and act on product-level intent ↔ reality divergence. The memory tools are unchanged.
 
 ### CLI utilities
 
@@ -343,6 +416,10 @@ The conversation↔file linkage is the key. Every file edit captured by the Stop
 - ✅ Structured memory v2 (3-axis classification: altitude × type × state)
 - ✅ Cross-LLM: Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI
 - ✅ Landing page ([linksee-site.vercel.app](https://linksee-site.vercel.app))
+- ✅ Drift detection engine + 4 MCP drift tools — v0.8.0
+- ✅ 4-species truth map (hypothesis/constraint/commitment/source_of_truth) — v0.8.0
+- ✅ Dashboard with Decision Register visualization
+- 🔮 Obsidian plugin (read truth map in your vault)
 - 🔮 Vector search via `sqlite-vec` (already in deps, embedding backend pending)
 - 🔮 Cross-device cloud sync (Pro tier)
 
@@ -477,6 +554,16 @@ If you want to force a manual consolidation, restart the MCP server — auto-con
 
 ## FAQ
 
+<details>
+<summary><strong>What is drift detection and why do I need it?</strong></summary>
+
+Drift = when your code reality silently diverges from what you decided. Example: Last week you decided "FTS5, not vector search" but this week a new agent session installs pgvector without knowing the history.
+
+Linksee Memory tracks this by letting you declare decisions as "anchors" and then automatically checking committed code against them. The make-or-break rule: **intentional evolution (recorded as fix/supersede) stays quiet, while unaccounted gaps get flagged.** It's like Datadog but for product decisions instead of server metrics.
+
+You don't need to use drift detection to benefit from linksee-memory — the 3 memory tools (remember/recall/read_smart) work independently. Drift tools are an additional layer for teams and solo devs managing multiple projects.
+</details>
+
 <details>
 <summary><strong>How is this different from Mem0 / Letta / Zep?</strong></summary>
 
@@ -556,6 +643,23 @@ After install, in a new Claude session ask: *"Can you remember that I prefer Typ
 
 ## Changelog
 
+### v0.8.0 — Drift Detection MCP Tools (2026-06-08)
+
+**3 tools → 7 tools.** The biggest update since launch — agents can now detect, query, and resolve intent ↔ reality drift.
+
+**New tools:**
+- **`drift_status`** — returns the truth map with 4-species classification and per-node drift state
+- **`check_decision`** — deep-dive into a single anchor: state, edges, pending candidates
+- **`declare_anchor`** — record a decision/constraint/prohibition as a truth-map node (with v9 ProjectCoreNode fields)
+- **`resolve_drift`** — close the feedback loop: fix / supersede / acknowledge / dismiss
+
+**New engine module:**
+- **`truth-engine.ts`** — state derivation logic migrated from the dashboard into the MCP engine. Any MCP client can now query drift status without a dashboard.
+- **Resolution priority fix**: when multiple resolutions reference the same anchor, the most recent one wins (by `resolved_at` timestamp). Prevents a stale acknowledge from shadowing a newer fix.
+- **4-species classification**: nodes classified by `decision_mode` into hypothesis / constraint / commitment / source_of_truth with display format guidance.
+
+No breaking changes to existing memory tools. All 3 memory tools (remember, recall, read_smart) are unchanged.
+
 ### v0.7.2 — Recall ergonomics + auto-edge detection + classifier precision (2026-05-30)
 
 Quality pass on v0.7.0 / v0.7.1 — sharper day-to-day agent UX and cleaner data for the dashboard:

package/dist/bin/declare-anchor.d.ts

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

package/dist/bin/declare-anchor.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+// linksee-memory-declare — declare / list / retire drift anchors (v8).
+//
+// The explicit write path for drift observability. Anchors declared here are clean
+// by construction (declare-don't-mine): a human typed them. The bulk seeding script
+// (curate the existing candidate pool) reuses curateAnchorFromMemory() from the lib.
+//
+// Usage:
+//   linksee-memory-declare list [--status active|retired] [--kind prohibition|decision|constraint]
+//   linksee-memory-declare add --kind <k> --statement "<text>" [--rationale "<text>"]
+//        [--affects "glob1,glob2"] [--terms "t1,t2"] [--violation "v1,v2"] [--tier human|explicit]
+//   linksee-memory-declare retire --id <n>
+import { openDb, runMigrations } from '../db/migrate.js';
+import { declareAnchor, listAnchors, retireAnchor, setNodeFields, getCurrentTruth, getAlertPolicy, setAlertPolicy, } from '../lib/drift-anchors.js';
+function parseFlags(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const key = a.slice(2);
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith('--')) {
+                out[key] = 'true';
+            }
+            else {
+                out[key] = next;
+                i++;
+            }
+        }
+    }
+    return out;
+}
+function splitList(v) {
+    if (!v)
+        return [];
+    return v
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function print(obj) {
+    process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+}
+function main() {
+    const [, , sub, ...rest] = process.argv;
+    const flags = parseFlags(rest);
+    const db = openDb();
+    runMigrations(db); // ensure drift tables exist when run standalone
+    try {
+        switch (sub) {
+            case 'add': {
+                const anchor = declareAnchor(db, {
+                    kind: flags.kind,
+                    statement: flags.statement ?? '',
+                    rationale: flags.rationale,
+                    affects: splitList(flags.affects),
+                    detect_terms: splitList(flags.terms),
+                    violation_signal: splitList(flags.violation),
+                    tier: flags.tier || undefined,
+                });
+                // v9 ProjectCoreNode fields (minimal input — only what's given):
+                //   --node-type --domain --mode --confidence --cadence --stale-days --applies --not-applies
+                const nf = {};
+                if (flags['node-type'])
+                    nf.node_type = flags['node-type'];
+                if (flags.domain)
+                    nf.domain = flags.domain;
+                if (flags.mode)
+                    nf.decision_mode = flags.mode;
+                if (flags.confidence)
+                    nf.confidence = Number(flags.confidence);
+                if (flags.cadence || flags['stale-days']) {
+                    const cp = { enabled: true };
+                    if (flags.cadence)
+                        cp.cadence_days = Number(flags.cadence);
+                    if (flags['stale-days'])
+                        cp.stale_threshold_days = Number(flags['stale-days']);
+                    nf.card_policy = cp;
+                }
+                if (flags.applies || flags['not-applies']) {
+                    const vs = {};
+                    if (flags.applies)
+                        vs.applies_to = splitList(flags.applies);
+                    if (flags['not-applies'])
+                        vs.does_not_apply_to = splitList(flags['not-applies']);
+                    nf.validity_scope = vs;
+                }
+                if (Object.keys(nf).length)
+                    setNodeFields(db, anchor.id, nf);
+                print({ ok: true, declared: anchor, node_fields: Object.keys(nf).length ? nf : null });
+                break;
+            }
+            case 'retire': {
+                const id = Number(flags.id);
+                if (!Number.isFinite(id))
+                    throw new Error('--id <n> required');
+                const ok = retireAnchor(db, id);
+                print({ ok, retired: ok ? id : null });
+                break;
+            }
+            case 'list':
+            case undefined: {
+                const anchors = listAnchors(db, {
+                    status: flags.status,
+                    kind: flags.kind,
+                });
+                print({ ok: true, count: anchors.length, anchors });
+                break;
+            }
+            case 'truth': {
+                // ⑧ read_smart-style scoped read: active Current-Truth slice only.
+                const nodes = getCurrentTruth(db, { domain: flags.domain, decision_mode: flags.mode });
+                print({ ok: true, scope: { domain: flags.domain ?? 'all', decision_mode: flags.mode ?? 'all' }, count: nodes.length, current_truth: nodes });
+                break;
+            }
+            case 'policy': {
+                const p = {};
+                if (flags['max-cards-per-day'])
+                    p.max_cards_per_day = Number(flags['max-cards-per-day']);
+                if (flags['max-soft-per-week'])
+                    p.max_soft_cards_per_week = Number(flags['max-soft-per-week']);
+                if (flags['min-soft-confidence'])
+                    p.min_confidence_for_soft_card = Number(flags['min-soft-confidence']);
+                if (flags['two-sided'])
+                    p.require_two_sided_evidence = flags['two-sided'] !== 'false';
+                const policy = Object.keys(p).length ? setAlertPolicy(db, p) : getAlertPolicy(db);
+                print({ ok: true, alert_policy: policy });
+                break;
+            }
+            default:
+                throw new Error(`unknown subcommand "${sub}" — use: add | list | retire | truth | policy`);
+        }
+    }
+    catch (err) {
+        print({ ok: false, error: err?.message ?? String(err) });
+        db.close();
+        process.exit(1);
+    }
+    db.close();
+}
+if (import.meta.url === `file://${process.argv[1]}` ||
+    process.argv[1]?.endsWith('declare-anchor.ts') ||
+    process.argv[1]?.endsWith('declare-anchor.js')) {
+    main();
+}
+//# sourceMappingURL=declare-anchor.js.map

package/dist/bin/detect-drift.d.ts

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

package/dist/bin/detect-drift.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// linksee-memory-detect — run the drift detector (照合: declared intent vs. actual reality).
+//
+// The manual-trigger entry point for drift detection (the cadence question). Mirrors
+// declare-anchor.ts; purely additive — touches only drift_edges (the feature's own table) and
+// ONLY when --persist is passed. SAFE BY DEFAULT: a bare run is a dry-run (reads only, no
+// writes), so you can preview drift before committing it to the view. Pass --persist to write
+// the edges that /drift renders. No embedding layer: matching is lexical/glob/trigram-FTS only.
+//
+// Usage:
+//   linksee-memory-detect                  # dry-run — preview drift, writes NOTHING (default)
+//   linksee-memory-detect --persist         # write contradicts/absent edges into drift_edges
+//   linksee-memory-detect --stale-days 30   # override absence staleness gate (default 14)
+//   linksee-memory-detect --threshold 0.5   # override emit threshold (default 0.5)
+import { openDb, runMigrations } from '../db/migrate.js';
+import { detectDrift, detectFileViolations } from '../lib/drift-detection.js';
+function parseFlags(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const key = a.slice(2);
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith('--')) {
+                out[key] = 'true';
+            }
+            else {
+                out[key] = next;
+                i++;
+            }
+        }
+    }
+    return out;
+}
+function print(obj) {
+    process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+}
+function main() {
+    const [, , ...rest] = process.argv;
+    const flags = parseFlags(rest);
+    const persist = flags.persist === 'true';
+    const staleDays = flags['stale-days'] !== undefined ? Number(flags['stale-days']) : undefined;
+    const emitThreshold = flags.threshold !== undefined ? Number(flags.threshold) : undefined;
+    if (staleDays !== undefined && !Number.isFinite(staleDays))
+        throw new Error('--stale-days <n> must be a number');
+    if (emitThreshold !== undefined && !Number.isFinite(emitThreshold))
+        throw new Error('--threshold <n> must be a number');
+    const db = openDb();
+    runMigrations(db); // ensure drift tables exist when run standalone
+    try {
+        const res = detectDrift(db, { dryRun: !persist, staleDays, emitThreshold });
+        const fres = detectFileViolations(db, { dryRun: !persist, emitThreshold });
+        print({
+            ok: true,
+            mode: persist ? 'PERSISTED' : 'DRY RUN (no writes — pass --persist to write)',
+            persisted: res.persisted,
+            anchorsScanned: res.anchorsScanned,
+            editsScanned: res.editsScanned,
+            // v1 — edit-snippet scan (what a captured edit's snippet contained)
+            editSnippetScan: {
+                contradicts: res.contradicts,
+                absent: res.absent,
+                edgesEmitted: res.edgesEmitted,
+                byAnchorHits: res.byAnchor.filter((b) => b.contradicts > 0 || b.absent > 0),
+                samples: res.samples.slice(0, 6),
+            },
+            // v2 — current-file scan (live file:line against violation_signal)
+            currentFileScan: {
+                filesScanned: fres.filesScanned,
+                anchorsCapped: fres.anchorsCapped,
+                contradicts: fres.contradicts,
+                edgesEmitted: fres.edgesEmitted,
+                byAnchorHits: fres.byAnchor,
+                samples: fres.samples.slice(0, 14),
+            },
+            totalEdgesEmitted: res.edgesEmitted + fres.edgesEmitted,
+        });
+    }
+    catch (err) {
+        print({ ok: false, error: err?.message ?? String(err) });
+        db.close();
+        process.exit(1);
+    }
+    db.close();
+}
+if (import.meta.url === `file://${process.argv[1]}` ||
+    process.argv[1]?.endsWith('detect-drift.ts') ||
+    process.argv[1]?.endsWith('detect-drift.js')) {
+    main();
+}
+//# sourceMappingURL=detect-drift.js.map

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