linksee-memory 0.13.0 → 0.14.0

package/dist/db/schema.sql

@@ -377,6 +377,25 @@ CREATE TABLE IF NOT EXISTS anchor_touch_log (
 CREATE INDEX IF NOT EXISTS idx_anchor_touch_time   ON anchor_touch_log(occurred_at);
 CREATE INDEX IF NOT EXISTS idx_anchor_touch_anchor ON anchor_touch_log(anchor_id, occurred_at);
 
+-- ============================================================
+-- v16: gate_dismissals — the human's "that was a false positive", made durable.
+-- resolve_drift(action:'dismiss') closed drift_edges but the GATE never read the verdict, so
+-- the same wrong match fired again on the next command. Observed: anchor #13 ("don't favour
+-- our own products in rankings", signals = the bare product names) fired 6× in two minutes
+-- because a temp file path contained "Sake-Navi". A verdict that does not change the next
+-- detection is not a feedback loop.
+-- hit_term NULL = silence this anchor at the gate entirely; otherwise only that match term.
+-- ============================================================
+CREATE TABLE IF NOT EXISTS gate_dismissals (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  anchor_id   INTEGER NOT NULL REFERENCES drift_anchors(id) ON DELETE CASCADE,
+  hit_term    TEXT,                                  -- lowercased match term; NULL = whole anchor
+  rationale   TEXT,
+  created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_gate_dismissal_uniq
+  ON gate_dismissals(anchor_id, COALESCE(hit_term, ''));
+
 -- ============================================================
 -- v11: Current Truth Map — journey-spine topology (Product Drift OS spec v3).
 -- map.yaml (git) is the desired-state SOURCE OF TRUTH (anchor #58); these tables
@@ -456,6 +475,6 @@ CREATE TABLE IF NOT EXISTS meta (
   value         TEXT NOT NULL
 );
 
-INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '15');
+INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '16');
 INSERT OR IGNORE INTO meta (key, value) VALUES ('created_at', CAST(unixepoch() AS TEXT));
-UPDATE meta SET value = '15' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14');
+UPDATE meta SET value = '16' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15');

package/dist/lib/guard.d.ts

@@ -18,6 +18,8 @@ export interface GateMatch {
     verdict: 'contradicts' | 'in_scope';
     why: string;
     gate_mode: GateMode;
+    /** The exact term that matched, so the reader can dismiss precisely this match. */
+    hit_term?: string | null;
 }
 export interface GateResult {
     gate: GateLevel;

package/dist/lib/guard.js

@@ -67,9 +67,35 @@ function buildActionCtx(input) {
     const haystack = [...files.map(normPath), ...rawParts].join('\n').toLowerCase();
     return { tool: input.tool ?? 'unknown', files, lines, haystack };
 }
+/**
+ * What the human has already called a false positive.
+ *
+ * Keyed by anchor and (optionally) the exact term that matched, so dismissing "this anchor
+ * matched my file path" does not throw away the anchor's real detections.
+ */
+function dismissedFor(db) {
+    const out = new Map();
+    let rows = [];
+    try {
+        rows = db.prepare('SELECT anchor_id, hit_term FROM gate_dismissals').all();
+    }
+    catch {
+        return out; // table not migrated yet → nothing dismissed
+    }
+    for (const r of rows) {
+        if (!out.has(r.anchor_id))
+            out.set(r.anchor_id, new Set());
+        out.get(r.anchor_id).add((r.hit_term ?? '*').toLowerCase());
+    }
+    return out;
+}
 export function matchAction(db, act) {
     const out = [];
+    const dismissed = dismissedFor(db);
     for (const a of acceptedAnchors(db)) {
+        const dis = dismissed.get(a.id);
+        if (dis?.has('*'))
+            continue; // whole anchor silenced at the gate
         const gate_mode = jsonGet(a.card_policy, 'gate_mode', 'soft');
         if (gate_mode === 'off')
             continue;
@@ -98,17 +124,31 @@ export function matchAction(db, act) {
             }
         }
         // 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.
+        //
+        // A path-scoped anchor is blind to `Bash`, which carries no file path — measured on a real
+        // machine, 21 of 42 active anchors could never fire on a Bash command, including "ALTER
+        // TABLE memories DROP" on the anchor that exists to prevent exactly that. So a signal hit
+        // counts on its own WHEN THERE IS NO PATH TO CHECK.
+        //
+        // But only then. Making signal hits scope-free outright (0.13.0) traded one failure for
+        // another: an anchor scoped to one repo started firing in every repo that happened to
+        // contain its term — "insert or ignore" is ordinary SQLite everywhere, and a temp file path
+        // containing "Sake-Navi" is not favouritism in a ranking. When the action names files, the
+        // anchor's own scope is the better evidence and it decides.
         //
         // (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);
+        const actionNamesFiles = act.files.length > 0;
+        const inScope = hasScope
+            ? pathHit || (!actionNamesFiles && sigHit != null)
+            : termHit || sigHit != null;
         if (!inScope)
             continue;
+        // A dismissed term stops firing; the anchor's other terms keep working.
+        if (sigHit && dis?.has(sigHit.toLowerCase()))
+            continue;
+        if (!sigHit && dis?.has('*'))
+            continue;
         out.push({
             anchor_id: a.id,
             statement: a.statement,
@@ -120,6 +160,7 @@ export function matchAction(db, act) {
                     ? `touches a file under this decision's scope`
                     : `matches this decision's topic`,
             gate_mode,
+            hit_term: sigHit ?? null,
         });
     }
     // contradicts first (the headline), then in_scope.
@@ -178,9 +219,21 @@ export function formatReinject(matches, gate) {
         const tail = m.verdict === 'contradicts' ? `${m.why} → contradicts it.` : `${m.why}.`;
         return `• [#${m.anchor_id}] "${m.statement}"${rationale}\n  ↳ ${tail}`;
     });
+    // Offer both exits, because the reader is in one of two situations and only they know which:
+    // the decision changed (supersede), or the match was wrong (dismiss). Naming the exact term
+    // matters — dismissing a whole anchor to escape one bad match throws away its real work.
     const firstContra = matches.find((m) => m.verdict === 'contradicts');
     const foot = firstContra
-        ? `\nIf you are intentionally changing this decision, supersede it on the record:\n  resolve_drift(anchor_id: ${firstContra.anchor_id}, action: 'supersede', superseded_by: <new anchor>).`
+        ? `
+If you are intentionally changing this decision, supersede it on the record:
+` +
+            `  resolve_drift(anchor_id: ${firstContra.anchor_id}, action: 'supersede', superseded_by: <new anchor>).
+` +
+            `If this match is simply wrong, say so and it stops firing:
+` +
+            `  resolve_drift(anchor_id: ${firstContra.anchor_id}, action: 'dismiss'` +
+            (firstContra.hit_term ? `, hit_term: '${firstContra.hit_term}'` : '') +
+            `, rationale: '<why>').`
         : '';
     return [head, ...body, foot].filter(Boolean).join('\n');
 }

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[];
@@ -88,6 +93,8 @@ export declare function getTruthView(db: Database.Database, opts?: {
 export declare function getDecisionDetail(db: Database.Database, anchorId: number): DecisionDetail | null;
 export type ResolutionAction = 'fix' | 'supersede' | 'acknowledge' | 'dismiss';
 export interface ResolveInput {
+    /** For dismiss: silence only this match term. Omitted → silence the anchor at the gate. */
+    hit_term?: string;
     anchor_id: number;
     action: ResolutionAction;
     rationale?: string;

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
@@ -490,9 +537,18 @@ export function resolveDrift(db, input) {
     existing[`A${input.anchor_id}`] = resolution;
     db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?")
         .run(key, JSON.stringify(existing), JSON.stringify(existing));
-    // If action is 'dismiss', also mark all open drift_edges for this anchor as dismissed
+    // 'dismiss' must change what happens NEXT time, not just tidy the current edges — otherwise
+    // the same wrong match fires on the next command and the verdict was theatre. Record it where
+    // the gate reads (gate_dismissals), keyed to the exact term when one was given so the anchor's
+    // real detections survive.
     if (input.action === 'dismiss') {
         db.prepare("UPDATE drift_edges SET status = 'dismissed' WHERE anchor_id = ? AND status = 'open'").run(input.anchor_id);
+        try {
+            db.prepare(`INSERT INTO gate_dismissals (anchor_id, hit_term, rationale) VALUES (?, ?, ?)
+         ON CONFLICT(anchor_id, COALESCE(hit_term, '')) DO UPDATE SET rationale = excluded.rationale`).run(input.anchor_id, input.hit_term ? input.hit_term.toLowerCase() : null, input.rationale ?? null);
+            resolution.gate_dismissed = input.hit_term ? input.hit_term.toLowerCase() : 'all matches';
+        }
+        catch { /* pre-v16 DB → edges-only dismiss, as before */ }
     }
     // If action is 'fix', mark open edges as resolved
     if (input.action === 'fix') {

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.' },
@@ -255,7 +272,7 @@ const TOOLS = [
     },
     {
         name: 'resolve_drift',
-        description: 'Record a resolution for a drifting anchor — the human feedback loop.\n\n6 actions:\n• fix — "we fixed the code/reality to match intent" → state becomes aligned\n• supersede — "intent evolved, this is the new direction" → state becomes aligned\n• acknowledge — "we know, parking it for now" → state becomes held (with optional review date)\n• dismiss — "false positive, not actually drifting" → edges dismissed\n• harden — "re-injected but still violated, enforce it" → card_policy.gate_mode=hard (PreToolUse will BLOCK)\n• soften — "back off to a warning" → gate_mode=soft\n\nWHEN TO CALL:\n• After drift_status shows 🔴 drift or 🟡 review items\n• When the user says "that\'s fixed" / "ignore that" / "we changed direction"\n• When acknowledging a known gap with a review date',
+        description: 'Record a resolution for a drifting anchor — the human feedback loop.\n\n6 actions:\n• fix — "we fixed the code/reality to match intent" → state becomes aligned\n• supersede — "intent evolved, this is the new direction" → state becomes aligned\n• acknowledge — "we know, parking it for now" → state becomes held (with optional review date)\n• dismiss — "false positive, not actually drifting" → edges dismissed AND the gate stops firing on it (pass hit_term to silence just that word)\n• harden — "re-injected but still violated, enforce it" → card_policy.gate_mode=hard (PreToolUse will BLOCK)\n• soften — "back off to a warning" → gate_mode=soft\n\nWHEN TO CALL:\n• After drift_status shows 🔴 drift or 🟡 review items\n• When the user says "that\'s fixed" / "ignore that" / "we changed direction"\n• When acknowledging a known gap with a review date',
         inputSchema: {
             type: 'object',
             properties: {
@@ -264,6 +281,7 @@ const TOOLS = [
                 rationale: { type: 'string', description: 'Why this resolution (recorded for audit trail)' },
                 review_after: { type: 'string', description: 'For acknowledge: ISO date to re-check (e.g. "2026-07-04")' },
                 superseded_by: { type: 'number', description: 'For supersede: the new anchor ID that replaces this one' },
+                hit_term: { type: 'string', description: "For dismiss: silence only this match term (the word the gate quoted back at you). Omit to silence the whole anchor at the gate — prefer the term, so the anchor's real detections keep working." },
             },
             required: ['anchor_id', 'action'],
         },
@@ -435,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.
@@ -1233,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)
@@ -1293,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({
@@ -1314,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,
@@ -1321,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
@@ -1485,6 +1635,7 @@ function handleResolveDrift(args) {
         rationale: args.rationale,
         review_after: args.review_after,
         superseded_by: args.superseded_by,
+        hit_term: args.hit_term,
     });
     return JSON.stringify(result);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linksee-memory",
-  "version": "0.13.0",
+  "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",