linksee-memory 0.2.0 → 0.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Local-first agent memory MCP. A cross-agent brain for Claude Code, Cursor, and ChatGPT Desktop — with a token-saving file diff cache that nobody else does.
 >
-> **v0.2.0** makes the package English-first for global launch: the bundled auto-invocation skill is now bilingual (EN + JP), session-extractor patterns cover common English keywords (`let's go`, `pivot`, `doesn't work`, `same error again`, etc.), and the install CLI shows test examples in both languages. No API changes. See [CHANGELOG](#changelog).
+> **v0.3.0** ships the **Five Blocks**: Tools + Resources + Prompts + Sampling + Roots, plus the newer **Elicitation** primitive. Most public MCP servers expose only Tools; v0.3.0 moves linksee-memory into the differentiated tier. Backward compatible — all 8 v0.2.x tools keep their signatures. See [CHANGELOG.md](./CHANGELOG.md).
 
 [![npm](https://img.shields.io/npm/v/linksee-memory.svg)](https://www.npmjs.com/package/linksee-memory)
 [![license](https://img.shields.io/npm/l/linksee-memory.svg)](./LICENSE)
@@ -147,18 +147,29 @@ Add to `~/.claude/settings.json` to record every Claude Code session to your loc
 
 Each turn end takes ~100 ms. Failures are silent (Claude Code never blocks). Logs at `~/.linksee-memory/hook.log`.
 
+## v0.3.0 — Five Blocks at a glance
+
+| MCP Block | Surface |
+|---|---|
+| **Tools** | 8 tools (unchanged signatures since v0.2). |
+| **Resources** | 4 static URIs (`memory://stats`, `memory://hot`, `memory://recent`, `memory://caveats`) + 3 templates (`memory://entity/{name}`, `memory://layer/{layer}`, `memory://memory/{id}`). Browseable via `@-mention` in clients that support it. |
+| **Prompts** | 5 reusable templates: `summarize-session`, `extract-caveats`, `weekly-consolidation`, `recall-and-write`, `entity-handoff`. |
+| **Sampling** *(client opt-in)* | `consolidate{use_llm:true}` asks the client LLM to rewrite consolidated cluster summaries into prose. Falls back to the heuristic when the client declines. |
+| **Roots** *(client opt-in)* | `recall_file{scope_to_roots:true}` filters path matches to files inside any client-provided working root. |
+| **Elicitation** *(client opt-in, newer primitive)* | `forget{interactive:true, memory_id:N}` asks the user to confirm via the client UI before deleting. |
+
 ## Tools
 
 | Tool | Purpose |
 |---|---|
 | `remember` | Store memory in 1 of 6 layers for an entity. Rejects pasted assistant output / CI logs unless `force=true`. Set `importance=1.0` to pin (survives auto-forget). |
 | `recall` | FTS5 + heat × momentum × importance composite ranking with `match_reasons` explaining WHY each row matched. Supports pagination (`offset`/`has_more`), `band` filter, layer aliases (`decisions`/`warnings`/`how`/...), and `mark_accessed=false` for passive previews. |
-| `recall_file` | Complete edit history of a file across all sessions, with per-edit user-intent context. |
+| `recall_file` | Complete edit history of a file across all sessions, with per-edit user-intent context. **v0.3.0** `scope_to_roots` flag filters by client roots. |
 | `update_memory` | **v0.1.0** Atomic edit of an existing memory. Preserves `memory_id` (session_file_edits links stay intact). Prefer over forget+remember. |
 | `list_entities` | **v0.1.0** List what the memory knows about — cheapest "what do I know?" primitive. Filter by `kind`/`min_memories`; returns layer breakdown per entity. |
 | `read_smart` | Diff-only file read. Returns full content on first read, ~50 tokens on unchanged re-reads, only changed chunks on real edits. |
-| `forget` | Explicit delete OR auto-sweep based on `forgettingRisk`. Pinned (`importance>=1.0`) and caveat-layer memories are always preserved. |
-| `consolidate` | Sleep-mode compression: cluster cold low-importance memories → protected learning-layer summary. Supports `dry_run` preview. |
+| `forget` | Explicit delete OR auto-sweep based on `forgettingRisk`. Pinned (`importance>=1.0`) and caveat-layer memories are always preserved. **v0.3.0** `interactive` flag asks the user via Elicitation before deleting a specific memory_id. |
+| `consolidate` | Sleep-mode compression: cluster cold low-importance memories → protected learning-layer summary. Supports `dry_run` preview. **v0.3.0** `use_llm` flag asks the client LLM (Sampling) to rewrite cluster summaries into prose. |
 
 ### CLI utilities
 

package/dist/mcp/elicitation.d.ts

@@ -0,0 +1,24 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+interface ElicitResult {
+    action: 'accept' | 'decline' | 'cancel' | 'unsupported';
+    content?: Record<string, unknown>;
+    reason?: string;
+}
+interface ElicitParams {
+    message: string;
+    requestedSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare function elicit(server: Server, p: ElicitParams): Promise<ElicitResult>;
+export declare function confirmForget(server: Server, candidate: {
+    id: number;
+    entity: string;
+    layer: string;
+    importance: number;
+    preview: string;
+}): Promise<boolean>;
+export declare function confirmPin(server: Server, memoryId: number, preview: string, newImportance: number): Promise<boolean>;
+export {};

package/dist/mcp/elicitation.js

@@ -0,0 +1,58 @@
+// Elicitation block — server asks the client (and ultimately the user) a structured question.
+//
+// MCP semantics: server.request({method: 'elicitation/create', params: {message, requestedSchema}})
+// The user responds via the client UI. Used by:
+//   - Stale-memory cleanup (forget candidates require confirmation)
+//   - Pin/unpin confirmation when importance crosses 0.9
+//
+// Clients without elicitation support fail gracefully — caller falls back to "decline = skip".
+import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+export async function elicit(server, p) {
+    try {
+        const res = await server.request({ method: 'elicitation/create', params: p }, ElicitRequestSchema);
+        return {
+            action: res?.action ?? 'decline',
+            content: res?.content,
+        };
+    }
+    catch (err) {
+        return { action: 'unsupported', reason: err?.message ?? String(err) };
+    }
+}
+export async function confirmForget(server, candidate) {
+    const res = await elicit(server, {
+        message: `Forget memory #${candidate.id} for "${candidate.entity}"?\n\nLayer: ${candidate.layer}  Importance: ${candidate.importance.toFixed(2)}\nPreview: ${candidate.preview.slice(0, 200)}`,
+        requestedSchema: {
+            type: 'object',
+            properties: {
+                confirm: {
+                    type: 'boolean',
+                    title: 'Forget this memory',
+                    description: 'Yes = delete permanently. No = keep.',
+                },
+            },
+            required: ['confirm'],
+        },
+    });
+    if (res.action === 'accept' && res.content && typeof res.content.confirm === 'boolean') {
+        return res.content.confirm;
+    }
+    return false;
+}
+export async function confirmPin(server, memoryId, preview, newImportance) {
+    const res = await elicit(server, {
+        message: `Pin memory #${memoryId}? (importance ${newImportance.toFixed(2)})\n\nPreview: ${preview.slice(0, 200)}\n\nPinned memories survive forget-sweeps and consolidation.`,
+        requestedSchema: {
+            type: 'object',
+            properties: {
+                confirm: { type: 'boolean', title: 'Pin this memory', description: 'Yes = pin. No = save without pinning.' },
+            },
+            required: ['confirm'],
+        },
+    });
+    if (res.action === 'accept' && res.content && typeof res.content.confirm === 'boolean') {
+        return res.content.confirm;
+    }
+    return false;
+}
+//# sourceMappingURL=elicitation.js.map

package/dist/mcp/prompts.d.ts

@@ -0,0 +1,21 @@
+export declare const PROMPTS: {
+    name: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+}[];
+interface PromptMessage {
+    role: 'user' | 'assistant';
+    content: {
+        type: 'text';
+        text: string;
+    };
+}
+export declare function getPrompt(name: string, args: Record<string, string> | undefined): {
+    description?: string;
+    messages: PromptMessage[];
+};
+export {};

package/dist/mcp/prompts.js

@@ -0,0 +1,201 @@
+// Prompts block — reusable prompt templates that agents can pull from the server.
+//
+// Templates:
+//   summarize-session       — turn a chat transcript into structured memories (1 per layer)
+//   extract-caveats         — read text and produce caveat-layer entries (pain lessons)
+//   weekly-consolidation    — sleep-mode summary of the past week's memories
+//   recall-and-write        — recall first, then write — anti-pattern guard
+//   entity-handoff          — produce a handoff doc for an entity (name + memories + next steps)
+//
+// Each prompt accepts arguments and returns a list of messages the client can feed to its LLM.
+export const PROMPTS = [
+    {
+        name: 'summarize-session',
+        description: 'Turn a chat session transcript into structured memories. Produces up to 6 memories (one per layer) capturing goal/context/emotion/implementation/caveat/learning. Use at session end.',
+        arguments: [
+            { name: 'transcript', description: 'The session transcript text. Free-form.', required: true },
+            { name: 'entity_hint', description: 'Optional canonical entity name to attach the memories to.', required: false },
+        ],
+    },
+    {
+        name: 'extract-caveats',
+        description: 'Scan a body of text (post-mortem, error log, decision doc) and propose caveat-layer memories — concise pain lessons starting with verbs ("Never", "Always", "Watch out"). Returns JSON list of caveats.',
+        arguments: [
+            { name: 'text', description: 'Source text (post-mortem, debug session, retro). Free-form.', required: true },
+            { name: 'entity_hint', description: 'Optional canonical entity name for the caveats.', required: false },
+        ],
+    },
+    {
+        name: 'weekly-consolidation',
+        description: 'Sleep-mode summary of the past week\'s memories for an entity. Produces a single learning-layer entry that captures the trajectory. Use as input to the consolidate tool, or to write a Friday digest.',
+        arguments: [
+            { name: 'entity_name', description: 'The entity to consolidate.', required: true },
+            { name: 'week_offset', description: 'Weeks-ago offset (0 = this week, 1 = last week). Default 0.', required: false },
+        ],
+    },
+    {
+        name: 'recall-and-write',
+        description: 'Anti-pattern guard. Before writing code, draft a doc, or making a decision: recall relevant memories first, then produce the answer with explicit citations to the recalled memory_ids. Forces "memory before action" discipline.',
+        arguments: [
+            { name: 'task', description: 'What you are about to do (code task, decision, doc draft). One sentence.', required: true },
+            { name: 'entity_hint', description: 'Optional entity to focus recall on.', required: false },
+        ],
+    },
+    {
+        name: 'entity-handoff',
+        description: 'Produce a handoff document for an entity: name, kind, key memories per layer, current open questions, and next steps. Use when transferring context to a new session, a new agent, or a new collaborator.',
+        arguments: [
+            { name: 'entity_name', description: 'The entity to hand off.', required: true },
+            { name: 'audience', description: 'Who receives the handoff (e.g. "new claude session", "human teammate"). Default "new claude session".', required: false },
+        ],
+    },
+];
+export function getPrompt(name, args) {
+    const a = args ?? {};
+    switch (name) {
+        case 'summarize-session': {
+            const transcript = a.transcript ?? '';
+            const entityHint = a.entity_hint ? `\n\nFocus entity: ${a.entity_hint}` : '';
+            return {
+                description: 'Summarize the session into 6-layer structured memories.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `You are an agent-memory writer. Read the session transcript below and propose memories to save. Output a JSON array; each item has {entity_name, entity_kind, layer, content, importance}.
+
+Layers (use exactly one per memory):
+- goal: WHY this work exists, target outcome
+- context: WHY THIS NOW, situation, timing
+- emotion: USER tone, feelings expressed
+- implementation: HOW it was done, what worked, what failed
+- caveat: PAIN lesson, "never X" / "always Y" — these are protected from forgetting
+- learning: GROWTH, decisions made, insights
+
+Rules:
+- Max 6 entries (one per layer). Skip layers with nothing worth saving.
+- Importance 0-1. Set 0.9+ to pin (use sparingly).
+- Caveats must be 1 sentence and start with a verb.
+- Quote nothing verbatim; summarize.
+
+Transcript:
+${transcript}${entityHint}`,
+                        },
+                    },
+                ],
+            };
+        }
+        case 'extract-caveats': {
+            const text = a.text ?? '';
+            const entityHint = a.entity_hint ? `\n\nFocus entity: ${a.entity_hint}` : '';
+            return {
+                description: 'Extract caveat-layer pain lessons.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `You are a caveat extractor. Read the source text below and output a JSON list of caveats. Each caveat:
+- Starts with a verb ("Never", "Always", "Watch out", "Reject", "Confirm")
+- Is one sentence
+- Is concrete (a specific failure mode, not abstract advice)
+- Captures something the reader does NOT want to relearn the hard way
+
+Output format: [{"content": "Never X when Y, because Z", "importance": 0.7-1.0}]
+
+Source text:
+${text}${entityHint}`,
+                        },
+                    },
+                ],
+            };
+        }
+        case 'weekly-consolidation': {
+            const entityName = a.entity_name ?? '<entity>';
+            const weekOffset = a.week_offset ?? '0';
+            return {
+                description: `Consolidate the last week of memories for ${entityName}.`,
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Consolidate the past week's memories for entity "${entityName}" (week_offset=${weekOffset}).
+
+Step 1: Call recall(query="${entityName}", entity_name="${entityName}", max_tokens=4000) to retrieve recent memories.
+Step 2: Read the returned memories and produce ONE learning-layer summary that captures:
+  - What we set out to do (goal trajectory)
+  - What actually happened (implementation summary)
+  - What we learned (1-3 insights)
+  - Any caveats we should never forget (preserve these — do NOT consolidate them away)
+
+Step 3: Output a JSON object {entity_name, layer:"learning", content, importance:0.7}.
+
+Do not write to memory directly — just return the JSON. The user will choose whether to save.`,
+                        },
+                    },
+                ],
+            };
+        }
+        case 'recall-and-write': {
+            const task = a.task ?? '<task>';
+            const entityHint = a.entity_hint ?? '';
+            const recallCmd = entityHint
+                ? `recall(query="${task}", entity_name="${entityHint}", max_tokens=2000)`
+                : `recall(query="${task}", max_tokens=2000)`;
+            return {
+                description: 'Memory-before-action discipline.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Before doing this task, recall first.
+
+Task: ${task}
+
+Step 1: Call ${recallCmd}.
+Step 2: Skim the returned memories. Identify any caveats that apply.
+Step 3: Produce your output with INLINE citations to relevant memory_ids: e.g. "Use better-sqlite3 v12+ [memory:1234] because v11 breaks on Node 24 [memory:5678]."
+Step 4: If you found NO relevant memories, say so explicitly: "No prior memories on this — proceeding from first principles."
+
+Goal: never solve a problem twice without checking.`,
+                        },
+                    },
+                ],
+            };
+        }
+        case 'entity-handoff': {
+            const entityName = a.entity_name ?? '<entity>';
+            const audience = a.audience ?? 'new claude session';
+            return {
+                description: `Produce a handoff document for ${entityName}.`,
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Produce a handoff document for entity "${entityName}", aimed at: ${audience}.
+
+Step 1: Call recall(query="${entityName}", entity_name="${entityName}", max_tokens=6000).
+Step 2: Skim memories grouped by layer.
+Step 3: Output a markdown doc with these sections:
+  - **Identity**: name, kind, canonical key (if any)
+  - **Goal** (from goal-layer memories): what this entity is for
+  - **State** (from latest implementation memories): where things stand right now
+  - **Caveats** (from caveat-layer memories): what NEVER to do, with memory_id citations
+  - **Open questions**: things the prior session left unresolved
+  - **Suggested next steps**: 3 concrete actions for the audience
+
+Keep it under 1 page. Cite memory_ids inline like [memory:1234].`,
+                        },
+                    },
+                ],
+            };
+        }
+        default:
+            throw new Error(`unknown prompt: ${name}`);
+    }
+}
+//# sourceMappingURL=prompts.js.map

package/dist/mcp/resources.d.ts

@@ -0,0 +1,18 @@
+import type Database from 'better-sqlite3';
+export declare const STATIC_RESOURCES: {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+}[];
+export declare const RESOURCE_TEMPLATES: {
+    uriTemplate: string;
+    name: string;
+    description: string;
+    mimeType: string;
+}[];
+export declare function readResource(db: Database.Database, uri: string): {
+    uri: string;
+    mimeType: string;
+    text: string;
+};

package/dist/mcp/resources.js

@@ -0,0 +1,162 @@
+// Resources block — expose memories as URI-addressable resources.
+//
+// Static resources (always present):
+//   memory://stats       — DB statistics summary
+//   memory://hot         — currently hot memories (top heat band)
+//   memory://recent      — recently accessed memories (last 7 days)
+//   memory://caveats     — all caveat-layer memories (the never-forget pile)
+//
+// Resource templates (parameterized):
+//   memory://entity/{name}  — all memories for an entity
+//   memory://layer/{layer}  — all memories in a layer (goal/context/emotion/implementation/caveat/learning)
+//   memory://memory/{id}    — single memory by ID
+export const STATIC_RESOURCES = [
+    {
+        uri: 'memory://stats',
+        name: 'Memory store statistics',
+        description: 'Summary counts: entities, memories, layer breakdown, heat distribution.',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'memory://hot',
+        name: 'Hot memories',
+        description: 'Memories currently in the "hot" heat band — what the agent is actively working with.',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'memory://recent',
+        name: 'Recently accessed memories',
+        description: 'Memories accessed in the last 7 days, ordered by recency.',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'memory://caveats',
+        name: 'All caveats',
+        description: 'Every caveat-layer memory — the protected "never forget" pile of pain lessons.',
+        mimeType: 'application/json',
+    },
+];
+export const RESOURCE_TEMPLATES = [
+    {
+        uriTemplate: 'memory://entity/{name}',
+        name: 'Memories for an entity',
+        description: 'All memories about a specific entity (person/company/project/concept/file). Replace {name} with the entity name.',
+        mimeType: 'application/json',
+    },
+    {
+        uriTemplate: 'memory://layer/{layer}',
+        name: 'Memories in a layer',
+        description: 'All memories in a specific layer. Replace {layer} with one of: goal, context, emotion, implementation, caveat, learning.',
+        mimeType: 'application/json',
+    },
+    {
+        uriTemplate: 'memory://memory/{id}',
+        name: 'A single memory',
+        description: 'Read a single memory by its numeric id. Replace {id} with the memory_id.',
+        mimeType: 'application/json',
+    },
+];
+const VALID_LAYERS = new Set(['goal', 'context', 'emotion', 'implementation', 'caveat', 'learning']);
+function fmtMemory(row) {
+    return {
+        id: row.id,
+        entity: row.entity_name,
+        entity_kind: row.entity_kind,
+        layer: row.layer,
+        importance: row.importance,
+        pinned: row.protected === 1 || row.importance >= 0.9,
+        content: row.content,
+        created_at: row.created_at ? new Date(row.created_at * 1000).toISOString() : null,
+        last_accessed_at: row.last_accessed_at ? new Date(row.last_accessed_at * 1000).toISOString() : null,
+        access_count: row.access_count,
+    };
+}
+const SELECT_MEMORY_BASE = `
+  SELECT m.id, m.layer, m.content, m.importance, m.protected, m.created_at, m.last_accessed_at, m.access_count,
+         e.name as entity_name, e.kind as entity_kind
+  FROM memories m JOIN entities e ON e.id = m.entity_id
+`;
+export function readResource(db, uri) {
+    // Static endpoints
+    if (uri === 'memory://stats') {
+        const entityCount = db.prepare('SELECT COUNT(*) as c FROM entities').get().c;
+        const memCount = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
+        const byLayer = db.prepare('SELECT layer, COUNT(*) as c FROM memories GROUP BY layer').all();
+        const byKind = db.prepare('SELECT kind, COUNT(*) as c FROM entities GROUP BY kind').all();
+        const pinned = db.prepare('SELECT COUNT(*) as c FROM memories WHERE importance >= 0.9 OR protected = 1').get().c;
+        return {
+            uri,
+            mimeType: 'application/json',
+            text: JSON.stringify({
+                entity_count: entityCount,
+                memory_count: memCount,
+                pinned_count: pinned,
+                by_layer: Object.fromEntries(byLayer.map((r) => [r.layer, r.c])),
+                by_entity_kind: Object.fromEntries(byKind.map((r) => [r.kind, r.c])),
+                // Note: heat_band is computed at recall-time, not stored — see recall tool for live heat.
+            }, null, 2),
+        };
+    }
+    if (uri === 'memory://hot') {
+        // heat_band is dynamic; approximate "hot" via access_count + recent access desc.
+        // For exact heat scoring, use the recall tool with band='hot'.
+        const rows = db
+            .prepare(`${SELECT_MEMORY_BASE}
+         WHERE m.last_accessed_at IS NOT NULL
+         ORDER BY m.access_count DESC, m.last_accessed_at DESC
+         LIMIT 50`)
+            .all();
+        return {
+            uri,
+            mimeType: 'application/json',
+            text: JSON.stringify({ count: rows.length, note: 'Approximation by access_count + last_accessed_at. Use the recall tool with band="hot" for exact heat scoring.', memories: rows.map(fmtMemory) }, null, 2),
+        };
+    }
+    if (uri === 'memory://recent') {
+        const cutoff = Math.floor(Date.now() / 1000) - 7 * 24 * 3600;
+        const rows = db.prepare(`${SELECT_MEMORY_BASE} WHERE m.last_accessed_at >= ? ORDER BY m.last_accessed_at DESC LIMIT 50`).all(cutoff);
+        return { uri, mimeType: 'application/json', text: JSON.stringify({ count: rows.length, memories: rows.map(fmtMemory) }, null, 2) };
+    }
+    if (uri === 'memory://caveats') {
+        const rows = db.prepare(`${SELECT_MEMORY_BASE} WHERE m.layer = 'caveat' ORDER BY m.importance DESC, m.created_at DESC`).all();
+        return { uri, mimeType: 'application/json', text: JSON.stringify({ count: rows.length, memories: rows.map(fmtMemory) }, null, 2) };
+    }
+    // Templates
+    const entityMatch = uri.match(/^memory:\/\/entity\/(.+)$/);
+    if (entityMatch) {
+        const name = decodeURIComponent(entityMatch[1]);
+        const rows = db
+            .prepare(`${SELECT_MEMORY_BASE} WHERE LOWER(e.name) = LOWER(?) ORDER BY m.importance DESC, m.created_at DESC`)
+            .all(name);
+        return {
+            uri,
+            mimeType: 'application/json',
+            text: JSON.stringify({ entity: name, count: rows.length, memories: rows.map(fmtMemory) }, null, 2),
+        };
+    }
+    const layerMatch = uri.match(/^memory:\/\/layer\/(.+)$/);
+    if (layerMatch) {
+        const layer = decodeURIComponent(layerMatch[1]).toLowerCase();
+        if (!VALID_LAYERS.has(layer)) {
+            throw new Error(`unknown layer "${layer}". Known: goal, context, emotion, implementation, caveat, learning`);
+        }
+        const rows = db
+            .prepare(`${SELECT_MEMORY_BASE} WHERE m.layer = ? ORDER BY m.importance DESC, m.created_at DESC LIMIT 200`)
+            .all(layer);
+        return {
+            uri,
+            mimeType: 'application/json',
+            text: JSON.stringify({ layer, count: rows.length, memories: rows.map(fmtMemory) }, null, 2),
+        };
+    }
+    const idMatch = uri.match(/^memory:\/\/memory\/(\d+)$/);
+    if (idMatch) {
+        const id = Number(idMatch[1]);
+        const row = db.prepare(`${SELECT_MEMORY_BASE} WHERE m.id = ?`).get(id);
+        if (!row)
+            throw new Error(`memory id ${id} not found`);
+        return { uri, mimeType: 'application/json', text: JSON.stringify(fmtMemory(row), null, 2) };
+    }
+    throw new Error(`unknown resource URI: ${uri}`);
+}
+//# sourceMappingURL=resources.js.map

package/dist/mcp/roots.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+interface Root {
+    uri: string;
+    name?: string;
+}
+export declare function fetchRoots(server: Server): Promise<Root[]>;
+export declare function invalidateRootsCache(): void;
+export declare function rootPathFromUri(uri: string): string;
+export declare function isInsideRoots(filePath: string, roots: Root[]): boolean;
+export {};

package/dist/mcp/roots.js

@@ -0,0 +1,64 @@
+// Roots block — track the client's working roots (directories the agent is operating in).
+//
+// The server pulls roots from the client via server.request({method: 'roots/list'}) and caches them.
+// Used by recall_file and read_smart to bias path-substring matches toward files inside a current root.
+//
+// MCP semantics: client owns the root list, server is informed. We refresh on demand
+// (lazily on first use) and on roots/list_changed notification.
+import { ListRootsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+let cachedRoots = null;
+let lastFetched = 0;
+const STALE_MS = 60_000; // re-fetch at most once a minute
+export async function fetchRoots(server) {
+    const now = Date.now();
+    if (cachedRoots && now - lastFetched < STALE_MS)
+        return cachedRoots;
+    try {
+        const res = await server.request({ method: 'roots/list', params: {} }, ListRootsRequestSchema);
+        cachedRoots = Array.isArray(res?.roots) ? res.roots : [];
+        lastFetched = now;
+    }
+    catch {
+        // Client may not support roots; treat as empty.
+        cachedRoots = [];
+        lastFetched = now;
+    }
+    return cachedRoots ?? [];
+}
+export function invalidateRootsCache() {
+    cachedRoots = null;
+    lastFetched = 0;
+}
+// Convert "file:///C:/Users/HP/foo" → "C:/Users/HP/foo" (or "/Users/foo" on POSIX)
+export function rootPathFromUri(uri) {
+    if (uri.startsWith('file:///')) {
+        let p = uri.slice('file:///'.length);
+        // Windows: convert "C:/Users/..." (already POSIX-ish) — leave as-is, caller normalizes.
+        if (process.platform === 'win32') {
+            // also handle "C%3A/" encoding
+            p = p.replace(/^([A-Za-z])(?:%3A|:)\//, '$1:/');
+        }
+        else {
+            p = '/' + p;
+        }
+        try {
+            return decodeURIComponent(p);
+        }
+        catch {
+            return p;
+        }
+    }
+    return uri;
+}
+// Returns true if filePath is inside any of the roots (case-insensitive on win32).
+export function isInsideRoots(filePath, roots) {
+    if (roots.length === 0)
+        return true; // no roots → no filtering
+    const norm = process.platform === 'win32' ? filePath.toLowerCase().replace(/\\/g, '/') : filePath;
+    return roots.some((r) => {
+        const rp = rootPathFromUri(r.uri);
+        const rpn = process.platform === 'win32' ? rp.toLowerCase().replace(/\\/g, '/') : rp;
+        return norm.startsWith(rpn);
+    });
+}
+//# sourceMappingURL=roots.js.map

package/dist/mcp/sampling.d.ts

@@ -0,0 +1,16 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+interface SampleParams {
+    systemPrompt?: string;
+    userPrompt: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+interface SampleResult {
+    ok: boolean;
+    text?: string;
+    reason?: string;
+}
+export declare function sample(server: Server, p: SampleParams): Promise<SampleResult>;
+export declare function sampleConsolidation(server: Server, memoryTexts: string[], entityName: string): Promise<SampleResult>;
+export declare function sampleLayerClassification(server: Server, content: string): Promise<SampleResult>;
+export {};

package/dist/mcp/sampling.js

@@ -0,0 +1,78 @@
+// Sampling block — server requests text generation from the client's LLM.
+//
+// MCP semantics: server.request({method: 'sampling/createMessage', params: {messages, ...}})
+// Used by:
+//   - LLM-assisted consolidate (auto-summarize a memory cluster into a learning entry)
+//   - LLM-assisted layer classification (when the agent uses a vague layer alias)
+//
+// The client may decline (no LLM access, user opted out). All sampling calls are best-effort
+// with a graceful fallback to non-LLM behavior.
+import { CreateMessageRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+export async function sample(server, p) {
+    try {
+        const params = {
+            messages: [{ role: 'user', content: { type: 'text', text: p.userPrompt } }],
+            maxTokens: p.maxTokens ?? 800,
+            temperature: p.temperature ?? 0.3,
+            modelPreferences: {
+                // Prefer fast, cheap, good-enough for summarization.
+                speedPriority: 0.7,
+                costPriority: 0.7,
+                intelligencePriority: 0.4,
+            },
+            includeContext: 'none',
+        };
+        if (p.systemPrompt)
+            params.systemPrompt = p.systemPrompt;
+        const res = await server.request({ method: 'sampling/createMessage', params }, CreateMessageRequestSchema);
+        const text = res?.content?.text ?? res?.content?.[0]?.text ?? '';
+        if (!text)
+            return { ok: false, reason: 'empty response from sampling' };
+        return { ok: true, text };
+    }
+    catch (err) {
+        return { ok: false, reason: err?.message ?? String(err) };
+    }
+}
+export async function sampleConsolidation(server, memoryTexts, entityName) {
+    if (memoryTexts.length === 0)
+        return { ok: false, reason: 'no input memories' };
+    const numbered = memoryTexts.map((t, i) => `[${i + 1}] ${t}`).join('\n\n');
+    const userPrompt = `Consolidate these ${memoryTexts.length} memories about "${entityName}" into a single learning-layer summary. The summary must:
+- Preserve the trajectory (what was attempted, what worked, what changed)
+- Be 2-4 sentences max
+- Not invent facts not in the originals
+- Not include verbatim quotes
+
+Memories:
+${numbered}
+
+Output the summary text only — no preamble, no JSON wrapper.`;
+    return sample(server, {
+        systemPrompt: 'You are a memory consolidator. Compress without distorting.',
+        userPrompt,
+        maxTokens: 400,
+        temperature: 0.2,
+    });
+}
+export async function sampleLayerClassification(server, content) {
+    const userPrompt = `Classify this memory content into exactly one layer:
+- goal: WHY this work exists, target outcome
+- context: WHY THIS NOW, situation, timing
+- emotion: USER tone, feelings expressed
+- implementation: HOW it was done, what worked, what failed
+- caveat: PAIN lesson, "never X" / "always Y"
+- learning: GROWTH, decisions made, insights
+
+Content:
+${content}
+
+Output just the layer name — no explanation, no JSON.`;
+    return sample(server, {
+        systemPrompt: 'You are a layer classifier. Output one word.',
+        userPrompt,
+        maxTokens: 16,
+        temperature: 0,
+    });
+}
+//# sourceMappingURL=sampling.js.map

package/dist/mcp/server.js

@@ -4,7 +4,7 @@
 //        forget / consolidate / read_smart
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { openDb, runMigrations } from '../db/migrate.js';
 import { computeHeat } from '../lib/heat-index.js';
 import { decideForgetting } from '../lib/forgetting.js';
@@ -12,10 +12,24 @@ import { refreshMomentumForEntity } from '../lib/momentum.js';
 import { consolidate as runConsolidate } from '../lib/consolidate.js';
 import { isPastedExternalContent } from '../lib/session-parser.js';
 import { handleReadSmart as handleReadSmartImpl } from './read-smart.js';
-const SERVER_VERSION = '0.1.1';
+import { STATIC_RESOURCES, RESOURCE_TEMPLATES, readResource } from './resources.js';
+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 db = openDb();
 runMigrations(db);
-const server = new Server({ name: 'linksee-memory', version: SERVER_VERSION }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'linksee-memory', version: SERVER_VERSION }, {
+    capabilities: {
+        tools: {},
+        resources: { subscribe: false, listChanged: false },
+        prompts: { listChanged: false },
+        // Sampling, Roots, Elicitation are CLIENT capabilities the server consumes.
+        // We don't declare them under "capabilities" — we just call them via server.request
+        // and gracefully degrade when the client doesn't support them.
+    },
+});
 // ============================================================
 // Layer alias map — natural language → canonical layer
 // (agents can say layer="decisions" and we resolve to "learning")
@@ -233,14 +247,14 @@ function toFtsQuery(raw) {
     return tokens.map((t) => `"${t}"`).join(' OR ');
 }
 function runFtsQuery(query, layer, limit) {
-    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,
-           bm25(memories_fts) as bm25_score
-    FROM memories_fts
-    JOIN memories m ON m.id = memories_fts.rowid
-    JOIN entities e ON e.id = m.entity_id
-    WHERE memories_fts MATCH ?
+    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,
+           bm25(memories_fts) as bm25_score
+    FROM memories_fts
+    JOIN memories m ON m.id = memories_fts.rowid
+    JOIN entities e ON e.id = m.entity_id
+    WHERE memories_fts MATCH ?
   `;
     const params = [query];
     if (layer) {
@@ -252,13 +266,13 @@ function runFtsQuery(query, layer, limit) {
     return db.prepare(sql).all(...params);
 }
 function runLikeQuery(query, entityName, layer, limit) {
-    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,
-           0 as bm25_score
-    FROM memories m
-    JOIN entities e ON e.id = m.entity_id
-    WHERE 1=1
+    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,
+           0 as bm25_score
+    FROM memories m
+    JOIN entities e ON e.id = m.entity_id
+    WHERE 1=1
   `;
     const params = [];
     if (entityName) {
@@ -494,8 +508,8 @@ 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
-              FROM memories
+        .prepare(`SELECT id, layer, importance, access_count, last_accessed_at, protected
+              FROM memories
               WHERE protected = 0 AND importance < 0.9`)
         .all();
     const now = Math.floor(Date.now() / 1000);
@@ -543,17 +557,17 @@ function handleConsolidate(args) {
         // read-only audit: count candidates using the same rules.
         const now = Math.floor(Date.now() / 1000);
         const ageCutoff = now - (args.min_age_days ?? 7) * 86400;
-        const candidates = db.prepare(`
-      SELECT m.entity_id, e.name as entity_name, m.layer, COUNT(*) as c
-      FROM memories m
-      JOIN entities e ON e.id = m.entity_id
-      WHERE m.protected = 0
-        AND m.importance < 0.9
-        AND m.layer IN ('context', 'emotion', 'implementation')
-        AND m.created_at <= ?
-      GROUP BY m.entity_id, m.layer
-      HAVING c >= 2
-      ORDER BY c DESC
+        const candidates = db.prepare(`
+      SELECT m.entity_id, e.name as entity_name, m.layer, COUNT(*) as c
+      FROM memories m
+      JOIN entities e ON e.id = m.entity_id
+      WHERE m.protected = 0
+        AND m.importance < 0.9
+        AND m.layer IN ('context', 'emotion', 'implementation')
+        AND m.created_at <= ?
+      GROUP BY m.entity_id, m.layer
+      HAVING c >= 2
+      ORDER BY c DESC
     `).all(ageCutoff);
         const totalReplaced = candidates.reduce((s, c) => s + c.c, 0);
         return JSON.stringify({
@@ -627,19 +641,19 @@ function handleListEntities(args) {
     const minMemories = Math.max(1, Number(args?.min_memories ?? 1));
     const limit = Math.max(1, Math.min(200, Number(args?.limit ?? 30)));
     const offset = Math.max(0, Number(args?.offset ?? 0));
-    let sql = `
-    SELECT e.id, e.name, e.kind, e.canonical_key, e.momentum_score,
-           e.updated_at, e.created_at,
-           COUNT(m.id) as memory_count,
-           MAX(m.last_accessed_at) as last_memory_access,
-           SUM(CASE WHEN m.layer = 'goal' THEN 1 ELSE 0 END) as goal_count,
-           SUM(CASE WHEN m.layer = 'caveat' THEN 1 ELSE 0 END) as caveat_count,
-           SUM(CASE WHEN m.layer = 'learning' THEN 1 ELSE 0 END) as learning_count,
-           SUM(CASE WHEN m.layer = 'implementation' THEN 1 ELSE 0 END) as impl_count,
-           SUM(CASE WHEN m.importance >= 0.9 THEN 1 ELSE 0 END) as pinned_count
-    FROM entities e
-    LEFT JOIN memories m ON m.entity_id = e.id
-    WHERE 1=1
+    let sql = `
+    SELECT e.id, e.name, e.kind, e.canonical_key, e.momentum_score,
+           e.updated_at, e.created_at,
+           COUNT(m.id) as memory_count,
+           MAX(m.last_accessed_at) as last_memory_access,
+           SUM(CASE WHEN m.layer = 'goal' THEN 1 ELSE 0 END) as goal_count,
+           SUM(CASE WHEN m.layer = 'caveat' THEN 1 ELSE 0 END) as caveat_count,
+           SUM(CASE WHEN m.layer = 'learning' THEN 1 ELSE 0 END) as learning_count,
+           SUM(CASE WHEN m.layer = 'implementation' THEN 1 ELSE 0 END) as impl_count,
+           SUM(CASE WHEN m.importance >= 0.9 THEN 1 ELSE 0 END) as pinned_count
+    FROM entities e
+    LEFT JOIN memories m ON m.entity_id = e.id
+    WHERE 1=1
   `;
     const params = [];
     if (kind) {
@@ -691,29 +705,29 @@ function handleRecallFile(args) {
         return JSON.stringify({ ok: true, count: 0, note: 'No edits found for that path substring.' });
     }
     // Daily breakdown
-    const daily = db.prepare(`
-    SELECT DATE(occurred_at, 'unixepoch') as day, operation, COUNT(*) as edits
-    FROM session_file_edits WHERE file_path LIKE ?
-    GROUP BY day, operation ORDER BY day
+    const daily = db.prepare(`
+    SELECT DATE(occurred_at, 'unixepoch') as day, operation, COUNT(*) as edits
+    FROM session_file_edits WHERE file_path LIKE ?
+    GROUP BY day, operation ORDER BY day
   `).all(`%${sub}%`);
     // Distinct context_snippets (intents) — deduped, ordered by recency
-    const intents = db.prepare(`
-    SELECT DISTINCT context_snippet, MAX(occurred_at) as last_at, COUNT(*) as freq
-    FROM session_file_edits
-    WHERE file_path LIKE ? AND context_snippet IS NOT NULL AND LENGTH(context_snippet) > 20
-    GROUP BY context_snippet
-    ORDER BY last_at DESC
-    LIMIT ?
+    const intents = db.prepare(`
+    SELECT DISTINCT context_snippet, MAX(occurred_at) as last_at, COUNT(*) as freq
+    FROM session_file_edits
+    WHERE file_path LIKE ? AND context_snippet IS NOT NULL AND LENGTH(context_snippet) > 20
+    GROUP BY context_snippet
+    ORDER BY last_at DESC
+    LIMIT ?
   `).all(`%${sub}%`, maxIntents);
     // Linked memories
-    const memories = db.prepare(`
-    SELECT DISTINCT m.id, m.layer, m.content, m.importance, e.name as entity_name
-    FROM session_file_edits sfe
-    JOIN memories m ON m.id = sfe.memory_id
-    JOIN entities e ON e.id = m.entity_id
-    WHERE sfe.file_path LIKE ?
-    ORDER BY m.importance DESC
-    LIMIT 20
+    const memories = db.prepare(`
+    SELECT DISTINCT m.id, m.layer, m.content, m.importance, e.name as entity_name
+    FROM session_file_edits sfe
+    JOIN memories m ON m.id = sfe.memory_id
+    JOIN entities e ON e.id = m.entity_id
+    WHERE sfe.file_path LIKE ?
+    ORDER BY m.importance DESC
+    LIMIT 20
   `).all(`%${sub}%`);
     // Distinct file paths matched (the substring may match multiple files)
     const paths = db.prepare(`SELECT file_path, COUNT(*) as edits FROM session_file_edits WHERE file_path LIKE ? GROUP BY file_path ORDER BY edits DESC`).all(`%${sub}%`);
@@ -746,6 +760,158 @@ function handleReadSmart(args) {
     return handleReadSmartImpl(db, { path: args.path, force: args.force });
 }
 // ============================================================
+// v0.3.0 — five-blocks helpers (sampling / roots / elicitation in handlers)
+// ============================================================
+async function handleRecallFileWithRoots(args) {
+    const baseJson = handleRecallFile(args);
+    if (!args?.scope_to_roots)
+        return baseJson;
+    let parsed;
+    try {
+        parsed = JSON.parse(baseJson);
+    }
+    catch {
+        return baseJson;
+    }
+    if (!parsed?.ok || !Array.isArray(parsed.paths_matched))
+        return baseJson;
+    const roots = await fetchRoots(server);
+    if (roots.length === 0) {
+        parsed.roots_filter = { applied: false, reason: 'client provided no roots' };
+        return JSON.stringify(parsed);
+    }
+    const filtered = parsed.paths_matched.filter((p) => isInsideRoots(p.file_path, roots));
+    parsed.roots_filter = { applied: true, root_count: roots.length, before: parsed.paths_matched.length, after: filtered.length };
+    parsed.paths_matched = filtered;
+    return JSON.stringify(parsed);
+}
+async function handleConsolidateWithSampling(args) {
+    // Sampling only applies on a real run (not dry-run) and only when explicitly opted in.
+    if (!args?.use_llm || args?.dry_run)
+        return handleConsolidate(args);
+    // 1. Snapshot all candidate memories BEFORE consolidate runs so we can recover
+    //    their content (the originals are deleted by consolidate).
+    const ageCutoff = Math.floor(Date.now() / 1000) - (typeof args?.min_age_days === 'number' ? args.min_age_days : 7) * 86400;
+    const snapshot = new Map();
+    const candidateRows = db
+        .prepare(`SELECT m.id, m.content, 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 ('context','emotion','implementation')
+         AND m.created_at <= ?`)
+        .all(ageCutoff);
+    for (const r of candidateRows)
+        snapshot.set(r.id, r);
+    // 2. Run the normal heuristic consolidate (creates learning entries, deletes source).
+    const baseJson = handleConsolidate(args);
+    let parsed;
+    try {
+        parsed = JSON.parse(baseJson);
+    }
+    catch {
+        return baseJson;
+    }
+    if (!parsed?.ok || !Array.isArray(parsed.learningIdsCreated)) {
+        parsed = parsed ?? {};
+        parsed.sampling = { applied: false, reason: 'consolidate returned no learning entries' };
+        return JSON.stringify(parsed);
+    }
+    // 3. For each new learning entry, look up its replaced_ids from the audit table,
+    //    gather source contents from the snapshot, and request a sampled summary.
+    let upgraded = 0;
+    let declined = 0;
+    const declineReasons = [];
+    for (const learningId of parsed.learningIdsCreated) {
+        const audit = db.prepare('SELECT replaced_ids FROM consolidations WHERE learning_id = ?').get(learningId);
+        if (!audit) {
+            declined++;
+            continue;
+        }
+        let replaced;
+        try {
+            replaced = JSON.parse(audit.replaced_ids);
+        }
+        catch {
+            declined++;
+            continue;
+        }
+        if (!Array.isArray(replaced) || replaced.length < 2) {
+            declined++;
+            continue;
+        }
+        const sources = replaced
+            .map((id) => snapshot.get(id))
+            .filter((s) => Boolean(s));
+        if (sources.length < 2) {
+            declined++;
+            continue;
+        }
+        const entityName = sources[0]?.entity_name ?? '<entity>';
+        const result = await sampleConsolidation(server, sources.map((s) => s.content), entityName);
+        if (result.ok && result.text) {
+            db.prepare('UPDATE memories SET content = ? WHERE id = ?').run(result.text.trim(), learningId);
+            upgraded++;
+        }
+        else {
+            declined++;
+            if (result.reason && declineReasons.length < 3)
+                declineReasons.push(result.reason);
+        }
+    }
+    parsed.sampling = {
+        applied: true,
+        upgraded,
+        declined,
+        ...(declineReasons.length ? { decline_reasons: declineReasons } : {}),
+    };
+    return JSON.stringify(parsed);
+}
+async function handleForgetInteractive(args) {
+    if (!args?.interactive || !args?.memory_id)
+        return handleForget(args);
+    const id = Number(args.memory_id);
+    const row = db
+        .prepare(`SELECT m.id, m.layer, m.content, m.importance, e.name as entity FROM memories m JOIN entities e ON e.id = m.entity_id WHERE m.id = ?`)
+        .get(id);
+    if (!row)
+        return JSON.stringify({ ok: false, error: `memory ${id} not found` });
+    const ok = await confirmForget(server, {
+        id: row.id,
+        entity: row.entity,
+        layer: row.layer,
+        importance: row.importance,
+        preview: row.content,
+    });
+    if (!ok)
+        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.',
+    };
+}
+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.',
+    };
+}
+// ============================================================
 // MCP wiring
 // ============================================================
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
@@ -767,13 +933,13 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
                 text = handleListEntities(args);
                 break;
             case 'forget':
-                text = handleForget(args);
+                text = await handleForgetInteractive(args);
                 break;
             case 'consolidate':
-                text = handleConsolidate(args);
+                text = await handleConsolidateWithSampling(args);
                 break;
             case 'recall_file':
-                text = handleRecallFile(args);
+                text = await handleRecallFileWithRoots(args);
                 break;
             case 'read_smart':
                 text = handleReadSmart(args);
@@ -789,6 +955,24 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
         };
     }
 });
+// ============================================================
+// Resources block
+// ============================================================
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: STATIC_RESOURCES }));
+server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({ resourceTemplates: RESOURCE_TEMPLATES }));
+server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    const { uri } = req.params;
+    const result = readResource(db, uri);
+    return { contents: [result] };
+});
+// ============================================================
+// Prompts block
+// ============================================================
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: PROMPTS }));
+server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    const { name, arguments: promptArgs } = req.params;
+    return getPrompt(name, promptArgs);
+});
 const transport = new StdioServerTransport();
 await server.connect(transport);
 process.stderr.write(`[linksee-memory] MCP server ready on stdio (v${SERVER_VERSION})\n`);

package/package.json

@@ -1,71 +1,82 @@
-{
-  "name": "linksee-memory",
-  "version": "0.2.0",
-  "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",
-  "bin": {
-    "linksee-memory": "dist/mcp/server.js",
-    "linksee-memory-import": "dist/bin/import-sessions.js",
-    "linksee-memory-sync": "dist/bin/sync-session.js",
-    "linksee-memory-install-skill": "dist/bin/install-skill.js",
-    "linksee-memory-stats": "dist/bin/stats.js"
-  },
-  "main": "./dist/mcp/server.js",
-  "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts",
-    "dist/db/schema.sql",
-    "dist/skill/SKILL.md",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc && node -e \"require('fs').copyFileSync('src/db/schema.sql','dist/db/schema.sql'); require('fs').mkdirSync('dist/skill',{recursive:true}); require('fs').copyFileSync('src/skill/SKILL.md','dist/skill/SKILL.md')\"",
-    "start": "node dist/mcp/server.js",
-    "dev": "tsx src/mcp/server.ts",
-    "migrate": "node dist/db/migrate.js",
-    "migrate:dev": "tsx src/db/migrate.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "memory",
-    "agent",
-    "agent-memory",
-    "claude",
-    "claude-code",
-    "cursor",
-    "chatgpt",
-    "sqlite",
-    "local-first",
-    "token-savings",
-    "cross-agent"
-  ],
-  "author": "Synapse Arrows PTE. LTD.",
-  "license": "MIT",
-  "homepage": "https://github.com/michielinksee/linksee-memory",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/michielinksee/linksee-memory.git"
-  },
-  "bugs": {
-    "url": "https://github.com/michielinksee/linksee-memory/issues"
-  },
-  "dependencies": {
-    "@babel/parser": "^7.25.0",
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "better-sqlite3": "^11.3.0",
-    "sqlite-vec": "^0.1.6"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11",
-    "@types/node": "^22.7.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.6.0"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "linksee-memory",
+  "version": "0.3.0",
+  "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",
+  "bin": {
+    "linksee-memory": "dist/mcp/server.js",
+    "linksee-memory-import": "dist/bin/import-sessions.js",
+    "linksee-memory-sync": "dist/bin/sync-session.js",
+    "linksee-memory-install-skill": "dist/bin/install-skill.js",
+    "linksee-memory-stats": "dist/bin/stats.js"
+  },
+  "main": "./dist/mcp/server.js",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/db/schema.sql",
+    "dist/skill/SKILL.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').copyFileSync('src/db/schema.sql','dist/db/schema.sql'); require('fs').mkdirSync('dist/skill',{recursive:true}); require('fs').copyFileSync('src/skill/SKILL.md','dist/skill/SKILL.md')\"",
+    "start": "node dist/mcp/server.js",
+    "dev": "tsx src/mcp/server.ts",
+    "migrate": "node dist/db/migrate.js",
+    "migrate:dev": "tsx src/db/migrate.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "memory",
+    "agent",
+    "agent-memory",
+    "claude",
+    "claude-code",
+    "cursor",
+    "chatgpt",
+    "sqlite",
+    "local-first",
+    "token-savings",
+    "cross-agent"
+  ],
+  "author": "Synapse Arrows PTE. LTD.",
+  "license": "MIT",
+  "homepage": "https://github.com/michielinksee/linksee-memory",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michielinksee/linksee-memory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/michielinksee/linksee-memory/issues"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.25.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^12.9.0",
+    "sqlite-vec": "^0.1.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^22.7.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "overrides": {
+    "ip-address": "^10.2.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3"
+    ],
+    "overrides": {
+      "ip-address": "^10.2.0"
+    }
+  }
+}