linksee-memory 0.2.0 → 0.4.0

package/dist/lib/session-extractor.js

@@ -3,6 +3,54 @@
 // to its intent context. A memory like "edited server.ts" becomes
 // "edited server.ts BECAUSE the user wanted the FTS5 + LIKE merge fix".
 import { isMetaOrNoise, isAutomatedSession, isPastedExternalContent } from './session-parser.js';
+const ALTITUDE_PATTERNS = [
+    [/mission|ミッション|ビジョン|vision|product\s+direction|事業方針/i, 'mission'],
+    [/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) {
+    for (const [pattern, altitude] of ALTITUDE_PATTERNS) {
+        if (pattern.test(text))
+            return altitude;
+    }
+    return 'implementation';
+}
+/** 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();
+    const firstSentence = cleaned.split(/[。！？!?\n]/)[0].trim();
+    if (firstSentence.length <= maxLen)
+        return firstSentence;
+    return firstSentence.slice(0, maxLen - 3) + '...';
+}
+/** Extract file paths from surrounding context */
+function extractAffectedPaths(ops) {
+    const unique = new Set(ops.map((o) => o.path));
+    return Array.from(unique).slice(0, 10);
+}
+function buildStructuredContent(opts) {
+    const obj = {
+        title: opts.title,
+        altitude: opts.altitude,
+        type: opts.type,
+        state: opts.state,
+        what: opts.what,
+    };
+    if (opts.why)
+        obj.why = opts.why;
+    if (opts.affects && opts.affects.length > 0)
+        obj.affects = opts.affects;
+    if (opts.next_action !== undefined)
+        obj.next_action = opts.next_action;
+    if (opts.evidence_refs && opts.evidence_refs.length > 0)
+        obj.evidence_refs = opts.evidence_refs;
+    // Merge any extra fields (session_id, git_branch, etc.)
+    for (const [k, v] of Object.entries(opts)) {
+        if (!(k in obj) && v !== undefined)
+            obj[k] = v;
+    }
+    return JSON.stringify(obj, null, 2);
+}
 // ============================================================
 // Intent detection — first non-noise user message in the session.
 // ============================================================
@@ -50,7 +98,9 @@ const CAVEAT_PATTERNS = [
     //   sentence terminators 。！!、 / particles ね・よ / whitespace / ください
     // Anything else (e.g. も = concessive「〜ないでも」, 止まる・いる・ほしい etc.)
     // is treated as descriptive and excluded.
-    /気をつけて|注意して|[！!]注意[！!]|避けて(?!いる|いない)|[ぁ-ん一-龯]ないで(?=[。！!、\s]|ください|ね[^い]|よ[^う]|$)|やめて(?!おく|ほし)|禁止|ダメだ(?!った|ろうと|と思)|危険[だです]/,
+    // 心配し・気にし・遠慮し are reassurance ("don't worry / don't mind / don't hesitate")
+    // — semantically opposite to a caveat. Lookbehind excludes them.
+    /気をつけて|注意して|[！!]注意[！!]|避けて(?!いる|いない)|(?<!心配|気に|遠慮)[ぁ-ん一-龯]ないで(?=[。！!、\s]|ください|ね[^い]|よ[^う]|$)|やめて(?!おく|ほし)|禁止|ダメだ(?!った|ろうと|と思)|危険[だです]/,
     // English: require a concrete action after avoid/don't/never — a bare
     // "Avoiding rebuild of unchanged files" in a Vercel log is not a caveat.
     /\b(?:don'?t|do\s+not)\s+(?:do|use|run|call|forget|try|send|share|commit|push|paste|edit)\b|\bnever\s+(?:do|use|call|share|commit|paste|run|push|edit)\b|\bavoid\s+(?:using|running|calling|committing|pushing|sharing|pasting|editing|creating|modifying)\b|\bwatch\s+out\b/i,
@@ -58,6 +108,27 @@ const CAVEAT_PATTERNS = [
 function matchesAny(text, patterns) {
     return patterns.some((p) => p.test(text));
 }
+/**
+ * Check if a message is mostly chitchat with a decision keyword buried in it.
+ * The サイダー problem: "おお！そうだね。書斎で無糖のサイダーでした。…決めた"
+ * matches DECISION_PATTERNS because of "決めた" at the end, but the message
+ * is primarily casual conversation, not a project decision.
+ *
+ * Heuristic: if the decision keyword appears ONLY in the last 30% of a long
+ * message (>100 chars) AND the first 50 chars match chitchat patterns, skip it.
+ */
+const CHITCHAT_OPENERS = /^(?:おお|うん|そう(?:だね|だよね)|ありがと|はは|笑|www|OK|おー|へー|なるほど|ちなみに|そういえば|あー|えー|まぁ|まあ|ああ)/;
+function isChitchatWithBuriedDecision(text, patterns) {
+    if (text.length < 100)
+        return false; // short messages are fine
+    if (!CHITCHAT_OPENERS.test(text.trim()))
+        return false; // doesn't open with chitchat
+    // Check if any pattern matches in the first 40% of the text
+    const earlyPortion = text.slice(0, Math.floor(text.length * 0.4));
+    if (patterns.some((p) => p.test(earlyPortion)))
+        return false; // decision is early = legitimate
+    return true; // chitchat opening + decision keyword only appears late = noise
+}
 // Dedupe successive file edits to the same path within N seconds —
 // they're usually the same logical change.
 // NOTE: this only dedupes for memory CREATION (1 implementation memory per file
@@ -86,31 +157,39 @@ export function extractSession(session, projectName) {
     // 1) Goal layer — the first REAL intent (or synthetic marker for automated sessions)
     const firstIntent = findFirstIntent(session);
     if (firstIntent) {
+        const intentText = firstIntent.text.slice(0, 1000);
         memories.push({
             layer: 'goal',
-            content: JSON.stringify({
-                intent: firstIntent.text.slice(0, 1000),
-                when: new Date(firstIntent.timestamp * 1000).toISOString(),
+            content: buildStructuredContent({
+                title: makeTitle(intentText),
+                altitude: inferAltitude(intentText),
+                type: 'work',
+                state: 'in_progress',
+                what: intentText,
+                why: 'Session intent — first user message',
+                evidence_refs: [{ type: 'session', id: session.session_id, label: 'source session' }],
                 session_id: session.session_id,
                 git_branch: session.git_branch,
-            }, null, 2),
-            importance: automated ? 0.3 : 0.8, // lower for automated runs
+            }),
+            importance: automated ? 0.3 : 0.8,
             source: { session_id: session.session_id, turn_uuid: firstIntent.uuid, kind: 'first_intent' },
         });
     }
     else if (automated) {
-        // Synthetic goal so the session is still discoverable
         const match = firstRawUserText.match(/<scheduled-task\s+name="([^"]+)"/);
         const taskName = match ? match[1] : 'unknown';
         memories.push({
             layer: 'goal',
-            content: JSON.stringify({
-                intent: `Automated scheduled task run: ${taskName}`,
-                automated: true,
-                when: new Date(session.started_at * 1000).toISOString(),
+            content: buildStructuredContent({
+                title: `Automated: ${taskName}`,
+                altitude: 'implementation',
+                type: 'work',
+                state: 'in_progress',
+                what: `Automated scheduled task run: ${taskName}`,
+                why: 'Scheduled automation',
                 session_id: session.session_id,
                 git_branch: session.git_branch,
-            }, null, 2),
+            }),
             importance: 0.2,
             source: { session_id: session.session_id, kind: 'automated_task' },
         });
@@ -131,11 +210,17 @@ export function extractSession(session, projectName) {
         if (t.text.trim().length < 40)
             continue;
         clarifyCount++;
+        const msgText = t.text.slice(0, 600);
         memories.push({
             layer: 'context',
-            content: JSON.stringify({
-                message: t.text.slice(0, 600),
-                when: new Date(t.timestamp * 1000).toISOString(),
+            content: buildStructuredContent({
+                title: makeTitle(msgText, 60),
+                altitude: inferAltitude(msgText),
+                type: 'note',
+                state: 'open',
+                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,
@@ -153,17 +238,23 @@ export function extractSession(session, projectName) {
     for (const [path, ops] of byPath) {
         const first = ops[0];
         const opsKinds = Array.from(new Set(ops.map((o) => o.operation))).join('+');
-        const why = (first.preceding_user_text || '(no explicit preceding intent)').slice(0, 400);
+        const userIntent = (first.preceding_user_text || '').slice(0, 400);
         const contentSnippet = ops.map((o) => o.tool_input_preview).slice(0, 2).join(' | ').slice(0, 500);
-        const memoryContent = JSON.stringify({
-            file: path,
-            ops: opsKinds,
-            op_count: ops.length,
-            why_extracted: why,
+        const fileName = path.replace(/\\/g, '/').split('/').pop() || path;
+        const memoryContent = buildStructuredContent({
+            title: `${opsKinds} ${fileName} (${ops.length} ops)`,
+            altitude: 'implementation',
+            type: 'work',
+            state: 'done',
+            what: userIntent || `File operation: ${opsKinds} on ${path}`,
+            why: userIntent ? `User intent: ${makeTitle(userIntent, 120)}` : '(no explicit preceding intent)',
+            affects: [path],
+            next_action: null,
+            evidence_refs: [{ type: 'session', id: session.session_id, label: 'source session' }],
             sample_change: contentSnippet,
-            when: new Date(first.timestamp * 1000).toISOString(),
+            op_count: ops.length,
             session_id: session.session_id,
-        }, null, 2);
+        });
         memories.push({
             layer: 'implementation',
             content: memoryContent,
@@ -195,12 +286,20 @@ export function extractSession(session, projectName) {
             continue;
         if (isPastedExternalContent(t.text))
             continue;
-        if (matchesAny(t.text, CAVEAT_PATTERNS) && t.text.length > 20) {
+        if (matchesAny(t.text, CAVEAT_PATTERNS) && t.text.length > 20 && !isChitchatWithBuriedDecision(t.text, CAVEAT_PATTERNS)) {
+            const caveatText = t.text.slice(0, 500);
             memories.push({
                 layer: 'caveat',
-                content: JSON.stringify({
-                    rule_or_warning: t.text.slice(0, 500),
-                    when: new Date(t.timestamp * 1000).toISOString(),
+                content: buildStructuredContent({
+                    title: makeTitle(caveatText, 70),
+                    altitude: inferAltitude(caveatText),
+                    type: 'learning',
+                    state: 'done',
+                    what: caveatText,
+                    why: 'User-stated warning/prohibition — auto-extracted by caveat pattern match',
+                    affects: extractAffectedPaths(session.file_ops),
+                    next_action: null,
+                    evidence_refs: [{ type: 'session', id: session.session_id, label: 'caveat source' }],
                     session_id: session.session_id,
                 }),
                 importance: 0.75,
@@ -210,6 +309,9 @@ export function extractSession(session, projectName) {
     }
     // 5) Learning layer — messages matching decision patterns
     //    Same strict filter applies.
+    //    NOTE: Without LLM, we store the raw user text as `what` — this is the best
+    //    heuristic extraction can do. Agent-initiated `remember()` calls should use
+    //    the full structured format with agent_proposal + user_approval_scope.
     for (const t of session.turns) {
         if (t.role !== 'user' || isMetaOrNoise(t.text))
             continue;
@@ -217,12 +319,20 @@ export function extractSession(session, projectName) {
             continue;
         if (isPastedExternalContent(t.text))
             continue;
-        if (matchesAny(t.text, DECISION_PATTERNS) && t.text.length > 15) {
+        if (matchesAny(t.text, DECISION_PATTERNS) && t.text.length > 15 && !isChitchatWithBuriedDecision(t.text, DECISION_PATTERNS)) {
+            const decisionText = t.text.slice(0, 500);
             memories.push({
                 layer: 'learning',
-                content: JSON.stringify({
-                    decision: t.text.slice(0, 500),
-                    when: new Date(t.timestamp * 1000).toISOString(),
+                content: buildStructuredContent({
+                    title: makeTitle(decisionText, 70),
+                    altitude: inferAltitude(decisionText),
+                    type: 'decision',
+                    state: 'decided',
+                    what: decisionText,
+                    why: 'Decision detected by pattern match — may need agent enrichment',
+                    affects: extractAffectedPaths(session.file_ops),
+                    next_action: null,
+                    evidence_refs: [{ type: 'session', id: session.session_id, label: 'decision source' }],
                     session_id: session.session_id,
                 }),
                 importance: 0.7,
@@ -236,10 +346,15 @@ export function extractSession(session, projectName) {
     if (session.errors_count > 3) {
         memories.push({
             layer: 'context',
-            content: JSON.stringify({
-                why_now: `This session had ${session.errors_count} tool errors across ${session.turns.length} turns.`,
-                triggering_event: 'high_error_rate',
-                when: new Date(session.started_at * 1000).toISOString(),
+            content: buildStructuredContent({
+                title: `High error session (${session.errors_count} errors / ${session.turns.length} turns)`,
+                altitude: 'implementation',
+                type: 'outcome',
+                state: 'done',
+                what: `This session had ${session.errors_count} tool errors across ${session.turns.length} turns.`,
+                why: 'High error rate may indicate environmental or configuration issues worth investigating',
+                affects: extractAffectedPaths(session.file_ops),
+                evidence_refs: [{ type: 'session', id: session.session_id, label: 'error session' }],
                 session_id: session.session_id,
             }),
             importance: 0.4,
@@ -248,20 +363,31 @@ export function extractSession(session, projectName) {
     }
     // 7) Session summary — one meta-implementation memory per session for overview
     if (memories.length > 0) {
+        const durationMin = Math.round((session.ended_at - session.started_at) / 60);
+        const firstGoalTitle = firstIntent ? makeTitle(firstIntent.text, 60) : 'automated task';
         memories.push({
             layer: 'implementation',
-            content: JSON.stringify({
+            content: buildStructuredContent({
+                title: `Session: ${firstGoalTitle} (${durationMin}min, ${byPath.size} files)`,
+                altitude: 'implementation',
+                type: 'outcome',
+                state: 'done',
+                what: `Session completed: ${durationMin} minutes, ${session.turn_count_user} user turns, ${byPath.size} files touched, ${session.errors_count} errors`,
+                why: 'Session overview for timeline and activity tracking',
+                affects: extractAffectedPaths(session.file_ops),
+                next_action: null,
+                evidence_refs: [{ type: 'session', id: session.session_id, label: 'session overview' }],
                 summary_kind: 'session_overview',
                 session_id: session.session_id,
                 started_at: new Date(session.started_at * 1000).toISOString(),
                 ended_at: new Date(session.ended_at * 1000).toISOString(),
-                duration_min: Math.round((session.ended_at - session.started_at) / 60),
+                duration_min: durationMin,
                 turns_user: session.turn_count_user,
                 turns_assistant: session.turn_count_assistant,
                 files_touched: byPath.size,
                 errors: session.errors_count,
                 git_branch: session.git_branch,
-            }, null, 2),
+            }),
             importance: 0.4,
             source: { session_id: session.session_id, kind: 'session_summary' },
         });

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