linksee-memory 0.12.0 → 0.13.0

package/dist/lib/drift-anchors.js

@@ -74,9 +74,9 @@ export function declareAnchor(db, input) {
         throw new Error(`${input.kind} anchors need at least one violation_signal term (the forbidden act / rejected alternative) — otherwise the detector can never deduce a contradiction`);
     }
     const info = db
-        .prepare(`INSERT INTO drift_anchors
-         (kind, statement, rationale, affects, detect_terms, violation_signal, tier, source, source_memory_id)
-       VALUES
+        .prepare(`INSERT INTO drift_anchors
+         (kind, statement, rationale, affects, detect_terms, violation_signal, tier, source, source_memory_id)
+       VALUES
          (@kind, @statement, @rationale, @affects, @detect_terms, @violation_signal, @tier, @source, @source_memory_id)`)
         .run({
         kind: input.kind,

package/dist/lib/drift-detection.js

@@ -110,7 +110,7 @@ export function detectDrift(db, opts = {}) {
         samples: [],
     };
     const anchors = db
-        .prepare(`SELECT id, kind, statement, affects, detect_terms, violation_signal, tier, created_at
+        .prepare(`SELECT id, kind, statement, affects, detect_terms, violation_signal, tier, created_at
          FROM drift_anchors WHERE status = 'active'`)
         .all();
     res.anchorsScanned = anchors.length;
@@ -120,8 +120,8 @@ export function detectDrift(db, opts = {}) {
     // the "why this edit" text, not just path + snippet. (session_file_edits.memory_id →
     // memories.id; memories_fts.rowid = memories.id.)
     const edits = db
-        .prepare(`SELECT e.id, e.file_path, e.context_snippet, e.memory_id, m.content AS memory_content, e.occurred_at
-         FROM session_file_edits e
+        .prepare(`SELECT e.id, e.file_path, e.context_snippet, e.memory_id, m.content AS memory_content, e.occurred_at
+         FROM session_file_edits e
          LEFT JOIN memories m ON m.id = e.memory_id`)
         .all();
     res.editsScanned = edits.length;
@@ -137,19 +137,19 @@ export function detectDrift(db, opts = {}) {
     // Write paths prepared only when persisting — keeps dryRun safe on a readonly connection.
     const upsertContradicts = opts.dryRun
         ? null
-        : db.prepare(`
-        INSERT INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
-        VALUES (@anchor_id, @edit_id, 'contradicts', @confidence, @evidence, 'open')
-        ON CONFLICT(anchor_id, edit_id, verdict) DO UPDATE SET
-          confidence = excluded.confidence,
-          evidence   = excluded.evidence
-        WHERE drift_edges.status = 'open'
+        : db.prepare(`
+        INSERT INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
+        VALUES (@anchor_id, @edit_id, 'contradicts', @confidence, @evidence, 'open')
+        ON CONFLICT(anchor_id, edit_id, verdict) DO UPDATE SET
+          confidence = excluded.confidence,
+          evidence   = excluded.evidence
+        WHERE drift_edges.status = 'open'
       `);
     const insertAbsent = opts.dryRun
         ? null
-        : db.prepare(`
-        INSERT OR IGNORE INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
-        VALUES (@anchor_id, NULL, 'absent', @confidence, @evidence, 'open')
+        : db.prepare(`
+        INSERT OR IGNORE INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
+        VALUES (@anchor_id, NULL, 'absent', @confidence, @evidence, 'open')
       `);
     const apply = () => {
         for (const a of anchors) {
@@ -351,13 +351,13 @@ export function detectFileViolations(db, opts = {}) {
         .all();
     const upsert = opts.dryRun
         ? null
-        : db.prepare(`
-        INSERT INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
-        VALUES (@anchor_id, @edit_id, 'contradicts', @confidence, @evidence, 'open')
-        ON CONFLICT(anchor_id, edit_id, verdict) DO UPDATE SET
-          confidence = excluded.confidence,
-          evidence   = excluded.evidence
-        WHERE drift_edges.status = 'open'
+        : db.prepare(`
+        INSERT INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
+        VALUES (@anchor_id, @edit_id, 'contradicts', @confidence, @evidence, 'open')
+        ON CONFLICT(anchor_id, edit_id, verdict) DO UPDATE SET
+          confidence = excluded.confidence,
+          evidence   = excluded.evidence
+        WHERE drift_edges.status = 'open'
       `);
     const apply = () => {
         for (const a of anchors) {

package/dist/lib/drift-view.js

@@ -27,14 +27,14 @@ function parseEvidence(s) {
 export function getDriftHeadline(db, opts = {}) {
     const limit = opts.limit ?? 3;
     const rows = db
-        .prepare(`SELECT d.id AS edge_id, d.anchor_id, a.kind, a.statement, a.rationale,
-              e.file_path, e.context_snippet, e.occurred_at,
-              d.confidence, d.evidence
-         FROM drift_edges d
-         JOIN drift_anchors a ON a.id = d.anchor_id
-         JOIN session_file_edits e ON e.id = d.edit_id
-        WHERE d.verdict = 'contradicts' AND d.status = 'open' AND a.status = 'active'
-        ORDER BY d.confidence DESC, (a.tier = 'human') DESC, e.occurred_at DESC
+        .prepare(`SELECT d.id AS edge_id, d.anchor_id, a.kind, a.statement, a.rationale,
+              e.file_path, e.context_snippet, e.occurred_at,
+              d.confidence, d.evidence
+         FROM drift_edges d
+         JOIN drift_anchors a ON a.id = d.anchor_id
+         JOIN session_file_edits e ON e.id = d.edit_id
+        WHERE d.verdict = 'contradicts' AND d.status = 'open' AND a.status = 'active'
+        ORDER BY d.confidence DESC, (a.tier = 'human') DESC, e.occurred_at DESC
         LIMIT ?`)
         .all(limit);
     return rows.map((r) => {
@@ -61,12 +61,12 @@ export function getDriftHeadline(db, opts = {}) {
 export function getDriftAbsences(db, opts = {}) {
     const limit = opts.limit ?? 10;
     const rows = db
-        .prepare(`SELECT d.id AS edge_id, d.anchor_id, a.kind, a.statement, a.rationale,
-              d.confidence, d.evidence, d.detected_at
-         FROM drift_edges d
-         JOIN drift_anchors a ON a.id = d.anchor_id
-        WHERE d.verdict = 'absent' AND d.status = 'open' AND a.status = 'active'
-        ORDER BY a.created_at ASC
+        .prepare(`SELECT d.id AS edge_id, d.anchor_id, a.kind, a.statement, a.rationale,
+              d.confidence, d.evidence, d.detected_at
+         FROM drift_edges d
+         JOIN drift_anchors a ON a.id = d.anchor_id
+        WHERE d.verdict = 'absent' AND d.status = 'open' AND a.status = 'active'
+        ORDER BY a.created_at ASC
         LIMIT ?`)
         .all(limit);
     return rows.map((r) => {
@@ -85,8 +85,8 @@ export function getDriftAbsences(db, opts = {}) {
 }
 function countOpen(db, verdict) {
     return db
-        .prepare(`SELECT COUNT(*) AS n
-           FROM drift_edges d JOIN drift_anchors a ON a.id = d.anchor_id
+        .prepare(`SELECT COUNT(*) AS n
+           FROM drift_edges d JOIN drift_anchors a ON a.id = d.anchor_id
           WHERE d.verdict = ? AND d.status = 'open' AND a.status = 'active'`)
         .get(verdict).n;
 }

package/dist/lib/guard-wiring.d.ts

@@ -0,0 +1,54 @@
+export type HookCommand = {
+    type: string;
+    command?: string;
+    timeout?: number;
+    args?: string[];
+};
+export type HookEntry = {
+    matcher?: string;
+    hooks?: HookCommand[];
+};
+export type ClaudeSettings = {
+    hooks?: Record<string, HookEntry[]>;
+    [k: string]: unknown;
+};
+export declare const GUARD_EVENTS: readonly ["SessionStart", "PreToolUse"];
+export type GuardEvent = (typeof GUARD_EVENTS)[number];
+/** The bin every wiring form resolves to; used as the idempotency key. */
+export declare const GUARD_BIN = "linksee-memory-guard";
+export declare const GUARD_COMMAND = "npx -y linksee-memory guard";
+export declare const GUARD_HOOKS: Record<GuardEvent, HookEntry>;
+/**
+ * Is one of OUR hooks of `kind` already wired for this event?
+ *
+ * Shared by the guard and the session-sync hook because they hit the same trap: each has been
+ * wired as an npx subcommand, as a global bin, as a dist path, and in exec form with the path
+ * in `args`. A probe that knows only one shape appends a duplicate — which is exactly what
+ * happened to the Stop hook on 2026-09-07 (`sync-session.js` did not match `linksee-memory-sync`,
+ * so setup added a second one and sessions were captured twice).
+ */
+export declare function linkseeHookWired(settings: ClaudeSettings, event: string, kind: 'guard' | 'sync'): boolean;
+/** Is the session-sync (Stop) hook already wired? */
+export declare function syncWiredFor(settings: ClaudeSettings, event?: string): boolean;
+/**
+ * Is OUR guard already wired for this event?
+ *
+ * Has to recognise every shape the guard has ever been wired in, or setup duplicates it:
+ *   npx -y linksee-memory guard                              (what setup writes)
+ *   linksee-memory-guard                                     (the global bin)
+ *   node /path/to/linksee-memory/dist/bin/guard-hook.js      (the old README block)
+ *   { command: 'node', args: ['.../dist/bin/guard-hook.js'] } (exec form — the path is in args)
+ *
+ * The last two put the identifying part in different places, so match against command and args
+ * joined together. `guard-hook` alone is accepted because the exec form carries no package name.
+ */
+export declare function guardWiredFor(settings: ClaudeSettings, event: string): boolean;
+export declare function guardFullyWired(settings: ClaudeSettings): boolean;
+/**
+ * Add the guard to any event it does not already own. Mutates and returns `settings`, plus the
+ * events that were actually added (empty when it was already wired).
+ */
+export declare function wireGuard(settings: ClaudeSettings): {
+    settings: ClaudeSettings;
+    added: GuardEvent[];
+};

package/dist/lib/guard-wiring.js

@@ -0,0 +1,85 @@
+// guard-wiring — merge the re-injection guard's hooks into a Claude Code settings object.
+//
+// Extracted from bin/setup.ts so the merge is testable without running the installer (which
+// also registers an MCP server and copies a skill). The rules that matter here:
+//
+//   • merge, never replace — other people's hooks in the same event must survive
+//   • idempotent — running setup twice must not produce two guard entries
+//   • recognise a hand-pasted guard from the README as already-wired (match on the bin name,
+//     not on the exact command string, which differs between `npx` and a dist path)
+export const GUARD_EVENTS = ['SessionStart', 'PreToolUse'];
+/** The bin every wiring form resolves to; used as the idempotency key. */
+export const GUARD_BIN = 'linksee-memory-guard';
+export const GUARD_COMMAND = 'npx -y linksee-memory guard';
+export const GUARD_HOOKS = {
+    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 }],
+    },
+};
+/** Everything a hook entry could carry an identifier in: `command`, or `args` for the exec form. */
+function hookHaystack(h) {
+    return [h?.command, ...(h?.args ?? [])].filter((x) => typeof x === 'string').join(' ');
+}
+/**
+ * Is one of OUR hooks of `kind` already wired for this event?
+ *
+ * Shared by the guard and the session-sync hook because they hit the same trap: each has been
+ * wired as an npx subcommand, as a global bin, as a dist path, and in exec form with the path
+ * in `args`. A probe that knows only one shape appends a duplicate — which is exactly what
+ * happened to the Stop hook on 2026-09-07 (`sync-session.js` did not match `linksee-memory-sync`,
+ * so setup added a second one and sessions were captured twice).
+ */
+export function linkseeHookWired(settings, event, kind) {
+    const bare = kind === 'guard' ? 'guard-hook' : 'sync-session';
+    return (settings.hooks?.[event] ?? []).some((entry) => entry?.hooks?.some((h) => {
+        const hay = hookHaystack(h);
+        if (!hay)
+            return false;
+        return hay.includes(bare) || (hay.includes('linksee-memory') && hay.includes(kind));
+    }));
+}
+/** Is the session-sync (Stop) hook already wired? */
+export function syncWiredFor(settings, event = 'Stop') {
+    return linkseeHookWired(settings, event, 'sync');
+}
+/**
+ * Is OUR guard already wired for this event?
+ *
+ * Has to recognise every shape the guard has ever been wired in, or setup duplicates it:
+ *   npx -y linksee-memory guard                              (what setup writes)
+ *   linksee-memory-guard                                     (the global bin)
+ *   node /path/to/linksee-memory/dist/bin/guard-hook.js      (the old README block)
+ *   { command: 'node', args: ['.../dist/bin/guard-hook.js'] } (exec form — the path is in args)
+ *
+ * The last two put the identifying part in different places, so match against command and args
+ * joined together. `guard-hook` alone is accepted because the exec form carries no package name.
+ */
+export function guardWiredFor(settings, event) {
+    return linkseeHookWired(settings, event, 'guard');
+}
+export function guardFullyWired(settings) {
+    return GUARD_EVENTS.every((ev) => guardWiredFor(settings, ev));
+}
+/**
+ * Add the guard to any event it does not already own. Mutates and returns `settings`, plus the
+ * events that were actually added (empty when it was already wired).
+ */
+export function wireGuard(settings) {
+    const hooks = (settings.hooks ??= {});
+    const added = [];
+    for (const ev of GUARD_EVENTS) {
+        if (!Array.isArray(hooks[ev]))
+            hooks[ev] = [];
+        if (!guardWiredFor(settings, ev)) {
+            hooks[ev].push(GUARD_HOOKS[ev]);
+            added.push(ev);
+        }
+    }
+    return { settings, added };
+}
+//# sourceMappingURL=guard-wiring.js.map

package/dist/lib/guard.js

@@ -16,8 +16,8 @@ import { supersededAnchorIds } from './truth-engine.js';
 // "accepted = the only thing the gate compares against": declared (status active), still live
 // (lifecycle active|experiment — NOT at_risk/superseded/deprecated), and not explicitly card-disabled.
 // at_risk(stale) anchors deliberately DON'T gate — we don't enforce a rule we're no longer sure of.
-const ACCEPTED_SQL = `status = 'active'
-  AND lifecycle IN ('active', 'experiment')
+const ACCEPTED_SQL = `status = 'active'
+  AND lifecycle IN ('active', 'experiment')
   AND COALESCE(json_extract(card_policy, '$.enabled'), 1) != 0`;
 const nowSec = () => Math.floor(Date.now() / 1000);
 function jsonGet(json, key, def) {
@@ -39,7 +39,7 @@ function bestEffort(fn) {
 }
 export function acceptedAnchors(db) {
     const rows = db
-        .prepare(`SELECT id, kind, statement, rationale, affects, detect_terms, violation_signal, card_policy
+        .prepare(`SELECT id, kind, statement, rationale, affects, detect_terms, violation_signal, card_policy
          FROM drift_anchors WHERE ${ACCEPTED_SQL}`)
         .all();
     // A superseded anchor must stop gating. The block/warn text tells the user to run
@@ -97,9 +97,16 @@ export function matchAction(db, act) {
                 }
             }
         }
-        // Scope (mirrors the detector): a path-scoped anchor requires the action to touch an in-scope
-        // file; a global anchor (no affects) fires on topical-term OR forbidden-signal relevance.
-        const inScope = hasScope ? pathHit : termHit || sigHit != null;
+        // Scope. `affects` says WHERE a decision applies; `violation_signal` says WHAT is forbidden.
+        // An explicit signal hit is the stronger evidence, so it brings the anchor into scope on its
+        // own — otherwise a path-scoped anchor is blind to `Bash`, which carries no file path at all.
+        // That blindness was measured on a real machine: 21 of 42 active anchors declared forbidden
+        // strings and could never fire on a Bash command — including "ALTER TABLE memories DROP" on
+        // the anchor that exists to prevent exactly that. Bash is where the destructive things run.
+        //
+        // (matchViolation already guards the obvious false positives: word boundaries, a negation
+        // window, and citation-without-call — a naive substring test produced ~90% noise.)
+        const inScope = sigHit != null || (hasScope ? pathHit : termHit);
         if (!inScope)
             continue;
         out.push({
@@ -130,7 +137,7 @@ function withinCooldown(db, anchorId, sessionId) {
     return !!row;
 }
 function logInjection(db, matches, act, surface, sessionId) {
-    const ins = db.prepare(`INSERT INTO injection_log (anchor_id, session_id, trigger, surface, tool_name, action_snip, verdict)
+    const ins = db.prepare(`INSERT INTO injection_log (anchor_id, session_id, trigger, surface, tool_name, action_snip, verdict)
      VALUES (?, ?, 'gate', ?, ?, ?, ?)`);
     const snip = (act.lines[0] ?? '').slice(0, 120);
     const tx = db.transaction(() => {
@@ -185,16 +192,16 @@ export function buildBootDigest(db, opts = {}) {
     // Same rule as the gate: never re-surface a decision the user has already superseded.
     const retiredIds = supersededAnchorIds(db);
     const anchorRows = db
-        .prepare(`SELECT id, statement, rationale FROM drift_anchors
-         WHERE ${ACCEPTED_SQL} AND kind IN ('prohibition', 'decision', 'constraint')
+        .prepare(`SELECT id, statement, rationale FROM drift_anchors
+         WHERE ${ACCEPTED_SQL} AND kind IN ('prohibition', 'decision', 'constraint')
          ORDER BY confidence DESC, updated_at DESC LIMIT ?`)
         .all(maxAnchors + retiredIds.size);
     const anchors = anchorRows.filter((a) => !retiredIds.has(a.id)).slice(0, maxAnchors);
     const forks = db
-        .prepare(`SELECT c.id, c.rationale, a.statement
-         FROM memory_write_candidates c
-         LEFT JOIN drift_anchors a ON a.id = c.target_node_id
-         WHERE c.scope = 'orphaned_proposal' AND c.status = 'pending_review'
+        .prepare(`SELECT c.id, c.rationale, a.statement
+         FROM memory_write_candidates c
+         LEFT JOIN drift_anchors a ON a.id = c.target_node_id
+         WHERE c.scope = 'orphaned_proposal' AND c.status = 'pending_review'
          ORDER BY c.created_at DESC LIMIT ?`)
         .all(maxForks);
     // Distillation pressure — the routine's structural trigger. The drain must not depend on
@@ -202,10 +209,10 @@ export function buildBootDigest(db, opts = {}) {
     // EVERY session boot says so. Inflow (new sessions) vs drain (8/dream) stays visible.
     let distill = 0;
     try {
-        distill = db.prepare(`SELECT COUNT(*) AS n FROM memories
-          WHERE layer IN ('learning', 'caveat') AND json_valid(content)
-            AND (json_extract(content, '$.needs_distill') = 1
-                 OR json_extract(content, '$.why') = 'Decision detected by pattern match — may need agent enrichment'
+        distill = db.prepare(`SELECT COUNT(*) AS n FROM memories
+          WHERE layer IN ('learning', 'caveat') AND json_valid(content)
+            AND (json_extract(content, '$.needs_distill') = 1
+                 OR json_extract(content, '$.why') = 'Decision detected by pattern match — may need agent enrichment'
                  OR json_extract(content, '$.why') = 'User-stated warning/prohibition — auto-extracted by caveat pattern match')`).get().n;
     }
     catch {
@@ -238,11 +245,11 @@ export function buildBootDigest(db, opts = {}) {
 export function backfillHeeded(db) {
     bestEffort(() => {
         const live = `SELECT anchor_id FROM drift_edges WHERE verdict = 'contradicts' AND status = 'open'`;
-        db.prepare(`UPDATE injection_log SET heeded = 0
-         WHERE heeded IS NULL AND surface IN ('warn', 'inform') AND verdict = 'contradicts'
+        db.prepare(`UPDATE injection_log SET heeded = 0
+         WHERE heeded IS NULL AND surface IN ('warn', 'inform') AND verdict = 'contradicts'
            AND anchor_id IN (${live})`).run();
-        db.prepare(`UPDATE injection_log SET heeded = 1
-         WHERE heeded IS NULL AND surface IN ('warn', 'inform')
+        db.prepare(`UPDATE injection_log SET heeded = 1
+         WHERE heeded IS NULL AND surface IN ('warn', 'inform')
            AND anchor_id NOT IN (${live})`).run();
         db.prepare(`UPDATE injection_log SET heeded = 1 WHERE heeded IS NULL AND surface = 'block'`).run();
     });
@@ -254,16 +261,16 @@ export function getReinjectionFriction(db, opts = {}) {
     const minC = opts.minContradicts ?? 3;
     backfillHeeded(db);
     const rows = db
-        .prepare(`SELECT i.anchor_id,
-              SUM(CASE WHEN i.verdict = 'contradicts' THEN 1 ELSE 0 END) AS gate_contradicts,
-              SUM(CASE WHEN i.surface = 'block' THEN 1 ELSE 0 END)       AS gate_blocks,
-              SUM(CASE WHEN i.heeded = 0 THEN 1 ELSE 0 END)              AS ignored,
-              datetime(MAX(i.occurred_at), 'unixepoch')                 AS last_at,
-              a.statement, a.lifecycle, a.card_policy
-         FROM injection_log i
-         JOIN drift_anchors a ON a.id = i.anchor_id
-        WHERE a.status = 'active'
-        GROUP BY i.anchor_id
+        .prepare(`SELECT i.anchor_id,
+              SUM(CASE WHEN i.verdict = 'contradicts' THEN 1 ELSE 0 END) AS gate_contradicts,
+              SUM(CASE WHEN i.surface = 'block' THEN 1 ELSE 0 END)       AS gate_blocks,
+              SUM(CASE WHEN i.heeded = 0 THEN 1 ELSE 0 END)              AS ignored,
+              datetime(MAX(i.occurred_at), 'unixepoch')                 AS last_at,
+              a.statement, a.lifecycle, a.card_policy
+         FROM injection_log i
+         JOIN drift_anchors a ON a.id = i.anchor_id
+        WHERE a.status = 'active'
+        GROUP BY i.anchor_id
        HAVING gate_contradicts >= ?`)
         .all(minC);
     const realityStmt = db.prepare(`SELECT COUNT(*) AS n FROM drift_edges WHERE anchor_id = ? AND verdict = 'contradicts' AND status = 'open'`);

package/dist/lib/map-import.js

@@ -71,13 +71,13 @@ export function importMap(db, map) {
     const anchorExists = db.prepare('SELECT 1 FROM drift_anchors WHERE id = ?');
     let linked = 0;
     const tx = db.transaction(() => {
-        db.prepare(`
-      INSERT INTO map_projects (project, job, audience, product_status, template, stages, related_projects, updated_at)
-      VALUES (@project, @job, @audience, @product_status, @template, @stages, @related_projects, unixepoch())
-      ON CONFLICT(project) DO UPDATE SET
-        job=excluded.job, audience=excluded.audience, product_status=excluded.product_status,
-        template=excluded.template, stages=excluded.stages, related_projects=excluded.related_projects,
-        updated_at=unixepoch()
+        db.prepare(`
+      INSERT INTO map_projects (project, job, audience, product_status, template, stages, related_projects, updated_at)
+      VALUES (@project, @job, @audience, @product_status, @template, @stages, @related_projects, unixepoch())
+      ON CONFLICT(project) DO UPDATE SET
+        job=excluded.job, audience=excluded.audience, product_status=excluded.product_status,
+        template=excluded.template, stages=excluded.stages, related_projects=excluded.related_projects,
+        updated_at=unixepoch()
     `).run({
             project: map.project,
             job: map.job ?? null,
@@ -89,13 +89,13 @@ export function importMap(db, map) {
         });
         db.prepare('DELETE FROM map_edges WHERE project = ?').run(map.project);
         db.prepare('DELETE FROM map_nodes WHERE project = ?').run(map.project);
-        const insNode = db.prepare(`
-      INSERT INTO map_nodes
-        (id, project, layer, stage, statement, status, facets, role, note, due,
-         paused_reason, related_project, spinout_candidate, anchor_id, review_by, revival_condition, reality, extra, updated_at)
-      VALUES
-        (@id, @project, @layer, @stage, @statement, @status, @facets, @role, @note, @due,
-         @paused_reason, @related_project, @spinout_candidate, @anchor_id, @review_by, @revival_condition, @reality, @extra, unixepoch())
+        const insNode = db.prepare(`
+      INSERT INTO map_nodes
+        (id, project, layer, stage, statement, status, facets, role, note, due,
+         paused_reason, related_project, spinout_candidate, anchor_id, review_by, revival_condition, reality, extra, updated_at)
+      VALUES
+        (@id, @project, @layer, @stage, @statement, @status, @facets, @role, @note, @due,
+         @paused_reason, @related_project, @spinout_candidate, @anchor_id, @review_by, @revival_condition, @reality, @extra, unixepoch())
     `);
         for (const n of map.nodes) {
             if (!n.id)
@@ -134,9 +134,9 @@ export function importMap(db, map) {
                 extra: JSON.stringify(extra),
             });
         }
-        const insEdge = db.prepare(`
-      INSERT OR IGNORE INTO map_edges (project, from_id, to_id, type, strength, note)
-      VALUES (?, ?, ?, ?, ?, ?)
+        const insEdge = db.prepare(`
+      INSERT OR IGNORE INTO map_edges (project, from_id, to_id, type, strength, note)
+      VALUES (?, ?, ?, ?, ?, ?)
     `);
         for (const e of map.edges)
             insEdge.run(map.project, e.from, e.to, e.type, e.strength ?? null, e.note ?? null);

package/dist/lib/truth-engine.js

@@ -144,7 +144,7 @@ export function getTruthView(db, opts = {}) {
     const resolutionFor = buildResolutionLookup(db);
     // ── Candidates (indexed by target node) ──
     const candRows = db
-        .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status, proposed_node
+        .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status, proposed_node
        FROM memory_write_candidates ORDER BY id DESC`)
         .all();
     const pendingByNode = new Map();
@@ -165,8 +165,8 @@ export function getTruthView(db, opts = {}) {
     // anchors it has hard evidence against. (2026-09-05: 11 open `contradicts` edges across 4
     // anchors — one of them the PII constraint — all rendered "reality matches intent".)
     const edgeRows = db
-        .prepare(`SELECT anchor_id, verdict, confidence, evidence, detected_at
-         FROM drift_edges WHERE status = 'open'
+        .prepare(`SELECT anchor_id, verdict, confidence, evidence, detected_at
+         FROM drift_edges WHERE status = 'open'
         ORDER BY detected_at DESC`)
         .all();
     const openEdges = new Map();
@@ -176,8 +176,8 @@ export function getTruthView(db, opts = {}) {
         openEdges.get(e.anchor_id).push(e);
     }
     // ── Active nodes + state derivation ──
-    let sql = `SELECT id, node_type, domain, decision_mode, statement, rationale, confidence, lifecycle,
-            card_policy, review_after
+    let sql = `SELECT id, node_type, domain, decision_mode, statement, rationale, confidence, lifecycle,
+            card_policy, review_after
      FROM drift_anchors WHERE status = 'active'`;
     const params = [];
     if (opts.domain) {
@@ -350,8 +350,8 @@ export function getTruthView(db, opts = {}) {
 // ── check_decision: single-node deep view ────────────────────────────────────
 export function getDecisionDetail(db, anchorId) {
     const row = db
-        .prepare(`SELECT id, kind, node_type, domain, decision_mode, statement, rationale, confidence,
-              lifecycle, card_policy, review_after, affects, detect_terms, violation_signal, tier
+        .prepare(`SELECT id, kind, node_type, domain, decision_mode, statement, rationale, confidence,
+              lifecycle, card_policy, review_after, affects, detect_terms, violation_signal, tier
        FROM drift_anchors WHERE id = ? AND status = 'active'`)
         .get(anchorId);
     if (!row)
@@ -369,14 +369,14 @@ export function getDecisionDetail(db, anchorId) {
     // State derivation (same logic)
     let state, accounted, accountedBy;
     const pendingCand = db
-        .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status
-       FROM memory_write_candidates
-       WHERE target_node_id = ? AND status = 'pending_review'
+        .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status
+       FROM memory_write_candidates
+       WHERE target_node_id = ? AND status = 'pending_review'
        ORDER BY id DESC`)
         .all(anchorId);
     const cardCand = db
-        .prepare(`SELECT rationale FROM memory_write_candidates
-       WHERE target_node_id = ? AND proposed_node LIKE '%"src":"t%'
+        .prepare(`SELECT rationale FROM memory_write_candidates
+       WHERE target_node_id = ? AND proposed_node LIKE '%"src":"t%'
        ORDER BY id DESC LIMIT 1`)
         .get(anchorId);
     const hasPending = pendingCand.length > 0;
@@ -414,7 +414,7 @@ export function getDecisionDetail(db, anchorId) {
         ?? (state === 'aligned' ? 'Committed reality matches intent (convergent)' : null);
     // Drift edges for this anchor
     const edges = db
-        .prepare(`SELECT id AS edge_id, verdict, confidence, status, detected_at
+        .prepare(`SELECT id AS edge_id, verdict, confidence, status, detected_at
        FROM drift_edges WHERE anchor_id = ? ORDER BY detected_at DESC`)
         .all(anchorId);
     return {