linksee-memory 0.10.0 → 0.11.0

package/dist/lib/map-reconcile.js

@@ -0,0 +1,245 @@
+import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { join, extname } from 'node:path';
+const CODE_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.sql', '.py', '.go', '.rs', '.java', '.rb', '.php', '.sh']);
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', '.next', 'coverage', 'build']);
+const COMMENT_PREFIXES = ['//', '*', '/*', '#', '<!--', '--'];
+const MAX_FILES = 4000;
+function signalHit(line, signals, skipComments) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    // For CODE scans, a comment MENTIONS a term but doesn't realize it — skip. For DOC
+    // scans (README etc.) the content IS in those lines, so don't skip.
+    if (skipComments && COMMENT_PREFIXES.some((p) => trimmed.startsWith(p)))
+        return null;
+    const lower = trimmed.toLowerCase();
+    for (const s of signals) {
+        const sl = s.toLowerCase();
+        if (/^[\x20-\x7e]+$/.test(sl)) {
+            const esc = sl.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            if (new RegExp(`(?<![a-z0-9_])${esc}(?![a-z0-9_])`).test(lower))
+                return s;
+        }
+        else if (lower.includes(sl))
+            return s;
+    }
+    return null;
+}
+// Scan a single file (any type; e.g. README.md) for the first signal match.
+function scanFileForSignal(file, signals, skipComments) {
+    return scanFile(file, (line) => signalHit(line, signals, skipComments));
+}
+// Scan a single file for the first regex match (meaning-aware: "where_am_i\s+.*(tool|MCP)").
+function scanFileForRegex(file, re, skipComments) {
+    return scanFile(file, (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        if (skipComments && COMMENT_PREFIXES.some((p) => trimmed.startsWith(p)))
+            return null;
+        const m = re.exec(trimmed);
+        return m ? m[0].slice(0, 60) : null;
+    });
+}
+function scanFile(file, match) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const hit = match(lines[i]);
+        if (hit)
+            return { file, line_no: i + 1, line_text: lines[i].trim().slice(0, 200), hit };
+    }
+    return null;
+}
+// Walk a code subtree, applying a per-file matcher (comments skipped). Returns first hit or null.
+function scanDir(root, perFile) {
+    let scanned = 0;
+    const stack = [root];
+    while (stack.length) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            const full = join(dir, name);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (!SKIP_DIRS.has(name))
+                    stack.push(full);
+                continue;
+            }
+            if (!CODE_EXT.has(extname(name)))
+                continue;
+            if (++scanned > MAX_FILES)
+                return null;
+            const hit = perFile(full);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+const scanForSignal = (root, signals) => scanDir(root, (f) => scanFileForSignal(f, signals, true));
+const scanForRegex = (root, re) => scanDir(root, (f) => scanFileForRegex(f, re, true));
+// Scan ONLY within a named markdown section (header containing `section`, until the next
+// same-or-higher header). Beats a bare substring: "where_am_i" must be IN the Tools section,
+// not merely somewhere in the file (e.g. next to "未対応です").
+function scanSection(file, section, signals) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const lines = text.split('\n');
+    const want = section.toLowerCase();
+    let start = -1, level = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const m = /^(#{1,6})\s+(.*)$/.exec(lines[i].trim());
+        if (m && m[2].toLowerCase().includes(want)) {
+            start = i;
+            level = m[1].length;
+            break;
+        }
+    }
+    if (start < 0)
+        return null; // section not found at all
+    for (let i = start + 1; i < lines.length; i++) {
+        const h = /^(#{1,6})\s+/.exec(lines[i].trim());
+        if (h && h[1].length <= level)
+            break; // reached the end of this section
+        const hit = signalHit(lines[i], signals, false);
+        if (hit)
+            return { file, line_no: i + 1, line_text: lines[i].trim().slice(0, 200), hit };
+    }
+    return null;
+}
+// Run ONE check → ✓/✗ with evidence. path-targeted scans don't skip comments (docs).
+function runCheck(check, repoRoot) {
+    if (check.kind === 'file_present' || check.kind === 'file_absent') {
+        const present = check.path ? existsSync(join(repoRoot, check.path)) : false;
+        const ok = check.kind === 'file_present' ? present : !present;
+        return { claim: check.claim, ok, file: check.path ?? null, line: null, detail: present ? 'file present' : 'file absent' };
+    }
+    // regex check — meaning-aware ("where_am_i\s+.*(tool|MCP)"), beats a bare substring
+    if (check.kind === 'regex_present' || check.kind === 'regex_absent') {
+        let re;
+        try {
+            re = new RegExp(check.pattern ?? '', 'i');
+        }
+        catch {
+            return { claim: check.claim, ok: false, file: null, line: null, detail: `bad regex: ${check.pattern}` };
+        }
+        const hit = check.path ? scanFileForRegex(join(repoRoot, check.path), re, false) : scanForRegex(join(repoRoot, check.dir ?? '.'), re);
+        const found = hit != null;
+        const ok = check.kind === 'regex_present' ? found : !found;
+        return {
+            claim: check.claim, ok, file: hit ? hit.file : (check.path ?? check.dir ?? null), line: hit ? hit.line_no : null,
+            detail: found ? `matched /${check.pattern}/` : `/${check.pattern}/ not matched`,
+        };
+    }
+    const signals = (check.signal ?? []).filter(Boolean);
+    // section_contains — the signal must appear inside a named markdown section
+    if (check.kind === 'section_contains') {
+        const hit = check.path ? scanSection(join(repoRoot, check.path), check.section ?? '', signals) : null;
+        return {
+            claim: check.claim, ok: hit != null, file: hit ? hit.file : (check.path ?? null), line: hit ? hit.line_no : null,
+            detail: hit ? `found "${hit.hit}" in section "${check.section}"` : `"${signals.join(', ')}" not in section "${check.section}"`,
+        };
+    }
+    // signal scan: a single path (doc, no comment-skip) or a code subtree (comment-skip)
+    const hit = check.path
+        ? scanFileForSignal(join(repoRoot, check.path), signals, false)
+        : scanForSignal(join(repoRoot, check.dir ?? '.'), signals);
+    const found = hit != null;
+    const ok = check.kind === 'signal_present' ? found : !found;
+    return {
+        claim: check.claim, ok,
+        file: hit ? hit.file : (check.path ?? check.dir ?? null), line: hit ? hit.line_no : null,
+        detail: found ? `found "${hit.hit}"` : `"${signals.join(', ')}" not found`,
+    };
+}
+function evaluate(reality, repoRoot) {
+    if (!reality.kind && !reality.checks) {
+        return { verdict: null, reason: 'no reality declaration — stays human-declared', why: null, fix: [], checks: [], expected: null, check: null };
+    }
+    if (reality.kind === 'external') {
+        return {
+            verdict: null, reason: 'external state — not locally verifiable; human-confirmed',
+            why: reality.why ?? null, fix: reality.fix ?? [], checks: [],
+            expected: reality.expected ?? null, check: reality.check ?? null,
+        };
+    }
+    // Multiple named checks, or one check from the single-kind shorthand (back-compat).
+    const checks = reality.checks ?? [{
+            claim: reality.kind === 'signal_present' ? `code implements: ${(reality.signal ?? []).join(', ')}`
+                : reality.kind === 'signal_absent' ? `forbidden absent: ${(reality.signal ?? []).join(', ')}`
+                    : reality.kind === 'file_present' ? `file present: ${reality.path}`
+                        : `file absent: ${reality.path}`,
+            kind: reality.kind, dir: reality.dir, path: reality.path, signal: reality.signal,
+        }];
+    const results = checks.map((c) => runCheck(c, repoRoot));
+    const failed = results.filter((r) => !r.ok);
+    const verdict = failed.length === 0 ? 'convergence' : 'divergence';
+    const why = reality.why ?? (failed.length === 0
+        ? 'all checks pass — reality matches the declaration'
+        : `${failed.length} check(s) fail: ${failed.map((f) => f.claim).join('; ')}`);
+    const reason = failed.length === 0 ? `verified: ${results.length} check(s) pass` : `${failed.length}/${results.length} checks failed`;
+    return { verdict, reason, why, fix: reality.fix ?? [], checks: results, expected: null, check: null };
+}
+export function reconcile(db, project, repoRoot) {
+    const rows = db.prepare('SELECT id, status, reality FROM map_nodes WHERE project = ?').all(project);
+    const upd = db.prepare('UPDATE map_nodes SET live_verdict = ?, verdict_evidence = ?, reconciled_at = unixepoch() WHERE project = ? AND id = ?');
+    const verdicts = [];
+    let checked = 0, external = 0;
+    const tx = db.transaction(() => {
+        for (const r of rows) {
+            let reality = {};
+            try {
+                reality = JSON.parse(r.reality || '{}');
+            }
+            catch { /* malformed → treat as none */ }
+            const { verdict, reason, why, fix, checks, expected, check } = evaluate(reality, repoRoot);
+            const firstShown = checks.find((c) => !c.ok) ?? checks[0];
+            const evidence = {
+                reason, why, fix, checks, expected, check,
+                file: firstShown?.file ?? null, line_no: firstShown?.line ?? null, // compact convenience for the dashboard
+            };
+            if (verdict === null) {
+                external++;
+                upd.run(null, JSON.stringify(evidence), project, r.id);
+            }
+            else {
+                checked++;
+                upd.run(verdict, JSON.stringify(evidence), project, r.id);
+            }
+            // "flipped" = hand-declared suspect that reality contradicts (suspect→convergence),
+            // or a non-suspect that reality flags (→divergence).
+            const flipped = (r.status === 'suspect' && verdict === 'convergence')
+                || (r.status !== 'suspect' && verdict === 'divergence');
+            verdicts.push({ id: r.id, status: r.status, verdict, reason, why, fix, checks, evidence, flipped });
+        }
+    });
+    tx();
+    const refuted = verdicts.filter((v) => v.status === 'suspect' && v.verdict === 'convergence');
+    const confirmed = verdicts.filter((v) => v.status === 'suspect' && (v.verdict === 'divergence' || v.verdict === 'absence'));
+    return { project, checked, external, verdicts, refuted, confirmed };
+}
+//# sourceMappingURL=map-reconcile.js.map

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

@@ -0,0 +1,103 @@
+import type Database from 'better-sqlite3';
+export interface NodeRow {
+    id: string;
+    project: string;
+    layer: string;
+    stage: string | null;
+    statement: string;
+    status: string;
+    facets: string;
+    role: string | null;
+    note: string | null;
+    due: string | null;
+    paused_reason: string | null;
+    related_project: string | null;
+    spinout_candidate: number;
+    anchor_id: number | null;
+    live_verdict?: string | null;
+    verdict_evidence?: string | null;
+}
+export interface EdgeRow {
+    from_id: string;
+    to_id: string;
+    type: string;
+    strength: string | null;
+    note: string | null;
+}
+export type EdgeStrength = 'hard' | 'soft' | 'watch';
+export declare const edgeStrength: (e: {
+    type: string;
+    strength?: string | null;
+}) => EdgeStrength;
+export type StatusColor = 'green' | 'red' | 'gray' | 'amber' | 'blue';
+export declare function statusColor(status: string): StatusColor;
+export declare function verdictColor(verdict: string): StatusColor;
+export declare function nodeColor(n: {
+    status: string;
+    live_verdict?: string | null;
+}): StatusColor;
+export interface ProjectMeta {
+    project: string;
+    job: string | null;
+    audience: Record<string, unknown>;
+    product_status: string | null;
+    template: string | null;
+    stages: Array<{
+        id: string;
+        label?: string;
+    }>;
+    related_projects: unknown[];
+}
+export declare function getProjectMeta(db: Database.Database, project: string): ProjectMeta | undefined;
+export declare function listMapProjects(db: Database.Database): string[];
+export declare function getNode(db: Database.Database, project: string, id: string): NodeRow | undefined;
+export declare function getSuspects(db: Database.Database, project: string): NodeRow[];
+export interface BlastHit {
+    id: string;
+    statement: string;
+    status: string;
+    via: string;
+    relation: string;
+    strength: EdgeStrength;
+}
+export declare function blastRadius(db: Database.Database, project: string, id: string): BlastHit[];
+export interface WhereAmIMatch {
+    node: NodeRow;
+    stage_label: string | null;
+    match_reason: string;
+    blast: BlastHit[];
+    anchor: {
+        id: number;
+        statement: string;
+    } | null;
+}
+export interface WhereAmIResult {
+    project: string;
+    job: string | null;
+    matched: WhereAmIMatch[];
+}
+export declare function whereAmI(db: Database.Database, opts: {
+    project?: string;
+    query?: string;
+    node_id?: string;
+    limit?: number;
+}): WhereAmIResult;
+export interface BlueprintCell {
+    stage: string;
+    label: string;
+    nodes: Array<NodeRow & {
+        color: StatusColor;
+    }>;
+}
+export interface Blueprint {
+    project: string;
+    stages: BlueprintCell[];
+    implementation: Array<NodeRow & {
+        color: StatusColor;
+    }>;
+    counts: Record<string, number>;
+}
+export declare function getBlueprint(db: Database.Database, project: string, stageOrder?: Array<{
+    id: string;
+    label?: string;
+}>): Blueprint;

package/dist/lib/map-view.js

@@ -0,0 +1,201 @@
+const DEFAULT_STRENGTH = {
+    'must-stay-consistent-with': 'hard',
+    realizes: 'hard',
+    'should-align-with': 'soft',
+    supports: 'soft',
+    mentions: 'watch',
+    reflux: 'watch',
+};
+export const edgeStrength = (e) => e.strength || DEFAULT_STRENGTH[e.type] || 'soft';
+export function statusColor(status) {
+    switch (status) {
+        case 'active':
+        case 'commitment': return 'green'; // convergence (realized / on the hook)
+        case 'suspect': return 'red'; // divergence (reality may contradict)
+        case 'paused':
+        case 'planned':
+        case 'future_thesis': return 'gray'; // absence (declared, not realized)
+        case 'experiment': return 'amber'; // in flight, allowed to wobble
+        default: return 'blue';
+    }
+}
+// A live reconciler verdict (when present) OVERRIDES the declared-status color —
+// reality wins over what we hand-declared.
+export function verdictColor(verdict) {
+    switch (verdict) {
+        case 'convergence': return 'green';
+        case 'divergence': return 'red';
+        case 'absence': return 'gray';
+        default: return 'blue';
+    }
+}
+export function nodeColor(n) {
+    return n.live_verdict ? verdictColor(n.live_verdict) : statusColor(n.status);
+}
+export function getProjectMeta(db, project) {
+    const r = db.prepare('SELECT * FROM map_projects WHERE project = ?').get(project);
+    if (!r)
+        return undefined;
+    const j = (s, dflt) => { try {
+        return JSON.parse(s);
+    }
+    catch {
+        return dflt;
+    } };
+    return {
+        project: r.project, job: r.job, audience: j(r.audience, {}), product_status: r.product_status,
+        template: r.template, stages: j(r.stages, []), related_projects: j(r.related_projects, []),
+    };
+}
+export function listMapProjects(db) {
+    return db.prepare('SELECT project FROM map_projects ORDER BY project').all().map((r) => r.project);
+}
+export function getNode(db, project, id) {
+    return db.prepare('SELECT * FROM map_nodes WHERE project = ? AND id = ?').get(project, id);
+}
+export function getSuspects(db, project) {
+    return db.prepare("SELECT * FROM map_nodes WHERE project = ? AND status = 'suspect' ORDER BY stage, id").all(project);
+}
+// 1-hop blast radius. Propagation rules, by edge type:
+//   must-stay-consistent-with — SYMMETRIC: touch either end, the other is suspect.
+//   realizes / supports       — DIRECTIONAL: an out-of-band change to the SOURCE
+//     threatens the TARGET (the thing it realizes/supports). We also surface the
+//     reverse for `realizes` (changing a surface's intent implicates its impl).
+//   reflux                    — informational only (expand→discover feedback), not
+//     a breakage path; excluded from the suspect set.
+export function blastRadius(db, project, id) {
+    const edges = db.prepare('SELECT from_id, to_id, type, strength, note FROM map_edges WHERE project = ? AND (from_id = ? OR to_id = ?)')
+        .all(project, id, id);
+    const hits = new Map();
+    const rank = { hard: 0, soft: 1, watch: 2 };
+    const add = (other, relation, strength) => {
+        if (other === id)
+            return;
+        const existing = hits.get(other);
+        if (existing && rank[existing.strength] <= rank[strength])
+            return; // keep the stronger edge
+        const n = getNode(db, project, other);
+        if (!n)
+            return;
+        hits.set(other, { id: n.id, statement: n.statement, status: n.status, via: id, relation, strength });
+    };
+    for (const e of edges) {
+        if (e.type === 'reflux')
+            continue; // feedback loop, not a dependency path
+        const s = edgeStrength(e);
+        if (e.type === 'must-stay-consistent-with')
+            add(e.from_id === id ? e.to_id : e.from_id, e.type, s);
+        else if (e.type === 'should-align-with')
+            add(e.from_id === id ? e.to_id : e.from_id, e.type, s);
+        else if (e.type === 'mentions')
+            add(e.from_id === id ? e.to_id : e.from_id, e.type, s);
+        else if (e.type === 'realizes') {
+            if (e.from_id === id)
+                add(e.to_id, 'realizes→ (impl change threatens surface)', s);
+            else
+                add(e.from_id, '←realizes (surface intent change implicates impl)', s);
+        }
+        else if (e.type === 'supports') {
+            if (e.from_id === id)
+                add(e.to_id, 'supports→ (this underpins it)', s);
+        }
+    }
+    // hard first, then soft, then watch
+    return [...hits.values()].sort((a, b) => rank[a.strength] - rank[b.strength]);
+}
+function queryTerms(q) {
+    return q.toLowerCase().split(/[\s、。,.\/_()「」"'`:：]+/).map((t) => t.trim()).filter((t) => t.length >= 2);
+}
+export function whereAmI(db, opts) {
+    const project = opts.project
+        ?? db.prepare('SELECT project FROM map_projects ORDER BY updated_at DESC LIMIT 1').get()?.project
+        ?? '';
+    const meta = project ? getProjectMeta(db, project) : undefined;
+    const stageLabel = (stageId) => stageId ? meta?.stages.find((s) => s.id === stageId)?.label ?? stageId : null;
+    const anchorOf = (n) => n.anchor_id != null
+        ? db.prepare('SELECT id, statement FROM drift_anchors WHERE id = ?').get(n.anchor_id) ?? null
+        : null;
+    const wrap = (n, reason) => ({
+        node: n, stage_label: stageLabel(n.stage), match_reason: reason,
+        blast: blastRadius(db, project, n.id), anchor: anchorOf(n),
+    });
+    const limit = opts.limit ?? 3;
+    const norm = (p) => p.replace(/\\/g, '/');
+    const nodePaths = (n) => {
+        let r = {};
+        try {
+            r = JSON.parse(n.reality || '{}');
+        }
+        catch { /* none */ }
+        const ps = [];
+        if (r.path)
+            ps.push(norm(r.path));
+        for (const c of (r.checks ?? []))
+            if (c.path)
+                ps.push(norm(c.path));
+        return ps;
+    };
+    // 1. exact node id
+    if (opts.node_id) {
+        const n = getNode(db, project, opts.node_id);
+        return { project, job: meta?.job ?? null, matched: n ? [wrap(n, 'exact node id')] : [] };
+    }
+    // 2. AUTO-INFERENCE: no query/node_id → locate from what you just edited (the per-turn
+    // re-anchor with zero args). Recent edit/write file paths → the node that owns the file.
+    if (!opts.query) {
+        const recents = db.prepare("SELECT file_path, MAX(occurred_at) AS t FROM session_file_edits WHERE operation IN ('edit','write') GROUP BY file_path ORDER BY t DESC LIMIT 25").all();
+        const all = db.prepare('SELECT * FROM map_nodes WHERE project = ?').all(project);
+        const matched = [];
+        const seen = new Set();
+        for (const r of recents) {
+            const fp = norm(r.file_path);
+            for (const n of all) {
+                if (seen.has(n.id))
+                    continue;
+                if (nodePaths(n).some((p) => fp === p || fp.endsWith('/' + p))) {
+                    seen.add(n.id);
+                    matched.push(wrap(n, `recently edited ${r.file_path.split(/[\\/]/).pop()}`));
+                }
+            }
+            if (matched.length >= limit)
+                break;
+        }
+        return { project, job: meta?.job ?? null, matched: matched.slice(0, limit) };
+    }
+    // 3. lexical scoring over id + statement + note + facets
+    const terms = queryTerms(opts.query ?? '');
+    const all = db.prepare('SELECT * FROM map_nodes WHERE project = ?').all(project);
+    const scored = all.map((n) => {
+        const hay = `${n.id} ${n.statement} ${n.note ?? ''} ${n.facets}`.toLowerCase();
+        let score = 0;
+        if (terms.some((t) => n.id.toLowerCase() === t))
+            score += 10; // id hit dominates
+        for (const t of terms)
+            if (hay.includes(t))
+                score += n.id.toLowerCase().includes(t) ? 3 : 1;
+        return { n, score };
+    }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+    return {
+        project, job: meta?.job ?? null,
+        matched: scored.map((x) => wrap(x.n, `lexical match (score ${x.score})`)),
+    };
+}
+// The dashboard home: surface nodes laid out by journey stage (the columns),
+// implementation nodes in their own tray, every node carrying a status color.
+export function getBlueprint(db, project, stageOrder) {
+    // Fall back to the persisted canonical spine when the caller didn't pass one (the dashboard path).
+    const order = stageOrder ?? getProjectMeta(db, project)?.stages ?? [];
+    const all = db.prepare('SELECT * FROM map_nodes WHERE project = ? ORDER BY stage, id').all(project);
+    const withColor = (n) => ({ ...n, color: nodeColor(n) });
+    const stages = order.map((s) => ({
+        stage: s.id,
+        label: s.label ?? s.id,
+        nodes: all.filter((n) => n.layer === 'surface' && n.stage === s.id).map(withColor),
+    }));
+    const implementation = all.filter((n) => n.layer === 'implementation').map(withColor);
+    const counts = {};
+    for (const n of all)
+        counts[n.status] = (counts[n.status] ?? 0) + 1;
+    return { project, stages, implementation, counts };
+}
+//# sourceMappingURL=map-view.js.map

package/dist/lib/momentum.js

@@ -52,13 +52,13 @@ export function refreshMomentumForEntity(db, entityId) {
     const dayAgo = now - 86400;
     const weekAgo = now - 7 * 86400;
     const stats = db
-        .prepare(`
-      SELECT
-        (SELECT COUNT(*) FROM events WHERE entity_id = ? AND occurred_at >= ?) as e24,
-        (SELECT COUNT(*) FROM events WHERE entity_id = ? AND occurred_at >= ?) as e7d,
-        (SELECT COUNT(*) FROM events WHERE entity_id = ?) as eAll,
-        (SELECT created_at FROM entities WHERE id = ?) as createdAt,
-        (SELECT COALESCE(AVG(importance), 0.5) FROM memories WHERE entity_id = ? AND created_at >= ?) as avgImpRecent
+        .prepare(`
+      SELECT
+        (SELECT COUNT(*) FROM events WHERE entity_id = ? AND occurred_at >= ?) as e24,
+        (SELECT COUNT(*) FROM events WHERE entity_id = ? AND occurred_at >= ?) as e7d,
+        (SELECT COUNT(*) FROM events WHERE entity_id = ?) as eAll,
+        (SELECT created_at FROM entities WHERE id = ?) as createdAt,
+        (SELECT COALESCE(AVG(importance), 0.5) FROM memories WHERE entity_id = ? AND created_at >= ?) as avgImpRecent
       `)
         .get(entityId, dayAgo, entityId, weekAgo, entityId, entityId, entityId, weekAgo);
     const daysObserved = stats.createdAt ? Math.max(1, (now - stats.createdAt) / 86400) : 1;

package/dist/lib/truth-engine.js

@@ -96,7 +96,7 @@ export function getTruthView(db, opts = {}) {
     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
+        .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();
@@ -113,8 +113,8 @@ export function getTruthView(db, opts = {}) {
         }
     }
     // ── Active nodes + state derivation ──
-    let sql = `SELECT id, node_type, domain, decision_mode, statement, rationale, confidence, lifecycle,
-            card_policy, review_after
+    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) {
@@ -264,8 +264,8 @@ export function getTruthView(db, opts = {}) {
 // ── 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
+        .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)
@@ -283,14 +283,14 @@ export function getDecisionDetail(db, anchorId) {
     // 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'
+        .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%'
+        .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;
@@ -328,7 +328,7 @@ export function getDecisionDetail(db, anchorId) {
         ?? (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
+        .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 {

package/dist/mcp/read-smart.js

@@ -30,14 +30,14 @@ export function handleReadSmart(db, args) {
         const fileHash = hashFile(content);
         const chunks = chunkFile(path, content);
         const chunkMeta = chunks.map(toMeta);
-        db.prepare(`INSERT INTO file_snapshots (path, content_hash, mtime, size_bytes, chunks, last_read_at, read_count)
-       VALUES (?, ?, ?, ?, ?, unixepoch(), 1)
-       ON CONFLICT(path) DO UPDATE SET
-         content_hash = excluded.content_hash,
-         mtime = excluded.mtime,
-         size_bytes = excluded.size_bytes,
-         chunks = excluded.chunks,
-         last_read_at = unixepoch(),
+        db.prepare(`INSERT INTO file_snapshots (path, content_hash, mtime, size_bytes, chunks, last_read_at, read_count)
+       VALUES (?, ?, ?, ?, ?, unixepoch(), 1)
+       ON CONFLICT(path) DO UPDATE SET
+         content_hash = excluded.content_hash,
+         mtime = excluded.mtime,
+         size_bytes = excluded.size_bytes,
+         chunks = excluded.chunks,
+         last_read_at = unixepoch(),
          read_count = read_count + 1`).run(path, fileHash, mtime, size, JSON.stringify(chunkMeta));
         return JSON.stringify({
             ok: true,