linksee-memory 0.7.2 → 0.8.0

package/dist/lib/truth-engine.js

@@ -0,0 +1,417 @@
+// Truth Engine — drift state derivation (engine-side, P0).
+//
+// Migrated from linksee-dashboard/lib/truth.ts into the MCP engine so that
+// agents can query drift status via MCP tools. The dashboard can later import
+// from here instead of duplicating the logic.
+//
+// Make-or-break rule: a divergence accounted for by a recorded resolution
+// (supersede/fix/acknowledge) is NOT drift. Only unaccounted gaps are flagged.
+//
+// 4-species taxonomy (display-layer classification):
+//   hypothesis  → Decision Cards (decision journal format)
+//   constraint  → Rules (compact pass/fail checklist)
+//   commitment  → Heartbeats (cadence monitoring, alive/dead)
+//   source_of_truth → Reference (quiet, rarely changes)
+// ── Constants ────────────────────────────────────────────────────────────────
+const DOMAIN_ORDER = [
+    'strategy', 'monetization', 'product', 'engineering',
+    'growth', 'operations', 'security', 'roadmap', 'memory', 'other',
+];
+const STATE_RANK = {
+    drift: 0, review: 1, held: 2, aligned: 3,
+};
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function safeJsonParse(s, fallback) {
+    if (s == null)
+        return fallback;
+    try {
+        return JSON.parse(String(s));
+    }
+    catch {
+        return fallback;
+    }
+}
+function formatDate(ts) {
+    if (ts == null)
+        return null;
+    return new Date(ts * 1000).toISOString().slice(0, 10);
+}
+function parseJsonArray(s) {
+    if (!s)
+        return [];
+    try {
+        const a = JSON.parse(s);
+        return Array.isArray(a) ? a.map(String) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Classify a node into one of 4 species based on decision_mode */
+function classifySpecies(decision_mode) {
+    switch (decision_mode) {
+        case 'hypothesis': return 'hypothesis';
+        case 'constraint': return 'constraint';
+        case 'commitment': return 'commitment';
+        case 'source_of_truth': return 'source_of_truth';
+        // Fallback: constraints and prohibitions map to 'constraint',
+        // metrics to 'hypothesis', anything else to 'hypothesis' (safest default)
+        default: return 'hypothesis';
+    }
+}
+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, {});
+    // Collect ALL matching resolutions, then pick the most recent one.
+    // Without this, an older acknowledge can shadow a newer fix.
+    return function resolutionFor(id) {
+        const matches = [];
+        for (const r of Object.values(t3res)) {
+            if (r && (r.superseded_node === id || r.superseded_by === id ||
+                r.node === id || r.direction_node === id || r.constraint_node === id)) {
+                matches.push(r);
+            }
+        }
+        for (const r of Object.values(t2res)) {
+            if (r && (r.node === id || r.constraint_node === id)) {
+                matches.push(r);
+            }
+        }
+        if (matches.length === 0)
+            return null;
+        if (matches.length === 1)
+            return { action: matches[0].action };
+        // Multiple matches → prefer most recent (by resolved_at, falling back to last found)
+        matches.sort((a, b) => {
+            const ta = a.resolved_at ? new Date(a.resolved_at).getTime() : 0;
+            const tb = b.resolved_at ? new Date(b.resolved_at).getTime() : 0;
+            return tb - ta; // newest first
+        });
+        return { action: matches[0].action };
+    };
+}
+// ── Core: getTruthView ───────────────────────────────────────────────────────
+export function getTruthView(db, opts = {}) {
+    const now = Date.now();
+    const resolutionFor = buildResolutionLookup(db);
+    // ── Candidates (indexed by target node) ──
+    const candRows = db
+        .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status, proposed_node
+       FROM memory_write_candidates ORDER BY id DESC`)
+        .all();
+    const pendingByNode = new Map();
+    const cardByNode = new Map();
+    for (const c of candRows) {
+        if (c.target_node_id == null)
+            continue;
+        if (c.status === 'pending_review' && !pendingByNode.has(c.target_node_id)) {
+            pendingByNode.set(c.target_node_id, c);
+        }
+        const pn = String(c.proposed_node || '');
+        if ((pn.includes('"src":"t3"') || pn.includes('"src":"t2"')) && !cardByNode.has(c.target_node_id)) {
+            cardByNode.set(c.target_node_id, c);
+        }
+    }
+    // ── Active nodes + state derivation ──
+    let sql = `SELECT id, node_type, domain, decision_mode, statement, rationale, confidence, lifecycle,
+            card_policy, review_after
+     FROM drift_anchors WHERE status = 'active'`;
+    const params = [];
+    if (opts.domain) {
+        sql += ' AND domain = ?';
+        params.push(opts.domain);
+    }
+    if (opts.decision_mode) {
+        sql += ' AND decision_mode = ?';
+        params.push(opts.decision_mode);
+    }
+    sql += ' ORDER BY domain, id';
+    const rows = db.prepare(sql).all(...params);
+    const nodes = rows.map((r) => {
+        let cadence = null;
+        try {
+            cadence = JSON.parse(r.card_policy || '{}').cadence_days ?? null;
+        }
+        catch { /* ignore */ }
+        const res = resolutionFor(r.id);
+        const pending = pendingByNode.get(r.id);
+        const card = cardByNode.get(r.id);
+        const overdue = r.review_after != null && r.review_after * 1000 < now;
+        // ── State derivation (the make-or-break logic) ──
+        let state;
+        let accounted;
+        let accountedBy;
+        if (res?.action === 'acknowledge_validate' || res?.action === 'acknowledge') {
+            // ⚪ held — but if time-box expired, escalate to 🔴
+            state = overdue ? 'drift' : 'held';
+            accounted = !overdue;
+            accountedBy = overdue
+                ? 'acknowledge (expired → reopened)'
+                : 'acknowledge (held, time-boxed)';
+        }
+        else if (res?.action === 'fix' || res?.action === 'fix_implemented') {
+            state = 'aligned';
+            accounted = true;
+            accountedBy = 'fix (resolved)';
+        }
+        else if (res?.action === 'supersede') {
+            state = 'aligned';
+            accounted = true;
+            accountedBy = 'supersede (intentional evolution)';
+        }
+        else if (pending) {
+            // 🟡 Soft signal awaiting human decision
+            state = 'review';
+            accounted = false;
+            accountedBy = null;
+        }
+        else if (r.lifecycle === 'at_risk') {
+            // 🔴 declared-core but unproven / unaccounted
+            state = 'drift';
+            accounted = false;
+            accountedBy = null;
+        }
+        else {
+            // 🔵 convergent — reality matches intent (or no signal)
+            state = 'aligned';
+            accounted = true;
+            accountedBy = null;
+        }
+        const reality = card?.rationale
+            ?? pending?.rationale
+            ?? (state === 'aligned' ? 'Committed reality matches intent (convergent)' : null);
+        return {
+            id: r.id,
+            node_type: r.node_type,
+            domain: r.domain,
+            decision_mode: r.decision_mode,
+            species: classifySpecies(r.decision_mode),
+            statement: r.statement,
+            rationale: r.rationale ?? null,
+            confidence: r.confidence,
+            lifecycle: r.lifecycle ?? 'active',
+            cadence_days: cadence,
+            review_after: r.review_after ?? null,
+            state,
+            accounted,
+            accountedBy,
+            reality,
+            reviewDate: formatDate(r.review_after),
+            overdue,
+        };
+    });
+    // ── Partition: attention (loud) vs aligned (quiet) ──
+    const attention = nodes
+        .filter((n) => n.state !== 'aligned')
+        .sort((a, b) => STATE_RANK[a.state] - STATE_RANK[b.state] || b.confidence - a.confidence);
+    const alignedGroups = new Map();
+    for (const n of nodes.filter((n) => n.state === 'aligned')) {
+        const d = n.domain ?? 'other';
+        if (!alignedGroups.has(d))
+            alignedGroups.set(d, []);
+        alignedGroups.get(d).push(n);
+    }
+    const alignedByDomain = [...alignedGroups.entries()]
+        .sort((a, b) => DOMAIN_ORDER.indexOf(a[0]) - DOMAIN_ORDER.indexOf(b[0]))
+        .map(([domain, ns]) => ({ domain, nodes: ns }));
+    // ── Counts + next reopen ──
+    const by_mode = {};
+    for (const n of nodes) {
+        const m = n.decision_mode ?? 'unset';
+        by_mode[m] = (by_mode[m] || 0) + 1;
+    }
+    const by_species = {
+        hypothesis: 0, constraint: 0, commitment: 0, source_of_truth: 0,
+    };
+    for (const n of nodes)
+        by_species[n.species]++;
+    const by_state = { drift: 0, review: 0, held: 0, aligned: 0 };
+    for (const n of nodes)
+        by_state[n.state]++;
+    const reopenDates = nodes
+        .filter((n) => n.state === 'held' && n.reviewDate)
+        .map((n) => n.reviewDate)
+        .sort();
+    const nextReopen = reopenDates[0] ?? null;
+    // ── Candidate mapping ──
+    const stmtById = new Map(nodes.map((n) => [n.id, n.statement]));
+    const mapCand = (c) => ({
+        id: c.id,
+        candidate_type: c.candidate_type,
+        target_node_id: c.target_node_id,
+        target_statement: c.target_node_id != null ? stmtById.get(c.target_node_id) ?? null : null,
+        rationale: c.rationale,
+        confidence: c.confidence,
+        status: c.status,
+    });
+    const auto = candRows.filter((c) => c.status === 'auto_accepted').map(mapCand);
+    const suppressed = candRows.filter((c) => c.status === 'rejected').map(mapCand);
+    return {
+        attention,
+        alignedByDomain,
+        candidates: { auto, suppressed },
+        counts: {
+            nodes: nodes.length,
+            by_mode,
+            by_species,
+            by_state,
+            auto: auto.length,
+            suppressed: suppressed.length,
+        },
+        nextReopen,
+    };
+}
+// ── check_decision: single-node deep view ────────────────────────────────────
+export function getDecisionDetail(db, anchorId) {
+    const row = db
+        .prepare(`SELECT id, kind, node_type, domain, decision_mode, statement, rationale, confidence,
+              lifecycle, card_policy, review_after, affects, detect_terms, violation_signal, tier
+       FROM drift_anchors WHERE id = ? AND status = 'active'`)
+        .get(anchorId);
+    if (!row)
+        return null;
+    // Get full truth view for this single node (reuse state derivation)
+    const resolutionFor = buildResolutionLookup(db);
+    const now = Date.now();
+    let cadence = null;
+    try {
+        cadence = JSON.parse(row.card_policy || '{}').cadence_days ?? null;
+    }
+    catch { /* */ }
+    const res = resolutionFor(row.id);
+    const overdue = row.review_after != null && row.review_after * 1000 < now;
+    // State derivation (same logic)
+    let state, accounted, accountedBy;
+    const pendingCand = db
+        .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status
+       FROM memory_write_candidates
+       WHERE target_node_id = ? AND status = 'pending_review'
+       ORDER BY id DESC`)
+        .all(anchorId);
+    const cardCand = db
+        .prepare(`SELECT rationale FROM memory_write_candidates
+       WHERE target_node_id = ? AND proposed_node LIKE '%"src":"t%'
+       ORDER BY id DESC LIMIT 1`)
+        .get(anchorId);
+    const hasPending = pendingCand.length > 0;
+    if (res?.action === 'acknowledge_validate' || res?.action === 'acknowledge') {
+        state = overdue ? 'drift' : 'held';
+        accounted = !overdue;
+        accountedBy = overdue ? 'acknowledge (expired → reopened)' : 'acknowledge (held, time-boxed)';
+    }
+    else if (res?.action === 'fix' || res?.action === 'fix_implemented') {
+        state = 'aligned';
+        accounted = true;
+        accountedBy = 'fix (resolved)';
+    }
+    else if (res?.action === 'supersede') {
+        state = 'aligned';
+        accounted = true;
+        accountedBy = 'supersede (intentional evolution)';
+    }
+    else if (hasPending) {
+        state = 'review';
+        accounted = false;
+        accountedBy = null;
+    }
+    else if (row.lifecycle === 'at_risk') {
+        state = 'drift';
+        accounted = false;
+        accountedBy = null;
+    }
+    else {
+        state = 'aligned';
+        accounted = true;
+        accountedBy = null;
+    }
+    const reality = cardCand?.rationale ?? (hasPending ? pendingCand[0].rationale : null)
+        ?? (state === 'aligned' ? 'Committed reality matches intent (convergent)' : null);
+    // Drift edges for this anchor
+    const edges = db
+        .prepare(`SELECT id AS edge_id, verdict, confidence, status, detected_at
+       FROM drift_edges WHERE anchor_id = ? ORDER BY detected_at DESC`)
+        .all(anchorId);
+    return {
+        id: row.id,
+        kind: row.kind,
+        node_type: row.node_type,
+        domain: row.domain,
+        decision_mode: row.decision_mode,
+        species: classifySpecies(row.decision_mode),
+        statement: row.statement,
+        rationale: row.rationale ?? null,
+        confidence: row.confidence,
+        lifecycle: row.lifecycle ?? 'active',
+        cadence_days: cadence,
+        review_after: row.review_after ?? null,
+        state,
+        accounted,
+        accountedBy,
+        reality,
+        reviewDate: formatDate(row.review_after),
+        overdue,
+        // Deep fields
+        affects: parseJsonArray(row.affects),
+        detect_terms: parseJsonArray(row.detect_terms),
+        violation_signal: parseJsonArray(row.violation_signal),
+        tier: row.tier,
+        pendingCandidates: pendingCand.map((c) => ({
+            id: c.id,
+            candidate_type: c.candidate_type,
+            target_node_id: c.target_node_id,
+            target_statement: row.statement,
+            rationale: c.rationale,
+            confidence: c.confidence,
+            status: c.status,
+        })),
+        driftEdges: edges,
+    };
+}
+export function resolveDrift(db, input) {
+    const ACTIONS = new Set(['fix', 'supersede', 'acknowledge', 'dismiss']);
+    if (!ACTIONS.has(input.action)) {
+        throw new Error(`invalid action "${input.action}" — one of: fix, supersede, acknowledge, dismiss`);
+    }
+    // Verify anchor exists and is active
+    const anchor = db
+        .prepare("SELECT id, statement FROM drift_anchors WHERE id = ? AND status = 'active'")
+        .get(input.anchor_id);
+    if (!anchor) {
+        throw new Error(`anchor ${input.anchor_id} not found or not active`);
+    }
+    // Build resolution record
+    const resolution = {
+        action: input.action,
+        node: input.anchor_id,
+        rationale: input.rationale ?? null,
+        resolved_at: new Date().toISOString(),
+    };
+    if (input.action === 'acknowledge' && input.review_after) {
+        resolution.action = 'acknowledge_validate';
+        const ts = Math.floor(new Date(input.review_after).getTime() / 1000);
+        resolution.review_after = ts;
+        // Also set review_after on the anchor itself
+        db.prepare('UPDATE drift_anchors SET review_after = ?, updated_at = unixepoch() WHERE id = ?')
+            .run(ts, input.anchor_id);
+    }
+    if (input.action === 'supersede' && input.superseded_by != null) {
+        resolution.superseded_node = input.anchor_id;
+        resolution.superseded_by = input.superseded_by;
+    }
+    // Write to meta (t3_resolutions) — additive, keyed by anchor id
+    const key = 't3_resolutions';
+    const existing = safeJsonParse(db.prepare("SELECT value FROM meta WHERE key = ?").get(key)?.value, {});
+    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
+    if (input.action === 'dismiss') {
+        db.prepare("UPDATE drift_edges SET status = 'dismissed' WHERE anchor_id = ? AND status = 'open'").run(input.anchor_id);
+    }
+    // If action is 'fix', mark open edges as resolved
+    if (input.action === 'fix') {
+        db.prepare("UPDATE drift_edges SET status = 'resolved' WHERE anchor_id = ? AND status = 'open'").run(input.anchor_id);
+    }
+    return { ok: true, resolution };
+}
+//# sourceMappingURL=truth-engine.js.map

package/dist/mcp/server.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // linksee-memory MCP server (stdio transport).
-// Tools: remember / recall / read_smart
-// v0.7.0 — unified 3-tool surface (Context7-style simplification)
+// Tools: remember / recall / read_smart / drift_status / check_decision / declare_anchor / resolve_drift
+// v0.8.0 — drift MCP tools (P0: agents can now query & act on drift state)
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
@@ -19,7 +19,9 @@ import { PROMPTS, getPrompt } from './prompts.js';
 import { fetchRoots, isInsideRoots } from './roots.js';
 import { sampleConsolidation } from './sampling.js';
 import { confirmForget } from './elicitation.js';
-const SERVER_VERSION = '0.7.0';
+import { getTruthView, getDecisionDetail, resolveDrift } from '../lib/truth-engine.js';
+import { declareAnchor, setNodeFields } from '../lib/drift-anchors.js';
+const SERVER_VERSION = '0.8.0';
 const db = openDb();
 runMigrations(db);
 // Auto-maintenance: consolidate stale memories on startup (non-blocking)
@@ -142,6 +144,68 @@ const TOOLS = [
             required: ['path'],
         },
     },
+    // ── Drift tools (v0.8.0) ─────────────────────────────────────────────────
+    {
+        name: 'drift_status',
+        description: 'Check what\'s drifting right now — the "Intent Datadog" for your product decisions.\n\nReturns a structured truth map showing which decisions/constraints/hypotheses are:\n🔴 drift (unaccounted divergence from intent)\n🟡 review (soft signal, awaiting human decision)\n⚪ held (acknowledged, time-boxed, not forgotten)\n🔵 aligned (reality matches intent)\n\nNodes are classified into 4 species:\n• hypothesis → Decision Cards (decision journal format)\n• constraint → Rules (pass/fail checklist)\n• commitment → Heartbeats (cadence monitoring)\n• source_of_truth → Reference (stable anchors)\n\nWHEN TO CALL:\n• At session start — "what needs my attention?"\n• Before making a decision — check for existing anchors on the topic\n• After completing work — verify drift state changed\n• When the user asks about product health / what\'s broken / what\'s stale',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                domain: { type: 'string', description: 'Filter by domain (strategy, product, engineering, growth, etc.)' },
+                decision_mode: { type: 'string', description: 'Filter by decision_mode (hypothesis, constraint, commitment, source_of_truth)' },
+            },
+        },
+    },
+    {
+        name: 'check_decision',
+        description: 'Deep-dive into a specific decision/anchor — its state, premises, drift edges, and pending candidates.\n\nReturns the full context for one truth-map node: what was decided, why, what reality says, whether it\'s drifting, and what actions are pending.\n\nWHEN TO CALL:\n• When the user asks about a specific decision ("what happened with X?")\n• Before resolving a drift signal — understand the full picture first\n• When reviewing premises of a decision ("is this still true?")',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                anchor_id: { type: 'number', description: 'The drift_anchor ID to inspect' },
+            },
+            required: ['anchor_id'],
+        },
+    },
+    {
+        name: 'declare_anchor',
+        description: 'Declare a new decision, constraint, or prohibition as a truth-map anchor.\n\nAnchors are NORMATIVE claims: "we decided X", "Y is forbidden", "Z must always hold."\nThe drift detector later checks these against committed reality.\n\ndeclare-don\'t-mine: anchors come ONLY from explicit human declaration, never from pattern extraction.\n\nWHEN TO CALL:\n• When the user makes a product decision ("let\'s go with approach A")\n• When a constraint is established ("never do X")\n• When a commitment is made ("we ship weekly")\n• When the user says "anchor this" / "record this decision"',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kind: { type: 'string', enum: ['prohibition', 'decision', 'constraint'], description: 'Anchor type' },
+                statement: { type: 'string', description: 'The normative claim (>= 8 chars)' },
+                rationale: { type: 'string', description: 'Why this was decided' },
+                affects: { type: 'array', items: { type: 'string' }, description: 'Path globs that scope this anchor' },
+                detect_terms: { type: 'array', items: { type: 'string' }, description: 'Keywords for scoping' },
+                violation_signal: { type: 'array', items: { type: 'string' }, description: 'Terms whose presence = violation (required for prohibition/decision)' },
+                tier: { type: 'string', enum: ['human', 'explicit'], description: 'Declaration tier (default: human)' },
+                // v9 ProjectCoreNode fields
+                node_type: { type: 'string', description: 'Node type label' },
+                domain: { type: 'string', description: 'Domain (strategy, product, engineering, etc.)' },
+                decision_mode: { type: 'string', enum: ['hypothesis', 'constraint', 'commitment', 'source_of_truth'], description: 'Classification for 4-species display' },
+                confidence: { type: 'number', minimum: 0, maximum: 1, description: 'Confidence level (0.0-1.0)' },
+                lifecycle: { type: 'string', description: 'Lifecycle state (active, at_risk, retired)' },
+                review_after: { type: 'string', description: 'ISO date for next review (e.g. "2026-07-04")' },
+            },
+            required: ['kind', 'statement'],
+        },
+    },
+    {
+        name: 'resolve_drift',
+        description: 'Record a resolution for a drifting anchor — the human feedback loop.\n\n4 resolution 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\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: {
+                anchor_id: { type: 'number', description: 'The drift_anchor ID to resolve' },
+                action: { type: 'string', enum: ['fix', 'supersede', 'acknowledge', 'dismiss'], description: 'Resolution action' },
+                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' },
+            },
+            required: ['anchor_id', 'action'],
+        },
+    },
 ];
 // ============================================================
 // Handlers
@@ -1067,6 +1131,94 @@ async function handleRecallUnified(args) {
     return handleRecall(args);
 }
 // ============================================================
+// Drift tool handlers (v0.8.0)
+// ============================================================
+function handleDriftStatus(args) {
+    const view = getTruthView(db, {
+        domain: args?.domain,
+        decision_mode: args?.decision_mode,
+    });
+    // Build a concise triage line
+    const { by_state, nodes } = view.counts;
+    const triage = [
+        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`,
+    ].filter(Boolean).join(' · ');
+    return JSON.stringify({
+        ok: true,
+        triage: `${nodes} anchors: ${triage}`,
+        nextReopen: view.nextReopen,
+        attention: view.attention,
+        alignedByDomain: view.alignedByDomain,
+        candidates: view.candidates,
+        counts: view.counts,
+    });
+}
+function handleCheckDecision(args) {
+    if (!args?.anchor_id)
+        throw new Error('anchor_id is required');
+    const detail = getDecisionDetail(db, args.anchor_id);
+    if (!detail) {
+        return JSON.stringify({ ok: false, error: `Anchor ${args.anchor_id} not found or not active` });
+    }
+    return JSON.stringify({ ok: true, decision: detail });
+}
+function handleDeclareAnchor(args) {
+    if (!args?.kind || !args?.statement) {
+        throw new Error('kind and statement are required');
+    }
+    // Create the base anchor
+    const anchor = declareAnchor(db, {
+        kind: args.kind,
+        statement: args.statement,
+        rationale: args.rationale,
+        affects: args.affects,
+        detect_terms: args.detect_terms,
+        violation_signal: args.violation_signal,
+        tier: args.tier ?? 'human',
+    });
+    // Apply v9 ProjectCoreNode fields if provided
+    const nodeFields = {};
+    if (args.node_type !== undefined)
+        nodeFields.node_type = args.node_type;
+    if (args.domain !== undefined)
+        nodeFields.domain = args.domain;
+    if (args.decision_mode !== undefined)
+        nodeFields.decision_mode = args.decision_mode;
+    if (args.confidence !== undefined)
+        nodeFields.confidence = args.confidence;
+    if (args.lifecycle !== undefined)
+        nodeFields.lifecycle = args.lifecycle;
+    if (args.review_after !== undefined) {
+        nodeFields.review_after = Math.floor(new Date(args.review_after).getTime() / 1000);
+    }
+    if (Object.keys(nodeFields).length > 0) {
+        setNodeFields(db, anchor.id, nodeFields);
+    }
+    return JSON.stringify({
+        ok: true,
+        anchor_id: anchor.id,
+        statement: anchor.statement,
+        kind: anchor.kind,
+        message: `Anchor #${anchor.id} declared: "${anchor.statement.substring(0, 80)}"`,
+    });
+}
+function handleResolveDrift(args) {
+    if (!args?.anchor_id || !args?.action) {
+        throw new Error('anchor_id and action are required');
+    }
+    const result = resolveDrift(db, {
+        anchor_id: args.anchor_id,
+        action: args.action,
+        rationale: args.rationale,
+        review_after: args.review_after,
+        superseded_by: args.superseded_by,
+    });
+    return JSON.stringify(result);
+}
+// ============================================================
 // MCP wiring
 // ============================================================
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
@@ -1084,6 +1236,19 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
             case 'read_smart':
                 text = handleReadSmart(args);
                 break;
+            // Drift tools (v0.8.0)
+            case 'drift_status':
+                text = handleDriftStatus(args);
+                break;
+            case 'check_decision':
+                text = handleCheckDecision(args);
+                break;
+            case 'declare_anchor':
+                text = handleDeclareAnchor(args);
+                break;
+            case 'resolve_drift':
+                text = handleResolveDrift(args);
+                break;
             default: {
                 const migrations = {
                     update_memory: 'remember({ memory_id: <id>, content: "...", importance: 0.8 })',

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "linksee-memory",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "mcpName": "io.github.michielinksee/linksee-memory",
-  "description": "Local-first agent memory MCP — cross-agent brain with 6-layer structured memory + token-saving file diff cache",
+  "description": "Local-first agent memory MCP — cross-agent brain with drift detection, 6-layer structured memory + token-saving file diff cache",
   "type": "module",
   "bin": {
     "linksee-memory": "dist/mcp/server.js",
@@ -10,7 +10,9 @@
     "linksee-memory-sync": "dist/bin/sync-session.js",
     "linksee-memory-install-skill": "dist/bin/install-skill.js",
     "linksee-memory-stats": "dist/bin/stats.js",
-    "linksee-memory-setup": "dist/bin/setup.js"
+    "linksee-memory-setup": "dist/bin/setup.js",
+    "linksee-memory-declare": "dist/bin/declare-anchor.js",
+    "linksee-memory-detect": "dist/bin/detect-drift.js"
   },
   "main": "./dist/mcp/server.js",
   "files": [