linksee-memory 0.8.0 → 0.11.0

package/dist/lib/lexical-match.js

@@ -0,0 +1,87 @@
+// Lexical matching primitives — path-glob + violation-signal detection with precision guards.
+//
+// DUPLICATED VERBATIM from drift-detection.ts (parseArray / normPath / compileGlob / signalIndex /
+// matchViolation / SCRAPE_ANCHOR). Kept standalone so the re-injection guard (guard.ts) reuses the
+// EXACT same lexical logic as the post-hoc drift detector WITHOUT importing the detector (which carries
+// unrelated state, and is mid-WIP). FOLLOW-UP: when drift-detection.ts's in-flight changes land, unify
+// by having it import from here and deleting its private copies. No embedding layer in this stack:
+// matching is substring + path-glob + word-boundary by construction.
+export 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/glob to canonical form (forward slashes, lowercase) so Windows reality
+// (mixed `C:\...` and `C:/...`, mixed case) matches lowercase forward-slash anchor fragments.
+export 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; `*` matches within a path segment, `**` crosses segments; tested unanchored so a fragment
+// matches anywhere in the absolute path.
+export 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);
+}
+// ── precision guards (mirror drift-detection.ts §"precision guards") ───────────
+// A raw substring of a forbidden term is too weak a notion of "violation"; reject three FP classes
+// deductively: 1. sub-token ("cp" in "scp") → word-boundary; 2. negated ("do NOT cp") → negation
+// window before; 3. citation (a scrape-host appears only as a stored value) → require a real net call.
+const NEGATION_NEAR = /\b(?:not|never|no\s+longer|don'?t|do\s+not|avoid|without)\b|禁止|しない|させない|不可|避け|してはいけない|ではなく/i;
+export const SCRAPE_ANCHOR = /crawl|scrap|robots|クロール|スクレイピング|スクレイプ|自動収集|自動巡回/i;
+const NET_CALL = /\b(?:fetch|axios|requests?|urllib|httpx|curl|wget|got|puppeteer|playwright|cheerio|beautifulsoup|selenium|crawl|scrape|scraping)\b|クロール|スクレイピング/i;
+// Locate a signal: ASCII signals must hit on a word boundary; CJK (no boundaries) stays substring.
+export function signalIndex(lowerLine, signal) {
+    if (/^[\x20-\x7e]+$/.test(signal)) {
+        const esc = signal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const m = new RegExp(`(?<![a-z0-9_])${esc}(?![a-z0-9_])`).exec(lowerLine);
+        return m ? m.index : -1;
+    }
+    return lowerLine.indexOf(signal);
+}
+// Deductive violation match with the three precision guards applied (returns the hit term or null).
+export function matchViolation(rawLine, lowerLine, signals, isScrapeAnchor) {
+    for (const s of signals) {
+        const idx = signalIndex(lowerLine, s);
+        if (idx < 0)
+            continue; // 1. word-boundary
+        if (NEGATION_NEAR.test(rawLine.slice(Math.max(0, idx - 24), idx)))
+            continue; // 2. negated context
+        if (isScrapeAnchor && !NET_CALL.test(rawLine))
+            continue; // 3. citation, no net call
+        return s;
+    }
+    return null;
+}
+//# sourceMappingURL=lexical-match.js.map

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

@@ -0,0 +1,55 @@
+import type Database from 'better-sqlite3';
+export declare const EDGE_TYPES: Set<string>;
+export declare const EDGE_STRENGTHS: Set<string>;
+export declare const NODE_LAYERS: Set<string>;
+export declare const NODE_STATUSES: Set<string>;
+export interface MapNode {
+    id: string;
+    layer: string;
+    stage?: string;
+    statement: string;
+    status?: string;
+    facets?: string[];
+    role?: string;
+    note?: string;
+    due?: string;
+    paused_reason?: string;
+    related_project?: string;
+    spinout_candidate?: boolean;
+    anchor?: number;
+    review_by?: string;
+    revival_condition?: string;
+    reality?: Record<string, unknown>;
+    [k: string]: unknown;
+}
+export interface MapEdge {
+    from: string;
+    to: string;
+    type: string;
+    strength?: string;
+    note?: string;
+}
+export interface ParsedMap {
+    project: string;
+    template?: string;
+    product_status?: string;
+    job?: string;
+    audience?: Record<string, unknown>;
+    related_projects?: unknown[];
+    stages: Array<{
+        id: string;
+        label?: string;
+    }>;
+    nodes: MapNode[];
+    edges: MapEdge[];
+}
+export declare function parseMapFile(path: string): ParsedMap;
+export interface ImportResult {
+    project: string;
+    nodes: number;
+    edges: number;
+    linked_anchors: number;
+    warnings: string[];
+}
+export declare function importMap(db: Database.Database, map: ParsedMap): ImportResult;
+export declare function importMapFile(db: Database.Database, path: string): ImportResult;

package/dist/lib/map-import.js

@@ -0,0 +1,150 @@
+import { readFileSync } from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+export const EDGE_TYPES = new Set(['realizes', 'supports', 'must-stay-consistent-with', 'should-align-with', 'mentions', 'reflux']);
+export const EDGE_STRENGTHS = new Set(['hard', 'soft', 'watch']);
+export const NODE_LAYERS = new Set(['surface', 'implementation']);
+// Recognized statuses — anything else imports but is flagged as a warning (so a
+// typo can't silently become a phantom lifecycle the dashboard renders blank).
+export const NODE_STATUSES = new Set([
+    'active', 'experiment', 'commitment', 'planned', 'paused', 'suspect', 'future_thesis',
+]);
+const KNOWN_NODE_COLS = new Set([
+    'id', 'layer', 'stage', 'statement', 'status', 'facets', 'role', 'note',
+    'due', 'paused_reason', 'related_project', 'spinout_candidate', 'anchor', 'reality',
+    'review_by', 'revival_condition',
+]);
+export function parseMapFile(path) {
+    const raw = parseYaml(readFileSync(path, 'utf8'));
+    if (!raw || typeof raw !== 'object')
+        throw new Error(`map.yaml at ${path} parsed to nothing`);
+    if (!raw.project)
+        throw new Error('map.yaml missing required top-level `project`');
+    if (!Array.isArray(raw.stages) || raw.stages.length === 0)
+        throw new Error('map.yaml needs a non-empty `stages` spine');
+    if (!Array.isArray(raw.nodes))
+        throw new Error('map.yaml `nodes` must be a list');
+    return {
+        project: String(raw.project),
+        template: raw.template ? String(raw.template) : undefined,
+        product_status: raw.product_status ? String(raw.product_status) : undefined,
+        job: raw.job ? String(raw.job) : undefined,
+        audience: raw.audience ?? undefined,
+        related_projects: Array.isArray(raw.related_projects) ? raw.related_projects : undefined,
+        stages: raw.stages.map((s) => ({ id: String(s.id), label: s.label ? String(s.label) : undefined })),
+        nodes: raw.nodes ?? [],
+        edges: Array.isArray(raw.edges) ? raw.edges : [],
+    };
+}
+// Full-rebuild import inside one transaction. Validates topology and collects
+// warnings (dangling edge endpoints, unknown stage/status) WITHOUT aborting — a
+// map mid-edit should still load so the dashboard can show what IS there.
+export function importMap(db, map) {
+    const warnings = [];
+    const stageIds = new Set(map.stages.map((s) => s.id));
+    const nodeIds = new Set(map.nodes.map((n) => n.id));
+    // validate nodes
+    for (const n of map.nodes) {
+        if (!n.id) {
+            warnings.push('node with no id skipped');
+            continue;
+        }
+        if (!NODE_LAYERS.has(n.layer))
+            warnings.push(`node ${n.id}: unknown layer "${n.layer}"`);
+        if (n.layer === 'surface' && n.stage && !stageIds.has(n.stage))
+            warnings.push(`node ${n.id}: stage "${n.stage}" not in spine`);
+        if (n.layer === 'surface' && !n.stage)
+            warnings.push(`node ${n.id}: surface node has no stage`);
+        if (n.status && !NODE_STATUSES.has(n.status))
+            warnings.push(`node ${n.id}: unrecognized status "${n.status}"`);
+    }
+    // validate edges
+    for (const e of map.edges) {
+        if (!EDGE_TYPES.has(e.type))
+            warnings.push(`edge ${e.from}→${e.to}: unknown type "${e.type}"`);
+        if (e.strength && !EDGE_STRENGTHS.has(e.strength))
+            warnings.push(`edge ${e.from}→${e.to}: unknown strength "${e.strength}"`);
+        if (!nodeIds.has(e.from))
+            warnings.push(`edge endpoint "${e.from}" is not a node (dangling)`);
+        if (!nodeIds.has(e.to))
+            warnings.push(`edge endpoint "${e.to}" is not a node (dangling)`);
+    }
+    const anchorExists = db.prepare('SELECT 1 FROM drift_anchors WHERE id = ?');
+    let linked = 0;
+    const tx = db.transaction(() => {
+        db.prepare(`
+      INSERT INTO map_projects (project, job, audience, product_status, template, stages, related_projects, updated_at)
+      VALUES (@project, @job, @audience, @product_status, @template, @stages, @related_projects, unixepoch())
+      ON CONFLICT(project) DO UPDATE SET
+        job=excluded.job, audience=excluded.audience, product_status=excluded.product_status,
+        template=excluded.template, stages=excluded.stages, related_projects=excluded.related_projects,
+        updated_at=unixepoch()
+    `).run({
+            project: map.project,
+            job: map.job ?? null,
+            audience: JSON.stringify(map.audience ?? {}),
+            product_status: map.product_status ?? null,
+            template: map.template ?? null,
+            stages: JSON.stringify(map.stages),
+            related_projects: JSON.stringify(map.related_projects ?? []),
+        });
+        db.prepare('DELETE FROM map_edges WHERE project = ?').run(map.project);
+        db.prepare('DELETE FROM map_nodes WHERE project = ?').run(map.project);
+        const insNode = db.prepare(`
+      INSERT INTO map_nodes
+        (id, project, layer, stage, statement, status, facets, role, note, due,
+         paused_reason, related_project, spinout_candidate, anchor_id, review_by, revival_condition, reality, extra, updated_at)
+      VALUES
+        (@id, @project, @layer, @stage, @statement, @status, @facets, @role, @note, @due,
+         @paused_reason, @related_project, @spinout_candidate, @anchor_id, @review_by, @revival_condition, @reality, @extra, unixepoch())
+    `);
+        for (const n of map.nodes) {
+            if (!n.id)
+                continue;
+            let anchorId = null;
+            if (n.anchor != null) {
+                if (anchorExists.get(n.anchor)) {
+                    anchorId = Number(n.anchor);
+                    linked++;
+                }
+                else
+                    warnings.push(`node ${n.id}: anchor #${n.anchor} not found — link skipped`);
+            }
+            const extra = {};
+            for (const k of Object.keys(n))
+                if (!KNOWN_NODE_COLS.has(k))
+                    extra[k] = n[k];
+            insNode.run({
+                id: n.id,
+                project: map.project,
+                layer: n.layer ?? 'surface',
+                stage: n.stage ?? null,
+                statement: n.statement ?? '',
+                status: n.status ?? 'active',
+                facets: JSON.stringify(n.facets ?? []),
+                role: n.role ?? null,
+                note: n.note ?? null,
+                due: n.due ?? null,
+                paused_reason: n.paused_reason ?? null,
+                related_project: n.related_project ?? null,
+                spinout_candidate: n.spinout_candidate ? 1 : 0,
+                anchor_id: anchorId,
+                review_by: n.review_by ?? null,
+                revival_condition: n.revival_condition ?? null,
+                reality: JSON.stringify(n.reality ?? {}),
+                extra: JSON.stringify(extra),
+            });
+        }
+        const insEdge = db.prepare(`
+      INSERT OR IGNORE INTO map_edges (project, from_id, to_id, type, strength, note)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        for (const e of map.edges)
+            insEdge.run(map.project, e.from, e.to, e.type, e.strength ?? null, e.note ?? null);
+    });
+    tx();
+    return { project: map.project, nodes: map.nodes.filter((n) => n.id).length, edges: map.edges.length, linked_anchors: linked, warnings };
+}
+export function importMapFile(db, path) {
+    return importMap(db, parseMapFile(path));
+}
+//# sourceMappingURL=map-import.js.map

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

@@ -0,0 +1,29 @@
+import type Database from 'better-sqlite3';
+export type Verdict = 'convergence' | 'divergence' | 'absence';
+export interface CheckResult {
+    claim: string;
+    ok: boolean;
+    file: string | null;
+    line: number | null;
+    detail: string;
+}
+export interface NodeVerdict {
+    id: string;
+    status: string;
+    verdict: Verdict | null;
+    reason: string;
+    why: string | null;
+    fix: string[];
+    checks: CheckResult[];
+    evidence: Record<string, unknown>;
+    flipped: boolean;
+}
+export interface ReconcileResult {
+    project: string;
+    checked: number;
+    external: number;
+    verdicts: NodeVerdict[];
+    refuted: NodeVerdict[];
+    confirmed: NodeVerdict[];
+}
+export declare function reconcile(db: Database.Database, project: string, repoRoot: string): ReconcileResult;

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;