agent-working-memory 0.3.1 → 0.4.0

package/dist/mcp.js

@@ -52,257 +52,308 @@ import { RetractionEngine } from './engine/retraction.js';
 import { EvalEngine } from './engine/eval.js';
 import { ConsolidationEngine } from './engine/consolidation.js';
 import { ConsolidationScheduler } from './engine/consolidation-scheduler.js';
-import { evaluateSalience } from './core/salience.js';
+import { evaluateSalience, computeNovelty } from './core/salience.js';
 import { DEFAULT_AGENT_CONFIG } from './types/agent.js';
 import { embed } from './core/embeddings.js';
-// --- Setup ---
-const DB_PATH = process.env.AWM_DB_PATH ?? 'memory.db';
-const AGENT_ID = process.env.AWM_AGENT_ID ?? 'claude-code';
-const store = new EngramStore(DB_PATH);
-const activationEngine = new ActivationEngine(store);
-const connectionEngine = new ConnectionEngine(store, activationEngine);
-const stagingBuffer = new StagingBuffer(store, activationEngine);
-const evictionEngine = new EvictionEngine(store);
-const retractionEngine = new RetractionEngine(store);
-const evalEngine = new EvalEngine(store);
-const consolidationEngine = new ConsolidationEngine(store);
-const consolidationScheduler = new ConsolidationScheduler(store, consolidationEngine);
-stagingBuffer.start(DEFAULT_AGENT_CONFIG.stagingTtlMs);
-consolidationScheduler.start();
-const server = new McpServer({
-    name: 'agent-working-memory',
-    version: '0.3.0',
-});
-// --- Tools ---
-server.tool('memory_write', `Store a memory. The salience filter decides whether it's worth keeping (active), needs more evidence (staging), or should be discarded.
+import { startSidecar } from './hooks/sidecar.js';
+import { initLogger, log, getLogPath } from './core/logger.js';
+// --- Incognito Mode ---
+// When AWM_INCOGNITO=1, register zero tools. Claude won't see memory tools at all.
+// No DB, no engines, no sidecar — just a bare MCP server that exposes nothing.
+const INCOGNITO = process.env.AWM_INCOGNITO === '1' || process.env.AWM_INCOGNITO === 'true';
+if (INCOGNITO) {
+    console.error('AWM: incognito mode — all memory tools disabled, nothing will be recorded');
+    const server = new McpServer({ name: 'agent-working-memory', version: '0.4.0' });
+    const transport = new StdioServerTransport();
+    server.connect(transport).catch(err => {
+        console.error('MCP server failed:', err);
+        process.exit(1);
+    });
+    // No tools registered — Claude won't see any memory_* tools
+}
+else {
+    // --- Setup ---
+    const DB_PATH = process.env.AWM_DB_PATH ?? 'memory.db';
+    const AGENT_ID = process.env.AWM_AGENT_ID ?? 'claude-code';
+    const HOOK_PORT = parseInt(process.env.AWM_HOOK_PORT ?? '8401', 10);
+    const HOOK_SECRET = process.env.AWM_HOOK_SECRET ?? null;
+    initLogger(DB_PATH);
+    log(AGENT_ID, 'startup', `MCP server starting (db: ${DB_PATH}, hooks: ${HOOK_PORT})`);
+    const store = new EngramStore(DB_PATH);
+    const activationEngine = new ActivationEngine(store);
+    const connectionEngine = new ConnectionEngine(store, activationEngine);
+    const stagingBuffer = new StagingBuffer(store, activationEngine);
+    const evictionEngine = new EvictionEngine(store);
+    const retractionEngine = new RetractionEngine(store);
+    const evalEngine = new EvalEngine(store);
+    const consolidationEngine = new ConsolidationEngine(store);
+    const consolidationScheduler = new ConsolidationScheduler(store, consolidationEngine);
+    stagingBuffer.start(DEFAULT_AGENT_CONFIG.stagingTtlMs);
+    consolidationScheduler.start();
+    const server = new McpServer({
+        name: 'agent-working-memory',
+        version: '0.4.0',
+    });
+    // --- Tools ---
+    server.tool('memory_write', `Store a memory. The salience filter decides whether it's worth keeping (active), needs more evidence (staging), or should be discarded.
 
-Use this when you learn something that might be useful later:
-- Discoveries about the codebase, bugs, or architecture
-- Decisions you made and why
-- Errors encountered and how they were resolved
-- User preferences or project patterns
+CALL THIS PROACTIVELY — do not wait to be asked. Write memories when you:
+- Discover something about the codebase, bugs, or architecture
+- Make a decision and want to remember why
+- Encounter and resolve an error
+- Learn a user preference or project pattern
+- Complete a significant piece of work
 
 The concept should be a short label (3-8 words). The content should be the full detail.`, {
-    concept: z.string().describe('Short label for this memory (3-8 words)'),
-    content: z.string().describe('Full detail of what was learned'),
-    tags: z.array(z.string()).optional().describe('Optional tags for categorization'),
-    event_type: z.enum(['observation', 'decision', 'friction', 'surprise', 'causal'])
-        .optional().default('observation')
-        .describe('Type of event: observation (default), decision, friction (error/blocker), surprise, causal (root cause)'),
-    surprise: z.number().min(0).max(1).optional().default(0.3)
-        .describe('How surprising was this? 0=expected, 1=very unexpected'),
-    decision_made: z.boolean().optional().default(false)
-        .describe('Was a decision made? True boosts importance'),
-    causal_depth: z.number().min(0).max(1).optional().default(0.3)
-        .describe('How deep is the causal understanding? 0=surface, 1=root cause'),
-    resolution_effort: z.number().min(0).max(1).optional().default(0.3)
-        .describe('How much effort to resolve? 0=trivial, 1=significant debugging'),
-}, async (params) => {
-    const salience = evaluateSalience({
-        content: params.content,
-        eventType: params.event_type,
-        surprise: params.surprise,
-        decisionMade: params.decision_made,
-        causalDepth: params.causal_depth,
-        resolutionEffort: params.resolution_effort,
-    });
-    if (salience.disposition === 'discard') {
+        concept: z.string().describe('Short label for this memory (3-8 words)'),
+        content: z.string().describe('Full detail of what was learned'),
+        tags: z.array(z.string()).optional().describe('Optional tags for categorization'),
+        event_type: z.enum(['observation', 'decision', 'friction', 'surprise', 'causal'])
+            .optional().default('observation')
+            .describe('Type of event: observation (default), decision, friction (error/blocker), surprise, causal (root cause)'),
+        surprise: z.number().min(0).max(1).optional().default(0.3)
+            .describe('How surprising was this? 0=expected, 1=very unexpected'),
+        decision_made: z.boolean().optional().default(false)
+            .describe('Was a decision made? True boosts importance'),
+        causal_depth: z.number().min(0).max(1).optional().default(0.3)
+            .describe('How deep is the causal understanding? 0=surface, 1=root cause'),
+        resolution_effort: z.number().min(0).max(1).optional().default(0.3)
+            .describe('How much effort to resolve? 0=trivial, 1=significant debugging'),
+    }, async (params) => {
+        // Check novelty — is this new information or a duplicate?
+        const novelty = computeNovelty(store, AGENT_ID, params.concept, params.content);
+        const salience = evaluateSalience({
+            content: params.content,
+            eventType: params.event_type,
+            surprise: params.surprise,
+            decisionMade: params.decision_made,
+            causalDepth: params.causal_depth,
+            resolutionEffort: params.resolution_effort,
+            novelty,
+        });
+        if (salience.disposition === 'discard') {
+            log(AGENT_ID, 'write:discard', `"${params.concept}" salience=${salience.score.toFixed(2)} novelty=${novelty.toFixed(1)}`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Memory discarded (salience ${salience.score.toFixed(2)} below threshold, novelty ${novelty.toFixed(1)}). Not worth storing.`,
+                    }],
+            };
+        }
+        const engram = store.createEngram({
+            agentId: AGENT_ID,
+            concept: params.concept,
+            content: params.content,
+            tags: params.tags,
+            salience: salience.score,
+            salienceFeatures: salience.features,
+            reasonCodes: salience.reasonCodes,
+            ttl: salience.disposition === 'staging' ? DEFAULT_AGENT_CONFIG.stagingTtlMs : undefined,
+        });
+        if (salience.disposition === 'staging') {
+            store.updateStage(engram.id, 'staging');
+        }
+        else {
+            connectionEngine.enqueue(engram.id);
+        }
+        // Generate embedding asynchronously (don't block response)
+        embed(`${params.concept} ${params.content}`).then(vec => {
+            store.updateEmbedding(engram.id, vec);
+        }).catch(() => { }); // Embedding failure is non-fatal
+        // Auto-checkpoint: track write
+        try {
+            store.updateAutoCheckpointWrite(AGENT_ID, engram.id);
+        }
+        catch { /* non-fatal */ }
+        log(AGENT_ID, `write:${salience.disposition}`, `"${params.concept}" salience=${salience.score.toFixed(2)} novelty=${novelty.toFixed(1)} id=${engram.id}`);
         return {
             content: [{
                     type: 'text',
-                    text: `Memory discarded (salience ${salience.score.toFixed(2)} below threshold). Not worth storing.`,
+                    text: `Memory stored (${salience.disposition}). ID: ${engram.id}\nConcept: ${params.concept}\nSalience: ${salience.score.toFixed(2)}`,
                 }],
         };
-    }
-    const engram = store.createEngram({
-        agentId: AGENT_ID,
-        concept: params.concept,
-        content: params.content,
-        tags: params.tags,
-        salience: salience.score,
-        salienceFeatures: salience.features,
-        reasonCodes: salience.reasonCodes,
-        ttl: salience.disposition === 'staging' ? DEFAULT_AGENT_CONFIG.stagingTtlMs : undefined,
     });
-    if (salience.disposition === 'staging') {
-        store.updateStage(engram.id, 'staging');
-    }
-    else {
-        connectionEngine.enqueue(engram.id);
-    }
-    // Generate embedding asynchronously (don't block response)
-    embed(`${params.concept} ${params.content}`).then(vec => {
-        store.updateEmbedding(engram.id, vec);
-    }).catch(() => { }); // Embedding failure is non-fatal
-    // Auto-checkpoint: track write
-    try {
-        store.updateAutoCheckpointWrite(AGENT_ID, engram.id);
-    }
-    catch { /* non-fatal */ }
-    return {
-        content: [{
-                type: 'text',
-                text: `Memory stored (${salience.disposition}). ID: ${engram.id}\nConcept: ${params.concept}\nSalience: ${salience.score.toFixed(2)}`,
-            }],
-    };
-});
-server.tool('memory_recall', `Recall memories relevant to a context. Uses cognitive activation — not keyword search.
+    server.tool('memory_recall', `Recall memories relevant to a query. Uses cognitive activation — not keyword search.
 
-Use this when you need to remember something:
-- Starting a new task (recall relevant past experience)
+ALWAYS call this when:
+- Starting work on a project or topic (recall what you know)
 - Debugging (recall similar errors and solutions)
 - Making decisions (recall past decisions and outcomes)
+- The user mentions a topic you might have stored memories about
 
-Returns the most relevant memories ranked by a composite score of text relevance, temporal recency, and associative strength.`, {
-    context: z.string().describe('What are you thinking about? Describe the current situation or question'),
-    limit: z.number().optional().default(5).describe('Max memories to return (default 5)'),
-    min_score: z.number().optional().default(0.05).describe('Minimum relevance score (default 0.05)'),
-    include_staging: z.boolean().optional().default(false).describe('Include weak/unconfirmed memories?'),
-    use_reranker: z.boolean().optional().default(true).describe('Use cross-encoder re-ranking for better relevance (default true)'),
-    use_expansion: z.boolean().optional().default(true).describe('Expand query with synonyms for better recall (default true)'),
-}, async (params) => {
-    const results = await activationEngine.activate({
-        agentId: AGENT_ID,
-        context: params.context,
-        limit: params.limit,
-        minScore: params.min_score,
-        includeStaging: params.include_staging,
-        useReranker: params.use_reranker,
-        useExpansion: params.use_expansion,
-    });
-    // Auto-checkpoint: track recall
-    try {
-        const ids = results.map(r => r.engram.id);
-        store.updateAutoCheckpointRecall(AGENT_ID, params.context, ids);
-    }
-    catch { /* non-fatal */ }
-    if (results.length === 0) {
+Accepts either "query" or "context" parameter — both work identically.
+Returns the most relevant memories ranked by text relevance, temporal recency, and associative strength.`, {
+        query: z.string().optional().describe('What to search for — describe the situation, question, or topic'),
+        context: z.string().optional().describe('Alias for query (either works)'),
+        limit: z.number().optional().default(5).describe('Max memories to return (default 5)'),
+        min_score: z.number().optional().default(0.05).describe('Minimum relevance score (default 0.05)'),
+        include_staging: z.boolean().optional().default(false).describe('Include weak/unconfirmed memories?'),
+        use_reranker: z.boolean().optional().default(true).describe('Use cross-encoder re-ranking for better relevance (default true)'),
+        use_expansion: z.boolean().optional().default(true).describe('Expand query with synonyms for better recall (default true)'),
+    }, async (params) => {
+        const queryText = params.query ?? params.context;
+        if (!queryText) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'Error: provide either "query" or "context" parameter with your search text.',
+                    }],
+            };
+        }
+        const results = await activationEngine.activate({
+            agentId: AGENT_ID,
+            context: queryText,
+            limit: params.limit,
+            minScore: params.min_score,
+            includeStaging: params.include_staging,
+            useReranker: params.use_reranker,
+            useExpansion: params.use_expansion,
+        });
+        // Auto-checkpoint: track recall
+        try {
+            const ids = results.map(r => r.engram.id);
+            store.updateAutoCheckpointRecall(AGENT_ID, queryText, ids);
+        }
+        catch { /* non-fatal */ }
+        log(AGENT_ID, 'recall', `"${queryText.slice(0, 80)}" → ${results.length} results`);
+        if (results.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No relevant memories found.',
+                    }],
+            };
+        }
+        const lines = results.map((r, i) => {
+            const tags = r.engram.tags?.length ? ` [${r.engram.tags.join(', ')}]` : '';
+            return `${i + 1}. **${r.engram.concept}** (score: ${r.score.toFixed(3)})${tags}\n   ${r.engram.content}\n   _${r.why}_\n   ID: ${r.engram.id}`;
+        });
         return {
             content: [{
                     type: 'text',
-                    text: 'No relevant memories found.',
+                    text: `Recalled ${results.length} memories:\n\n${lines.join('\n\n')}`,
                 }],
         };
-    }
-    const lines = results.map((r, i) => {
-        const tags = r.engram.tags?.length ? ` [${r.engram.tags.join(', ')}]` : '';
-        return `${i + 1}. **${r.engram.concept}** (score: ${r.score.toFixed(3)})${tags}\n   ${r.engram.content}\n   _${r.why}_\n   ID: ${r.engram.id}`;
     });
-    return {
-        content: [{
-                type: 'text',
-                text: `Recalled ${results.length} memories:\n\n${lines.join('\n\n')}`,
-            }],
-    };
-});
-server.tool('memory_feedback', `Report whether a recalled memory was actually useful. This updates the memory's confidence score — useful memories become stronger, useless ones weaken.
+    server.tool('memory_feedback', `Report whether a recalled memory was actually useful. This updates the memory's confidence score — useful memories become stronger, useless ones weaken.
 
 Always call this after using a recalled memory so the system learns what's valuable.`, {
-    engram_id: z.string().describe('ID of the memory (from memory_recall results)'),
-    useful: z.boolean().describe('Was this memory actually helpful?'),
-    context: z.string().optional().describe('Brief note on why it was/wasn\'t useful'),
-}, async (params) => {
-    store.logRetrievalFeedback(null, params.engram_id, params.useful, params.context ?? '');
-    const engram = store.getEngram(params.engram_id);
-    if (engram) {
-        const delta = params.useful
-            ? DEFAULT_AGENT_CONFIG.feedbackPositiveBoost
-            : -DEFAULT_AGENT_CONFIG.feedbackNegativePenalty;
-        store.updateConfidence(engram.id, engram.confidence + delta);
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: `Feedback recorded: ${params.useful ? 'useful' : 'not useful'}. Confidence ${params.useful ? 'increased' : 'decreased'}.`,
-            }],
-    };
-});
-server.tool('memory_retract', `Retract a memory that turned out to be wrong. Creates a correction and reduces confidence of related memories.
+        engram_id: z.string().describe('ID of the memory (from memory_recall results)'),
+        useful: z.boolean().describe('Was this memory actually helpful?'),
+        context: z.string().optional().describe('Brief note on why it was/wasn\'t useful'),
+    }, async (params) => {
+        store.logRetrievalFeedback(null, params.engram_id, params.useful, params.context ?? '');
+        const engram = store.getEngram(params.engram_id);
+        if (engram) {
+            const delta = params.useful
+                ? DEFAULT_AGENT_CONFIG.feedbackPositiveBoost
+                : -DEFAULT_AGENT_CONFIG.feedbackNegativePenalty;
+            store.updateConfidence(engram.id, engram.confidence + delta);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Feedback recorded: ${params.useful ? 'useful' : 'not useful'}. Confidence ${params.useful ? 'increased' : 'decreased'}.`,
+                }],
+        };
+    });
+    server.tool('memory_retract', `Retract a memory that turned out to be wrong. Creates a correction and reduces confidence of related memories.
 
 Use this when you discover a memory contains incorrect information.`, {
-    engram_id: z.string().describe('ID of the wrong memory'),
-    reason: z.string().describe('Why is this memory wrong?'),
-    correction: z.string().optional().describe('What is the correct information? (creates a new memory)'),
-}, async (params) => {
-    const result = retractionEngine.retract({
-        agentId: AGENT_ID,
-        targetEngramId: params.engram_id,
-        reason: params.reason,
-        counterContent: params.correction,
+        engram_id: z.string().describe('ID of the wrong memory'),
+        reason: z.string().describe('Why is this memory wrong?'),
+        correction: z.string().optional().describe('What is the correct information? (creates a new memory)'),
+    }, async (params) => {
+        const result = retractionEngine.retract({
+            agentId: AGENT_ID,
+            targetEngramId: params.engram_id,
+            reason: params.reason,
+            counterContent: params.correction,
+        });
+        const parts = [`Memory ${params.engram_id} retracted.`];
+        if (result.correctionId) {
+            parts.push(`Correction stored as ${result.correctionId}.`);
+        }
+        parts.push(`${result.associatesAffected} related memories had confidence reduced.`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: parts.join(' '),
+                }],
+        };
     });
-    const parts = [`Memory ${params.engram_id} retracted.`];
-    if (result.correctionId) {
-        parts.push(`Correction stored as ${result.correctionId}.`);
-    }
-    parts.push(`${result.associatesAffected} related memories had confidence reduced.`);
-    return {
-        content: [{
-                type: 'text',
-                text: parts.join(' '),
-            }],
-    };
-});
-server.tool('memory_stats', `Get memory health stats — how many memories, confidence levels, association count, and system performance.`, {}, async () => {
-    const metrics = evalEngine.computeMetrics(AGENT_ID);
-    const lines = [
-        `Agent: ${AGENT_ID}`,
-        `Active memories: ${metrics.activeEngramCount}`,
-        `Staging: ${metrics.stagingEngramCount}`,
-        `Retracted: ${metrics.retractedCount}`,
-        `Avg confidence: ${metrics.avgConfidence.toFixed(3)}`,
-        `Total edges: ${metrics.totalEdges}`,
-        `Edge utility: ${(metrics.edgeUtilityRate * 100).toFixed(1)}%`,
-        `Activations (24h): ${metrics.activationCount}`,
-        `Avg latency: ${metrics.avgLatencyMs.toFixed(1)}ms`,
-    ];
-    return {
-        content: [{
-                type: 'text',
-                text: lines.join('\n'),
-            }],
-    };
-});
-// --- Checkpointing Tools ---
-server.tool('memory_checkpoint', `Save your current execution state so you can recover after context compaction.
+    server.tool('memory_stats', `Get memory health stats — how many memories, confidence levels, association count, and system performance.
+Also shows the activity log path so the user can tail it to see what's happening.`, {}, async () => {
+        const metrics = evalEngine.computeMetrics(AGENT_ID);
+        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const lines = [
+            `Agent: ${AGENT_ID}`,
+            `Active memories: ${metrics.activeEngramCount}`,
+            `Staging: ${metrics.stagingEngramCount}`,
+            `Retracted: ${metrics.retractedCount}`,
+            `Avg confidence: ${metrics.avgConfidence.toFixed(3)}`,
+            `Total edges: ${metrics.totalEdges}`,
+            `Edge utility: ${(metrics.edgeUtilityRate * 100).toFixed(1)}%`,
+            `Activations (24h): ${metrics.activationCount}`,
+            `Avg latency: ${metrics.avgLatencyMs.toFixed(1)}ms`,
+            ``,
+            `Session writes: ${checkpoint?.auto.writeCountSinceConsolidation ?? 0}`,
+            `Session recalls: ${checkpoint?.auto.recallCountSinceConsolidation ?? 0}`,
+            `Last activity: ${checkpoint?.auto.lastActivityAt?.toISOString() ?? 'never'}`,
+            `Checkpoint: ${checkpoint?.executionState ? checkpoint.executionState.currentTask : 'none'}`,
+            ``,
+            `Activity log: ${getLogPath() ?? 'not configured'}`,
+            `Hook sidecar: 127.0.0.1:${HOOK_PORT}`,
+        ];
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n'),
+                }],
+        };
+    });
+    // --- Checkpointing Tools ---
+    server.tool('memory_checkpoint', `Save your current execution state so you can recover after context compaction.
 
-Use this when:
-- You're about to do something that might fill the context window
-- You've made important decisions you don't want to lose
-- You want to preserve your working state before a long operation
+ALWAYS call this before:
+- Long operations (multi-file generation, large refactors, overnight work)
+- Anything that might fill the context window
+- Switching to a different task
 
-The state is saved per-agent and overwrites any previous checkpoint.`, {
-    current_task: z.string().describe('What you are currently working on'),
-    decisions: z.array(z.string()).optional().default([])
-        .describe('Key decisions made so far'),
-    active_files: z.array(z.string()).optional().default([])
-        .describe('Files you are currently working with'),
-    next_steps: z.array(z.string()).optional().default([])
-        .describe('What needs to happen next'),
-    related_memory_ids: z.array(z.string()).optional().default([])
-        .describe('IDs of memories relevant to current work'),
-    notes: z.string().optional().default('')
-        .describe('Any other context worth preserving'),
-    episode_id: z.string().optional()
-        .describe('Current episode ID if known'),
-}, async (params) => {
-    const state = {
-        currentTask: params.current_task,
-        decisions: params.decisions,
-        activeFiles: params.active_files,
-        nextSteps: params.next_steps,
-        relatedMemoryIds: params.related_memory_ids,
-        notes: params.notes,
-        episodeId: params.episode_id ?? null,
-    };
-    store.saveCheckpoint(AGENT_ID, state);
-    return {
-        content: [{
-                type: 'text',
-                text: `Checkpoint saved.\nTask: ${params.current_task}\nDecisions: ${params.decisions.length}\nNext steps: ${params.next_steps.length}\nFiles: ${params.active_files.length}`,
-            }],
-    };
-});
-server.tool('memory_restore', `Restore your previous execution state after context compaction or at session start.
+Also call periodically during long sessions to avoid losing state. The state is saved per-agent and overwrites any previous checkpoint.`, {
+        current_task: z.string().describe('What you are currently working on'),
+        decisions: z.array(z.string()).optional().default([])
+            .describe('Key decisions made so far'),
+        active_files: z.array(z.string()).optional().default([])
+            .describe('Files you are currently working with'),
+        next_steps: z.array(z.string()).optional().default([])
+            .describe('What needs to happen next'),
+        related_memory_ids: z.array(z.string()).optional().default([])
+            .describe('IDs of memories relevant to current work'),
+        notes: z.string().optional().default('')
+            .describe('Any other context worth preserving'),
+        episode_id: z.string().optional()
+            .describe('Current episode ID if known'),
+    }, async (params) => {
+        const state = {
+            currentTask: params.current_task,
+            decisions: params.decisions,
+            activeFiles: params.active_files,
+            nextSteps: params.next_steps,
+            relatedMemoryIds: params.related_memory_ids,
+            notes: params.notes,
+            episodeId: params.episode_id ?? null,
+        };
+        store.saveCheckpoint(AGENT_ID, state);
+        log(AGENT_ID, 'checkpoint', `"${params.current_task}" decisions=${params.decisions.length} files=${params.active_files.length}`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Checkpoint saved.\nTask: ${params.current_task}\nDecisions: ${params.decisions.length}\nNext steps: ${params.next_steps.length}\nFiles: ${params.active_files.length}`,
+                }],
+        };
+    });
+    server.tool('memory_restore', `Restore your previous execution state after context compaction or at session start.
 
 Returns:
 - Your saved execution state (task, decisions, next steps, files)
@@ -311,89 +362,116 @@ Returns:
 - How long you were idle
 
 Use this at the start of every session or after compaction to pick up where you left off.`, {}, async () => {
-    const checkpoint = store.getCheckpoint(AGENT_ID);
-    const now = Date.now();
-    const idleMs = checkpoint
-        ? now - checkpoint.auto.lastActivityAt.getTime()
-        : 0;
-    // Get last written engram
-    let lastWrite = null;
-    if (checkpoint?.auto.lastWriteId) {
-        const engram = store.getEngram(checkpoint.auto.lastWriteId);
-        if (engram) {
-            lastWrite = { id: engram.id, concept: engram.concept, content: engram.content };
+        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const now = Date.now();
+        const idleMs = checkpoint
+            ? now - checkpoint.auto.lastActivityAt.getTime()
+            : 0;
+        // Get last written engram
+        let lastWrite = null;
+        if (checkpoint?.auto.lastWriteId) {
+            const engram = store.getEngram(checkpoint.auto.lastWriteId);
+            if (engram) {
+                lastWrite = { id: engram.id, concept: engram.concept, content: engram.content };
+            }
         }
-    }
-    // Recall memories using last context
-    let recalledMemories = [];
-    const recallContext = checkpoint?.auto.lastRecallContext
-        ?? checkpoint?.executionState?.currentTask
-        ?? null;
-    if (recallContext) {
-        try {
-            const results = await activationEngine.activate({
-                agentId: AGENT_ID,
-                context: recallContext,
-                limit: 5,
-                minScore: 0.05,
-                useReranker: true,
-                useExpansion: true,
-            });
-            recalledMemories = results.map(r => ({
-                id: r.engram.id,
-                concept: r.engram.concept,
-                content: r.engram.content,
-                score: r.score,
-            }));
+        // Recall memories using last context
+        let recalledMemories = [];
+        const recallContext = checkpoint?.auto.lastRecallContext
+            ?? checkpoint?.executionState?.currentTask
+            ?? null;
+        if (recallContext) {
+            try {
+                const results = await activationEngine.activate({
+                    agentId: AGENT_ID,
+                    context: recallContext,
+                    limit: 5,
+                    minScore: 0.05,
+                    useReranker: true,
+                    useExpansion: true,
+                });
+                recalledMemories = results.map(r => ({
+                    id: r.engram.id,
+                    concept: r.engram.concept,
+                    content: r.engram.content,
+                    score: r.score,
+                }));
+            }
+            catch { /* recall failure is non-fatal */ }
         }
-        catch { /* recall failure is non-fatal */ }
-    }
-    // Trigger mini-consolidation if idle >5min
-    const MINI_IDLE_MS = 5 * 60_000;
-    let miniConsolidationTriggered = false;
-    if (idleMs > MINI_IDLE_MS) {
-        miniConsolidationTriggered = true;
-        consolidationScheduler.runMiniConsolidation(AGENT_ID).catch(() => { });
-    }
-    // Format response
-    const parts = [];
-    const idleMin = Math.round(idleMs / 60_000);
-    parts.push(`Idle: ${idleMin}min${miniConsolidationTriggered ? ' (mini-consolidation triggered)' : ''}`);
-    if (checkpoint?.executionState) {
-        const s = checkpoint.executionState;
-        parts.push(`\n**Current task:** ${s.currentTask}`);
-        if (s.decisions.length)
-            parts.push(`**Decisions:** ${s.decisions.join('; ')}`);
-        if (s.nextSteps.length)
-            parts.push(`**Next steps:** ${s.nextSteps.map((st, i) => `${i + 1}. ${st}`).join(', ')}`);
-        if (s.activeFiles.length)
-            parts.push(`**Active files:** ${s.activeFiles.join(', ')}`);
-        if (s.notes)
-            parts.push(`**Notes:** ${s.notes}`);
-        if (checkpoint.checkpointAt)
-            parts.push(`_Saved at: ${checkpoint.checkpointAt.toISOString()}_`);
-    }
-    else {
-        parts.push('\nNo explicit checkpoint saved.');
-    }
-    if (lastWrite) {
-        parts.push(`\n**Last write:** ${lastWrite.concept}\n${lastWrite.content}`);
-    }
-    if (recalledMemories.length > 0) {
-        parts.push(`\n**Recalled memories (${recalledMemories.length}):**`);
-        for (const m of recalledMemories) {
-            parts.push(`- **${m.concept}** (${m.score.toFixed(3)}): ${m.content.slice(0, 150)}${m.content.length > 150 ? '...' : ''}`);
+        // Consolidation on restore:
+        // - If idle >5min but last consolidation was recent (graceful exit ran it), skip
+        // - If idle >5min and no recent consolidation, run full cycle (non-graceful exit fallback)
+        const MINI_IDLE_MS = 5 * 60_000;
+        const FULL_CONSOLIDATION_GAP_MS = 10 * 60_000; // 10 min — if last consolidation was longer ago, run full
+        let miniConsolidationTriggered = false;
+        let fullConsolidationTriggered = false;
+        if (idleMs > MINI_IDLE_MS) {
+            const sinceLastConsolidation = checkpoint?.lastConsolidationAt
+                ? now - checkpoint.lastConsolidationAt.getTime()
+                : Infinity;
+            if (sinceLastConsolidation > FULL_CONSOLIDATION_GAP_MS) {
+                // No recent consolidation — graceful exit didn't happen, run full cycle
+                fullConsolidationTriggered = true;
+                try {
+                    const result = consolidationEngine.consolidate(AGENT_ID);
+                    store.markConsolidation(AGENT_ID, false);
+                    log(AGENT_ID, 'consolidation', `full sleep cycle on restore (no graceful exit, idle ${Math.round(idleMs / 60_000)}min, last consolidation ${Math.round(sinceLastConsolidation / 60_000)}min ago) — ${result.edgesStrengthened} strengthened, ${result.memoriesForgotten} forgotten`);
+                }
+                catch { /* consolidation failure is non-fatal */ }
+            }
+            else {
+                // Recent consolidation exists — graceful exit already handled it, just do mini
+                miniConsolidationTriggered = true;
+                consolidationScheduler.runMiniConsolidation(AGENT_ID).catch(() => { });
+            }
         }
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: parts.join('\n'),
-            }],
-    };
-});
-// --- Task Management Tools ---
-server.tool('memory_task_add', `Create a task that you need to come back to. Tasks are memories with status and priority tracking.
+        // Format response
+        const parts = [];
+        const idleMin = Math.round(idleMs / 60_000);
+        const consolidationNote = fullConsolidationTriggered
+            ? ' (full consolidation — no graceful exit detected)'
+            : miniConsolidationTriggered
+                ? ' (mini-consolidation triggered)'
+                : '';
+        log(AGENT_ID, 'restore', `idle=${idleMin}min checkpoint=${!!checkpoint?.executionState} recalled=${recalledMemories.length} lastWrite=${lastWrite?.concept ?? 'none'}${fullConsolidationTriggered ? ' FULL_CONSOLIDATION' : ''}`);
+        parts.push(`Idle: ${idleMin}min${consolidationNote}`);
+        if (checkpoint?.executionState) {
+            const s = checkpoint.executionState;
+            parts.push(`\n**Current task:** ${s.currentTask}`);
+            if (s.decisions.length)
+                parts.push(`**Decisions:** ${s.decisions.join('; ')}`);
+            if (s.nextSteps.length)
+                parts.push(`**Next steps:** ${s.nextSteps.map((st, i) => `${i + 1}. ${st}`).join(', ')}`);
+            if (s.activeFiles.length)
+                parts.push(`**Active files:** ${s.activeFiles.join(', ')}`);
+            if (s.notes)
+                parts.push(`**Notes:** ${s.notes}`);
+            if (checkpoint.checkpointAt)
+                parts.push(`_Saved at: ${checkpoint.checkpointAt.toISOString()}_`);
+        }
+        else {
+            parts.push('\nNo explicit checkpoint saved.');
+            parts.push('\n**Tip:** Use memory_write to save important learnings, and memory_checkpoint before long operations so you can recover state.');
+        }
+        if (lastWrite) {
+            parts.push(`\n**Last write:** ${lastWrite.concept}\n${lastWrite.content}`);
+        }
+        if (recalledMemories.length > 0) {
+            parts.push(`\n**Recalled memories (${recalledMemories.length}):**`);
+            for (const m of recalledMemories) {
+                parts.push(`- **${m.concept}** (${m.score.toFixed(3)}): ${m.content.slice(0, 150)}${m.content.length > 150 ? '...' : ''}`);
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: parts.join('\n'),
+                }],
+        };
+    });
+    // --- Task Management Tools ---
+    server.tool('memory_task_add', `Create a task that you need to come back to. Tasks are memories with status and priority tracking.
 
 Use this when:
 - You identify work that needs doing but can't do it right now
@@ -401,132 +479,269 @@ Use this when:
 - You want to park a sub-task while focusing on something more urgent
 
 Tasks automatically get high salience so they won't be discarded.`, {
-    concept: z.string().describe('Short task title (3-10 words)'),
-    content: z.string().describe('Full task description — what needs doing, context, acceptance criteria'),
-    tags: z.array(z.string()).optional().describe('Tags for categorization'),
-    priority: z.enum(['urgent', 'high', 'medium', 'low']).default('medium')
-        .describe('Task priority: urgent (do now), high (do soon), medium (normal), low (backlog)'),
-    blocked_by: z.string().optional().describe('ID of a task that must finish first'),
-}, async (params) => {
-    const engram = store.createEngram({
-        agentId: AGENT_ID,
-        concept: params.concept,
-        content: params.content,
-        tags: [...(params.tags ?? []), 'task'],
-        salience: 0.9, // Tasks always high salience
-        confidence: 0.8,
-        salienceFeatures: {
-            surprise: 0.5,
-            decisionMade: true,
-            causalDepth: 0.5,
-            resolutionEffort: 0.5,
-            eventType: 'decision',
-        },
-        reasonCodes: ['task-created'],
-        taskStatus: params.blocked_by ? 'blocked' : 'open',
-        taskPriority: params.priority,
-        blockedBy: params.blocked_by,
+        concept: z.string().describe('Short task title (3-10 words)'),
+        content: z.string().describe('Full task description — what needs doing, context, acceptance criteria'),
+        tags: z.array(z.string()).optional().describe('Tags for categorization'),
+        priority: z.enum(['urgent', 'high', 'medium', 'low']).default('medium')
+            .describe('Task priority: urgent (do now), high (do soon), medium (normal), low (backlog)'),
+        blocked_by: z.string().optional().describe('ID of a task that must finish first'),
+    }, async (params) => {
+        const engram = store.createEngram({
+            agentId: AGENT_ID,
+            concept: params.concept,
+            content: params.content,
+            tags: [...(params.tags ?? []), 'task'],
+            salience: 0.9, // Tasks always high salience
+            confidence: 0.8,
+            salienceFeatures: {
+                surprise: 0.5,
+                decisionMade: true,
+                causalDepth: 0.5,
+                resolutionEffort: 0.5,
+                eventType: 'decision',
+            },
+            reasonCodes: ['task-created'],
+            taskStatus: params.blocked_by ? 'blocked' : 'open',
+            taskPriority: params.priority,
+            blockedBy: params.blocked_by,
+        });
+        connectionEngine.enqueue(engram.id);
+        // Generate embedding asynchronously
+        embed(`${params.concept} ${params.content}`).then(vec => {
+            store.updateEmbedding(engram.id, vec);
+        }).catch(() => { });
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Task created: ${engram.id}\nTitle: ${params.concept}\nPriority: ${params.priority}\nStatus: ${engram.taskStatus}`,
+                }],
+        };
     });
-    connectionEngine.enqueue(engram.id);
-    // Generate embedding asynchronously
-    embed(`${params.concept} ${params.content}`).then(vec => {
-        store.updateEmbedding(engram.id, vec);
-    }).catch(() => { });
-    return {
-        content: [{
-                type: 'text',
-                text: `Task created: ${engram.id}\nTitle: ${params.concept}\nPriority: ${params.priority}\nStatus: ${engram.taskStatus}`,
-            }],
-    };
-});
-server.tool('memory_task_update', `Update a task's status or priority. Use this to:
+    server.tool('memory_task_update', `Update a task's status or priority. Use this to:
 - Start working on a task (open → in_progress)
 - Mark a task done (→ done)
 - Block a task on another (→ blocked)
 - Reprioritize (change priority)
 - Unblock a task (clear blocked_by)`, {
-    task_id: z.string().describe('ID of the task to update'),
-    status: z.enum(['open', 'in_progress', 'blocked', 'done']).optional()
-        .describe('New status'),
-    priority: z.enum(['urgent', 'high', 'medium', 'low']).optional()
-        .describe('New priority'),
-    blocked_by: z.string().optional().describe('ID of blocking task (set to empty string to unblock)'),
-}, async (params) => {
-    const engram = store.getEngram(params.task_id);
-    if (!engram || !engram.taskStatus) {
-        return { content: [{ type: 'text', text: `Task not found: ${params.task_id}` }] };
-    }
-    if (params.blocked_by !== undefined) {
-        store.updateBlockedBy(params.task_id, params.blocked_by || null);
-    }
-    if (params.status) {
-        store.updateTaskStatus(params.task_id, params.status);
-    }
-    if (params.priority) {
-        store.updateTaskPriority(params.task_id, params.priority);
-    }
-    const updated = store.getEngram(params.task_id);
-    return {
-        content: [{
-                type: 'text',
-                text: `Task updated: ${updated.concept}\nStatus: ${updated.taskStatus}\nPriority: ${updated.taskPriority}${updated.blockedBy ? `\nBlocked by: ${updated.blockedBy}` : ''}`,
-            }],
-    };
-});
-server.tool('memory_task_list', `List tasks with optional status filter. Shows tasks ordered by priority (urgent first).
+        task_id: z.string().describe('ID of the task to update'),
+        status: z.enum(['open', 'in_progress', 'blocked', 'done']).optional()
+            .describe('New status'),
+        priority: z.enum(['urgent', 'high', 'medium', 'low']).optional()
+            .describe('New priority'),
+        blocked_by: z.string().optional().describe('ID of blocking task (set to empty string to unblock)'),
+    }, async (params) => {
+        const engram = store.getEngram(params.task_id);
+        if (!engram || !engram.taskStatus) {
+            return { content: [{ type: 'text', text: `Task not found: ${params.task_id}` }] };
+        }
+        if (params.blocked_by !== undefined) {
+            store.updateBlockedBy(params.task_id, params.blocked_by || null);
+        }
+        if (params.status) {
+            store.updateTaskStatus(params.task_id, params.status);
+        }
+        if (params.priority) {
+            store.updateTaskPriority(params.task_id, params.priority);
+        }
+        const updated = store.getEngram(params.task_id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Task updated: ${updated.concept}\nStatus: ${updated.taskStatus}\nPriority: ${updated.taskPriority}${updated.blockedBy ? `\nBlocked by: ${updated.blockedBy}` : ''}`,
+                }],
+        };
+    });
+    server.tool('memory_task_list', `List tasks with optional status filter. Shows tasks ordered by priority (urgent first).
 
 Use at the start of a session to see what's pending, or to check blocked/done tasks.`, {
-    status: z.enum(['open', 'in_progress', 'blocked', 'done']).optional()
-        .describe('Filter by status (omit to see all active tasks)'),
-    include_done: z.boolean().optional().default(false)
-        .describe('Include completed tasks?'),
-}, async (params) => {
-    let tasks = store.getTasks(AGENT_ID, params.status);
-    if (!params.include_done && !params.status) {
-        tasks = tasks.filter(t => t.taskStatus !== 'done');
-    }
-    if (tasks.length === 0) {
-        return { content: [{ type: 'text', text: 'No tasks found.' }] };
-    }
-    const lines = tasks.map((t, i) => {
-        const blocked = t.blockedBy ? ` [blocked by ${t.blockedBy}]` : '';
-        const tags = t.tags?.filter(tag => tag !== 'task').join(', ');
-        return `${i + 1}. [${t.taskStatus}] **${t.concept}** (${t.taskPriority})${blocked}\n   ${t.content.slice(0, 120)}${t.content.length > 120 ? '...' : ''}\n   ${tags ? `Tags: ${tags} | ` : ''}ID: ${t.id}`;
+        status: z.enum(['open', 'in_progress', 'blocked', 'done']).optional()
+            .describe('Filter by status (omit to see all active tasks)'),
+        include_done: z.boolean().optional().default(false)
+            .describe('Include completed tasks?'),
+    }, async (params) => {
+        let tasks = store.getTasks(AGENT_ID, params.status);
+        if (!params.include_done && !params.status) {
+            tasks = tasks.filter(t => t.taskStatus !== 'done');
+        }
+        if (tasks.length === 0) {
+            return { content: [{ type: 'text', text: 'No tasks found.' }] };
+        }
+        const lines = tasks.map((t, i) => {
+            const blocked = t.blockedBy ? ` [blocked by ${t.blockedBy}]` : '';
+            const tags = t.tags?.filter(tag => tag !== 'task').join(', ');
+            return `${i + 1}. [${t.taskStatus}] **${t.concept}** (${t.taskPriority})${blocked}\n   ${t.content.slice(0, 120)}${t.content.length > 120 ? '...' : ''}\n   ${tags ? `Tags: ${tags} | ` : ''}ID: ${t.id}`;
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Tasks (${tasks.length}):\n\n${lines.join('\n\n')}`,
+                }],
+        };
     });
-    return {
-        content: [{
-                type: 'text',
-                text: `Tasks (${tasks.length}):\n\n${lines.join('\n\n')}`,
-            }],
-    };
-});
-server.tool('memory_task_next', `Get the single most important task to work on next.
+    server.tool('memory_task_next', `Get the single most important task to work on next.
 
 Prioritizes: in_progress tasks first (finish what you started), then by priority level, then oldest first. Skips blocked and done tasks.
 
 Use this when you finish a task or need to decide what to do next.`, {}, async () => {
-    const next = store.getNextTask(AGENT_ID);
-    if (!next) {
-        return { content: [{ type: 'text', text: 'No actionable tasks. All clear!' }] };
+        const next = store.getNextTask(AGENT_ID);
+        if (!next) {
+            return { content: [{ type: 'text', text: 'No actionable tasks. All clear!' }] };
+        }
+        const blocked = next.blockedBy ? `\nBlocked by: ${next.blockedBy}` : '';
+        const tags = next.tags?.filter(tag => tag !== 'task').join(', ');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Next task:\n**${next.concept}** (${next.taskPriority})\nStatus: ${next.taskStatus}\n${next.content}${blocked}\n${tags ? `Tags: ${tags}\n` : ''}ID: ${next.id}`,
+                }],
+        };
+    });
+    // --- Task Bracket Tools ---
+    server.tool('memory_task_begin', `Signal that you're starting a significant task. Auto-checkpoints current state and recalls relevant memories.
+
+CALL THIS when starting:
+- A multi-step operation (doc generation, large refactor, migration)
+- Work on a new topic or project area
+- Anything that might fill the context window
+
+This ensures your state is saved before you start, and primes recall with relevant context.`, {
+        topic: z.string().describe('What task are you starting? (3-15 words)'),
+        files: z.array(z.string()).optional().default([])
+            .describe('Files you expect to work with'),
+        notes: z.string().optional().default('')
+            .describe('Any additional context'),
+    }, async (params) => {
+        // 1. Checkpoint current state
+        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const prevTask = checkpoint?.executionState?.currentTask ?? 'None';
+        store.saveCheckpoint(AGENT_ID, {
+            currentTask: params.topic,
+            decisions: [],
+            activeFiles: params.files,
+            nextSteps: [],
+            relatedMemoryIds: [],
+            notes: params.notes || `Started via memory_task_begin. Previous task: ${prevTask}`,
+            episodeId: null,
+        });
+        // 2. Auto-recall relevant memories
+        let recalledSummary = '';
+        try {
+            const results = await activationEngine.activate({
+                agentId: AGENT_ID,
+                context: params.topic,
+                limit: 5,
+                minScore: 0.05,
+                useReranker: true,
+                useExpansion: true,
+            });
+            if (results.length > 0) {
+                const lines = results.map((r, i) => {
+                    const tags = r.engram.tags?.length ? ` [${r.engram.tags.join(', ')}]` : '';
+                    return `${i + 1}. **${r.engram.concept}** (${r.score.toFixed(3)})${tags}\n   ${r.engram.content.slice(0, 150)}${r.engram.content.length > 150 ? '...' : ''}`;
+                });
+                recalledSummary = `\n\n**Recalled memories (${results.length}):**\n${lines.join('\n')}`;
+                // Track recall
+                store.updateAutoCheckpointRecall(AGENT_ID, params.topic, results.map(r => r.engram.id));
+            }
+        }
+        catch { /* recall failure is non-fatal */ }
+        log(AGENT_ID, 'task:begin', `"${params.topic}" prev="${prevTask}"`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Task started: ${params.topic}\nCheckpoint saved (previous: ${prevTask}).${params.files.length ? `\nFiles: ${params.files.join(', ')}` : ''}${recalledSummary}`,
+                }],
+        };
+    });
+    server.tool('memory_task_end', `Signal that you've finished a significant task. Writes a summary memory and auto-checkpoints.
+
+CALL THIS when you finish:
+- A multi-step operation
+- Before switching to a different topic
+- At the end of a work session
+
+This captures what was accomplished so future sessions can recall it.`, {
+        summary: z.string().describe('What was accomplished? Include key outcomes, decisions, and any issues.'),
+        tags: z.array(z.string()).optional().default([])
+            .describe('Tags for the summary memory'),
+    }, async (params) => {
+        // 1. Write summary as a memory
+        const salience = evaluateSalience({
+            content: params.summary,
+            eventType: 'decision',
+            surprise: 0.3,
+            decisionMade: true,
+            causalDepth: 0.5,
+            resolutionEffort: 0.5,
+        });
+        const engram = store.createEngram({
+            agentId: AGENT_ID,
+            concept: 'Task completed',
+            content: params.summary,
+            tags: [...params.tags, 'task-summary'],
+            salience: Math.max(salience.score, 0.7), // Always high salience for task summaries
+            salienceFeatures: salience.features,
+            reasonCodes: [...salience.reasonCodes, 'task-end'],
+        });
+        connectionEngine.enqueue(engram.id);
+        // Generate embedding asynchronously
+        embed(`Task completed: ${params.summary}`).then(vec => {
+            store.updateEmbedding(engram.id, vec);
+        }).catch(() => { });
+        // 2. Update checkpoint to reflect completion
+        const checkpoint = store.getCheckpoint(AGENT_ID);
+        const completedTask = checkpoint?.executionState?.currentTask ?? 'Unknown task';
+        store.saveCheckpoint(AGENT_ID, {
+            currentTask: `Completed: ${completedTask}`,
+            decisions: checkpoint?.executionState?.decisions ?? [],
+            activeFiles: [],
+            nextSteps: [],
+            relatedMemoryIds: [engram.id],
+            notes: `Task completed. Summary memory: ${engram.id}`,
+            episodeId: null,
+        });
+        store.updateAutoCheckpointWrite(AGENT_ID, engram.id);
+        log(AGENT_ID, 'task:end', `"${completedTask}" summary=${engram.id} salience=${salience.score.toFixed(2)}`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Task completed and saved.\nSummary memory: ${engram.id}\nSalience: ${salience.score.toFixed(2)}\nCheckpoint updated.`,
+                }],
+        };
+    });
+    // --- Start ---
+    async function main() {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        // Start hook sidecar (lightweight HTTP for Claude Code hooks)
+        const sidecar = startSidecar({
+            store,
+            agentId: AGENT_ID,
+            secret: HOOK_SECRET,
+            port: HOOK_PORT,
+            onConsolidate: (agentId, reason) => {
+                console.error(`[mcp] consolidation triggered: ${reason}`);
+                const result = consolidationEngine.consolidate(agentId);
+                store.markConsolidation(agentId, false);
+                console.error(`[mcp] consolidation done: ${result.edgesStrengthened} strengthened, ${result.memoriesForgotten} forgotten`);
+            },
+        });
+        // Log to stderr (stdout is reserved for MCP protocol)
+        console.error(`AgentWorkingMemory MCP server started (agent: ${AGENT_ID}, db: ${DB_PATH})`);
+        console.error(`Hook sidecar on 127.0.0.1:${HOOK_PORT}${HOOK_SECRET ? ' (auth enabled)' : ' (no auth — set AWM_HOOK_SECRET)'}`);
+        // Clean shutdown
+        const cleanup = () => {
+            sidecar.close();
+            consolidationScheduler.stop();
+            stagingBuffer.stop();
+            store.close();
+        };
+        process.on('SIGINT', () => { cleanup(); process.exit(0); });
+        process.on('SIGTERM', () => { cleanup(); process.exit(0); });
     }
-    const blocked = next.blockedBy ? `\nBlocked by: ${next.blockedBy}` : '';
-    const tags = next.tags?.filter(tag => tag !== 'task').join(', ');
-    return {
-        content: [{
-                type: 'text',
-                text: `Next task:\n**${next.concept}** (${next.taskPriority})\nStatus: ${next.taskStatus}\n${next.content}${blocked}\n${tags ? `Tags: ${tags}\n` : ''}ID: ${next.id}`,
-            }],
-    };
-});
-// --- Start ---
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Log to stderr (stdout is reserved for MCP protocol)
-    console.error(`AgentWorkingMemory MCP server started (agent: ${AGENT_ID}, db: ${DB_PATH})`);
-}
-main().catch(err => {
-    console.error('MCP server failed:', err);
-    process.exit(1);
-});
+    main().catch(err => {
+        console.error('MCP server failed:', err);
+        process.exit(1);
+    });
+} // end else (non-incognito)
 //# sourceMappingURL=mcp.js.map