linksee-memory 0.7.2 → 0.10.0

package/dist/lib/session-extractor.js

@@ -157,7 +157,9 @@ function findFirstIntent(session) {
 // Decisions & learnings — user messages containing explicit commitment words.
 // ============================================================
 const DECISION_PATTERNS = [
-    /決めた|採用|確定|これで(いい|進め)|OK進めて|やろう|行こう/,
+    // ひらがな「いこう」「すすめよう」 variants were missed (real loss observed: "OK. CからAいこう").
+    // Widening is safe now that content-dedup + chitchat guard + needs_distill triage exist downstream.
+    /決めた|採用|確定|これで(いい|進め)|OK進めて|やろう|行こう|いこう|進めよう|すすめよう/,
     /learn(ed)?|decid(?:e|ed|ing)|chose|picked|going with|let'?s\s+go|pivot(?:ing|ed)?|switch(?:ing)?\s+to|settled\s+on|approved|we'?ll\s+use|commit(?:ting)?\s+to/i,
 ];
 const FAILURE_PATTERNS = [
@@ -240,6 +242,10 @@ export function extractSession(session, projectName) {
     // Priority: goal(first_intent) > caveat > decision > context. capturedTurns
     // tracks caveat-claimed turns so the decision pass skips them.
     const capturedTurns = new Set();
+    // Content-level dedup: the SAME utterance sent twice (interrupt + resend is common)
+    // arrives as two distinct turns and used to become two identical memories.
+    const seenWhats = new Set();
+    const whatKey = (layer, text) => `${layer}::${text.replace(/\s+/g, ' ').trim().toLowerCase().slice(0, 200)}`;
     // 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);
@@ -262,6 +268,7 @@ export function extractSession(session, projectName) {
             }),
             importance: automated ? 0.3 : 0.8,
             thread_id: session.session_id,
+            occurred_at: firstIntent.timestamp,
             source: { session_id: session.session_id, turn_uuid: firstIntent.uuid, kind: 'first_intent' },
         });
     }
@@ -282,6 +289,7 @@ export function extractSession(session, projectName) {
             }),
             importance: 0.2,
             thread_id: session.session_id,
+            occurred_at: session.started_at,
             source: { session_id: session.session_id, kind: 'automated_task' },
         });
     }
@@ -306,8 +314,12 @@ export function extractSession(session, projectName) {
         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);
+        const ctxKey = whatKey('context', msgText);
+        if (seenWhats.has(ctxKey))
+            continue;
+        seenWhats.add(ctxKey);
+        clarifyCount++;
         memories.push({
             layer: 'context',
             content: buildStructuredContent({
@@ -322,6 +334,7 @@ export function extractSession(session, projectName) {
             }),
             importance: 0.5,
             thread_id: session.session_id,
+            occurred_at: t.timestamp,
             source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'clarification' },
         });
     }
@@ -339,13 +352,16 @@ export function extractSession(session, projectName) {
         const userIntent = (first.preceding_user_text || '').slice(0, 400);
         const contentSnippet = ops.map((o) => o.tool_input_preview).slice(0, 2).join(' | ').slice(0, 500);
         const fileName = path.replace(/\\/g, '/').split('/').pop() || path;
+        // `what` must be op-specific, NOT the shared user utterance: one turn editing 5 files
+        // produces 5 of these memories, and a shared raw-utterance `what` rendered as 5 visual
+        // duplicates in every digest/recall view. The intent lives ONCE, titled, in `why`.
         const memoryContent = buildStructuredContent({
             title: `${opsKinds} ${fileName} (${ops.length} ops)`,
             altitude: 'implementation',
             type: 'work',
             state: 'done',
-            what: userIntent || `File operation: ${opsKinds} on ${path}`,
-            why: userIntent ? `User intent: ${makeTitle(userIntent, 120)}` : '(no explicit preceding intent)',
+            what: `${opsKinds} ${path} (${ops.length} ops)`,
+            why: userIntent ? makeTitle(userIntent, 160) : '(no explicit preceding intent)',
             affects: [path],
             next_action: null,
             evidence_refs: [{ type: 'session', id: session.session_id, label: 'source session' }],
@@ -358,6 +374,7 @@ export function extractSession(session, projectName) {
             content: memoryContent,
             importance: 0.6,
             thread_id: session.session_id,
+            occurred_at: first.timestamp,
             source: { session_id: session.session_id, turn_uuid: first.turn_uuid, kind: 'file_edit' },
         });
         // Create a file_edit link record for EACH physical op (NOT deduped),
@@ -378,7 +395,16 @@ export function extractSession(session, projectName) {
     }
     // 4) Caveat layer — user messages matching caveat/failure patterns
     //    Stricter filter: must NOT be pasted external content.
+    //    needs_distill: the stored `what` is a RAW utterance (best heuristic extraction can do
+    //    without an LLM in the hook path) — `dream` queues these for agent rewriting.
+    //    context_hint: tail of the assistant message the user was replying to, so the distiller
+    //    can resolve references like「a)やろう」without re-reading the transcript.
+    let prevAssistantForCaveat = '';
     for (const t of session.turns) {
+        if (t.role === 'assistant') {
+            prevAssistantForCaveat = t.text;
+            continue;
+        }
         if (t.role !== 'user' || isMetaOrNoise(t.text))
             continue;
         if (t === firstIntent)
@@ -389,6 +415,13 @@ export function extractSession(session, projectName) {
             continue;
         if (matchesAny(t.text, CAVEAT_PATTERNS) && t.text.length > 20 && !isChitchatWithBuriedDecision(t.text, CAVEAT_PATTERNS)) {
             const caveatText = t.text.slice(0, 500);
+            const key = whatKey('caveat', caveatText);
+            if (seenWhats.has(key)) {
+                if (t.uuid)
+                    capturedTurns.add(t.uuid);
+                continue;
+            }
+            seenWhats.add(key);
             memories.push({
                 layer: 'caveat',
                 content: buildStructuredContent({
@@ -397,14 +430,17 @@ export function extractSession(session, projectName) {
                     type: inferType(caveatText, 'caveat'),
                     state: inferState(caveatText, 'caveat'),
                     what: caveatText,
-                    why: 'User-stated warning/prohibition — auto-extracted by caveat pattern match',
+                    why: 'user-stated warning (auto-extracted) — pending distillation',
                     affects: extractAffectedPaths(session.file_ops),
                     next_action: null,
                     evidence_refs: [{ type: 'session', id: session.session_id, label: 'caveat source' }],
                     session_id: session.session_id,
+                    needs_distill: true,
+                    context_hint: prevAssistantForCaveat.slice(-280),
                 }),
                 importance: 0.75,
                 thread_id: session.session_id,
+                occurred_at: t.timestamp,
                 source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'caveat' },
             });
             if (t.uuid)
@@ -412,11 +448,14 @@ export function extractSession(session, projectName) {
         }
     }
     // 5) Learning layer — messages matching decision patterns
-    //    Same strict filter applies.
-    //    NOTE: Without LLM, we store the raw user text as `what` — this is the best
-    //    heuristic extraction can do. Agent-initiated `remember()` calls should use
-    //    the full structured format with agent_proposal + user_approval_scope.
+    //    Same strict filter applies. Raw `what` + needs_distill + context_hint, same contract
+    //    as the caveat pass above — `dream` surfaces these for agent distillation.
+    let prevAssistantForDecision = '';
     for (const t of session.turns) {
+        if (t.role === 'assistant') {
+            prevAssistantForDecision = t.text;
+            continue;
+        }
         if (t.role !== 'user' || isMetaOrNoise(t.text))
             continue;
         if (t === firstIntent)
@@ -427,8 +466,15 @@ export function extractSession(session, projectName) {
             continue;
         if (isPastedExternalContent(t.text))
             continue;
-        if (matchesAny(t.text, DECISION_PATTERNS) && t.text.length > 15 && !isChitchatWithBuriedDecision(t.text, DECISION_PATTERNS)) {
+        // Length floor 8 (was 15): short JP approvals ARE the decision record ("OK. CからAいこう",
+        // "Bだね。以下OK." — both real, both were lost at 15). They only carry meaning WITH the
+        // context_hint captured below, which is exactly what the distill pass resolves.
+        if (matchesAny(t.text, DECISION_PATTERNS) && t.text.length > 8 && !isChitchatWithBuriedDecision(t.text, DECISION_PATTERNS)) {
             const decisionText = t.text.slice(0, 500);
+            const key = whatKey('learning', decisionText);
+            if (seenWhats.has(key))
+                continue;
+            seenWhats.add(key);
             memories.push({
                 layer: 'learning',
                 content: buildStructuredContent({
@@ -437,14 +483,17 @@ export function extractSession(session, projectName) {
                     type: inferType(decisionText, 'learning'),
                     state: inferState(decisionText, 'learning'),
                     what: decisionText,
-                    why: 'Decision detected by pattern match — may need agent enrichment',
+                    why: 'decision keyword matched (auto-extracted) — pending distillation',
                     affects: extractAffectedPaths(session.file_ops),
                     next_action: null,
                     evidence_refs: [{ type: 'session', id: session.session_id, label: 'decision source' }],
                     session_id: session.session_id,
+                    needs_distill: true,
+                    context_hint: prevAssistantForDecision.slice(-280),
                 }),
                 importance: 0.7,
                 thread_id: session.session_id,
+                occurred_at: t.timestamp,
                 source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'decision' },
             });
         }
@@ -468,6 +517,7 @@ export function extractSession(session, projectName) {
             }),
             importance: 0.4,
             thread_id: session.session_id,
+            occurred_at: session.ended_at,
             source: { session_id: session.session_id, kind: 'error_recovery' },
         });
     }
@@ -500,6 +550,7 @@ export function extractSession(session, projectName) {
             }),
             importance: 0.4,
             thread_id: session.session_id,
+            occurred_at: session.ended_at,
             source: { session_id: session.session_id, kind: 'session_summary' },
         });
     }

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