linksee-memory 0.11.5 → 0.12.1

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.js

@@ -12,6 +12,7 @@
 // FAIL-OPEN by construction: every DB op is best-effort; only an explicit 'hard' contradiction yields
 // a block. Lexical only (no embeddings): reuses lexical-match.ts (the same logic as the detector).
 import { normPath, compileGlob, parseArray, matchViolation, SCRAPE_ANCHOR } from './lexical-match.js';
+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.
@@ -37,10 +38,16 @@ function bestEffort(fn) {
     }
 }
 export function acceptedAnchors(db) {
-    return db
+    const rows = db
         .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
+    // resolve_drift(action:'supersede') — if the gate ignored that resolution, following the
+    // instruction would not lift the block (dead end). status/lifecycle are not touched by
+    // supersede, so the resolution record is the only place that knows.
+    const retired = supersededAnchorIds(db);
+    return retired.size === 0 ? rows : rows.filter((a) => !retired.has(a.id));
 }
 function buildActionCtx(input) {
     const files = [];
@@ -175,11 +182,14 @@ export function formatReinject(matches, gate) {
 export function buildBootDigest(db, opts = {}) {
     const maxAnchors = opts.maxAnchors ?? 8;
     const maxForks = opts.maxForks ?? 5;
-    const anchors = db
+    // 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')
          ORDER BY confidence DESC, updated_at DESC LIMIT ?`)
-        .all(maxAnchors);
+        .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

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.d.ts

@@ -65,6 +65,22 @@ export interface DecisionDetail extends TruthNode {
         detected_at: number;
     }>;
 }
+/**
+ * Anchors that have been explicitly superseded ("intent evolved, this is the new direction").
+ *
+ * Resolutions live in meta.t3_resolutions keyed `A<anchor_id>`, one record per anchor
+ * (a later resolve_drift overwrites the earlier one), so the current resolution for
+ * anchor N is simply t3_resolutions["A"+N].
+ *
+ * NOTE the asymmetry: a supersede record names BOTH sides (superseded_node = the old
+ * anchor, superseded_by = the new one). Only the OLD one is retired — the new anchor must
+ * keep enforcing, so we match on `superseded_node` and never on `superseded_by`.
+ *
+ * Used by the gate (guard.ts) so that the enforcement layer honours the same
+ * make-or-break rule as the reporting layer: a divergence accounted for by a recorded
+ * resolution is NOT drift.
+ */
+export declare function supersededAnchorIds(db: Database.Database): Set<number>;
 export declare function getTruthView(db: Database.Database, opts?: {
     domain?: string;
     decision_mode?: string;

package/dist/lib/truth-engine.js

@@ -59,6 +59,22 @@ function classifySpecies(decision_mode) {
         default: return 'hypothesis';
     }
 }
+// ── Edge summary (one line the agent can act on) ─────────────────────────────
+function summarizeEdges(verdict, edges) {
+    const latest = edges[0];
+    let ev = {};
+    try {
+        ev = JSON.parse(latest.evidence || '{}');
+    }
+    catch { /* ignore */ }
+    const file = ev.file_path ? String(ev.file_path).replace(/\\/g, '/').split('/').slice(-2).join('/') : null;
+    const hit = ev.hit_term ? ` hit "${ev.hit_term}"` : '';
+    const when = new Date(latest.detected_at * 1000).toISOString().slice(0, 10);
+    const head = verdict === 'contradicts'
+        ? `${edges.length} open contradiction${edges.length > 1 ? 's' : ''}`
+        : `declared but not found in reality (${edges.length} absent signal${edges.length > 1 ? 's' : ''})`;
+    return `${head}${file ? ` — ${file}` : ''}${hit} (${when}). resolve_drift: fix if reality is wrong, dismiss if false positive.`;
+}
 function buildResolutionLookup(db) {
     const t3res = safeJsonParse(db.prepare("SELECT value FROM meta WHERE key='t3_resolutions'").get()?.value, {});
     const t2res = safeJsonParse(db.prepare("SELECT value FROM meta WHERE key='t2_resolutions'").get()?.value, {});
@@ -67,6 +83,11 @@ function buildResolutionLookup(db) {
     return function resolutionFor(id) {
         const matches = [];
         for (const r of Object.values(t3res)) {
+            // A supersede record names both sides. Only the OLD anchor is accounted for by it;
+            // the replacement must stay checkable (otherwise a new North Star could never drift,
+            // because the supersede branch wins over the contradicts branch).
+            if (r && r.action === 'supersede' && r.superseded_by === id && r.superseded_node !== id)
+                continue;
             if (r && (r.superseded_node === id || r.superseded_by === id ||
                 r.node === id || r.direction_node === id || r.constraint_node === id)) {
                 matches.push(r);
@@ -91,6 +112,33 @@ function buildResolutionLookup(db) {
     };
 }
 // ── Core: getTruthView ───────────────────────────────────────────────────────
+/**
+ * Anchors that have been explicitly superseded ("intent evolved, this is the new direction").
+ *
+ * Resolutions live in meta.t3_resolutions keyed `A<anchor_id>`, one record per anchor
+ * (a later resolve_drift overwrites the earlier one), so the current resolution for
+ * anchor N is simply t3_resolutions["A"+N].
+ *
+ * NOTE the asymmetry: a supersede record names BOTH sides (superseded_node = the old
+ * anchor, superseded_by = the new one). Only the OLD one is retired — the new anchor must
+ * keep enforcing, so we match on `superseded_node` and never on `superseded_by`.
+ *
+ * Used by the gate (guard.ts) so that the enforcement layer honours the same
+ * make-or-break rule as the reporting layer: a divergence accounted for by a recorded
+ * resolution is NOT drift.
+ */
+export function supersededAnchorIds(db) {
+    const out = new Set();
+    for (const key of ['t3_resolutions', 't2_resolutions']) {
+        const res = safeJsonParse(db.prepare('SELECT value FROM meta WHERE key = ?').get(key)?.value, {});
+        for (const r of Object.values(res)) {
+            if (r && r.action === 'supersede' && typeof r.superseded_node === 'number') {
+                out.add(r.superseded_node);
+            }
+        }
+    }
+    return out;
+}
 export function getTruthView(db, opts = {}) {
     const now = Date.now();
     const resolutionFor = buildResolutionLookup(db);
@@ -112,6 +160,21 @@ export function getTruthView(db, opts = {}) {
             cardByNode.set(c.target_node_id, c);
         }
     }
+    // ── Open drift edges (what the detector actually observed) ──
+    // The detector writes drift_edges; a truth view that never reads them will report 🔵 for
+    // 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'
+        ORDER BY detected_at DESC`)
+        .all();
+    const openEdges = new Map();
+    for (const e of edgeRows) {
+        if (!openEdges.has(e.anchor_id))
+            openEdges.set(e.anchor_id, []);
+        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
@@ -137,6 +200,9 @@ export function getTruthView(db, opts = {}) {
         const pending = pendingByNode.get(r.id);
         const card = cardByNode.get(r.id);
         const overdue = r.review_after != null && r.review_after * 1000 < now;
+        const edges = openEdges.get(r.id) ?? [];
+        const contradicts = edges.filter((e) => e.verdict === 'contradicts');
+        const absent = edges.filter((e) => e.verdict === 'absent');
         // ── State derivation (the make-or-break logic) ──
         let state;
         let accounted;
@@ -159,8 +225,22 @@ export function getTruthView(db, opts = {}) {
             accounted = true;
             accountedBy = 'supersede (intentional evolution)';
         }
-        else if (pending) {
-            // 🟡 Soft signal awaiting human decision
+        else if (res?.action === 'dismiss') {
+            // 🔵 a human looked at the signal and called it a false positive — that IS an answer.
+            state = 'aligned';
+            accounted = true;
+            accountedBy = 'dismiss (false positive)';
+        }
+        else if (contradicts.length > 0) {
+            // 🔴 the detector has hard evidence against this anchor and nobody has answered it.
+            // resolve_drift(fix|dismiss) closes the edges; supersede/acknowledge are handled above.
+            state = 'drift';
+            accounted = false;
+            accountedBy = null;
+        }
+        else if (pending || absent.length > 0) {
+            // 🟡 Soft signal awaiting human decision (a pending candidate, or "declared but not
+            // found in reality" — absent is weaker than contradicts, so it asks rather than alarms)
             state = 'review';
             accounted = false;
             accountedBy = null;
@@ -177,9 +257,15 @@ export function getTruthView(db, opts = {}) {
             accounted = true;
             accountedBy = null;
         }
+        // Say what was observed. Never claim convergence when nothing was checked — an agent
+        // reading "reality matches intent" will trust it; "no signal observed" it will verify.
         const reality = card?.rationale
             ?? pending?.rationale
-            ?? (state === 'aligned' ? 'Committed reality matches intent (convergent)' : null);
+            ?? (contradicts.length > 0 ? summarizeEdges('contradicts', contradicts) : null)
+            ?? (absent.length > 0 ? summarizeEdges('absent', absent) : null)
+            ?? (state === 'aligned'
+                ? (accountedBy ? 'Accounted for by recorded resolution' : 'No signal observed (not verified against reality)')
+                : null);
         return {
             id: r.id,
             node_type: r.node_type,

package/dist/mcp/prompts.js

@@ -63,23 +63,23 @@ export function getPrompt(name, args) {
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `You are an agent-memory writer. Read the session transcript below and propose memories to save. Output a JSON array; each item has {entity_name, entity_kind, layer, content, importance}.
-
-Layers (use exactly one per memory):
-- goal: WHY this work exists, target outcome
-- context: WHY THIS NOW, situation, timing
-- emotion: USER tone, feelings expressed
-- implementation: HOW it was done, what worked, what failed
-- caveat: PAIN lesson, "never X" / "always Y" — these are protected from forgetting
-- learning: GROWTH, decisions made, insights
-
-Rules:
-- Max 6 entries (one per layer). Skip layers with nothing worth saving.
-- Importance 0-1. Set 0.9+ to pin (use sparingly).
-- Caveats must be 1 sentence and start with a verb.
-- Quote nothing verbatim; summarize.
-
-Transcript:
+                            text: `You are an agent-memory writer. Read the session transcript below and propose memories to save. Output a JSON array; each item has {entity_name, entity_kind, layer, content, importance}.
+
+Layers (use exactly one per memory):
+- goal: WHY this work exists, target outcome
+- context: WHY THIS NOW, situation, timing
+- emotion: USER tone, feelings expressed
+- implementation: HOW it was done, what worked, what failed
+- caveat: PAIN lesson, "never X" / "always Y" — these are protected from forgetting
+- learning: GROWTH, decisions made, insights
+
+Rules:
+- Max 6 entries (one per layer). Skip layers with nothing worth saving.
+- Importance 0-1. Set 0.9+ to pin (use sparingly).
+- Caveats must be 1 sentence and start with a verb.
+- Quote nothing verbatim; summarize.
+
+Transcript:
 ${transcript}${entityHint}`,
                         },
                     },
@@ -96,15 +96,15 @@ ${transcript}${entityHint}`,
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `You are a caveat extractor. Read the source text below and output a JSON list of caveats. Each caveat:
-- Starts with a verb ("Never", "Always", "Watch out", "Reject", "Confirm")
-- Is one sentence
-- Is concrete (a specific failure mode, not abstract advice)
-- Captures something the reader does NOT want to relearn the hard way
-
-Output format: [{"content": "Never X when Y, because Z", "importance": 0.7-1.0}]
-
-Source text:
+                            text: `You are a caveat extractor. Read the source text below and output a JSON list of caveats. Each caveat:
+- Starts with a verb ("Never", "Always", "Watch out", "Reject", "Confirm")
+- Is one sentence
+- Is concrete (a specific failure mode, not abstract advice)
+- Captures something the reader does NOT want to relearn the hard way
+
+Output format: [{"content": "Never X when Y, because Z", "importance": 0.7-1.0}]
+
+Source text:
 ${text}${entityHint}`,
                         },
                     },
@@ -121,17 +121,17 @@ ${text}${entityHint}`,
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `Consolidate the past week's memories for entity "${entityName}" (week_offset=${weekOffset}).
-
-Step 1: Call recall(query="${entityName}", entity_name="${entityName}", max_tokens=4000) to retrieve recent memories.
-Step 2: Read the returned memories and produce ONE learning-layer summary that captures:
-  - What we set out to do (goal trajectory)
-  - What actually happened (implementation summary)
-  - What we learned (1-3 insights)
-  - Any caveats we should never forget (preserve these — do NOT consolidate them away)
-
-Step 3: Output a JSON object {entity_name, layer:"learning", content, importance:0.7}.
-
+                            text: `Consolidate the past week's memories for entity "${entityName}" (week_offset=${weekOffset}).
+
+Step 1: Call recall(query="${entityName}", entity_name="${entityName}", max_tokens=4000) to retrieve recent memories.
+Step 2: Read the returned memories and produce ONE learning-layer summary that captures:
+  - What we set out to do (goal trajectory)
+  - What actually happened (implementation summary)
+  - What we learned (1-3 insights)
+  - Any caveats we should never forget (preserve these — do NOT consolidate them away)
+
+Step 3: Output a JSON object {entity_name, layer:"learning", content, importance:0.7}.
+
 Do not write to memory directly — just return the JSON. The user will choose whether to save.`,
                         },
                     },
@@ -151,15 +151,15 @@ Do not write to memory directly — just return the JSON. The user will choose w
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `Before doing this task, recall first.
-
-Task: ${task}
-
-Step 1: Call ${recallCmd}.
-Step 2: Skim the returned memories. Identify any caveats that apply.
-Step 3: Produce your output with INLINE citations to relevant memory_ids: e.g. "Use better-sqlite3 v12+ [memory:1234] because v11 breaks on Node 24 [memory:5678]."
-Step 4: If you found NO relevant memories, say so explicitly: "No prior memories on this — proceeding from first principles."
-
+                            text: `Before doing this task, recall first.
+
+Task: ${task}
+
+Step 1: Call ${recallCmd}.
+Step 2: Skim the returned memories. Identify any caveats that apply.
+Step 3: Produce your output with INLINE citations to relevant memory_ids: e.g. "Use better-sqlite3 v12+ [memory:1234] because v11 breaks on Node 24 [memory:5678]."
+Step 4: If you found NO relevant memories, say so explicitly: "No prior memories on this — proceeding from first principles."
+
 Goal: never solve a problem twice without checking.`,
                         },
                     },
@@ -176,18 +176,18 @@ Goal: never solve a problem twice without checking.`,
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `Produce a handoff document for entity "${entityName}", aimed at: ${audience}.
-
-Step 1: Call recall(query="${entityName}", entity_name="${entityName}", max_tokens=6000).
-Step 2: Skim memories grouped by layer.
-Step 3: Output a markdown doc with these sections:
-  - **Identity**: name, kind, canonical key (if any)
-  - **Goal** (from goal-layer memories): what this entity is for
-  - **State** (from latest implementation memories): where things stand right now
-  - **Caveats** (from caveat-layer memories): what NEVER to do, with memory_id citations
-  - **Open questions**: things the prior session left unresolved
-  - **Suggested next steps**: 3 concrete actions for the audience
-
+                            text: `Produce a handoff document for entity "${entityName}", aimed at: ${audience}.
+
+Step 1: Call recall(query="${entityName}", entity_name="${entityName}", max_tokens=6000).
+Step 2: Skim memories grouped by layer.
+Step 3: Output a markdown doc with these sections:
+  - **Identity**: name, kind, canonical key (if any)
+  - **Goal** (from goal-layer memories): what this entity is for
+  - **State** (from latest implementation memories): where things stand right now
+  - **Caveats** (from caveat-layer memories): what NEVER to do, with memory_id citations
+  - **Open questions**: things the prior session left unresolved
+  - **Suggested next steps**: 3 concrete actions for the audience
+
 Keep it under 1 page. Cite memory_ids inline like [memory:1234].`,
                         },
                     },

package/dist/mcp/resources.js

@@ -71,10 +71,10 @@ function fmtMemory(row) {
         access_count: row.access_count,
     };
 }
-const SELECT_MEMORY_BASE = `
-  SELECT m.id, m.layer, m.content, m.importance, m.protected, m.created_at, m.last_accessed_at, m.access_count,
-         e.name as entity_name, e.kind as entity_kind
-  FROM memories m JOIN entities e ON e.id = m.entity_id
+const SELECT_MEMORY_BASE = `
+  SELECT m.id, m.layer, m.content, m.importance, m.protected, m.created_at, m.last_accessed_at, m.access_count,
+         e.name as entity_name, e.kind as entity_kind
+  FROM memories m JOIN entities e ON e.id = m.entity_id
 `;
 export function readResource(db, uri) {
     // Static endpoints
@@ -101,9 +101,9 @@ export function readResource(db, uri) {
         // heat_band is dynamic; approximate "hot" via access_count + recent access desc.
         // For exact heat scoring, use the recall tool with band='hot'.
         const rows = db
-            .prepare(`${SELECT_MEMORY_BASE}
-         WHERE m.last_accessed_at IS NOT NULL
-         ORDER BY m.access_count DESC, m.last_accessed_at DESC
+            .prepare(`${SELECT_MEMORY_BASE}
+         WHERE m.last_accessed_at IS NOT NULL
+         ORDER BY m.access_count DESC, m.last_accessed_at DESC
          LIMIT 50`)
             .all();
         return {

package/dist/mcp/sampling.js

@@ -38,15 +38,15 @@ export async function sampleConsolidation(server, memoryTexts, entityName) {
     if (memoryTexts.length === 0)
         return { ok: false, reason: 'no input memories' };
     const numbered = memoryTexts.map((t, i) => `[${i + 1}] ${t}`).join('\n\n');
-    const userPrompt = `Consolidate these ${memoryTexts.length} memories about "${entityName}" into a single learning-layer summary. The summary must:
-- Preserve the trajectory (what was attempted, what worked, what changed)
-- Be 2-4 sentences max
-- Not invent facts not in the originals
-- Not include verbatim quotes
-
-Memories:
-${numbered}
-
+    const userPrompt = `Consolidate these ${memoryTexts.length} memories about "${entityName}" into a single learning-layer summary. The summary must:
+- Preserve the trajectory (what was attempted, what worked, what changed)
+- Be 2-4 sentences max
+- Not invent facts not in the originals
+- Not include verbatim quotes
+
+Memories:
+${numbered}
+
 Output the summary text only — no preamble, no JSON wrapper.`;
     return sample(server, {
         systemPrompt: 'You are a memory consolidator. Compress without distorting.',
@@ -56,17 +56,17 @@ Output the summary text only — no preamble, no JSON wrapper.`;
     });
 }
 export async function sampleLayerClassification(server, content) {
-    const userPrompt = `Classify this memory content into exactly one layer:
-- goal: WHY this work exists, target outcome
-- context: WHY THIS NOW, situation, timing
-- emotion: USER tone, feelings expressed
-- implementation: HOW it was done, what worked, what failed
-- caveat: PAIN lesson, "never X" / "always Y"
-- learning: GROWTH, decisions made, insights
-
-Content:
-${content}
-
+    const userPrompt = `Classify this memory content into exactly one layer:
+- goal: WHY this work exists, target outcome
+- context: WHY THIS NOW, situation, timing
+- emotion: USER tone, feelings expressed
+- implementation: HOW it was done, what worked, what failed
+- caveat: PAIN lesson, "never X" / "always Y"
+- learning: GROWTH, decisions made, insights
+
+Content:
+${content}
+
 Output just the layer name — no explanation, no JSON.`;
     return sample(server, {
         systemPrompt: 'You are a layer classifier. Output one word.',