linksee-memory 0.10.0 → 0.11.0

package/dist/db/schema.sql

@@ -358,6 +358,77 @@ CREATE TABLE IF NOT EXISTS injection_log (
 CREATE INDEX IF NOT EXISTS idx_injlog_anchor  ON injection_log(anchor_id, occurred_at);
 CREATE INDEX IF NOT EXISTS idx_injlog_session ON injection_log(session_id, occurred_at);
 
+-- ============================================================
+-- v11: Current Truth Map — journey-spine topology (Product Drift OS spec v3).
+-- map.yaml (git) is the desired-state SOURCE OF TRUTH (anchor #58); these tables
+-- are the runtime index the importer reconciles INTO. A map_node is product
+-- STRUCTURE (surface | implementation) — a SUPERSET of drift_anchors, which hold
+-- only NORMATIVE claims. A normative node links out via anchor_id; descriptive
+-- surfaces ("README exists") leave it NULL, so the violation scanner never sees
+-- them. Full-rebuild import: the importer wipes a project's rows and re-inserts.
+-- ============================================================
+CREATE TABLE IF NOT EXISTS map_nodes (
+  id              TEXT NOT NULL,                     -- stable slug from map.yaml (e.g. 'readme'); unique PER PROJECT
+  project         TEXT NOT NULL,
+  layer           TEXT NOT NULL,                     -- surface | implementation
+  stage           TEXT,                              -- journey stage id (NULL for implementation layer)
+  statement       TEXT NOT NULL,
+  status          TEXT NOT NULL DEFAULT 'active',    -- active|experiment|commitment|planned|paused|suspect|future_thesis
+  facets          TEXT NOT NULL DEFAULT '[]',        -- JSON array (the demoted old domains, as tags)
+  role            TEXT,                              -- e.g. 'diffusion'
+  note            TEXT,
+  due             TEXT,                              -- ISO date (commitments)
+  paused_reason   TEXT,
+  related_project TEXT,
+  spinout_candidate INTEGER NOT NULL DEFAULT 0,
+  anchor_id       INTEGER REFERENCES drift_anchors(id) ON DELETE SET NULL,  -- link IFF normative
+  review_by       TEXT,                              -- ISO date: when an accounted-for/deferred node must be revisited
+  revival_condition TEXT,                            -- the release condition that clears a deferral (anti-graveyard)
+  reality         TEXT NOT NULL DEFAULT '{}',        -- JSON: how to verify this node from reality (kind/dir/signal)
+  live_verdict    TEXT,                              -- reconciler overlay: convergence|divergence|absence|NULL(unchecked)
+  verdict_evidence TEXT NOT NULL DEFAULT '{}',       -- JSON: file/line/term that decided the verdict
+  reconciled_at   INTEGER,                           -- when the reconciler last ran for this node
+  extra           TEXT NOT NULL DEFAULT '{}',        -- JSON catch-all (forward-compat fields)
+  updated_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+  PRIMARY KEY (project, id)                          -- a node id is unique PER PROJECT, not globally
+);
+CREATE INDEX IF NOT EXISTS idx_map_nodes_project ON map_nodes(project);
+CREATE INDEX IF NOT EXISTS idx_map_nodes_stage   ON map_nodes(stage);
+CREATE INDEX IF NOT EXISTS idx_map_nodes_status  ON map_nodes(status);
+CREATE INDEX IF NOT EXISTS idx_map_nodes_layer   ON map_nodes(layer);
+
+-- Node↔node typed edges — the topology that makes blast-radius computable.
+-- type: realizes (impl→surface) | supports | must-stay-consistent-with | reflux (expand→discover).
+-- Endpoints are map_nodes slugs (validated in the lib, not FK-constrained, to keep
+-- the wipe+reinsert import order trivial).
+CREATE TABLE IF NOT EXISTS map_edges (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  project   TEXT NOT NULL,
+  from_id   TEXT NOT NULL,
+  to_id     TEXT NOT NULL,
+  type      TEXT NOT NULL,                           -- realizes|supports|must-stay-consistent-with|should-align-with|mentions|reflux
+  strength  TEXT,                                    -- hard|soft|watch (controls AFFECTS noise); NULL → derived from type
+  note      TEXT,
+  UNIQUE(project, from_id, to_id, type)              -- an edge is unique PER PROJECT
+);
+CREATE INDEX IF NOT EXISTS idx_map_edges_from ON map_edges(from_id);
+CREATE INDEX IF NOT EXISTS idx_map_edges_to   ON map_edges(to_id);
+CREATE INDEX IF NOT EXISTS idx_map_edges_type ON map_edges(type);
+
+-- Project-level Map meta — the spine order/labels + the Job statement live in map.yaml,
+-- NOT derivable from nodes alone. Persist them so any reader (dashboard) can render the
+-- canonical journey order and the Job headline without parsing the YAML.
+CREATE TABLE IF NOT EXISTS map_projects (
+  project          TEXT PRIMARY KEY,
+  job              TEXT,
+  audience         TEXT NOT NULL DEFAULT '{}',   -- JSON
+  product_status   TEXT,
+  template         TEXT,
+  stages           TEXT NOT NULL DEFAULT '[]',   -- JSON [{id,label}] — canonical spine order
+  related_projects TEXT NOT NULL DEFAULT '[]',   -- JSON
+  updated_at       INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
 -- ============================================================
 -- Meta — schema version tracking
 -- ============================================================
@@ -366,6 +437,6 @@ CREATE TABLE IF NOT EXISTS meta (
   value         TEXT NOT NULL
 );
 
-INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '10');
+INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '14');
 INSERT OR IGNORE INTO meta (key, value) VALUES ('created_at', CAST(unixepoch() AS TEXT));
-UPDATE meta SET value = '10' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6', '7', '8', '9');
+UPDATE meta SET value = '14' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13');

package/dist/lib/consolidate.js

@@ -25,17 +25,17 @@ export function consolidate(db, opts = {}) {
     // table is actually populated by the MCP server).
     const layerPlaceholders = CLUSTER_LAYERS.map(() => '?').join(',');
     const rows = db
-        .prepare(`
-      SELECT m.id, m.entity_id, m.layer, m.content, m.importance,
-             m.last_accessed_at, m.access_count, m.created_at, m.protected,
-             m.altitude,
-             e.name as entity_name
-      FROM memories m
-      JOIN entities e ON e.id = m.entity_id
-      WHERE m.protected = 0
-        AND m.layer IN (${layerPlaceholders})
-        AND m.created_at <= ?
-      ORDER BY m.entity_id, m.layer, m.created_at
+        .prepare(`
+      SELECT m.id, m.entity_id, m.layer, m.content, m.importance,
+             m.last_accessed_at, m.access_count, m.created_at, m.protected,
+             m.altitude,
+             e.name as entity_name
+      FROM memories m
+      JOIN entities e ON e.id = m.entity_id
+      WHERE m.protected = 0
+        AND m.layer IN (${layerPlaceholders})
+        AND m.created_at <= ?
+      ORDER BY m.entity_id, m.layer, m.created_at
       `)
         .all(...CLUSTER_LAYERS, ageCutoff);
     // Filter to cold-heat memories
@@ -68,10 +68,10 @@ export function consolidate(db, opts = {}) {
         memoryEdgesCreated: 0,
         decisionsSuperseded: 0,
     };
-    const insertLearning = db.prepare(`INSERT INTO memories (entity_id, layer, content, importance, protected, source)
+    const insertLearning = db.prepare(`INSERT INTO memories (entity_id, layer, content, importance, protected, source)
      VALUES (?, 'learning', ?, ?, 1, ?)`);
     const deleteMemory = db.prepare('DELETE FROM memories WHERE id = ?');
-    const insertAudit = db.prepare(`INSERT INTO consolidations (learning_id, replaced_ids, replaced_count, entity_id, original_layer)
+    const insertAudit = db.prepare(`INSERT INTO consolidations (learning_id, replaced_ids, replaced_count, entity_id, original_layer)
      VALUES (?, ?, ?, ?, ?)`);
     const insertEvent = db.prepare('INSERT INTO events (entity_id, kind, payload) VALUES (?, ?, ?)');
     const tx = db.transaction(() => {
@@ -137,12 +137,12 @@ export function consolidate(db, opts = {}) {
     // Uses json_set() to update the state field in content JSON atomically.
     const STALLED_THRESHOLD_DAYS = 30;
     const stalledCutoff = now - STALLED_THRESHOLD_DAYS * 86400;
-    const stalledResult = db.prepare(`
-    UPDATE memories SET content = json_set(content, '$.state', 'stalled')
-    WHERE json_valid(content)
-      AND json_extract(content, '$.state') = 'in_progress'
-      AND last_accessed_at < ?
-      AND protected = 0
+    const stalledResult = db.prepare(`
+    UPDATE memories SET content = json_set(content, '$.state', 'stalled')
+    WHERE json_valid(content)
+      AND json_extract(content, '$.state') = 'in_progress'
+      AND last_accessed_at < ?
+      AND protected = 0
   `).run(stalledCutoff);
     result.stalledTransitions = stalledResult.changes;
     // Memory→memory edge detection: link superseding/contradicting decisions so the

package/dist/lib/drift-detection.js

@@ -285,12 +285,47 @@ export function detectDrift(db, opts = {}) {
 // 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.
+// Prose (.md/.html) DESCRIBES rules; it is not where a code/operational constraint is *violated*.
+// Scanning it produced false positives (a SKILL.md line literally saying "NOT raw chat"). Code only.
 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',
+    '.java', '.rb', '.php', '.sh', '.yml', '.yaml', '.toml', '.env',
 ]);
 const MAX_FILES_PER_ANCHOR = 400;
 const COMMENT_PREFIXES = ['//', '*', '/*', '#', '<!--', '--'];
+// ── precision guards ─────────────────────────────────────────────────────────
+// A raw substring of a forbidden term is too weak a notion of "violation". On the real corpus
+// the bare-substring match produced ~90% false positives in three classes; reject each deductively:
+//   1. sub-token — "forget" inside "forgetting" / "decideForgetting"        → word-boundary match
+//   2. negated   — the line FORBIDS the term ("...NOT raw chat", "…禁止")     → negation window before
+//   3. citation  — a scrape-prohibition's host appears only as a stored value → require a real net call
+//                  ('cosmetic-info.jp' as a provenance label is not a fetch of it)
+const NEGATION_NEAR = /\b(?:not|never|no\s+longer|don'?t|do\s+not|avoid|without)\b|禁止|しない|させない|不可|避け|してはいけない|ではなく/i;
+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.
+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).
+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;
+}
 export function detectFileViolations(db, opts = {}) {
     const emitThreshold = opts.emitThreshold ?? EMIT_THRESHOLD_DEFAULT;
     const res = {
@@ -333,6 +368,7 @@ export function detectFileViolations(db, opts = {}) {
             if (signals.length === 0)
                 continue; // no signal → can't deduce a contradiction
             const terms = parseArray(a.detect_terms);
+            const isScrapeAnchor = SCRAPE_ANCHOR.test(a.statement);
             const aW = tierWeight(a.tier);
             const confidence = Math.min(aW, REALITY_TIER_WEIGHT) * SCOPE_WEIGHT_GLOB;
             if (confidence < emitThreshold)
@@ -367,7 +403,7 @@ export function detectFileViolations(db, opts = {}) {
                     if (COMMENT_PREFIXES.some((p) => trimmed.startsWith(p)))
                         continue; // skip comments
                     const ll = trimmed.toLowerCase();
-                    const hit = signals.find((s) => ll.includes(s));
+                    const hit = matchViolation(trimmed, ll, signals, isScrapeAnchor);
                     if (hit) {
                         found = { line_no: i + 1, line_text: trimmed.slice(0, 280), hit };
                         break; // one edge per (anchor, file): first real hit

package/dist/lib/edge-detection.js

@@ -71,11 +71,11 @@ export function detectMemoryEdges(db, opts = {}) {
     const res = {
         decisionsScanned: 0, edgesCreated: 0, supersedes: 0, contradicts: 0, extends: 0, supersededMarked: 0, samples: [],
     };
-    const rows = db.prepare(`
-    SELECT id, entity_id, content, created_at
-    FROM memories
-    WHERE mem_type = 'decision' AND json_valid(content)
-    ORDER BY entity_id ASC, created_at ASC, id ASC
+    const rows = db.prepare(`
+    SELECT id, entity_id, content, created_at
+    FROM memories
+    WHERE mem_type = 'decision' AND json_valid(content)
+    ORDER BY entity_id ASC, created_at ASC, id ASC
   `).all();
     res.decisionsScanned = rows.length;
     if (rows.length < 2)
@@ -91,9 +91,9 @@ export function detectMemoryEdges(db, opts = {}) {
     // Prepare write statements only when actually writing — keeps dryRun safe on a
     // readonly connection (preview / verification path).
     const insEdge = opts.dryRun ? null : db.prepare(`INSERT OR IGNORE INTO memory_edges (from_memory_id, to_memory_id, relation) VALUES (?, ?, ?)`);
-    const markSuperseded = opts.dryRun ? null : db.prepare(`
-    UPDATE memories SET content = json_set(content, '$.state', 'superseded')
-    WHERE id = ? AND json_valid(content) AND json_extract(content, '$.state') <> 'superseded'
+    const markSuperseded = opts.dryRun ? null : db.prepare(`
+    UPDATE memories SET content = json_set(content, '$.state', 'superseded')
+    WHERE id = ? AND json_valid(content) AND json_extract(content, '$.state') <> 'superseded'
   `);
     const apply = () => {
         for (const decisions of byEntity.values()) {

package/dist/lib/guard.js

@@ -15,8 +15,8 @@ import { normPath, compileGlob, parseArray, matchViolation, SCRAPE_ANCHOR } from
 // "accepted = the only thing the gate compares against": declared (status active), still live
 // (lifecycle active|experiment — NOT at_risk/superseded/deprecated), and not explicitly card-disabled.
 // at_risk(stale) anchors deliberately DON'T gate — we don't enforce a rule we're no longer sure of.
-const ACCEPTED_SQL = `status = 'active'
-  AND lifecycle IN ('active', 'experiment')
+const ACCEPTED_SQL = `status = 'active'
+  AND lifecycle IN ('active', 'experiment')
   AND COALESCE(json_extract(card_policy, '$.enabled'), 1) != 0`;
 const nowSec = () => Math.floor(Date.now() / 1000);
 function jsonGet(json, key, def) {
@@ -38,7 +38,7 @@ function bestEffort(fn) {
 }
 export function acceptedAnchors(db) {
     return db
-        .prepare(`SELECT id, kind, statement, rationale, affects, detect_terms, violation_signal, card_policy
+        .prepare(`SELECT id, kind, statement, rationale, affects, detect_terms, violation_signal, card_policy
          FROM drift_anchors WHERE ${ACCEPTED_SQL}`)
         .all();
 }
@@ -123,7 +123,7 @@ function withinCooldown(db, anchorId, sessionId) {
     return !!row;
 }
 function logInjection(db, matches, act, surface, sessionId) {
-    const ins = db.prepare(`INSERT INTO injection_log (anchor_id, session_id, trigger, surface, tool_name, action_snip, verdict)
+    const ins = db.prepare(`INSERT INTO injection_log (anchor_id, session_id, trigger, surface, tool_name, action_snip, verdict)
      VALUES (?, ?, 'gate', ?, ?, ?, ?)`);
     const snip = (act.lines[0] ?? '').slice(0, 120);
     const tx = db.transaction(() => {
@@ -176,15 +176,15 @@ export function buildBootDigest(db, opts = {}) {
     const maxAnchors = opts.maxAnchors ?? 8;
     const maxForks = opts.maxForks ?? 5;
     const anchors = db
-        .prepare(`SELECT id, statement, rationale FROM drift_anchors
-         WHERE ${ACCEPTED_SQL} AND kind IN ('prohibition', 'decision', 'constraint')
+        .prepare(`SELECT id, statement, rationale FROM drift_anchors
+         WHERE ${ACCEPTED_SQL} AND kind IN ('prohibition', 'decision', 'constraint')
          ORDER BY confidence DESC, updated_at DESC LIMIT ?`)
         .all(maxAnchors);
     const forks = db
-        .prepare(`SELECT c.id, c.rationale, a.statement
-         FROM memory_write_candidates c
-         LEFT JOIN drift_anchors a ON a.id = c.target_node_id
-         WHERE c.scope = 'orphaned_proposal' AND c.status = 'pending_review'
+        .prepare(`SELECT c.id, c.rationale, a.statement
+         FROM memory_write_candidates c
+         LEFT JOIN drift_anchors a ON a.id = c.target_node_id
+         WHERE c.scope = 'orphaned_proposal' AND c.status = 'pending_review'
          ORDER BY c.created_at DESC LIMIT ?`)
         .all(maxForks);
     // Distillation pressure — the routine's structural trigger. The drain must not depend on
@@ -192,10 +192,10 @@ export function buildBootDigest(db, opts = {}) {
     // EVERY session boot says so. Inflow (new sessions) vs drain (8/dream) stays visible.
     let distill = 0;
     try {
-        distill = db.prepare(`SELECT COUNT(*) AS n FROM memories
-          WHERE layer IN ('learning', 'caveat') AND json_valid(content)
-            AND (json_extract(content, '$.needs_distill') = 1
-                 OR json_extract(content, '$.why') = 'Decision detected by pattern match — may need agent enrichment'
+        distill = db.prepare(`SELECT COUNT(*) AS n FROM memories
+          WHERE layer IN ('learning', 'caveat') AND json_valid(content)
+            AND (json_extract(content, '$.needs_distill') = 1
+                 OR json_extract(content, '$.why') = 'Decision detected by pattern match — may need agent enrichment'
                  OR json_extract(content, '$.why') = 'User-stated warning/prohibition — auto-extracted by caveat pattern match')`).get().n;
     }
     catch {
@@ -228,11 +228,11 @@ export function buildBootDigest(db, opts = {}) {
 export function backfillHeeded(db) {
     bestEffort(() => {
         const live = `SELECT anchor_id FROM drift_edges WHERE verdict = 'contradicts' AND status = 'open'`;
-        db.prepare(`UPDATE injection_log SET heeded = 0
-         WHERE heeded IS NULL AND surface IN ('warn', 'inform') AND verdict = 'contradicts'
+        db.prepare(`UPDATE injection_log SET heeded = 0
+         WHERE heeded IS NULL AND surface IN ('warn', 'inform') AND verdict = 'contradicts'
            AND anchor_id IN (${live})`).run();
-        db.prepare(`UPDATE injection_log SET heeded = 1
-         WHERE heeded IS NULL AND surface IN ('warn', 'inform')
+        db.prepare(`UPDATE injection_log SET heeded = 1
+         WHERE heeded IS NULL AND surface IN ('warn', 'inform')
            AND anchor_id NOT IN (${live})`).run();
         db.prepare(`UPDATE injection_log SET heeded = 1 WHERE heeded IS NULL AND surface = 'block'`).run();
     });
@@ -244,16 +244,16 @@ export function getReinjectionFriction(db, opts = {}) {
     const minC = opts.minContradicts ?? 3;
     backfillHeeded(db);
     const rows = db
-        .prepare(`SELECT i.anchor_id,
-              SUM(CASE WHEN i.verdict = 'contradicts' THEN 1 ELSE 0 END) AS gate_contradicts,
-              SUM(CASE WHEN i.surface = 'block' THEN 1 ELSE 0 END)       AS gate_blocks,
-              SUM(CASE WHEN i.heeded = 0 THEN 1 ELSE 0 END)              AS ignored,
-              datetime(MAX(i.occurred_at), 'unixepoch')                 AS last_at,
-              a.statement, a.lifecycle, a.card_policy
-         FROM injection_log i
-         JOIN drift_anchors a ON a.id = i.anchor_id
-        WHERE a.status = 'active'
-        GROUP BY i.anchor_id
+        .prepare(`SELECT i.anchor_id,
+              SUM(CASE WHEN i.verdict = 'contradicts' THEN 1 ELSE 0 END) AS gate_contradicts,
+              SUM(CASE WHEN i.surface = 'block' THEN 1 ELSE 0 END)       AS gate_blocks,
+              SUM(CASE WHEN i.heeded = 0 THEN 1 ELSE 0 END)              AS ignored,
+              datetime(MAX(i.occurred_at), 'unixepoch')                 AS last_at,
+              a.statement, a.lifecycle, a.card_policy
+         FROM injection_log i
+         JOIN drift_anchors a ON a.id = i.anchor_id
+        WHERE a.status = 'active'
+        GROUP BY i.anchor_id
        HAVING gate_contradicts >= ?`)
         .all(minC);
     const realityStmt = db.prepare(`SELECT COUNT(*) AS n FROM drift_edges WHERE anchor_id = ? AND verdict = 'contradicts' AND status = 'open'`);

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;