linksee-memory 0.7.1 → 0.8.0

package/dist/lib/edge-detection.js

@@ -0,0 +1,178 @@
+// Memory→memory edge detection (precision-first, no LLM required).
+//
+// Populates the `memory_edges` table with supersedes/contradicts links between
+// DECISION memories, so the dashboard can render Pivot Chains and recall can
+// surface superseded decisions. Runs inside the sleep-mode consolidation sweep.
+// Idempotent (UNIQUE constraint on memory_edges).
+//
+// Heuristic: within one entity, a later decision that shares strong topical terms
+// with an earlier decision *supersedes* it (→ *contradicts* if it carries reversal
+// markers like やめる / 撤回 / revert / instead of). The earlier decision's state
+// is flipped to 'superseded'. We link to the MOST RECENT same-topic decision so
+// chains form (A → B → C) rather than cliques.
+import { isMetaOrNoise, isPastedExternalContent } from './session-parser.js';
+// A later decision either REVERSES an earlier one (→ contradicts) or REPLACES it
+// (→ supersedes). A same-topic decision with NEITHER marker only EXTENDS the earlier
+// one and must NOT deactivate it — marking a still-valid decision 'superseded' is
+// silent data loss (e.g. "v2 format" extends, it does not kill, the "2-layer arch" decision).
+const CONTRADICT_MARKERS = /やめ|撤回|取り消|ではなく|じゃなく|見直|revert|rollback|instead of|no longer|abandon|\bdon'?t\b/i;
+const SUPERSEDE_MARKERS = /の代わり|に変更|に切り替|乗り換|を置き換|に置換|廃止|replaces?\b|supersed|deprecat|switch(?:ing|ed)?\s+(?:to|from|away)/i;
+const STOPWORDS = new Set([
+    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'your', 'our', 'their',
+    'about', 'what', 'when', 'will', 'have', 'has', 'was', 'were', 'are', 'not', 'use', 'using',
+    'memory', 'linksee', 'session', 'decision', 'project', 'やった', 'する', 'した', 'して',
+    'こと', 'ため', 'よう', 'という', 'です', 'ます', 'など', 'その', 'この', 'これ', 'それ',
+    // conversational fillers — must never count as a shared "topic" term
+    'そうだね', 'そうね', 'ありがとう', 'なるほど', 'やろう', 'いいね', 'おおいね', 'これでいい',
+    'これでいいと思う', 'これでいいかな', 'わかった', '了解', 'おはよう', 'おつかれ',
+]);
+// Both endpoints must have substantive core text — kills "そうだね"/"ありがとう"
+// turns that the upstream classifier over-labels as decisions.
+const MIN_CORE_LEN = 40;
+// Decisions whose body opens with an acknowledgement are almost always chitchat
+// the upstream classifier mis-typed — never use them as edge endpoints.
+const CHITCHAT_OPENER = /^\s*(?:そう(?:だ?ね|だよね)?|うん|ありがと|なるほど|おお|へえ|了解|わかった|はい|おはよう|おつかれ|いいね|まあ|ええ|あー)/;
+// Terminal output, git/npm logs, and pasted emails also get mis-typed as decisions.
+// isPastedExternalContent misses these shapes, so guard them explicitly.
+const LOOKS_LIKE_PASTE = /PS [A-Za-z]:\\|[A-Za-z]:\\Users\\|create mode \d{6}|\bgit (?:commit|push|add|status|log|diff|branch|checkout|merge)\b|commit -m|\bnpm (?:run|install|ci)\b|Upon further review|resubmission|Thank you for your/i;
+function significantTerms(text) {
+    const out = new Set();
+    const lower = text.toLowerCase();
+    const asciiRe = /[a-z][a-z0-9_+.-]{2,}/g;
+    let m;
+    while ((m = asciiRe.exec(lower)) !== null) {
+        const w = m[0];
+        if (w.length >= 3 && !STOPWORDS.has(w))
+            out.add(w);
+    }
+    // CJK runs (hiragana / katakana / kanji / half-width kana), length 2..12.
+    const cjkRe = /[぀-ヿ㐀-鿿ｦ-ﾟ]{2,12}/g;
+    while ((m = cjkRe.exec(text)) !== null) {
+        const w = m[0];
+        if (!STOPWORDS.has(w))
+            out.add(w);
+    }
+    return out;
+}
+function coreText(content) {
+    try {
+        const o = JSON.parse(content);
+        return {
+            title: String(o.title ?? ''),
+            body: String(o.what ?? o.decision ?? o.intent ?? o.learned ?? ''),
+        };
+    }
+    catch {
+        return { title: '', body: content };
+    }
+}
+export function detectMemoryEdges(db, opts = {}) {
+    const lookback = opts.lookback ?? 25;
+    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
+  `).all();
+    res.decisionsScanned = rows.length;
+    if (rows.length < 2)
+        return res;
+    const byEntity = new Map();
+    for (const r of rows) {
+        const arr = byEntity.get(r.entity_id);
+        if (arr)
+            arr.push(r);
+        else
+            byEntity.set(r.entity_id, [r]);
+    }
+    // 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 apply = () => {
+        for (const decisions of byEntity.values()) {
+            if (decisions.length < 2)
+                continue;
+            const meta = decisions.map((d) => {
+                const { title, body } = coreText(d.content);
+                const text = `${title} ${body}`;
+                // Defend against the polluted 'decision' input set: drop pasted external
+                // content (emails / terminal logs), meta-noise, chitchat, and too-short bodies.
+                const usable = text.trim().length >= MIN_CORE_LEN
+                    && !CHITCHAT_OPENER.test(body)
+                    && !isMetaOrNoise(body)
+                    && !isPastedExternalContent(body)
+                    && !LOOKS_LIKE_PASTE.test(text);
+                return { id: d.id, title: (title || body).slice(0, 60), text, len: text.trim().length, terms: significantTerms(text), usable };
+            }).filter((m) => m.usable && m.terms.size >= 3);
+            for (let i = 1; i < meta.length; i++) {
+                if (meta[i].terms.size < 3 || meta[i].len < MIN_CORE_LEN)
+                    continue;
+                let linked = -1;
+                let linkedShared = [];
+                for (let j = i - 1; j >= 0 && i - j <= lookback; j--) {
+                    if (meta[j].terms.size < 3 || meta[j].len < MIN_CORE_LEN)
+                        continue;
+                    const shared = [];
+                    for (const t of meta[i].terms)
+                        if (meta[j].terms.has(t))
+                            shared.push(t);
+                    if (shared.length < 3)
+                        continue; // require >= 3 shared topic terms (precision-first)
+                    const overlap = shared.length / Math.min(meta[i].terms.size, meta[j].terms.size);
+                    if (overlap > 0.85)
+                        continue; // near-identical memories = a duplicate, not a supersession
+                    if (overlap >= 0.25) {
+                        linked = j;
+                        linkedShared = shared;
+                        break;
+                    } // most-recent same-topic → chain
+                }
+                if (linked < 0)
+                    continue;
+                const reversing = CONTRADICT_MARKERS.test(meta[i].text);
+                const replacing = SUPERSEDE_MARKERS.test(meta[i].text);
+                const relation = reversing ? 'contradicts' : replacing ? 'supersedes' : 'extends';
+                const deactivatesOlder = reversing || replacing; // 'extends' leaves the older decision valid
+                let counted = true;
+                if (!opts.dryRun) {
+                    const r = insEdge.run(meta[i].id, meta[linked].id, relation);
+                    if (r.changes > 0) {
+                        if (deactivatesOlder && markSuperseded.run(meta[linked].id).changes > 0)
+                            res.supersededMarked++;
+                    }
+                    else {
+                        counted = false; // edge already existed
+                    }
+                }
+                if (counted) {
+                    res.edgesCreated++;
+                    if (relation === 'contradicts')
+                        res.contradicts++;
+                    else if (relation === 'supersedes')
+                        res.supersedes++;
+                    else
+                        res.extends++;
+                    if (res.samples.length < 25) {
+                        res.samples.push({
+                            from_id: meta[i].id, to_id: meta[linked].id, relation,
+                            from_title: meta[i].title, to_title: meta[linked].title, shared: linkedShared.slice(0, 6),
+                        });
+                    }
+                }
+            }
+        }
+    };
+    if (opts.dryRun)
+        apply();
+    else
+        db.transaction(apply)();
+    return res;
+}
+//# sourceMappingURL=edge-detection.js.map

package/dist/lib/session-extractor.js

@@ -25,7 +25,35 @@ const TYPE_PATTERNS = [
     [/学び|教訓|分かった|判明|発見|learn|realize|discover|find\s+out|turns?\s+out|takeaway|insight/i, 'learning'],
     [/結果|完了|成功|失敗|outcome|result|shipped|deployed|launched|finished|accomplished/i, 'outcome'],
 ];
+// Pasted terminal/git/npm output and forwarded emails get mis-typed as decisions.
+// isPastedExternalContent misses these shapes, so guard them explicitly.
+const LOOKS_LIKE_PASTE = /PS [A-Za-z]:\\|[A-Za-z]:\\Users\\|create mode \d{6}|\bgit (?:commit|push|add|status|log|diff|branch|checkout|merge)\b|commit -m|\bnpm (?:run|install|ci)\b|Upon further review|resubmission|Thank you for your/i;
+// A turn that is ENTIRELY an acknowledgement carries no cognitive content. This only
+// fires on short, wholly-filler messages — anything with substance after the opener
+// (e.g. "そうだね、Reactを採用しよう") still flows to the patterns below.
+const PURE_ACK = /^(?:そう(?:だ?ね|だよね)?|うん+|ありがと[うー]?|なるほど|了解(?:です)?|わかった|おはよう|おつかれ(?:さま)?|はい+|おお+|へえ+|いいね|まあ|ええ|あー|ok|okay|thanks?|got it|sounds good)[。、,.!！?？\s~〜ねよ]*$/i;
+// Whether a memory's text carries enough signal to assign a meaningful cognitive type.
+// Junk (pasted logs/emails, meta-noise, pure acknowledgements) must NOT become a
+// 'decision'/'comparison' — that pollution caps memory_edges + dashboard quality.
+function isClassifiableContent(text) {
+    const t = text.trim();
+    if (t.length === 0)
+        return false;
+    if (PURE_ACK.test(t))
+        return false;
+    if (LOOKS_LIKE_PASTE.test(text))
+        return false;
+    if (isPastedExternalContent(text))
+        return false;
+    if (isMetaOrNoise(text))
+        return false;
+    return true;
+}
 export function inferType(text, layer) {
+    // Precision guard: junk content has no meaningful type — fall back to 'note'
+    // BEFORE pattern matching / layer defaults so it can never become a 'decision'.
+    if (!isClassifiableContent(text))
+        return 'note';
     for (const [pattern, type] of TYPE_PATTERNS) {
         if (pattern.test(text))
             return type;
@@ -54,6 +82,9 @@ const STATE_PATTERNS = [
     [/取り替え|代わりに|置き換え|replaced|superseded|deprecated|obsolete|旧版|old\s+approach/i, 'superseded'],
 ];
 export function inferState(text, layer) {
+    // Junk content gets a neutral 'open' state rather than a confident 'decided'/'done'.
+    if (!isClassifiableContent(text))
+        return 'open';
     for (const [pattern, state] of STATE_PATTERNS) {
         if (pattern.test(text))
             return state;
@@ -205,6 +236,10 @@ function dedupeEdits(edits) {
 export function extractSession(session, projectName) {
     const memories = [];
     const file_edits = [];
+    // Turn-level dedup: a single user turn should yield at most ONE memory.
+    // Priority: goal(first_intent) > caveat > decision > context. capturedTurns
+    // tracks caveat-claimed turns so the decision pass skips them.
+    const capturedTurns = new Set();
     // Detect fully-automated sessions (e.g. scheduled cron tasks) — no user intent to extract
     const firstRawUserText = session.turns.find((t) => t.role === 'user' && !t.tool_results)?.text ?? '';
     const automated = isAutomatedSession(firstRawUserText);
@@ -265,6 +300,12 @@ export function extractSession(session, projectName) {
             continue;
         if (t.text.trim().length < 40)
             continue;
+        // Defer to the caveat/decision passes when they WOULD capture this turn,
+        // so a clarification that is really a warning/decision isn't double-saved as context.
+        const wouldBeCaveat = matchesAny(t.text, CAVEAT_PATTERNS) && t.text.length > 20 && !isChitchatWithBuriedDecision(t.text, CAVEAT_PATTERNS);
+        const wouldBeDecision = matchesAny(t.text, DECISION_PATTERNS) && t.text.length > 15 && !isChitchatWithBuriedDecision(t.text, DECISION_PATTERNS);
+        if (wouldBeCaveat || wouldBeDecision)
+            continue;
         clarifyCount++;
         const msgText = t.text.slice(0, 600);
         memories.push({
@@ -340,6 +381,8 @@ export function extractSession(session, projectName) {
     for (const t of session.turns) {
         if (t.role !== 'user' || isMetaOrNoise(t.text))
             continue;
+        if (t === firstIntent)
+            continue; // already captured as the goal/first-intent memory
         if (t.tool_results && t.tool_results.length > 0)
             continue;
         if (isPastedExternalContent(t.text))
@@ -364,6 +407,8 @@ export function extractSession(session, projectName) {
                 thread_id: session.session_id,
                 source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'caveat' },
             });
+            if (t.uuid)
+                capturedTurns.add(t.uuid); // claim this turn so the decision pass skips it
         }
     }
     // 5) Learning layer — messages matching decision patterns
@@ -374,6 +419,10 @@ export function extractSession(session, projectName) {
     for (const t of session.turns) {
         if (t.role !== 'user' || isMetaOrNoise(t.text))
             continue;
+        if (t === firstIntent)
+            continue; // already captured as the goal/first-intent memory
+        if (t.uuid && capturedTurns.has(t.uuid))
+            continue; // already captured as a caveat
         if (t.tool_results && t.tool_results.length > 0)
             continue;
         if (isPastedExternalContent(t.text))

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;
+};