linksee-memory 0.7.2 → 0.8.0

package/dist/lib/drift-detection.js

@@ -0,0 +1,416 @@
+// Drift detection (v8) — the "照合" engine: declared intent (drift_anchors) vs. actual
+// reality (session_file_edits). Sibling to edge-detection.ts; must NOT touch it.
+//
+// Deductive, NOT inferential. A 'contradicts' edge is emitted ONLY when a declared
+// violation_signal literally appears inside a file edit that falls within the anchor's
+// declared path scope — a citation-backed match, never a gap-guess. Lexical/glob/FTS only:
+// there is no embedding layer in this stack (retrieval = trigram FTS5 + BM25), so all
+// matching here is substring + path-glob + trigram-FTS by construction.
+//
+// Verdict vocabulary (Software Reflexion Models, Murphy-Notkin-Sullivan 1995):
+//   contradicts = divergence | absent = absence | implements = convergence.
+//
+// v1 emits contradicts + absent only. 'implements' (low-priority convergence) is part of
+// the design but deliberately NOT emitted here: at ~6k edits it would flood the view, and
+// its match_strength is underspecified without a violation-signal to ground it. The FTS
+// topical scope is still computed — it correctly suppresses false 'absent' for an anchor
+// whose reality is reachable only by topic, not path.
+//
+// Idempotent: contradicts upserts, refreshing confidence/evidence for OPEN rows only, so a
+// user's dismissal is never resurrected; absent is INSERT OR IGNORE under the partial unique
+// index idx_drift_absent (one open absence per anchor). Run inside the consolidation sweep
+// or on a manual trigger.
+import { readFileSync, existsSync } from 'node:fs';
+import { extname } from 'node:path';
+// ── tuning knobs (design §5) ────────────────────────────────────────────────
+const TIER_WEIGHT = { human: 1.0, explicit: 0.8 };
+const REALITY_TIER_WEIGHT = 0.8; // a real session_file_edit demonstrably happened
+const SCOPE_WEIGHT_GLOB = 1.0; // path-glob hit — structural scope, trusted
+const SCOPE_WEIGHT_FTS = 0.6; // topical (detect_terms via FTS) scope only
+const EMIT_THRESHOLD_DEFAULT = 0.5;
+const STALE_DAYS_DEFAULT = 14; // "not done yet ≠ drift" — suppress young anchors' absence
+const SECONDS_PER_DAY = 86_400;
+const MAX_SAMPLES = 25;
+const SAMPLE_BUFFER = 500; // cap collection before the final sort+slice (bounds memory)
+function parseArray(s) {
+    if (!s)
+        return [];
+    try {
+        const a = JSON.parse(s);
+        return Array.isArray(a) ? a.map((x) => String(x)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+// Normalize a path or glob to the detector's canonical form so Windows reality
+// (mixed `C:\Users\...` and `C:/Users/...`, mixed case) matches the lowercase forward-slash
+// anchor fragments. SQLite GLOB is case-sensitive Unix-glob (no `**`, `*` crosses slashes)
+// and unreliable on these paths, so ALL path matching happens here in JS instead.
+function normPath(p) {
+    return p.replace(/\\/g, '/').toLowerCase();
+}
+// Compile an affects glob into a matcher over a normalized path. A glob with no wildcard is
+// a plain substring (e.g. "sake_navi", "linksee-memory/src/mcp/server.ts"); `*` matches
+// within a path segment, `**` crosses segments — tested unanchored so a fragment matches
+// anywhere in the absolute path.
+function compileGlob(glob) {
+    const g = normPath(glob.trim());
+    if (!g)
+        return () => false;
+    if (!/[*?]/.test(g)) {
+        return (path) => path.includes(g);
+    }
+    let re = '';
+    for (let i = 0; i < g.length; i++) {
+        const c = g[i];
+        if (c === '*') {
+            if (g[i + 1] === '*') {
+                re += '.*';
+                i++;
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else {
+            re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    const rx = new RegExp(re);
+    return (path) => rx.test(path);
+}
+// Build an FTS5 MATCH query from detect_terms: trigram needs >= 3 chars, each term quoted
+// (handles spaces / punctuation / CJK), OR-joined. Returns '' when no term qualifies.
+function ftsQuery(terms) {
+    return terms
+        .map((t) => t.trim())
+        .filter((t) => t.length >= 3)
+        .map((t) => '"' + t.replace(/"/g, '""') + '"')
+        .join(' OR ');
+}
+function tierWeight(tier) {
+    return TIER_WEIGHT[tier] ?? REALITY_TIER_WEIGHT;
+}
+export function detectDrift(db, opts = {}) {
+    const staleDays = opts.staleDays ?? STALE_DAYS_DEFAULT;
+    const emitThreshold = opts.emitThreshold ?? EMIT_THRESHOLD_DEFAULT;
+    const now = Math.floor(Date.now() / 1000);
+    const res = {
+        anchorsScanned: 0,
+        editsScanned: 0,
+        contradicts: 0,
+        absent: 0,
+        edgesEmitted: 0,
+        persisted: !opts.dryRun,
+        byAnchor: [],
+        samples: [],
+    };
+    const anchors = db
+        .prepare(`SELECT id, kind, statement, affects, detect_terms, violation_signal, tier, created_at
+         FROM drift_anchors WHERE status = 'active'`)
+        .all();
+    res.anchorsScanned = anchors.length;
+    if (anchors.length === 0)
+        return res;
+    // Reality, loaded once. LEFT JOIN the linked memory so violation_signal matching can see
+    // the "why this edit" text, not just path + snippet. (session_file_edits.memory_id →
+    // memories.id; memories_fts.rowid = memories.id.)
+    const edits = db
+        .prepare(`SELECT e.id, e.file_path, e.context_snippet, e.memory_id, m.content AS memory_content, e.occurred_at
+         FROM session_file_edits e
+         LEFT JOIN memories m ON m.id = e.memory_id`)
+        .all();
+    res.editsScanned = edits.length;
+    const editsNorm = edits.map((e) => {
+        const pathNorm = normPath(e.file_path);
+        return {
+            row: e,
+            pathNorm,
+            haystack: `${pathNorm}\n${e.context_snippet ?? ''}\n${e.memory_content ?? ''}`.toLowerCase(),
+        };
+    });
+    const ftsStmt = db.prepare(`SELECT rowid FROM memories_fts WHERE memories_fts MATCH ?`);
+    // Write paths prepared only when persisting — keeps dryRun safe on a readonly connection.
+    const upsertContradicts = opts.dryRun
+        ? null
+        : db.prepare(`
+        INSERT INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
+        VALUES (@anchor_id, @edit_id, 'contradicts', @confidence, @evidence, 'open')
+        ON CONFLICT(anchor_id, edit_id, verdict) DO UPDATE SET
+          confidence = excluded.confidence,
+          evidence   = excluded.evidence
+        WHERE drift_edges.status = 'open'
+      `);
+    const insertAbsent = opts.dryRun
+        ? null
+        : db.prepare(`
+        INSERT OR IGNORE INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
+        VALUES (@anchor_id, NULL, 'absent', @confidence, @evidence, 'open')
+      `);
+    const apply = () => {
+        for (const a of anchors) {
+            const globs = parseArray(a.affects).map(compileGlob);
+            const signals = parseArray(a.violation_signal)
+                .map((s) => s.trim().toLowerCase())
+                .filter(Boolean);
+            const terms = parseArray(a.detect_terms);
+            const aW = tierWeight(a.tier);
+            const tally = {
+                anchor_id: a.id,
+                kind: a.kind,
+                statement: a.statement.slice(0, 80),
+                contradicts: 0,
+                absent: 0,
+            };
+            // Topical scope: memory rowids whose content matches the anchor's detect_terms.
+            let ftsRowids = null;
+            const q = ftsQuery(terms);
+            if (q) {
+                try {
+                    ftsRowids = new Set(ftsStmt.all(q).map((r) => r.rowid));
+                }
+                catch {
+                    ftsRowids = null; // malformed query → fall back to glob-only scope
+                }
+            }
+            let scopedCount = 0;
+            for (const e of editsNorm) {
+                const globHit = globs.length > 0 && globs.some((m) => m(e.pathNorm));
+                const ftsHit = !globHit && ftsRowids != null && e.row.memory_id != null && ftsRowids.has(e.row.memory_id);
+                if (!globHit && !ftsHit)
+                    continue;
+                scopedCount++;
+                // Deduce a contradiction: a declared forbidden term literally present in scope text.
+                if (signals.length === 0)
+                    continue; // e.g. a constraint with no signal — can't deduce contradicts
+                const hit = signals.find((s) => e.haystack.includes(s));
+                if (!hit)
+                    continue;
+                const scopeWeight = globHit ? SCOPE_WEIGHT_GLOB : SCOPE_WEIGHT_FTS;
+                // confidence = min(tierWeight_anchor, tierWeight_reality) × scopeWeight × signalWeight.
+                // signalWeight = 1.0 (the forbidden term is literally present — binary presence).
+                const confidence = Math.min(aW, REALITY_TIER_WEIGHT) * scopeWeight;
+                if (confidence < emitThreshold)
+                    continue; // FTS-only scope (0.48) never clears 0.5 — path scope required
+                const evidence = JSON.stringify({
+                    file_path: e.row.file_path,
+                    context_snippet: (e.row.context_snippet ?? '').slice(0, 280),
+                    occurred_at: e.row.occurred_at,
+                    hit_term: hit,
+                    scope: globHit ? 'glob' : 'fts',
+                    matched_terms: terms.slice(0, 8),
+                    memory_id: e.row.memory_id,
+                });
+                if (!opts.dryRun) {
+                    upsertContradicts.run({ anchor_id: a.id, edit_id: e.row.id, confidence, evidence });
+                }
+                res.contradicts++;
+                tally.contradicts++;
+                res.edgesEmitted++;
+                if (res.samples.length < SAMPLE_BUFFER) {
+                    res.samples.push({
+                        anchor_id: a.id,
+                        kind: a.kind,
+                        statement: tally.statement,
+                        verdict: 'contradicts',
+                        confidence,
+                        file_path: e.row.file_path,
+                        hit_term: hit,
+                        scope: globHit ? 'glob' : 'fts',
+                        occurred_at: e.row.occurred_at,
+                    });
+                }
+            }
+            // Absence: a declared anchor with zero reality in scope, but only once it is old enough
+            // that "not built yet" can be ruled out (staleness gate). Confidence is for sort/display
+            // only — absence is not confidence-gated (see design §6/§7).
+            if (scopedCount === 0) {
+                const ageDays = (now - a.created_at) / SECONDS_PER_DAY;
+                if (ageDays >= staleDays) {
+                    const ageFactor = Math.min(1, ageDays / (2 * staleDays));
+                    const confidence = aW * ageFactor;
+                    const evidence = JSON.stringify({
+                        reason: 'no reality in declared scope',
+                        age_days: Math.round(ageDays),
+                        stale_days: staleDays,
+                    });
+                    if (!opts.dryRun) {
+                        insertAbsent.run({ anchor_id: a.id, confidence, evidence });
+                    }
+                    res.absent++;
+                    tally.absent++;
+                    res.edgesEmitted++;
+                    if (res.samples.length < SAMPLE_BUFFER) {
+                        res.samples.push({
+                            anchor_id: a.id,
+                            kind: a.kind,
+                            statement: tally.statement,
+                            verdict: 'absent',
+                            confidence,
+                            file_path: null,
+                            hit_term: null,
+                            scope: null,
+                            occurred_at: null,
+                        });
+                    }
+                }
+            }
+            res.byAnchor.push(tally);
+        }
+    };
+    if (opts.dryRun)
+        apply();
+    else
+        db.transaction(apply)();
+    // contradicts first (the headline verdict), then by descending confidence.
+    res.samples.sort((x, y) => {
+        if (x.verdict !== y.verdict)
+            return x.verdict === 'contradicts' ? -1 : 1;
+        return y.confidence - x.confidence;
+    });
+    res.samples = res.samples.slice(0, MAX_SAMPLES);
+    return res;
+}
+// ── v2: current-file scan ─────────────────────────────────────────────────────
+// detectDrift (above) sees only what a captured edit's SNIPPET window contained — a
+// violation whose line was never in a captured snippet is invisible to it (proven on the
+// real corpus: `INSERT OR IGNORE INTO services` sat in current files yet returned 0). This
+// pass closes the gap: for each anchor it reads the CURRENT contents of the files under its
+// affects scope and flags any (non-comment) line containing a violation_signal — the
+// strongest citation possible: the live file:line. Candidate files are grounded in
+// session_file_edits (so we know where the affects files actually live on disk); code
+// extensions only; most-recent first; capped per anchor. Purely additive — detectDrift is
+// untouched. Comment lines are skipped so a doc-mention of a forbidden term isn't a hit.
+const CODE_EXT = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.sql', '.py', '.go', '.rs',
+    '.java', '.rb', '.php', '.sh', '.yml', '.yaml', '.toml', '.env', '.md', '.html',
+]);
+const MAX_FILES_PER_ANCHOR = 400;
+const COMMENT_PREFIXES = ['//', '*', '/*', '#', '<!--', '--'];
+export function detectFileViolations(db, opts = {}) {
+    const emitThreshold = opts.emitThreshold ?? EMIT_THRESHOLD_DEFAULT;
+    const res = {
+        persisted: !opts.dryRun,
+        anchorsScanned: 0,
+        filesScanned: 0,
+        anchorsCapped: 0,
+        contradicts: 0,
+        edgesEmitted: 0,
+        byAnchor: [],
+        samples: [],
+    };
+    const anchors = db
+        .prepare(`SELECT id, kind, statement, affects, violation_signal, detect_terms, tier FROM drift_anchors WHERE status = 'active'`)
+        .all();
+    res.anchorsScanned = anchors.length;
+    if (anchors.length === 0)
+        return res;
+    // Distinct edited file paths + latest edit id per path. edit_id grounds the edge in a real
+    // row (FK + occurred_at); the CURRENT violating line lives in the evidence (current_file).
+    const pathRows = db
+        .prepare(`SELECT file_path, MAX(id) AS latest_edit_id FROM session_file_edits GROUP BY file_path`)
+        .all();
+    const upsert = opts.dryRun
+        ? null
+        : db.prepare(`
+        INSERT INTO drift_edges (anchor_id, edit_id, verdict, confidence, evidence, status)
+        VALUES (@anchor_id, @edit_id, 'contradicts', @confidence, @evidence, 'open')
+        ON CONFLICT(anchor_id, edit_id, verdict) DO UPDATE SET
+          confidence = excluded.confidence,
+          evidence   = excluded.evidence
+        WHERE drift_edges.status = 'open'
+      `);
+    const apply = () => {
+        for (const a of anchors) {
+            const globs = parseArray(a.affects).map(compileGlob);
+            if (globs.length === 0)
+                continue;
+            const signals = parseArray(a.violation_signal).map((s) => s.trim().toLowerCase()).filter(Boolean);
+            if (signals.length === 0)
+                continue; // no signal → can't deduce a contradiction
+            const terms = parseArray(a.detect_terms);
+            const aW = tierWeight(a.tier);
+            const confidence = Math.min(aW, REALITY_TIER_WEIGHT) * SCOPE_WEIGHT_GLOB;
+            if (confidence < emitThreshold)
+                continue;
+            let candidates = pathRows.filter((r) => {
+                const p = normPath(r.file_path);
+                return CODE_EXT.has(extname(p)) && globs.some((g) => g(p));
+            });
+            candidates.sort((x, y) => y.latest_edit_id - x.latest_edit_id);
+            if (candidates.length > MAX_FILES_PER_ANCHOR) {
+                res.anchorsCapped++;
+                candidates = candidates.slice(0, MAX_FILES_PER_ANCHOR);
+            }
+            const tally = { anchor_id: a.id, statement: a.statement.slice(0, 80), contradicts: 0 };
+            for (const c of candidates) {
+                if (!existsSync(c.file_path))
+                    continue; // deleted since the edit
+                let content;
+                try {
+                    content = readFileSync(c.file_path, 'utf8');
+                }
+                catch {
+                    continue;
+                }
+                res.filesScanned++;
+                const lines = content.split(/\r?\n/);
+                let found = null;
+                for (let i = 0; i < lines.length; i++) {
+                    const trimmed = lines[i].trim();
+                    if (!trimmed)
+                        continue;
+                    if (COMMENT_PREFIXES.some((p) => trimmed.startsWith(p)))
+                        continue; // skip comments
+                    const ll = trimmed.toLowerCase();
+                    const hit = signals.find((s) => ll.includes(s));
+                    if (hit) {
+                        found = { line_no: i + 1, line_text: trimmed.slice(0, 280), hit };
+                        break; // one edge per (anchor, file): first real hit
+                    }
+                }
+                if (!found)
+                    continue;
+                const evidence = JSON.stringify({
+                    file_path: c.file_path,
+                    line_no: found.line_no,
+                    context_snippet: found.line_text,
+                    current_file: true,
+                    hit_term: found.hit,
+                    scope: 'file',
+                    matched_terms: terms.slice(0, 8),
+                });
+                if (!opts.dryRun) {
+                    upsert.run({ anchor_id: a.id, edit_id: c.latest_edit_id, confidence, evidence });
+                }
+                res.contradicts++;
+                tally.contradicts++;
+                res.edgesEmitted++;
+                if (res.samples.length < 60) {
+                    res.samples.push({
+                        anchor_id: a.id,
+                        kind: a.kind,
+                        statement: tally.statement,
+                        file_path: c.file_path,
+                        line_no: found.line_no,
+                        line_text: found.line_text,
+                        hit_term: found.hit,
+                        confidence,
+                    });
+                }
+            }
+            if (tally.contradicts > 0)
+                res.byAnchor.push(tally);
+        }
+    };
+    if (opts.dryRun)
+        apply();
+    else
+        db.transaction(apply)();
+    return res;
+}
+//# sourceMappingURL=drift-detection.js.map

package/dist/lib/drift-view.d.ts

@@ -0,0 +1,62 @@
+import type Database from 'better-sqlite3';
+import type { AnchorKind } from './drift-anchors.js';
+export type DriftEdgeStatus = 'open' | 'ack' | 'dismissed' | 'resolved';
+export interface DriftHeadlineCard {
+    edge_id: number;
+    anchor_id: number;
+    kind: AnchorKind;
+    statement: string;
+    rationale: string | null;
+    file_path: string;
+    context_snippet: string | null;
+    occurred_at: number;
+    confidence: number;
+    hit_term: string | null;
+    evidence: Record<string, unknown>;
+}
+export interface DriftAbsenceCard {
+    edge_id: number;
+    anchor_id: number;
+    kind: AnchorKind;
+    statement: string;
+    rationale: string | null;
+    confidence: number;
+    age_days: number | null;
+    detected_at: number;
+}
+export interface DriftViewCounts {
+    contradicts_open: number;
+    absent_open: number;
+    dismissed: number;
+}
+export interface DriftView {
+    headline: DriftHeadlineCard[];
+    absences: DriftAbsenceCard[];
+    counts: DriftViewCounts;
+}
+/**
+ * §7①  Headline: divergence (decided-but-violated). Confidence, then entrenchment
+ * (human > explicit), then recency. Only OPEN edges on ACTIVE anchors — a dismissed card
+ * stays gone, a retired anchor stops surfacing.
+ */
+export declare function getDriftHeadline(db: Database.Database, opts?: {
+    limit?: number;
+}): DriftHeadlineCard[];
+/**
+ * §7②  Secondary: absence (decided-but-no-reality), staleness-gated at write time.
+ * Oldest unfulfilled decision first.
+ */
+export declare function getDriftAbsences(db: Database.Database, opts?: {
+    limit?: number;
+}): DriftAbsenceCard[];
+/** The whole Drift View in one call — headline + absences + the badge counts step 5 needs. */
+export declare function getDriftView(db: Database.Database, opts?: {
+    headlineLimit?: number;
+    absenceLimit?: number;
+}): DriftView;
+/**
+ * The feedback action behind a Drift View card. `dismissed` is the precision signal — a user
+ * marking a false positive teaches us to tune. (The detector's contradicts upsert never
+ * resurrects a non-open row, so a dismissal sticks across re-runs.) Returns true if it changed.
+ */
+export declare function setDriftEdgeStatus(db: Database.Database, edgeId: number, status: DriftEdgeStatus): boolean;

package/dist/lib/drift-view.js

@@ -0,0 +1,120 @@
+// Drift view (v8) — the READ side of drift observability (build order step 4).
+//
+// Pairs with drift-detection.ts (which WRITES drift_edges). This module turns those edges
+// into Drift View cards and provides the human feedback action. It is the §7 verdict layer,
+// consumed by step 5 (the top-3 contradiction cards in the dashboard) and by any CLI/MCP
+// surface later. Read-only except setDriftEdgeStatus (the dismiss/ack loop).
+//
+// A card = [anchor statement + WHY] / [reality file_path:snippet + occurred_at] /
+//          [verdict + confidence] / dismiss → status='dismissed' (the precision feedback loop).
+const EDGE_STATUSES = new Set(['open', 'ack', 'dismissed', 'resolved']);
+function parseEvidence(s) {
+    if (!s)
+        return {};
+    try {
+        const o = JSON.parse(s);
+        return o && typeof o === 'object' ? o : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * §7①  Headline: divergence (decided-but-violated). Confidence, then entrenchment
+ * (human > explicit), then recency. Only OPEN edges on ACTIVE anchors — a dismissed card
+ * stays gone, a retired anchor stops surfacing.
+ */
+export function getDriftHeadline(db, opts = {}) {
+    const limit = opts.limit ?? 3;
+    const rows = db
+        .prepare(`SELECT d.id AS edge_id, d.anchor_id, a.kind, a.statement, a.rationale,
+              e.file_path, e.context_snippet, e.occurred_at,
+              d.confidence, d.evidence
+         FROM drift_edges d
+         JOIN drift_anchors a ON a.id = d.anchor_id
+         JOIN session_file_edits e ON e.id = d.edit_id
+        WHERE d.verdict = 'contradicts' AND d.status = 'open' AND a.status = 'active'
+        ORDER BY d.confidence DESC, (a.tier = 'human') DESC, e.occurred_at DESC
+        LIMIT ?`)
+        .all(limit);
+    return rows.map((r) => {
+        const evidence = parseEvidence(r.evidence);
+        return {
+            edge_id: r.edge_id,
+            anchor_id: r.anchor_id,
+            kind: r.kind,
+            statement: r.statement,
+            rationale: r.rationale ?? null,
+            file_path: r.file_path,
+            context_snippet: r.context_snippet ?? null,
+            occurred_at: r.occurred_at,
+            confidence: r.confidence,
+            hit_term: typeof evidence.hit_term === 'string' ? evidence.hit_term : null,
+            evidence,
+        };
+    });
+}
+/**
+ * §7②  Secondary: absence (decided-but-no-reality), staleness-gated at write time.
+ * Oldest unfulfilled decision first.
+ */
+export function getDriftAbsences(db, opts = {}) {
+    const limit = opts.limit ?? 10;
+    const rows = db
+        .prepare(`SELECT d.id AS edge_id, d.anchor_id, a.kind, a.statement, a.rationale,
+              d.confidence, d.evidence, d.detected_at
+         FROM drift_edges d
+         JOIN drift_anchors a ON a.id = d.anchor_id
+        WHERE d.verdict = 'absent' AND d.status = 'open' AND a.status = 'active'
+        ORDER BY a.created_at ASC
+        LIMIT ?`)
+        .all(limit);
+    return rows.map((r) => {
+        const evidence = parseEvidence(r.evidence);
+        return {
+            edge_id: r.edge_id,
+            anchor_id: r.anchor_id,
+            kind: r.kind,
+            statement: r.statement,
+            rationale: r.rationale ?? null,
+            confidence: r.confidence,
+            age_days: typeof evidence.age_days === 'number' ? evidence.age_days : null,
+            detected_at: r.detected_at,
+        };
+    });
+}
+function countOpen(db, verdict) {
+    return db
+        .prepare(`SELECT COUNT(*) AS n
+           FROM drift_edges d JOIN drift_anchors a ON a.id = d.anchor_id
+          WHERE d.verdict = ? AND d.status = 'open' AND a.status = 'active'`)
+        .get(verdict).n;
+}
+/** The whole Drift View in one call — headline + absences + the badge counts step 5 needs. */
+export function getDriftView(db, opts = {}) {
+    const dismissed = db.prepare(`SELECT COUNT(*) AS n FROM drift_edges WHERE status = 'dismissed'`).get().n;
+    return {
+        headline: getDriftHeadline(db, { limit: opts.headlineLimit }),
+        absences: getDriftAbsences(db, { limit: opts.absenceLimit }),
+        counts: {
+            contradicts_open: countOpen(db, 'contradicts'),
+            absent_open: countOpen(db, 'absent'),
+            dismissed,
+        },
+    };
+}
+/**
+ * The feedback action behind a Drift View card. `dismissed` is the precision signal — a user
+ * marking a false positive teaches us to tune. (The detector's contradicts upsert never
+ * resurrects a non-open row, so a dismissal sticks across re-runs.) Returns true if it changed.
+ */
+export function setDriftEdgeStatus(db, edgeId, status) {
+    if (!EDGE_STATUSES.has(status)) {
+        throw new Error(`invalid status "${status}" — one of: open, ack, dismissed, resolved`);
+    }
+    const r = db
+        .prepare(`UPDATE drift_edges SET status = ? WHERE id = ? AND status <> ?`)
+        .run(status, edgeId, status);
+    return r.changes > 0;
+}
+//# sourceMappingURL=drift-view.js.map

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

@@ -0,0 +1,84 @@
+import type Database from 'better-sqlite3';
+export type DriftState = 'drift' | 'review' | 'held' | 'aligned';
+export type Species = 'hypothesis' | 'constraint' | 'commitment' | 'source_of_truth';
+export interface TruthNode {
+    id: number;
+    node_type: string | null;
+    domain: string | null;
+    decision_mode: string | null;
+    species: Species;
+    statement: string;
+    rationale: string | null;
+    confidence: number;
+    lifecycle: string;
+    cadence_days: number | null;
+    review_after: number | null;
+    state: DriftState;
+    accounted: boolean;
+    accountedBy: string | null;
+    reality: string | null;
+    reviewDate: string | null;
+    overdue: boolean;
+}
+export interface TruthCandidate {
+    id: number;
+    candidate_type: string;
+    target_node_id: number | null;
+    target_statement: string | null;
+    rationale: string;
+    confidence: number;
+    status: string;
+}
+export interface TruthCounts {
+    nodes: number;
+    by_mode: Record<string, number>;
+    by_species: Record<Species, number>;
+    by_state: Record<DriftState, number>;
+    auto: number;
+    suppressed: number;
+}
+export interface TruthView {
+    attention: TruthNode[];
+    alignedByDomain: Array<{
+        domain: string;
+        nodes: TruthNode[];
+    }>;
+    candidates: {
+        auto: TruthCandidate[];
+        suppressed: TruthCandidate[];
+    };
+    counts: TruthCounts;
+    nextReopen: string | null;
+}
+export interface DecisionDetail extends TruthNode {
+    kind: string | null;
+    affects: string[];
+    detect_terms: string[];
+    violation_signal: string[];
+    tier: string;
+    pendingCandidates: TruthCandidate[];
+    driftEdges: Array<{
+        edge_id: number;
+        verdict: string;
+        confidence: number;
+        status: string;
+        detected_at: number;
+    }>;
+}
+export declare function getTruthView(db: Database.Database, opts?: {
+    domain?: string;
+    decision_mode?: string;
+}): TruthView;
+export declare function getDecisionDetail(db: Database.Database, anchorId: number): DecisionDetail | null;
+export type ResolutionAction = 'fix' | 'supersede' | 'acknowledge' | 'dismiss';
+export interface ResolveInput {
+    anchor_id: number;
+    action: ResolutionAction;
+    rationale?: string;
+    review_after?: string;
+    superseded_by?: number;
+}
+export declare function resolveDrift(db: Database.Database, input: ResolveInput): {
+    ok: boolean;
+    resolution: any;
+};