linksee-memory 0.13.1 → 0.14.0

package/dist/lib/truth-engine.d.ts

@@ -1,5 +1,5 @@
 import type Database from 'better-sqlite3';
-export type DriftState = 'drift' | 'review' | 'held' | 'aligned';
+export type DriftState = 'drift' | 'review' | 'held' | 'aligned' | 'unverified';
 export type Species = 'hypothesis' | 'constraint' | 'commitment' | 'source_of_truth';
 export interface TruthNode {
     id: number;
@@ -39,6 +39,11 @@ export interface TruthCounts {
 }
 export interface TruthView {
     attention: TruthNode[];
+    /** Active anchors the detector has no evidence about — neither aligned nor drifting. */
+    unverifiedByDomain: Array<{
+        domain: string;
+        nodes: TruthNode[];
+    }>;
     alignedByDomain: Array<{
         domain: string;
         nodes: TruthNode[];

package/dist/lib/truth-engine.js

@@ -18,7 +18,7 @@ const DOMAIN_ORDER = [
     'growth', 'operations', 'security', 'roadmap', 'memory', 'other',
 ];
 const STATE_RANK = {
-    drift: 0, review: 1, held: 2, aligned: 3,
+    drift: 0, review: 1, held: 2, aligned: 3, unverified: 4,
 };
 // ── Helpers ──────────────────────────────────────────────────────────────────
 function safeJsonParse(s, fallback) {
@@ -70,6 +70,9 @@ function summarizeEdges(verdict, edges) {
     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);
+    if (verdict === 'implements') {
+        return `Observed in reality${file ? ` — ${file}` : ''} (${when}).`;
+    }
     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' : ''})`;
@@ -203,6 +206,7 @@ export function getTruthView(db, opts = {}) {
         const edges = openEdges.get(r.id) ?? [];
         const contradicts = edges.filter((e) => e.verdict === 'contradicts');
         const absent = edges.filter((e) => e.verdict === 'absent');
+        const implemented = edges.filter((e) => e.verdict === 'implements');
         // ── State derivation (the make-or-break logic) ──
         let state;
         let accounted;
@@ -251,10 +255,16 @@ export function getTruthView(db, opts = {}) {
             accounted = false;
             accountedBy = null;
         }
-        else {
-            // 🔵 convergent — reality matches intent (or no signal)
+        else if (implemented.length > 0) {
+            // 🔵 the detector saw reality match — this is the only way to be aligned without a verdict
             state = 'aligned';
             accounted = true;
+            accountedBy = 'observed (implements)';
+        }
+        else {
+            // ⚫ nothing checked, nothing decided. Not a problem — but not "fine" either.
+            state = 'unverified';
+            accounted = false;
             accountedBy = null;
         }
         // Say what was observed. Never claim convergence when nothing was checked — an agent
@@ -263,9 +273,9 @@ export function getTruthView(db, opts = {}) {
             ?? pending?.rationale
             ?? (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);
+            ?? (state === 'aligned' && implemented.length > 0 ? summarizeEdges('implements', implemented) : null)
+            ?? (state === 'aligned' ? 'Accounted for by recorded resolution' : null)
+            ?? (state === 'unverified' ? 'No signal observed (not verified against reality)' : null);
         return {
             id: r.id,
             node_type: r.node_type,
@@ -288,8 +298,18 @@ export function getTruthView(db, opts = {}) {
     });
     // ── Partition: attention (loud) vs aligned (quiet) ──
     const attention = nodes
-        .filter((n) => n.state !== 'aligned')
+        .filter((n) => n.state !== 'aligned' && n.state !== 'unverified')
         .sort((a, b) => STATE_RANK[a.state] - STATE_RANK[b.state] || b.confidence - a.confidence);
+    const unverifiedGroups = new Map();
+    for (const n of nodes.filter((n) => n.state === 'unverified')) {
+        const d = n.domain ?? 'other';
+        if (!unverifiedGroups.has(d))
+            unverifiedGroups.set(d, []);
+        unverifiedGroups.get(d).push(n);
+    }
+    const unverifiedByDomain = [...unverifiedGroups.entries()]
+        .sort((a, b) => DOMAIN_ORDER.indexOf(a[0]) - DOMAIN_ORDER.indexOf(b[0]))
+        .map(([domain, ns]) => ({ domain, nodes: ns }));
     const alignedGroups = new Map();
     for (const n of nodes.filter((n) => n.state === 'aligned')) {
         const d = n.domain ?? 'other';
@@ -311,7 +331,7 @@ export function getTruthView(db, opts = {}) {
     };
     for (const n of nodes)
         by_species[n.species]++;
-    const by_state = { drift: 0, review: 0, held: 0, aligned: 0 };
+    const by_state = { drift: 0, review: 0, held: 0, aligned: 0, unverified: 0 };
     for (const n of nodes)
         by_state[n.state]++;
     const reopenDates = nodes
@@ -335,6 +355,7 @@ export function getTruthView(db, opts = {}) {
     return {
         attention,
         alignedByDomain,
+        unverifiedByDomain,
         candidates: { auto, suppressed },
         counts: {
             nodes: nodes.length,
@@ -366,7 +387,14 @@ export function getDecisionDetail(db, anchorId) {
     catch { /* */ }
     const res = resolutionFor(row.id);
     const overdue = row.review_after != null && row.review_after * 1000 < now;
-    // State derivation (same logic)
+    // State derivation — MUST mirror getTruthView. It had drifted: this branch never looked at
+    // drift_edges, so check_decision could say "aligned" on the anchor drift_status flagged 🔴.
+    const openEdgesHere = db
+        .prepare(`SELECT verdict, confidence, evidence, detected_at FROM drift_edges WHERE anchor_id = ? AND status = 'open' ORDER BY detected_at DESC`)
+        .all(anchorId);
+    const contradictsHere = openEdgesHere.filter((e) => e.verdict === 'contradicts');
+    const absentHere = openEdgesHere.filter((e) => e.verdict === 'absent');
+    const implementedHere = openEdgesHere.filter((e) => e.verdict === 'implements');
     let state, accounted, accountedBy;
     const pendingCand = db
         .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status
@@ -395,7 +423,17 @@ export function getDecisionDetail(db, anchorId) {
         accounted = true;
         accountedBy = 'supersede (intentional evolution)';
     }
-    else if (hasPending) {
+    else if (res?.action === 'dismiss') {
+        state = 'aligned';
+        accounted = true;
+        accountedBy = 'dismiss (false positive)';
+    }
+    else if (contradictsHere.length > 0) {
+        state = 'drift';
+        accounted = false;
+        accountedBy = null;
+    }
+    else if (hasPending || absentHere.length > 0) {
         state = 'review';
         accounted = false;
         accountedBy = null;
@@ -405,13 +443,22 @@ export function getDecisionDetail(db, anchorId) {
         accounted = false;
         accountedBy = null;
     }
-    else {
+    else if (implementedHere.length > 0) {
         state = 'aligned';
         accounted = true;
+        accountedBy = 'observed (implements)';
+    }
+    else {
+        state = 'unverified';
+        accounted = false;
         accountedBy = null;
     }
     const reality = cardCand?.rationale ?? (hasPending ? pendingCand[0].rationale : null)
-        ?? (state === 'aligned' ? 'Committed reality matches intent (convergent)' : null);
+        ?? (contradictsHere.length > 0 ? summarizeEdges('contradicts', contradictsHere) : null)
+        ?? (absentHere.length > 0 ? summarizeEdges('absent', absentHere) : null)
+        ?? (state === 'aligned' && implementedHere.length > 0 ? summarizeEdges('implements', implementedHere) : null)
+        ?? (state === 'aligned' ? 'Accounted for by recorded resolution' : null)
+        ?? (state === 'unverified' ? 'No signal observed (not verified against reality)' : null);
     // Drift edges for this anchor
     const edges = db
         .prepare(`SELECT id AS edge_id, verdict, confidence, status, detected_at

package/dist/mcp/roots.js

@@ -5,7 +5,7 @@
 //
 // MCP semantics: client owns the root list, server is informed. We refresh on demand
 // (lazily on first use) and on roots/list_changed notification.
-import { ListRootsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ListRootsResultSchema } from '@modelcontextprotocol/sdk/types.js';
 let cachedRoots = null;
 let lastFetched = 0;
 const STALE_MS = 60_000; // re-fetch at most once a minute
@@ -14,7 +14,11 @@ export async function fetchRoots(server) {
     if (cachedRoots && now - lastFetched < STALE_MS)
         return cachedRoots;
     try {
-        const res = await server.request({ method: 'roots/list', params: {} }, ListRootsRequestSchema);
+        // Protocol.request(request, RESULT schema). This passed the REQUEST schema, so every client's
+        // reply — `{ roots: [...] }` — failed validation against a shape expecting `{ method: 'roots/list' }`,
+        // was swallowed by the catch below, and cached as "no roots" for a minute. Roots had been empty
+        // for every client since this was written; where_am_i's root inference never once fired.
+        const res = await server.request({ method: 'roots/list', params: {} }, ListRootsResultSchema);
         cachedRoots = Array.isArray(res?.roots) ? res.roots : [];
         lastFetched = now;
     }

package/dist/mcp/server.js

@@ -136,15 +136,32 @@ const LAYER_ENUM = ['goal', 'context', 'emotion', 'implementation', 'caveat', 'l
 const TOOLS = [
     {
         name: 'remember',
-        description: 'Persist knowledge across sessions and AI tools (Claude, GPT, Cursor, Codex, Gemini). The only cross-agent memory that survives session boundaries.\n\nWHEN TO CALL:\n• The moment an error or failure occurs → layer: "caveat" (auto-protected, never forgotten)\n• When a decision is made or approved → layer: "learning"\n• When a goal is set or updated → layer: "goal"\n• When something new is learned → layer: "learning"\n• When the user says "remember this" / "覚えておいて"\n• After completing a task or receiving user approval\n\nREQUIRED PARAMS BY MODE:\n• Create (default): entity_name + entity_kind + layer + content\n• Update: memory_id (+ optional content, layer, importance)\n• Delete: memory_id + forget: true\n\nImportance ≥ 0.9 pins the memory (protected from auto-forgetting). Supports Japanese (日本語) and English.',
+        description: 'Persist knowledge across sessions and AI tools (Claude, GPT, Cursor, Codex, Gemini). The only cross-agent memory that survives session boundaries.\n\nWHEN TO CALL:\n• The moment an error or failure occurs → layer: "caveat" (auto-protected, never forgotten)\n• When a decision is made or approved → content + anchor: {} (remembered AND enforced in one call)\n• When a goal is set or updated → layer: "goal"\n• When something new is learned → layer: "learning"\n• When the user says "remember this" / "覚えておいて"\n• After completing a task or receiving user approval\n\nMODES:\n• Create (default): content is the only required field. entity defaults to the project you are in; layer defaults to "context" (or "learning" when anchor is set).\n• Create + enforce: add anchor: {} — the memory also becomes a decision the guard re-injects before Edit/Write/Bash and on session start. Give anchor.violation_signal (forbidden strings) to make contradictions detectable; anchor.affects (path globs) to scope it.\n• Update: memory_id (+ optional content, layer, importance)\n• Delete: memory_id + forget: true\n\nImportance ≥ 0.9 pins the memory (protected from auto-forgetting). Supports Japanese (日本語) and English.',
         inputSchema: {
             type: 'object',
             properties: {
-                entity_name: { type: 'string', description: 'Name of the entity this memory is about (required for create)' },
-                entity_kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'Required for create' },
+                entity_name: { type: 'string', description: 'What this memory is about. Optional — defaults to the project you are working in (from workspace roots, else the files edited recently).' },
+                entity_kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'Optional — defaults to "project".' },
+                anchor: {
+                    description: 'Also declare this as an enforceable decision. Pass {} for defaults, or an object: { kind?: "decision"|"prohibition"|"constraint", violation_signal?: string[] (forbidden strings — needed for the gate to detect a contradiction), affects?: string[] (path globs that scope it), detect_terms?: string[], domain?: string, rationale?: string }. Without violation_signal the anchor is a constraint: re-injected on session start and when its scope is touched, but no contradiction can be detected.',
+                    anyOf: [
+                        { type: 'boolean' },
+                        {
+                            type: 'object',
+                            properties: {
+                                kind: { type: 'string', enum: ['decision', 'prohibition', 'constraint'] },
+                                violation_signal: { type: 'array', items: { type: 'string' } },
+                                affects: { type: 'array', items: { type: 'string' } },
+                                detect_terms: { type: 'array', items: { type: 'string' } },
+                                domain: { type: 'string' },
+                                rationale: { type: 'string' },
+                            },
+                        },
+                    ],
+                },
                 entity_key: { type: 'string', description: 'Optional canonical key (email, domain, file path)' },
-                layer: { type: 'string', description: 'One of: goal / context / emotion / implementation / caveat / learning. Aliases accepted (why→goal, warnings→caveat, decisions→learning, how→implementation).' },
-                content: { type: 'string', description: 'The memory content (plain text or structured JSON with altitude/type/state/what/why)' },
+                layer: { type: 'string', description: 'One of: goal / context / emotion / implementation / caveat / learning. Aliases accepted (why→goal, warnings→caveat, decisions→learning, how→implementation). Optional — defaults to "context", or "learning" when anchor is set.' },
+                content: { type: 'string', description: 'The memory content (plain text or structured JSON with altitude/type/state/what/why). The only required field for create.' },
                 importance: { type: 'number', minimum: 0, maximum: 1, description: '0.0-1.0. Set ≥0.9 to pin (protects from forgetting).' },
                 thread_id: { type: 'string', description: 'Optional thread ID to group related memories (decision chains, session groups).' },
                 force: { type: 'boolean', default: false, description: 'Bypass paste-back quality check.' },
@@ -436,14 +453,74 @@ function handleRemember(args) {
         .run(entityId, layer, rawContent, importance, importance >= 0.9 ? 1 : 0, args.thread_id ?? null);
     db.prepare('INSERT INTO events (entity_id, kind, payload) VALUES (?, ?, ?)').run(entityId, 'memory_stored', JSON.stringify({ layer, memory_id: result.lastInsertRowid }));
     const mom = refreshMomentumForEntity(db, entityId);
-    return JSON.stringify({
+    const memoryId = Number(result.lastInsertRowid);
+    const out = {
         ok: true,
-        memory_id: Number(result.lastInsertRowid),
+        memory_id: memoryId,
         entity_id: entityId,
         layer,
         pinned: importance >= 0.9,
         momentum: { score: mom.score, band: mom.band },
-    });
+    };
+    // "Remember" and "enforce" used to be two tools with two schemas, and an agent had to pick.
+    // Picking remember meant the decision was stored but never re-injected — the exact failure
+    // the product exists to prevent. One call now does both when the caller asks for it.
+    if (args.anchor) {
+        const spec = typeof args.anchor === 'object' && args.anchor !== null ? args.anchor : {};
+        let what = rawContent, why = spec.rationale;
+        try {
+            const c = JSON.parse(rawContent);
+            if (c && typeof c === 'object') {
+                what = String(c.what ?? c.title ?? rawContent);
+                why = why ?? (c.why ? String(c.why) : undefined);
+            }
+        }
+        catch { /* plain text */ }
+        const signals = Array.isArray(spec.violation_signal) ? spec.violation_signal : [];
+        // A decision/prohibition needs forbidden strings for a contradiction to be detectable; without
+        // them the honest shape is a constraint (still re-injected on boot and when its scope is touched).
+        const kind = spec.kind ?? (signals.length > 0 ? 'decision' : 'constraint');
+        try {
+            const anchor = declareAnchor(db, {
+                kind,
+                statement: what.length >= 8 ? what : `${what} (decision)`,
+                rationale: why,
+                affects: Array.isArray(spec.affects) ? spec.affects : undefined,
+                detect_terms: Array.isArray(spec.detect_terms) ? spec.detect_terms : undefined,
+                violation_signal: signals.length > 0 ? signals : undefined,
+                tier: 'human',
+                source_memory_id: memoryId,
+            });
+            const nodeFields = {};
+            if (spec.domain)
+                nodeFields.domain = spec.domain;
+            if (spec.confidence !== undefined)
+                nodeFields.confidence = spec.confidence;
+            if (Object.keys(nodeFields).length > 0)
+                setNodeFields(db, anchor.id, nodeFields);
+            // Link both ways so recall can show "this memory is enforced as #N" and the anchor can
+            // point back at the moment it was decided.
+            try {
+                const c = JSON.parse(rawContent);
+                if (c && typeof c === 'object') {
+                    c.anchor_id = anchor.id;
+                    db.prepare('UPDATE memories SET content = ? WHERE id = ?').run(JSON.stringify(c), memoryId);
+                }
+            }
+            catch { /* leave content as-is */ }
+            logAnchorTouch(db, { anchorId: anchor.id, tool: 'remember', interaction: 'create' });
+            out.anchor_id = anchor.id;
+            out.anchor_kind = kind;
+            out.enforced = signals.length > 0
+                ? 'contradictions are detected at the gate; re-injected on boot and in scope'
+                : 'no violation_signal given — re-injected on boot and when its scope is touched, but contradictions cannot be detected';
+        }
+        catch (e) {
+            out.anchor_error = String(e?.message ?? e);
+            out.hint = 'The memory was saved. Fix the anchor spec and call declare_anchor, or remember again with a corrected anchor.';
+        }
+    }
+    return JSON.stringify(out);
 }
 // Sanitize query for FTS5 MATCH (strip chars that break the grammar, quote it).
 // Note: with trigram tokenizer, tokens shorter than 3 chars cannot match anything.
@@ -1234,14 +1311,77 @@ async function handleRememberUnified(args) {
     if (args.memory_id) {
         return handleUpdateMemory(args);
     }
-    // Create mode (default) — validate required fields
-    if (!args.entity_name || !args.entity_kind || !args.layer || !args.content) {
+    // Create mode (default). Only content is required; everything an agent used to have to
+    // invent is defaulted. Inventing an entity name and picking a layer were the two places a
+    // "remember this" call stalled — the taxonomy is for the dashboard, not for the agent.
+    if (!args.content || !String(args.content).trim()) {
         return JSON.stringify({
             ok: false,
-            error: 'Create mode requires: entity_name, entity_kind, layer, content. To update, provide memory_id. To delete, set forget: true + memory_id.',
+            error: 'content is required. (entity/layer are optional now.) To update, provide memory_id. To delete, set forget: true + memory_id.',
         });
     }
-    return handleRemember(args);
+    const a = { ...args };
+    let entityInferred;
+    if (!a.entity_name) {
+        const inferred = await inferDefaultEntity();
+        a.entity_name = inferred.name;
+        a.entity_kind = a.entity_kind ?? inferred.kind;
+        entityInferred = inferred.from;
+    }
+    if (!a.entity_kind)
+        a.entity_kind = 'project';
+    if (!a.layer)
+        a.layer = a.anchor ? 'learning' : 'context';
+    const out = handleRemember(a);
+    if (!entityInferred)
+        return out;
+    try {
+        const parsed = JSON.parse(out);
+        if (parsed.ok)
+            parsed.entity_inferred_from = entityInferred;
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return out;
+    }
+}
+/**
+ * The entity a memory is about when the caller did not say: the project they are in.
+ * Same evidence chain as where_am_i — workspace roots first, then the files edited recently.
+ */
+async function inferDefaultEntity() {
+    try {
+        const roots = await fetchRoots(server);
+        if (roots.length === 1) {
+            const base = rootPathFromUri(roots[0].uri).replace(/\\/g, '/').replace(/\/+$/, '').split('/').pop();
+            if (base)
+                return { name: base, kind: 'project', from: 'workspace_root' };
+        }
+    }
+    catch { /* roots unsupported by this host */ }
+    try {
+        const rows = db
+            .prepare(`SELECT file_path FROM session_file_edits WHERE occurred_at > unixepoch() - 86400 ORDER BY occurred_at DESC LIMIT 40`)
+            .all();
+        const paths = rows.map((r) => r.file_path.replace(/\\/g, '/').split('/').filter(Boolean));
+        if (paths.length > 0) {
+            // longest common directory prefix of what was touched → its basename is the project
+            let prefix = paths[0].slice(0, -1);
+            for (const p of paths.slice(1)) {
+                let i = 0;
+                while (i < prefix.length && i < p.length - 1 && prefix[i].toLowerCase() === p[i].toLowerCase())
+                    i++;
+                prefix = prefix.slice(0, i);
+                if (prefix.length === 0)
+                    break;
+            }
+            const base = prefix[prefix.length - 1];
+            if (base && !/^(c:|users|home|[a-z])$/i.test(base))
+                return { name: base, kind: 'project', from: 'recent_edits' };
+        }
+    }
+    catch { /* fall through */ }
+    return { name: 'workspace', kind: 'project', from: 'fallback' };
 }
 async function handleRecallUnified(args) {
     // File history mode (path takes priority; if query also provided, include it as context)
@@ -1294,7 +1434,8 @@ function handleDriftStatus(args) {
         by_state.drift > 0 ? `🔴 ${by_state.drift} drifting` : null,
         by_state.review > 0 ? `🟡 ${by_state.review} needs review` : null,
         by_state.held > 0 ? `⚪ ${by_state.held} held` : null,
-        `🔵 ${by_state.aligned} aligned`,
+        `🔵 ${by_state.aligned} verified`,
+        by_state.unverified > 0 ? `⚫ ${by_state.unverified} unverified` : null,
     ].filter(Boolean).join(' · ');
     if (args?.verbose) {
         return JSON.stringify({
@@ -1315,6 +1456,13 @@ function handleDriftStatus(args) {
         count: g.nodes.length,
         nodes: g.nodes.map((n) => ({ id: n.id, statement: n.statement, reality: n.reality })),
     }));
+    // Unverified is the quiet majority on most machines. One line each, grouped by domain —
+    // enough to see where the detector has no eyes, not enough to bury the six that matter.
+    const unverified = view.unverifiedByDomain.map((g) => ({
+        domain: g.domain,
+        count: g.nodes.length,
+        nodes: g.nodes.map((n) => ({ id: n.id, statement: n.statement })),
+    }));
     const cand = view.candidates;
     return JSON.stringify({
         ok: true,
@@ -1322,9 +1470,10 @@ function handleDriftStatus(args) {
         nextReopen: view.nextReopen,
         attention: view.attention,
         aligned,
+        unverified,
         candidates: { auto: cand?.auto?.length ?? 0, suppressed: cand?.suppressed?.length ?? 0 },
         counts: view.counts,
-        hint: 'verbose:true for full aligned nodes and candidate details; check_decision(anchor_id) for one node.',
+        hint: 'verbose:true for full nodes and candidate details; check_decision(anchor_id) for one node. ⚫ unverified = declared, never checked against reality: give it affects/violation_signal so the detector can see it, or leave it as a note.',
     });
 }
 // Fix ① (2026-06-17): infer the Map project from the client's workspace roots when the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linksee-memory",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Local-first agent memory MCP — cross-agent brain with drift detection, 6-layer structured memory + token-saving file diff cache",
   "type": "module",