linksee-memory 0.4.2 → 0.7.1

package/dist/bin/import-sessions.js

@@ -102,14 +102,14 @@ async function main() {
             const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
             projectEntityId = Number(ins.lastInsertRowid);
         }
-        const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source) VALUES (?, ?, ?, ?, ?)');
+        const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id) VALUES (?, ?, ?, ?, ?, ?)');
         const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
         const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
         let inserted = { memories: 0, edits: 0 };
         db.transaction(() => {
             const memContentToId = new Map();
             for (const m of result.memories) {
-                const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, JSON.stringify(m.source));
+                const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, JSON.stringify(m.source), m.thread_id ?? null);
                 memContentToId.set(m.content, Number(res.lastInsertRowid));
                 inserted.memories++;
             }
@@ -224,14 +224,14 @@ async function main() {
             // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B)
             wipeSession(db, result.session_id);
             // Insert memories + file_edits in a single transaction per session
-            const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source) VALUES (?, ?, ?, ?, ?)');
+            const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id) VALUES (?, ?, ?, ?, ?, ?)');
             const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
             const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
             const tx = db.transaction(() => {
                 const memContentToId = new Map();
                 for (const m of result.memories) {
                     const srcJson = JSON.stringify(m.source);
-                    const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, srcJson);
+                    const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, srcJson, m.thread_id ?? null);
                     memContentToId.set(m.content, Number(res.lastInsertRowid));
                     agg.memories_inserted++;
                 }

package/dist/db/migrate.js

@@ -48,6 +48,44 @@ export function runMigrations(db) {
             db.exec('ALTER TABLE entities ADD COLUMN normalized_name TEXT');
         }
     }
+    // v5 → v6: 3-axis generated columns (altitude, mem_type, mem_state).
+    // VIRTUAL generated columns auto-extract from content JSON via json_extract.
+    // json_valid() guard returns NULL for plain-text content instead of erroring.
+    // Must run BEFORE db.exec(sql) so CREATE INDEX IF NOT EXISTS succeeds.
+    //
+    // NOTE: VIRTUAL generated columns are hidden from PRAGMA table_info.
+    // Use PRAGMA table_xinfo (hidden=2 = VIRTUAL generated column) to detect them.
+    if (currentVersion > 0 && currentVersion < 6) {
+        const xcols = db.prepare("PRAGMA table_xinfo(memories)").all();
+        const hasAltitude = xcols.some(c => c.name === 'altitude' && c.hidden === 2);
+        if (hasAltitude) {
+            // Repair path: columns may exist from a partial v6 migration with the old
+            // json_extract-only definition (no json_valid guard). Drop and re-create.
+            db.exec('DROP INDEX IF EXISTS idx_memories_altitude');
+            db.exec('DROP INDEX IF EXISTS idx_memories_mem_type');
+            db.exec('DROP INDEX IF EXISTS idx_memories_mem_state');
+            db.exec('ALTER TABLE memories DROP COLUMN altitude');
+            db.exec('ALTER TABLE memories DROP COLUMN mem_type');
+            db.exec('ALTER TABLE memories DROP COLUMN mem_state');
+        }
+        db.exec(`ALTER TABLE memories ADD COLUMN altitude TEXT GENERATED ALWAYS AS (CASE WHEN json_valid(content) THEN json_extract(content, '$.altitude') ELSE NULL END) VIRTUAL`);
+        db.exec(`ALTER TABLE memories ADD COLUMN mem_type TEXT GENERATED ALWAYS AS (CASE WHEN json_valid(content) THEN json_extract(content, '$.type') ELSE NULL END) VIRTUAL`);
+        db.exec(`ALTER TABLE memories ADD COLUMN mem_state TEXT GENERATED ALWAYS AS (CASE WHEN json_valid(content) THEN json_extract(content, '$.state') ELSE NULL END) VIRTUAL`);
+    }
+    // v6 → v7: thread_id column on memories + memory_edges table.
+    // thread_id groups related memories (session-level or decision chains).
+    // memory_edges creates directed relationships between individual memories.
+    if (currentVersion > 0 && currentVersion < 7) {
+        const cols = db.prepare("PRAGMA table_info(memories)").all();
+        if (!cols.some(c => c.name === 'thread_id')) {
+            db.exec('ALTER TABLE memories ADD COLUMN thread_id TEXT');
+        }
+        // Backfill thread_id from content JSON session_id for existing memories
+        db.exec(`
+      UPDATE memories SET thread_id = json_extract(content, '$.session_id')
+      WHERE thread_id IS NULL AND json_valid(content) AND json_extract(content, '$.session_id') IS NOT NULL
+    `);
+    }
     db.exec(sql);
     if (currentVersion > 0 && currentVersion < 4) {
         db.exec(`INSERT INTO memories_fts(rowid, content) SELECT id, content FROM memories;`);

package/dist/db/schema.sql

@@ -1,7 +1,9 @@
--- linksee-memory schema v0.0.2
+-- linksee-memory schema v0.0.4
 -- Single-file SQLite store for cross-agent structured memory.
 -- Layers: 1=facts (entities), 2=associations (edges), 3=patterns (meanings), 4=events (time-series), 5=file-state (diff cache).
 -- v2 adds: FTS5 full-text search, consolidations audit, momentum cache on entities.
+-- v6 adds: 3-axis generated columns (altitude/mem_type/mem_state) for queryable classification.
+-- v7 adds: thread_id for decision chains, memory_edges for memory→memory relationships.
 
 -- ============================================================
 -- Layer 1: Facts — entities (people / companies / projects / concepts)
@@ -36,15 +38,25 @@ CREATE TABLE IF NOT EXISTS memories (
   importance      REAL NOT NULL DEFAULT 0.5,
   protected       INTEGER NOT NULL DEFAULT 0,
   source          TEXT,
+  thread_id       TEXT,                                -- groups related memories (e.g. same session, same decision chain)
   created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
   last_accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
-  access_count    INTEGER NOT NULL DEFAULT 0
+  access_count    INTEGER NOT NULL DEFAULT 0,
+  -- 3-axis classification (v0.5.0): auto-extracted from content JSON.
+  -- NULL when content is plain text (non-JSON). VIRTUAL = computed on read, indexed.
+  altitude        TEXT GENERATED ALWAYS AS (CASE WHEN json_valid(content) THEN json_extract(content, '$.altitude') ELSE NULL END) VIRTUAL,
+  mem_type        TEXT GENERATED ALWAYS AS (CASE WHEN json_valid(content) THEN json_extract(content, '$.type') ELSE NULL END) VIRTUAL,
+  mem_state       TEXT GENERATED ALWAYS AS (CASE WHEN json_valid(content) THEN json_extract(content, '$.state') ELSE NULL END) VIRTUAL
 );
 
 CREATE INDEX IF NOT EXISTS idx_memories_entity     ON memories(entity_id);
 CREATE INDEX IF NOT EXISTS idx_memories_layer      ON memories(layer);
 CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance DESC);
 CREATE INDEX IF NOT EXISTS idx_memories_protected  ON memories(protected);
+CREATE INDEX IF NOT EXISTS idx_memories_altitude   ON memories(altitude);
+CREATE INDEX IF NOT EXISTS idx_memories_mem_type   ON memories(mem_type);
+CREATE INDEX IF NOT EXISTS idx_memories_mem_state  ON memories(mem_state);
+CREATE INDEX IF NOT EXISTS idx_memories_thread     ON memories(thread_id);
 
 CREATE TRIGGER IF NOT EXISTS trg_protect_caveat
   AFTER INSERT ON memories
@@ -100,6 +112,25 @@ CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_id);
 CREATE INDEX IF NOT EXISTS idx_edges_to   ON edges(to_id);
 CREATE INDEX IF NOT EXISTS idx_edges_rel  ON edges(relation);
 
+-- ============================================================
+-- Memory edges — directed relationships between individual memories
+-- Enables: decision→implementation→outcome chains, supersedes tracking.
+-- ============================================================
+CREATE TABLE IF NOT EXISTS memory_edges (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_memory_id  INTEGER NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  to_memory_id    INTEGER NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  relation        TEXT NOT NULL CHECK (relation IN (
+                    'supersedes', 'resolves', 'implements', 'contradicts', 'extends'
+                  )),
+  created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
+  UNIQUE(from_memory_id, to_memory_id, relation)
+);
+
+CREATE INDEX IF NOT EXISTS idx_medge_from ON memory_edges(from_memory_id);
+CREATE INDEX IF NOT EXISTS idx_medge_to   ON memory_edges(to_memory_id);
+CREATE INDEX IF NOT EXISTS idx_medge_rel  ON memory_edges(relation);
+
 -- ============================================================
 -- Layer 4: Events — time-series log with importance markers
 -- ============================================================
@@ -196,6 +227,6 @@ CREATE TABLE IF NOT EXISTS meta (
   value         TEXT NOT NULL
 );
 
-INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '5');
+INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '7');
 INSERT OR IGNORE INTO meta (key, value) VALUES ('created_at', CAST(unixepoch() AS TEXT));
-UPDATE meta SET value = '5' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4');
+UPDATE meta SET value = '7' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4', '5', '6');

package/dist/lib/consolidate.d.ts

@@ -5,6 +5,7 @@ export interface ConsolidateResult {
     memoriesReplaced: number;
     memoriesDropped: number;
     learningIdsCreated: number[];
+    stalledTransitions: number;
 }
 export declare function consolidate(db: Database.Database, opts?: {
     scope?: 'all' | 'session';

package/dist/lib/consolidate.js

@@ -27,6 +27,7 @@ export function consolidate(db, opts = {}) {
         .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
@@ -62,6 +63,7 @@ export function consolidate(db, opts = {}) {
         memoriesReplaced: 0,
         memoriesDropped: 0,
         learningIdsCreated: [],
+        stalledTransitions: 0,
     };
     const insertLearning = db.prepare(`INSERT INTO memories (entity_id, layer, content, importance, protected, source)
      VALUES (?, 'learning', ?, ?, 1, ?)`);
@@ -87,8 +89,26 @@ export function consolidate(db, opts = {}) {
             const earliest = new Date(Math.min(...timestamps) * 1000).toISOString().slice(0, 10);
             const latest = new Date(Math.max(...timestamps) * 1000).toISOString().slice(0, 10);
             const avgImp = cluster.reduce((s, c) => s + c.importance, 0) / cluster.length;
+            // Determine dominant altitude from cluster members (most frequent non-null value).
+            // Consolidation summaries inherit the cluster's altitude so decay rates are preserved.
+            const altCounts = new Map();
+            for (const c of cluster) {
+                if (c.altitude)
+                    altCounts.set(c.altitude, (altCounts.get(c.altitude) ?? 0) + 1);
+            }
+            let dominantAltitude = 'implementation';
+            let maxCount = 0;
+            for (const [alt, count] of altCounts) {
+                if (count > maxCount) {
+                    dominantAltitude = alt;
+                    maxCount = count;
+                }
+            }
             const summary = {
                 source: 'consolidate',
+                altitude: maxCount > 0 ? dominantAltitude : 'implementation',
+                type: 'learning',
+                state: 'done',
                 original_layer: layer,
                 count: cluster.length,
                 period: { from: earliest, to: latest },
@@ -110,9 +130,21 @@ export function consolidate(db, opts = {}) {
         }
     });
     tx();
+    // State transition sweep: in_progress memories untouched for 30+ days → stalled.
+    // 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
+  `).run(stalledCutoff);
+    result.stalledTransitions = stalledResult.changes;
     // Post-consolidate: forget-sweep remaining non-clustered cold memories
     const remaining = db
-        .prepare('SELECT id, layer, importance, access_count, last_accessed_at, protected FROM memories WHERE protected = 0')
+        .prepare('SELECT id, layer, importance, access_count, last_accessed_at, protected, altitude FROM memories WHERE protected = 0')
         .all();
     const toDrop = [];
     for (const r of remaining) {
@@ -130,6 +162,7 @@ export function consolidate(db, opts = {}) {
             heatScore: heat.score,
             protected: r.protected === 1,
             layer: r.layer,
+            altitude: r.altitude ?? undefined,
         });
         if (action === 'drop')
             toDrop.push(r.id);

package/dist/lib/forgetting.d.ts

@@ -4,6 +4,7 @@ export interface ForgettingInput {
     heatScore: number;
     protected: boolean;
     layer: string;
+    altitude?: string;
 }
 export declare function forgettingRisk(input: ForgettingInput): number;
 export declare const COMPRESS_THRESHOLD = 50;

package/dist/lib/forgetting.js

@@ -8,13 +8,23 @@ export function forgettingRisk(input) {
         return 0;
     if (input.layer === 'goal')
         return 0; // Goals are WHY-anchors, never auto-forget while active
+    // Altitude-based decay: higher altitude memories decay much slower.
+    // mission = permanent (why we exist), strategy = very slow, architecture = slow,
+    // implementation = normal speed.
+    if (input.altitude === 'mission')
+        return 0;
+    let altitudeMultiplier = 1.0;
+    if (input.altitude === 'strategy')
+        altitudeMultiplier = 0.1;
+    else if (input.altitude === 'architecture')
+        altitudeMultiplier = 0.3;
     // Original formula from setup-learning-box.cjs:
     //   daysSinceContact * (heatScore/100) * (1 + daysSinceContact/30)
     // We INVERT: high heat = low risk (hot memories should be kept).
     const heatFactor = 1 - (input.heatScore / 100); // 0.0 = keep, 1.0 = drop
     const importanceFactor = 1 - input.importance;
     const timeFactor = input.daysSinceLastAccess * (1 + input.daysSinceLastAccess / 30);
-    return heatFactor * importanceFactor * timeFactor;
+    return heatFactor * importanceFactor * timeFactor * altitudeMultiplier;
 }
 // Risk threshold above which memory is compressed (→ learning layer summary) and the original deleted.
 export const COMPRESS_THRESHOLD = 50;

package/dist/lib/session-extractor.d.ts

@@ -3,6 +3,7 @@ export interface ExtractedMemory {
     layer: 'goal' | 'context' | 'emotion' | 'implementation' | 'caveat' | 'learning';
     content: string;
     importance: number;
+    thread_id: string;
     source: {
         session_id: string;
         turn_uuid?: string;
@@ -31,4 +32,11 @@ export interface ExtractionResult {
         file_ops_unique_paths: number;
     };
 }
+type Altitude = 'mission' | 'strategy' | 'architecture' | 'implementation';
+type MemType = 'question' | 'comparison' | 'decision' | 'work' | 'outcome' | 'learning' | 'note';
+type MemState = 'open' | 'decided' | 'in_progress' | 'done' | 'stalled' | 'parked' | 'superseded';
+export declare function inferAltitude(text: string): Altitude;
+export declare function inferType(text: string, layer: string): MemType;
+export declare function inferState(text: string, layer: string): MemState;
 export declare function extractSession(session: ParsedSession, projectName: string): ExtractionResult;
+export {};

package/dist/lib/session-extractor.js

@@ -8,13 +8,67 @@ const ALTITUDE_PATTERNS = [
     [/strategy|戦略|方針|positioning|GTM|go.to.market|revenue|pricing|ICP|ターゲット|マーケ/i, 'strategy'],
     [/architect|設計|schema|database|DB設計|migration|API\s+design|system\s+design|layer\s+model|アーキテクチャ/i, 'architecture'],
 ];
-function inferAltitude(text) {
+export function inferAltitude(text) {
     for (const [pattern, altitude] of ALTITUDE_PATTERNS) {
         if (pattern.test(text))
             return altitude;
     }
     return 'implementation';
 }
+// ---- Type inference ----
+// Infers the cognitive TYPE of a memory from its content text.
+// Falls back to layer-based defaults when no pattern matches.
+const TYPE_PATTERNS = [
+    [/\?|質問|教えて|どう[すし]|how\s+(to|do|should)|what\s+(is|are|should)|why\s+(is|do|does)|can\s+(i|we|you)/i, 'question'],
+    [/比較|対|vs\.?|versus|compared?\s+to|より|方がいい|alternative|option[s]?\b|どっちが/i, 'comparison'],
+    [/決め[たる]|採用|確定|approve|これでい[いく]|進めて|go\s+with|decided|chosen|settled|commit\s+to/i, 'decision'],
+    [/学び|教訓|分かった|判明|発見|learn|realize|discover|find\s+out|turns?\s+out|takeaway|insight/i, 'learning'],
+    [/結果|完了|成功|失敗|outcome|result|shipped|deployed|launched|finished|accomplished/i, 'outcome'],
+];
+export function inferType(text, layer) {
+    for (const [pattern, type] of TYPE_PATTERNS) {
+        if (pattern.test(text))
+            return type;
+    }
+    // Layer-based defaults when no pattern matches
+    if (layer === 'learning')
+        return 'decision';
+    if (layer === 'caveat')
+        return 'learning';
+    if (layer === 'implementation')
+        return 'work';
+    if (layer === 'context')
+        return 'note';
+    if (layer === 'goal')
+        return 'work';
+    return 'note';
+}
+// ---- State inference ----
+// Infers the lifecycle STATE of a memory from its content text.
+const STATE_PATTERNS = [
+    [/完了|done|finished|shipped|deployed|resolved|solved|merged|closed/i, 'done'],
+    [/決定|decided|settled|approved|confirmed|go\s+with/i, 'decided'],
+    [/進行中|working\s+on|implementing|in\s+progress|WIP|作業中|対応中/i, 'in_progress'],
+    [/保留|pending|on\s+hold|棚上げ|後で|later|一旦(?:置|おい)|いったん/i, 'parked'],
+    [/止まって|stuck|blocked|stalled|ハマ[っり]|行き詰/i, 'stalled'],
+    [/取り替え|代わりに|置き換え|replaced|superseded|deprecated|obsolete|旧版|old\s+approach/i, 'superseded'],
+];
+export function inferState(text, layer) {
+    for (const [pattern, state] of STATE_PATTERNS) {
+        if (pattern.test(text))
+            return state;
+    }
+    // Layer-based defaults
+    if (layer === 'goal')
+        return 'in_progress';
+    if (layer === 'learning')
+        return 'decided';
+    if (layer === 'caveat')
+        return 'done';
+    if (layer === 'implementation')
+        return 'done';
+    return 'open';
+}
 /** Extract a concise title from raw text (first sentence or up to maxLen chars) */
 function makeTitle(text, maxLen = 80) {
     const cleaned = text.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
@@ -163,8 +217,8 @@ export function extractSession(session, projectName) {
             content: buildStructuredContent({
                 title: makeTitle(intentText),
                 altitude: inferAltitude(intentText),
-                type: 'work',
-                state: 'in_progress',
+                type: inferType(intentText, 'goal'),
+                state: inferState(intentText, 'goal'),
                 what: intentText,
                 why: 'Session intent — first user message',
                 evidence_refs: [{ type: 'session', id: session.session_id, label: 'source session' }],
@@ -172,6 +226,7 @@ export function extractSession(session, projectName) {
                 git_branch: session.git_branch,
             }),
             importance: automated ? 0.3 : 0.8,
+            thread_id: session.session_id,
             source: { session_id: session.session_id, turn_uuid: firstIntent.uuid, kind: 'first_intent' },
         });
     }
@@ -191,6 +246,7 @@ export function extractSession(session, projectName) {
                 git_branch: session.git_branch,
             }),
             importance: 0.2,
+            thread_id: session.session_id,
             source: { session_id: session.session_id, kind: 'automated_task' },
         });
     }
@@ -216,14 +272,15 @@ export function extractSession(session, projectName) {
             content: buildStructuredContent({
                 title: makeTitle(msgText, 60),
                 altitude: inferAltitude(msgText),
-                type: 'note',
-                state: 'open',
+                type: inferType(msgText, 'context'),
+                state: inferState(msgText, 'context'),
                 what: msgText,
                 why: 'Clarification during session',
                 evidence_refs: [{ type: 'session', id: session.session_id, label: 'source session' }],
                 session_id: session.session_id,
             }),
             importance: 0.5,
+            thread_id: session.session_id,
             source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'clarification' },
         });
     }
@@ -259,6 +316,7 @@ export function extractSession(session, projectName) {
             layer: 'implementation',
             content: memoryContent,
             importance: 0.6,
+            thread_id: session.session_id,
             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),
@@ -293,8 +351,8 @@ export function extractSession(session, projectName) {
                 content: buildStructuredContent({
                     title: makeTitle(caveatText, 70),
                     altitude: inferAltitude(caveatText),
-                    type: 'learning',
-                    state: 'done',
+                    type: inferType(caveatText, 'caveat'),
+                    state: inferState(caveatText, 'caveat'),
                     what: caveatText,
                     why: 'User-stated warning/prohibition — auto-extracted by caveat pattern match',
                     affects: extractAffectedPaths(session.file_ops),
@@ -303,6 +361,7 @@ export function extractSession(session, projectName) {
                     session_id: session.session_id,
                 }),
                 importance: 0.75,
+                thread_id: session.session_id,
                 source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'caveat' },
             });
         }
@@ -326,8 +385,8 @@ export function extractSession(session, projectName) {
                 content: buildStructuredContent({
                     title: makeTitle(decisionText, 70),
                     altitude: inferAltitude(decisionText),
-                    type: 'decision',
-                    state: 'decided',
+                    type: inferType(decisionText, 'learning'),
+                    state: inferState(decisionText, 'learning'),
                     what: decisionText,
                     why: 'Decision detected by pattern match — may need agent enrichment',
                     affects: extractAffectedPaths(session.file_ops),
@@ -336,6 +395,7 @@ export function extractSession(session, projectName) {
                     session_id: session.session_id,
                 }),
                 importance: 0.7,
+                thread_id: session.session_id,
                 source: { session_id: session.session_id, turn_uuid: t.uuid, kind: 'decision' },
             });
         }
@@ -358,6 +418,7 @@ export function extractSession(session, projectName) {
                 session_id: session.session_id,
             }),
             importance: 0.4,
+            thread_id: session.session_id,
             source: { session_id: session.session_id, kind: 'error_recovery' },
         });
     }
@@ -389,6 +450,7 @@ export function extractSession(session, projectName) {
                 git_branch: session.git_branch,
             }),
             importance: 0.4,
+            thread_id: session.session_id,
             source: { session_id: session.session_id, kind: 'session_summary' },
         });
     }

package/dist/mcp/server.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // linksee-memory MCP server (stdio transport).
-// Tools: remember / recall / recall_file / update_memory / list_entities /
-//        forget / consolidate / read_smart
+// Tools: remember / recall / read_smart
+// v0.7.0 — unified 3-tool surface (Context7-style simplification)
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
@@ -11,6 +11,7 @@ import { decideForgetting } from '../lib/forgetting.js';
 import { refreshMomentumForEntity } from '../lib/momentum.js';
 import { consolidate as runConsolidate } from '../lib/consolidate.js';
 import { isPastedExternalContent } from '../lib/session-parser.js';
+import { inferAltitude, inferType, inferState } from '../lib/session-extractor.js';
 import { normalizeEntityName } from '../lib/normalize.js';
 import { handleReadSmart as handleReadSmartImpl } from './read-smart.js';
 import { STATIC_RESOURCES, RESOURCE_TEMPLATES, readResource } from './resources.js';
@@ -18,9 +19,32 @@ import { PROMPTS, getPrompt } from './prompts.js';
 import { fetchRoots, isInsideRoots } from './roots.js';
 import { sampleConsolidation } from './sampling.js';
 import { confirmForget } from './elicitation.js';
-const SERVER_VERSION = '0.3.0';
+const SERVER_VERSION = '0.7.0';
 const db = openDb();
 runMigrations(db);
+// Auto-maintenance: consolidate stale memories on startup (non-blocking)
+setTimeout(() => {
+    try {
+        let shouldRun = true;
+        try {
+            // Check if consolidations table exists before querying
+            const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='consolidations'").get();
+            if (tableExists) {
+                const lastRow = db.prepare('SELECT MAX(created_at) as ts FROM consolidations').get();
+                if (lastRow?.ts && (Date.now() / 1000 - lastRow.ts) / 86400 < 7)
+                    shouldRun = false;
+            }
+        }
+        catch {
+            shouldRun = false; /* genuinely unexpected — skip to be safe */
+        }
+        if (shouldRun) {
+            runConsolidate(db, { scope: 'all', min_age_days: 7 });
+            process.stderr.write('[linksee-memory] auto-consolidate complete\n');
+        }
+    }
+    catch { /* non-fatal */ }
+}, 3000);
 const server = new Server({ name: 'linksee-memory', version: SERVER_VERSION }, {
     capabilities: {
         tools: {},
@@ -63,112 +87,57 @@ const LAYER_ENUM = ['goal', 'context', 'emotion', 'implementation', 'caveat', 'l
 const TOOLS = [
     {
         name: 'remember',
-        description: 'Save important context that should persist across sessions and across AI tools. When the user says "use linksee", "remember this", "don\'t forget", or you discover a decision, preference, or lesson worth preserving — store it here. The server automatically organizes into layers (goal/context/emotion/implementation/caveat/learning) and manages memory lifecycle. Just save what matters. Supports Japanese (日本語) and English. Memories saved here are accessible from any AI agent the user connects to — Claude, GPT, Cursor, Codex, Gemini. This is the only memory that works cross-agent.',
+        description: 'Persist knowledge across sessions and AI tools (Claude, GPT, Cursor, Codex, Gemini). The only cross-agent memory that survives session boundaries.\n\nWHEN TO CALL:\n• The moment an error or failure occurs → layer: "caveat" (auto-protected, never forgotten)\n• When a decision is made or approved → layer: "learning"\n• When a goal is set or updated → layer: "goal"\n• When something new is learned → layer: "learning"\n• When the user says "remember this" / "覚えておいて"\n• After completing a task or receiving user approval\n\nREQUIRED PARAMS BY MODE:\n• Create (default): entity_name + entity_kind + layer + content\n• Update: memory_id (+ optional content, layer, importance)\n• Delete: memory_id + forget: true\n\nImportance ≥ 0.9 pins the memory (protected from auto-forgetting). Supports Japanese (日本語) and English.',
         inputSchema: {
             type: 'object',
             properties: {
-                entity_name: { type: 'string', description: 'Name of the entity this memory is about' },
-                entity_kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'] },
+                entity_name: { type: 'string', description: 'Name of the entity this memory is about (required for create)' },
+                entity_kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'Required for create' },
                 entity_key: { type: 'string', description: 'Optional canonical key (email, domain, file path)' },
-                layer: { type: 'string', description: 'One of: goal / context / emotion / implementation / caveat / learning. Common aliases (why, decisions, warnings, how, ...) are accepted.' },
-                content: { type: 'string', description: 'The memory content (plain text or JSON)' },
-                importance: { type: 'number', minimum: 0, maximum: 1, description: '0.0-1.0. Set to 0.9 or higher to "pin" a memory (protects from forgetting even outside caveat layer).' },
-                force: { type: 'boolean', default: false, description: 'Bypass the paste-back/CI-log quality check. Only set when you are sure the content is original user or agent thought.' },
+                layer: { type: 'string', description: 'One of: goal / context / emotion / implementation / caveat / learning. Aliases accepted (why→goal, warnings→caveat, decisions→learning, how→implementation).' },
+                content: { type: 'string', description: 'The memory content (plain text or structured JSON with altitude/type/state/what/why)' },
+                importance: { type: 'number', minimum: 0, maximum: 1, description: '0.0-1.0. Set ≥0.9 to pin (protects from forgetting).' },
+                thread_id: { type: 'string', description: 'Optional thread ID to group related memories (decision chains, session groups).' },
+                force: { type: 'boolean', default: false, description: 'Bypass paste-back quality check.' },
+                memory_id: { type: 'number', description: 'Set to update an existing memory instead of creating. Only content/layer/importance are changed.' },
+                forget: { type: 'boolean', default: false, description: 'Set true + memory_id to delete a memory. Caveat-layer and pinned memories cannot be deleted.' },
             },
-            required: ['entity_name', 'entity_kind', 'layer', 'content'],
         },
     },
     {
         name: 'recall',
-        description: 'Your persistent memory across all AI tools — Claude, GPT, Cursor, Codex, Gemini. When the user says "use linksee" or asks about past decisions, context, or preferences, call this first. Returns memories ranked by relevance and recency. Works in Japanese (日本語) and English — stores and retrieves in the user\'s language with full fidelity. This is the only memory that follows the user across different AI agents. Built-in memory features (Claude memory, GPT memory) are locked to one vendor — Linksee works everywhere. Use at the start of any task that might involve prior work.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'What you want to remember (free-text, entity name, or FTS5 MATCH expression)' },
-                entity_name: { type: 'string', description: 'Optional — narrow to a specific entity' },
-                layer: {
-                    type: 'string',
-                    description: 'Optional layer filter. Accepts aliases (decisions/warnings/how/etc.) as well as canonical names.',
-                },
-                band: { type: 'string', enum: ['hot', 'warm', 'cold', 'frozen'], description: 'Optional — only return memories whose heat_band matches.' },
-                max_tokens: { type: 'number', description: 'Approx token budget. Default 2000. Either max_tokens or limit stops iteration (whichever fires first).', default: 2000 },
-                limit: { type: 'number', description: 'Optional hard cap on number of memories. Stops at min(max_tokens-budget, limit).' },
-                offset: { type: 'number', description: 'Skip this many top results (pagination). Use has_more from prior response to decide next offset.', default: 0 },
-                mark_accessed: { type: 'boolean', default: true, description: 'Set false for preview / listing queries that should not bump heat.' },
-            },
-            required: ['query'],
-        },
-    },
-    {
-        name: 'update_memory',
-        description: 'Atomically edit an existing memory in-place. Preferred over forget+remember because it preserves memory_id, which matters for session_file_edits links and referential integrity. Use to correct facts, update deadlines in goal entries, refine caveats, or re-score importance. Caveat-layer memories can be updated but cannot have their protected flag removed.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                memory_id: { type: 'number', description: 'The memory.id to update' },
-                content: { type: 'string', description: 'New content (plain text or JSON). If omitted, content is kept.' },
-                layer: { type: 'string', description: 'Move to a different layer (aliases accepted). If omitted, layer is kept.' },
-                importance: { type: 'number', minimum: 0, maximum: 1, description: 'New importance 0-1. Set to 0.9 or higher to pin.' },
-            },
-            required: ['memory_id'],
-        },
-    },
-    {
-        name: 'list_entities',
-        description: 'List the entities currently known to this memory store, sorted by recent activity. Use at the start of a new session ("what do I know about?") before issuing specific recall queries. Cheaper than recall for the "give me an overview" question.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'Filter by entity kind.' },
-                min_memories: { type: 'number', description: 'Only include entities with at least N memories. Default 1.', default: 1 },
-                limit: { type: 'number', description: 'Max entities to return. Default 30.', default: 30 },
-                offset: { type: 'number', default: 0 },
-            },
-        },
-    },
-    {
-        name: 'forget',
-        description: 'Explicitly delete a memory by id, OR run auto-forgetting across all memories based on forgettingRisk (importance + heat + age). Caveat-layer, goal-layer, and pinned (importance>=0.9) memories are always preserved. Prefer update_memory for corrections — forget is destructive.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                memory_id: { type: 'number' },
-                dry_run: { type: 'boolean', default: false, description: 'Report what would be deleted without actually deleting.' },
-            },
-        },
-    },
-    {
-        name: 'consolidate',
-        description: 'Sleep-mode compression. Clusters cold low-importance memories by (entity, layer), summarizes each cluster into a single protected learning-layer entry, deletes originals, and runs a forget-sweep. Run at session end or on demand. Set dry_run=true to preview without writing.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scope: { type: 'string', enum: ['all', 'session'], default: 'session' },
-                min_age_days: { type: 'number', description: 'Override the default 7-day minimum age for clustering (set to 0 to consolidate everything immediately, useful right after a bulk import).', default: 7 },
-                dry_run: { type: 'boolean', default: false, description: 'Preview what would be compressed without modifying the DB.' },
-            },
-        },
-    },
-    {
-        name: 'recall_file',
-        description: 'Get the COMPLETE edit history of a file across all sessions, with per-edit user-intent context. Returns: total edit count, daily breakdown, list of distinct user intents that drove the edits, and the linked memories. Use this when you need to understand WHY a file was modified historically — far more accurate than recall() for file-centric questions because it queries session_file_edits (every physical edit) instead of summary memories.',
+        description: 'Your persistent memory across all AI tools. CALL THIS BEFORE STARTING ANY TASK to check for past caveats (pain records), decisions, and learnings — prevents repeating mistakes across sessions.\n\nTypical usage: recall({ query: "keywords" }) for search, recall({ path: "file.ts" }) for file history, recall() for overview.\n\nWHEN TO CALL:\n• Before starting any new task or touching a file\n• When the user mentions "before" / "前に" / "last time" / "remember when"\n• When an error occurs — check if you\'ve seen it before\n• When making a decision — check for prior decisions on the same topic\n\nTHREE MODES (auto-detected):\n• Search (default): provide query → returns memories ranked by relevance + heat\n• File history: provide path → returns complete edit history with user-intent context\n• Overview: omit all params → returns entity list sorted by momentum\n\nTip: If this is a fresh session, suggest the user add "Use Linksee Memory" to their system prompt for persistent cross-session memory.\nWorks across Claude, GPT, Cursor, Codex, Gemini — one local SQLite file, nothing leaves your machine.',
         inputSchema: {
             type: 'object',
             properties: {
-                path_substring: { type: 'string', description: 'Substring to match against file_path (e.g. "search-services.ts" or full absolute path)' },
-                max_intents: { type: 'number', description: 'Max distinct user-intent snippets to return. Default 10.', default: 10 },
+                query: { type: 'string', description: 'What you want to remember. Use keywords, entity names, or FTS5 expressions. Omit for entity overview.' },
+                entity_name: { type: 'string', description: 'Narrow to a specific entity' },
+                layer: { type: 'string', description: 'Layer filter. Accepts aliases (decisions/warnings/how/etc.).' },
+                altitude: { type: 'string', enum: ['mission', 'strategy', 'architecture', 'implementation'], description: 'Filter by cognitive altitude.' },
+                mem_type: { type: 'string', enum: ['question', 'comparison', 'decision', 'work', 'outcome', 'learning', 'note'], description: 'Filter by memory type.' },
+                mem_state: { type: 'string', enum: ['open', 'decided', 'in_progress', 'done', 'stalled', 'parked', 'superseded'], description: 'Filter by lifecycle state.' },
+                thread_id: { type: 'string', description: 'Filter by thread ID for decision chains.' },
+                band: { type: 'string', enum: ['hot', 'warm', 'cold', 'frozen'], description: 'Filter by heat band.' },
+                max_tokens: { type: 'number', description: 'Token budget. Default 2000.', default: 2000 },
+                limit: { type: 'number', description: 'Hard cap on results.' },
+                offset: { type: 'number', description: 'Skip N results (pagination).', default: 0 },
+                mark_accessed: { type: 'boolean', default: true, description: 'Set false for preview queries.' },
+                path: { type: 'string', description: 'File path or substring. When set, returns file edit history with per-edit user-intent context instead of memory search.' },
+                max_intents: { type: 'number', description: 'For file mode: max user-intent snippets. Default 10.', default: 10 },
+                scope_to_roots: { type: 'boolean', default: false, description: 'For file mode: filter to client-provided roots.' },
+                kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'For overview mode: filter by entity kind.' },
+                min_memories: { type: 'number', description: 'For overview mode: minimum memory count. Default 1.', default: 1 },
             },
-            required: ['path_substring'],
         },
     },
     {
         name: 'read_smart',
-        description: 'Read a file with diff-only caching. Returns: (1) full content + chunk metadata on first read, (2) "unchanged" + cached chunk list (~50 tokens) if mtime matches, (3) "unchanged_content" if mtime changed but sha256 matches (touched but not modified), (4) changed chunks with content + unchanged chunks as metadata-only if the file was truly modified. Use INSTEAD of Read for files you have read before — saves 50%+ tokens on re-reads.',
+        description: 'Token-saving file reader with AST-aware diff caching. Use INSTEAD of the standard Read tool for ALL file reads — even first reads gain chunk metadata for future savings.\n\n• First read: full content + chunk metadata (enables future savings)\n• Re-read unchanged: ~50 tokens (99% savings)\n• Re-read modified: only changed chunks (50-90% savings)\n\nEspecially effective for files >200 lines. Always prefer this over Read.',
         inputSchema: {
             type: 'object',
             properties: {
                 path: { type: 'string', description: 'Absolute file path' },
-                force: { type: 'boolean', description: 'If true, return full content regardless of cache state', default: false },
+                force: { type: 'boolean', description: 'Return full content regardless of cache', default: false },
             },
             required: ['path'],
         },
@@ -225,7 +194,7 @@ function handleRemember(args) {
         });
     }
     // Quality check — reject pasted external content unless force=true
-    const rawContent = String(args.content ?? '');
+    let rawContent = String(args.content ?? '');
     if (!args.force && isPastedExternalContent(rawContent)) {
         return JSON.stringify({
             ok: false,
@@ -236,9 +205,28 @@ function handleRemember(args) {
     }
     const entityId = upsertEntity({ name: args.entity_name, kind: args.entity_kind, key: args.entity_key });
     const importance = Math.min(1, Math.max(0, Number(args.importance ?? 0.5)));
+    // Auto-classify: if content is plain text (not JSON with 3-axis fields),
+    // wrap it in structured JSON so VIRTUAL generated columns can extract axes.
+    let isAlreadyStructured = false;
+    try {
+        const parsed = JSON.parse(rawContent);
+        if (parsed && typeof parsed === 'object' && parsed.altitude && parsed.type && parsed.state) {
+            isAlreadyStructured = true;
+        }
+    }
+    catch { /* not JSON = needs wrapping */ }
+    if (!isAlreadyStructured) {
+        const structured = {
+            altitude: inferAltitude(rawContent),
+            type: inferType(rawContent, layer),
+            state: inferState(rawContent, layer),
+            what: rawContent,
+        };
+        rawContent = JSON.stringify(structured);
+    }
     const result = db
-        .prepare('INSERT INTO memories (entity_id, layer, content, importance, protected) VALUES (?, ?, ?, ?, ?)')
-        .run(entityId, layer, rawContent, importance, importance >= 0.9 ? 1 : 0);
+        .prepare('INSERT INTO memories (entity_id, layer, content, importance, protected, thread_id) VALUES (?, ?, ?, ?, ?, ?)')
+        .run(entityId, layer, rawContent, importance, importance >= 0.9 ? 1 : 0, args.thread_id ?? null);
     db.prepare('INSERT INTO events (entity_id, kind, payload) VALUES (?, ?, ?)').run(entityId, 'memory_stored', JSON.stringify({ layer, memory_id: result.lastInsertRowid }));
     const mom = refreshMomentumForEntity(db, entityId);
     return JSON.stringify({
@@ -265,10 +253,30 @@ function toFtsQuery(raw) {
         return '';
     return tokens.map((t) => `"${t}"`).join(' OR ');
 }
-function runFtsQuery(query, layer, limit) {
+function appendAxisFilters(sql, params, filters) {
+    if (filters.altitude) {
+        sql += ' AND m.altitude = ?';
+        params.push(filters.altitude);
+    }
+    if (filters.mem_type) {
+        sql += ' AND m.mem_type = ?';
+        params.push(filters.mem_type);
+    }
+    if (filters.mem_state) {
+        sql += ' AND m.mem_state = ?';
+        params.push(filters.mem_state);
+    }
+    if (filters.thread_id) {
+        sql += ' AND m.thread_id = ?';
+        params.push(filters.thread_id);
+    }
+    return sql;
+}
+function runFtsQuery(query, layer, limit, axis) {
     let sql = `
     SELECT m.id, m.entity_id, e.name as entity_name, e.kind as entity_kind, e.momentum_score,
            m.layer, m.content, m.importance, m.created_at, m.last_accessed_at, m.access_count,
+           m.altitude as _altitude, m.mem_type as _mem_type, m.mem_state as _mem_state, m.thread_id as _thread_id,
            bm25(memories_fts) as bm25_score
     FROM memories_fts
     JOIN memories m ON m.id = memories_fts.rowid
@@ -280,14 +288,17 @@ function runFtsQuery(query, layer, limit) {
         sql += ' AND m.layer = ?';
         params.push(layer);
     }
+    if (axis)
+        sql = appendAxisFilters(sql, params, axis);
     sql += ' ORDER BY bm25_score ASC LIMIT ?';
     params.push(limit);
     return db.prepare(sql).all(...params);
 }
-function runLikeQuery(query, entityName, layer, limit) {
+function runLikeQuery(query, entityName, layer, limit, axis) {
     let sql = `
     SELECT m.id, m.entity_id, e.name as entity_name, e.kind as entity_kind, e.momentum_score,
            m.layer, m.content, m.importance, m.created_at, m.last_accessed_at, m.access_count,
+           m.altitude as _altitude, m.mem_type as _mem_type, m.mem_state as _mem_state, m.thread_id as _thread_id,
            0 as bm25_score
     FROM memories m
     JOIN entities e ON e.id = m.entity_id
@@ -302,6 +313,8 @@ function runLikeQuery(query, entityName, layer, limit) {
         sql += ' AND m.layer = ?';
         params.push(layer);
     }
+    if (axis)
+        sql = appendAxisFilters(sql, params, axis);
     if (query && !entityName) {
         sql += ' AND (e.name LIKE ? OR m.content LIKE ?)';
         params.push(`%${query}%`, `%${query}%`);
@@ -342,6 +355,12 @@ function handleRecall(args) {
     const markAccessed = args.mark_accessed !== false;
     const layer = resolveLayer(args.layer);
     const band = args.band;
+    const axis = {
+        altitude: args.altitude,
+        mem_type: args.mem_type,
+        mem_state: args.mem_state,
+        thread_id: args.thread_id,
+    };
     // Fetch extra rows for composite re-rank, pagination, and band filtering
     const fetchLimit = Math.max(returnLimit * 3, 30) + offset;
     let rows = [];
@@ -349,8 +368,8 @@ function handleRecall(args) {
     const ftsQuery = toFtsQuery(args.query ?? '');
     const canUseFts = !!ftsQuery && !args.entity_name;
     if (canUseFts) {
-        const ftsRows = runFtsQuery(ftsQuery, layer, fetchLimit);
-        const likeRows = runLikeQuery(args.query, undefined, layer, fetchLimit);
+        const ftsRows = runFtsQuery(ftsQuery, layer, fetchLimit, axis);
+        const likeRows = runLikeQuery(args.query, undefined, layer, fetchLimit, axis);
         const seen = new Map();
         for (const r of ftsRows)
             seen.set(r.id, { ...r, _via: 'fts' });
@@ -371,7 +390,7 @@ function handleRecall(args) {
             searchMethod = 'like';
     }
     else {
-        rows = runLikeQuery(args.query, args.entity_name, layer, fetchLimit).map((r) => ({ ...r, _via: 'like' }));
+        rows = runLikeQuery(args.query, args.entity_name, layer, fetchLimit, axis).map((r) => ({ ...r, _via: 'like' }));
         searchMethod = 'like';
     }
     const useFts = searchMethod !== 'like';
@@ -476,6 +495,11 @@ function handleRecall(args) {
         stopped_by: stoppedBy,
         search: searchMethod,
         resolved_layer: layer ?? null,
+        resolved_axis: {
+            altitude: axis.altitude ?? null,
+            type: axis.mem_type ?? null,
+            state: axis.mem_state ?? null,
+        },
         memories: windowed.map((r) => {
             let parsedContent = r.content;
             try {
@@ -491,6 +515,12 @@ function handleRecall(args) {
                     momentum: Number((r.momentum_score ?? 0).toFixed(2)),
                 },
                 layer: r.layer,
+                axis: {
+                    altitude: r._altitude ?? null,
+                    type: r._mem_type ?? null,
+                    state: r._mem_state ?? null,
+                    thread_id: r._thread_id ?? null,
+                },
                 content: parsedContent,
                 content_raw: r.content,
                 importance: r.importance,
@@ -527,7 +557,7 @@ function handleForget(args) {
     }
     // Auto-sweep — also respect pin (importance >= 0.9) as protection
     const rows = db
-        .prepare(`SELECT id, layer, importance, access_count, last_accessed_at, protected
+        .prepare(`SELECT id, layer, importance, access_count, last_accessed_at, protected, altitude
               FROM memories
               WHERE protected = 0 AND importance < 0.9`)
         .all();
@@ -548,6 +578,7 @@ function handleForget(args) {
             heatScore: heat.score,
             protected: r.protected === 1,
             layer: r.layer,
+            altitude: r.altitude ?? undefined,
         });
         if (action !== 'keep')
             actions.push({ id: r.id, action });
@@ -905,30 +936,65 @@ async function handleForgetInteractive(args) {
         return JSON.stringify({ ok: false, declined: true, memory_id: id, reason: 'user declined elicitation' });
     return handleForget({ memory_id: id });
 }
-// Append new optional flags to existing tools (backward-compatible).
-const RECALL_FILE_TOOL = TOOLS.find((t) => t.name === 'recall_file');
-if (RECALL_FILE_TOOL && RECALL_FILE_TOOL.inputSchema.properties) {
-    RECALL_FILE_TOOL.inputSchema.properties.scope_to_roots = {
-        type: 'boolean',
-        default: false,
-        description: 'If true, filter results to files inside the client-provided roots (Roots block). Skip silently when client provides no roots.',
-    };
-}
-const CONSOLIDATE_TOOL = TOOLS.find((t) => t.name === 'consolidate');
-if (CONSOLIDATE_TOOL && CONSOLIDATE_TOOL.inputSchema.properties) {
-    CONSOLIDATE_TOOL.inputSchema.properties.use_llm = {
-        type: 'boolean',
-        default: false,
-        description: 'If true, request the client LLM (Sampling block) to write the consolidated summary instead of the heuristic. Falls back gracefully if the client refuses.',
-    };
+// ============================================================
+// Unified dispatchers (v0.7.0 — 3-tool surface)
+// ============================================================
+async function handleRememberUnified(args) {
+    // Delete mode
+    if (args.forget) {
+        if (!args.memory_id) {
+            return JSON.stringify({ ok: false, error: 'memory_id required for forget mode' });
+        }
+        return handleForgetInteractive({ memory_id: args.memory_id, interactive: !!args.interactive });
+    }
+    // Update mode
+    if (args.memory_id) {
+        return handleUpdateMemory(args);
+    }
+    // Create mode (default) — validate required fields
+    if (!args.entity_name || !args.entity_kind || !args.layer || !args.content) {
+        return JSON.stringify({
+            ok: false,
+            error: 'Create mode requires: entity_name, entity_kind, layer, content. To update, provide memory_id. To delete, set forget: true + memory_id.',
+        });
+    }
+    return handleRemember(args);
 }
-const FORGET_TOOL = TOOLS.find((t) => t.name === 'forget');
-if (FORGET_TOOL && FORGET_TOOL.inputSchema.properties) {
-    FORGET_TOOL.inputSchema.properties.interactive = {
-        type: 'boolean',
-        default: false,
-        description: 'If true, ask the user to confirm via Elicitation before deleting. Only applies when memory_id is set.',
-    };
+async function handleRecallUnified(args) {
+    // File history mode (path takes priority; if query also provided, include it as context)
+    if (args.path) {
+        const fileResult = await handleRecallFileWithRoots({
+            path_substring: args.path,
+            max_intents: args.max_intents,
+            scope_to_roots: args.scope_to_roots,
+        });
+        // If query was also provided, merge with memory search for richer context
+        if (args.query && String(args.query).trim().length > 0) {
+            const memResult = handleRecall({ ...args, limit: 5, max_tokens: 500 });
+            const fileParsed = JSON.parse(fileResult);
+            const memParsed = JSON.parse(memResult);
+            return JSON.stringify({
+                ...fileParsed,
+                related_memories: memParsed.memories ?? [],
+                note: 'Combined file history + memory search (both path and query were provided)',
+            });
+        }
+        return fileResult;
+    }
+    // Detect overview request (no search criteria at all)
+    const hasQuery = args.query && String(args.query).trim().length > 0;
+    const hasFilters = args.entity_name || args.layer || args.altitude ||
+        args.mem_type || args.mem_state || args.thread_id || args.band;
+    if (!hasQuery && !hasFilters) {
+        return handleListEntities({
+            kind: args.kind,
+            min_memories: args.min_memories,
+            limit: args.limit,
+            offset: args.offset,
+        });
+    }
+    // Search mode (default)
+    return handleRecall(args);
 }
 // ============================================================
 // MCP wiring
@@ -940,30 +1006,27 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
         let text;
         switch (name) {
             case 'remember':
-                text = handleRemember(args);
+                text = await handleRememberUnified(args);
                 break;
             case 'recall':
-                text = handleRecall(args);
-                break;
-            case 'update_memory':
-                text = handleUpdateMemory(args);
-                break;
-            case 'list_entities':
-                text = handleListEntities(args);
-                break;
-            case 'forget':
-                text = await handleForgetInteractive(args);
-                break;
-            case 'consolidate':
-                text = await handleConsolidateWithSampling(args);
-                break;
-            case 'recall_file':
-                text = await handleRecallFileWithRoots(args);
+                text = await handleRecallUnified(args);
                 break;
             case 'read_smart':
                 text = handleReadSmart(args);
                 break;
-            default: throw new Error(`Unknown tool: ${name}`);
+            default: {
+                const migrations = {
+                    update_memory: 'remember({ memory_id: <id>, content: "...", importance: 0.8 })',
+                    forget: 'remember({ forget: true, memory_id: <id> })',
+                    list_entities: 'recall() with no params',
+                    recall_file: 'recall({ path: "<file_path>" })',
+                    consolidate: 'Auto-runs on server startup. No manual call needed.',
+                };
+                if (name in migrations) {
+                    throw new Error(`Tool "${name}" was merged in v0.7.0. Migration: ${migrations[name]}`);
+                }
+                throw new Error(`Unknown tool: ${name}`);
+            }
         }
         return { content: [{ type: 'text', text }] };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linksee-memory",
-  "version": "0.4.2",
+  "version": "0.7.1",
   "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Local-first agent memory MCP — cross-agent brain with 6-layer structured memory + token-saving file diff cache",
   "type": "module",