squish-memory 1.1.5 → 1.2.0

package/dist/core/hooks/agent-hooks.js

@@ -12,12 +12,23 @@
  */
 import { randomUUID } from 'crypto';
 import { createLearning } from '../ingestion/learnings.js';
-import { getRecent } from '../memory/memories.js';
+import { getRecent, rememberMemory } from '../memory/memories.js';
 import { logger } from '../logger.js';
 import { shouldCaptureTool, categorizeTool } from './capture-filter.js';
 import { inferTags } from './auto-tagger.js';
 import { ensureProject, getProjectByPath } from '../projects.js';
 import { autoAssignMemory, initializeDefaultPlaces } from '../places/index.js';
+import { compressForContext } from '../compression.js';
+import { getAgentPreferences } from '../agent-preferences.js';
+import { classifySignalEvent, distillSignalEvent } from '../ingestion/signal-engine.js';
+import { compactSessionWorkingSet, recordSessionSignal } from '../session/working-set.js';
+import { getDbClient } from '../lib/db-client.js';
+import { eq } from 'drizzle-orm';
+import { serializeMetadata, deserializeMetadata } from '../memory/serialization.js';
+import { addMemoryToGraph } from '../graph/graph-builder.js';
+import { addSessionContextToHotCache } from '../hot-cache.js';
+import { extractBeliefsFromMemory } from '../beliefs/extractor.js';
+import { upsertBeliefsForMemory, getRecentFailures, getActiveConstraints, getActiveDecisions } from '../beliefs/store.js';
 /** Session ID for tracking across agents */
 let currentSessionId = null;
 /**
@@ -54,6 +65,7 @@ export async function handleSessionStart(params) {
     // Get recent memories based on mode
     const limit = mode === 'compact' ? 3 : 5;
     const memories = await getRecent(projectPath, limit);
+    const compactedWorkingSet = await compactSessionWorkingSet(currentSessionId, projectPath);
     // Get spatial memory context (places) for context injection
     let placesContext = '';
     try {
@@ -75,16 +87,76 @@ export async function handleSessionStart(params) {
         // Don't fail if places not available
         logger.debug(`[Hooks] Places context not available: ${e}`);
     }
-    // Format for injection
-    const formatted = memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}...`).join('\n');
-    const allContent = formatted + placesContext;
+    // Format for injection with compression
+    const formatted = memories.map((m, i) => {
+        const compressed = compressForContext(m.content || '');
+        return `${i + 1}. [${m.type}] ${compressed}`;
+    }).join('\n');
+    const workingSetContext = compactedWorkingSet.summary ? `Session working set:\n${compactedWorkingSet.summary}\n\n` : '';
+    const allContent = workingSetContext + formatted + placesContext;
+    // Get agent preferences for context injection
+    let preferences = [];
+    try {
+        const project = await getProjectByPath(projectPath);
+        if (project) {
+            preferences = await getAgentPreferences(project.id);
+            // Get beliefs for state reconstruction on session boot
+            // This is the "state reconstruction" - active beliefs shape next actions
+            const [failures, constraints, decisions] = await Promise.all([
+                getRecentFailures(project.id, 5),
+                getActiveConstraints(project.id, 10),
+                getActiveDecisions(project.id, 10),
+            ]);
+            // Format beliefs into context
+            const beliefsSection = formatBeliefsForContext(failures, constraints, decisions);
+            // Add beliefs to injected context
+            if (beliefsSection) {
+                allContent = beliefsSection + '\n\n' + allContent;
+            }
+            logger.info(`[Hooks] Injected ${failures.length} failures, ${constraints.length} constraints, ${decisions.length} decisions`);
+            return {
+                memories: allContent ? allContent.split('\n') : [],
+                sessionId: currentSessionId,
+                count: memories.length,
+                preferences: preferences.length > 0 ? preferences : undefined,
+                beliefs: {
+                    failures: failures.map(f => f.statement),
+                    constraints: constraints.map(c => c.statement),
+                    decisions: decisions.map(d => d.statement),
+                },
+            };
+        }
+    }
+    catch (e) {
+        logger.debug(`[Hooks] Agent preferences not available: ${e}`);
+    }
     logger.info(`[Hooks] Injected ${memories.length} memories for session start`);
     return {
         memories: allContent ? allContent.split('\n') : [],
         sessionId: currentSessionId,
         count: memories.length,
+        preferences: preferences.length > 0 ? preferences : undefined,
     };
 }
+/**
+ * Format beliefs into context section for session boot
+ * This drives "state reconstruction" - agent sees active constraints/failures/decisions
+ */
+function formatBeliefsForContext(failures, constraints, decisions) {
+    const sections = [];
+    if (failures.length > 0) {
+        sections.push('AVOID:\n' + failures.map((f, i) => `  ${i + 1}. ${f.statement}${f.context ? ` (${f.context})` : ''}`).join('\n'));
+    }
+    if (constraints.length > 0) {
+        sections.push('CONSTRAINTS:\n' + constraints.map((c, i) => `  ${i + 1}. ${c.statement}${c.context ? ` (${c.context})` : ''}`).join('\n'));
+    }
+    if (decisions.length > 0) {
+        sections.push('DECISIONS:\n' + decisions.map((d, i) => `  ${i + 1}. ${d.statement}${d.context ? ` (${d.context})` : ''}`).join('\n'));
+    }
+    if (sections.length === 0)
+        return '';
+    return sections.join('\n\n');
+}
 /**
  * Post-tool-use hook - record observations
  */
@@ -98,49 +170,157 @@ export async function handlePostToolUse(params) {
     }
     // Check if we should capture this tool
     if (!shouldCaptureTool(toolName)) {
+        await recordSessionSignal({
+            sessionId: currentSessionId,
+            projectPath,
+            classification: 'discard',
+            distilledContent: `Filtered tool: ${toolName}`,
+            toolName,
+            target: extractTarget(toolName, toolInput),
+        });
         return { captured: false, reason: `Tool ${toolName} filtered out` };
     }
     // Extract relevant information
     const category = categorizeTool(toolName);
     const target = extractTarget(toolName, toolInput);
     const content = extractContent(toolName, toolInput, toolResult);
+    const signalDecision = classifySignalEvent({
+        toolName,
+        toolInput,
+        toolResult,
+        sessionId: currentSessionId,
+    });
+    const distilledContent = distillSignalEvent({
+        toolName,
+        command: String(toolInput.command || toolInput.cmd || ''),
+        content: signalDecision.content || content,
+        classification: signalDecision.classification,
+    });
     // Infer tags from context
-    const tags = inferTags(toolName, toolInput, content);
-    // Create learning/observation
-    const learningInput = {
-        type: 'insight',
-        content: `[${category}] ${content}`,
-        action: toolName,
+    const tags = inferTags(toolName, toolInput, distilledContent || content);
+    await recordSessionSignal({
+        sessionId: currentSessionId,
+        projectPath,
+        classification: signalDecision.classification,
+        distilledContent,
+        toolName,
         target,
-        project: projectPath,
-        autoLink: true,
-    };
+        metadata: {
+            activeFiles: extractActiveFiles(toolName, toolInput),
+            command: String(toolInput.command || toolInput.cmd || ''),
+            outcome: inferOutcome(signalDecision, toolResult),
+            contentHash: signalDecision.contentHash,
+            tokensSaved: signalDecision.estimatedSavings,
+            activePlaces: signalDecision.placeHint.placeType ? [signalDecision.placeHint.placeType] : [],
+            graphEntities: signalDecision.graphHint.entityTerms,
+            placeRouted: Boolean(signalDecision.placeHint.placeType),
+            graphEnriched: signalDecision.graphHint.shouldEnrich,
+        },
+    });
+    if (signalDecision.classification === 'discard') {
+        return { captured: false, reason: signalDecision.reasons.join(', ') };
+    }
+    if (signalDecision.classification === 'session-only') {
+        return { captured: false, reason: 'Stored in session working set only' };
+    }
     try {
-        const learning = await createLearning(learningInput);
-        logger.info(`[Hooks] Captured ${toolName} → ${learning.id} (session: ${currentSessionId})`);
-        // Auto-assign to place (if places are initialized)
+        const memory = await rememberMemory({
+            content: `[${category}] ${distilledContent || content}`,
+            project: projectPath,
+            type: category === 'modification' ? 'decision' : category === 'planning' ? 'context' : 'observation',
+            source: 'auto-capture',
+            metadata: {
+                signal: {
+                    classification: signalDecision.classification,
+                    reasons: signalDecision.reasons,
+                    nuanceSuppressed: signalDecision.classification === 'durable-raw+distilled',
+                    wakeUpPriority: signalDecision.wakeUpPriority,
+                },
+                placeHint: signalDecision.placeHint,
+                graphHint: signalDecision.graphHint,
+                target,
+                toolName,
+            },
+        });
+        logger.info(`[Hooks] Captured ${toolName} → ${memory.id} (session: ${currentSessionId})`);
+        let placeAssignment;
         try {
             const project = await getProjectByPath(projectPath);
             if (project) {
-                // Initialize default places if they don't exist
                 await initializeDefaultPlaces(project.id);
-                // Auto-assign the memory to a place
-                await autoAssignMemory({
-                    memoryId: learning.id,
+                placeAssignment = await autoAssignMemory({
+                    memoryId: memory.id,
                     projectId: project.id,
                     toolName,
-                    content: learningInput.content,
+                    content: memory.content,
                     tags,
+                    memoryType: memory.type,
                 });
             }
         }
         catch (placeError) {
-            // Don't fail the hook if place assignment fails
             logger.warn(`[Hooks] Place assignment failed: ${placeError}`);
         }
+        let graphStatus = {
+            enriched: false,
+            entitiesCreated: 0,
+            relationsCreated: 0,
+            source: 'none',
+            entityTerms: signalDecision.graphHint.entityTerms,
+        };
+        if (signalDecision.graphHint.shouldEnrich) {
+            try {
+                const graphResult = await addMemoryToGraph(memory.id, { preferLLM: true });
+                graphStatus = {
+                    enriched: graphResult.entitiesCreated > 0 || graphResult.relationsCreated > 0,
+                    entitiesCreated: graphResult.entitiesCreated,
+                    relationsCreated: graphResult.relationsCreated,
+                    source: graphResult.source,
+                    entityTerms: signalDecision.graphHint.entityTerms,
+                };
+            }
+            catch (graphError) {
+                logger.warn(`[Hooks] Graph enrichment failed: ${graphError}`);
+            }
+        }
+        let rawFallbackSnapshotId;
+        if (signalDecision.classification === 'durable-raw+distilled') {
+            rawFallbackSnapshotId = await attachRawFallbackSnapshot(memory.id, signalDecision.content, signalDecision.reasons);
+        }
+        await attachInspectionMetadata(memory.id, {
+            classification: signalDecision.classification,
+            reasons: signalDecision.reasons,
+            rawFallbackSnapshotId,
+            nuanceSuppressed: signalDecision.classification === 'durable-raw+distilled',
+            placeId: placeAssignment?.placeId,
+            placeType: placeAssignment?.placeType,
+            graph: graphStatus,
+        });
+        try {
+            const project = await getProjectByPath(projectPath);
+            if (project) {
+                const beliefs = extractBeliefsFromMemory({
+                    memoryId: memory.id,
+                    content: memory.content,
+                    type: memory.type,
+                    metadata: memory.metadata ?? null,
+                });
+                if (beliefs.length > 0) {
+                    const storedBeliefs = await upsertBeliefsForMemory({
+                        projectId: project.id,
+                        memoryId: memory.id,
+                        beliefs,
+                    });
+                    await attachBeliefInspectionMetadata(memory.id, storedBeliefs);
+                }
+            }
+        }
+        catch (beliefError) {
+            logger.warn(`[Hooks] Belief extraction failed: ${beliefError}`);
+        }
         return {
             captured: true,
-            memoryId: learning.id,
+            memoryId: memory.id,
         };
     }
     catch (error) {
@@ -148,8 +328,90 @@ export async function handlePostToolUse(params) {
         return { captured: false, reason: 'Failed to create learning' };
     }
 }
+async function attachRawFallbackSnapshot(memoryId, rawContent, reasons) {
+    const { db, schema } = await getDbClient();
+    const snapshotId = randomUUID();
+    await db.insert(schema.memorySnapshots).values({
+        id: snapshotId,
+        memoryId,
+        snapshotType: 'periodic',
+        content: rawContent,
+        metadata: serializeMetadata({
+            role: 'raw-fallback',
+            reasons,
+            createdBy: 'signal-engine',
+        }),
+        createdAt: new Date(),
+    });
+    return snapshotId;
+}
+async function attachInspectionMetadata(memoryId, signal) {
+    const { db, schema } = await getDbClient();
+    const rows = await db.select().from(schema.memories).where(eq(schema.memories.id, memoryId)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return;
+    const details = deserializeMetadata(row.metadata ?? null) ?? {};
+    const next = {
+        ...details,
+        signal,
+        classification: signal.classification,
+        reasons: signal.reasons,
+        rawFallbackSnapshotId: signal.rawFallbackSnapshotId,
+        nuanceSuppressed: signal.nuanceSuppressed,
+        placeId: signal.placeId,
+        placeType: signal.placeType,
+        graph: signal.graph,
+        graphStatus: signal.graph
+            ? `${signal.graph.enriched ? 'enriched' : 'skipped'} (${signal.graph.entitiesCreated} entities, ${signal.graph.relationsCreated} relations)`
+            : 'none',
+    };
+    await db.update(schema.memories)
+        .set({ metadata: serializeMetadata(next), updatedAt: new Date() })
+        .where(eq(schema.memories.id, memoryId));
+}
+async function attachBeliefInspectionMetadata(memoryId, beliefs) {
+    const { db, schema } = await getDbClient();
+    const rows = await db.select().from(schema.memories).where(eq(schema.memories.id, memoryId)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return;
+    const details = deserializeMetadata(row.metadata ?? null) ?? {};
+    const next = {
+        ...details,
+        beliefs: beliefs.map((belief) => ({
+            id: belief.id,
+            type: belief.type,
+            statement: belief.statement,
+            status: belief.status,
+            confidence: belief.confidence,
+            sourceMemoryIds: belief.sourceMemoryIds,
+            reason: belief.reason,
+        })),
+    };
+    await db.update(schema.memories)
+        .set({ metadata: serializeMetadata(next), updatedAt: new Date() })
+        .where(eq(schema.memories.id, memoryId));
+}
+function extractActiveFiles(toolName, toolInput) {
+    const path = String(toolInput.filePath || toolInput.path || '');
+    if (['Write', 'Edit', 'MultiEdit'].includes(toolName) && path) {
+        return [path];
+    }
+    return [];
+}
+function inferOutcome(signalDecision, toolResult) {
+    const content = typeof toolResult === 'string' ? toolResult.toLowerCase() : String(toolResult ?? '').toLowerCase();
+    if (signalDecision.classification === 'discard')
+        return 'suppressed';
+    if (/\bfail|error|exception|traceback\b/.test(content))
+        return 'failure';
+    if (/\bpass|success|completed\b/.test(content))
+        return 'success';
+    return undefined;
+}
 /**
- * Session end hook - save snapshot and sync
+ * Session end hook - save snapshot and sync to persistent hot cache
  */
 export async function handleSessionEnd(params) {
     const { projectPath, agentType, workInProgress } = params;
@@ -166,6 +428,21 @@ export async function handleSessionEnd(params) {
             autoLink: false,
         });
         logger.info(`[Hooks] Saved session snapshot: ${snapshot.id}`);
+        // NEW: Also save to persistent hot cache (survives restart)
+        try {
+            const workingSet = await compactSessionWorkingSet(projectPath);
+            await addSessionContextToHotCache({
+                activeFiles: workingSet?.activeFiles || [],
+                commands: workingSet?.recentCommands?.slice(-3).map(c => c.command) || [],
+                failures: workingSet?.recentFailures?.slice(-2) || [],
+                decisions: [], // Could extract from recent signals
+                hypotheses: workingSet?.currentHypotheses?.slice(-2) || [],
+            }, projectPath);
+            logger.info('[Hooks] Saved session context to hot cache');
+        }
+        catch (error) {
+            logger.warn('[Hooks] Failed to save hot cache', error);
+        }
         currentSessionId = null; // Clear session
         return {
             snapshotId: snapshot.id,

package/dist/core/hot-cache.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Hot Cache - Persistent session context (Karpathy-style)
+ *
+ * Implements the "hot.md" layer from LLM Wiki pattern:
+ * - ~500 words persistent session context
+ * - Survives restart (unlike session working set)
+ * - Auto-updates on session events
+ * - Deduplication and stale detection
+ */
+export interface HotCacheEntry {
+    id: string;
+    content: string;
+    hash: string;
+    createdAt: number;
+    lastReferencedAt: number;
+    referenceCount: number;
+    tags?: string[];
+}
+export interface HotCache {
+    version: string;
+    projectPath: string;
+    entries: HotCacheEntry[];
+    lastUpdated: number;
+    staleEntries: string[];
+}
+/**
+ * Load hot cache from disk (or create new)
+ */
+export declare function loadHotCache(projectPath?: string): Promise<HotCache>;
+/**
+ * Save hot cache to disk
+ */
+export declare function saveHotCache(cache: HotCache): Promise<void>;
+/**
+ * Add an entry to hot cache (with deduplication)
+ */
+export declare function addToHotCache(content: string, options?: {
+    projectPath?: string;
+    tags?: string[];
+    reference?: boolean;
+}): Promise<HotCache>;
+/**
+ * Get hot cache summary for context
+ * Returns markdown-formatted summary of recent entries
+ */
+export declare function getHotCacheSummary(options?: {
+    projectPath?: string;
+    maxEntries?: number;
+}): Promise<string>;
+/**
+ * Reference an existing hot cache entry (prevents staleness)
+ */
+export declare function referenceHotCacheEntry(entryId: string, projectPath?: string): Promise<boolean>;
+/**
+ * Remove stale entries from hot cache
+ */
+export declare function cleanStaleEntries(projectPath?: string): Promise<number>;
+/**
+ * Add session context to hot cache
+ * Called from session hooks with key session information
+ */
+export declare function addSessionContextToHotCache(sessionInfo: {
+    activeFiles?: string[];
+    commands?: string[];
+    failures?: string[];
+    decisions?: string[];
+    hypotheses?: string[];
+}, projectPath?: string): Promise<HotCache>;
+/**
+ * Get all hot cache entries (for advanced use)
+ */
+export declare function getHotCacheEntries(projectPath?: string): Promise<HotCacheEntry[]>;
+/**
+ * Clear hot cache (dangerous - use with caution)
+ */
+export declare function clearHotCache(projectPath?: string): Promise<void>;
+/**
+ * Get hot cache statistics
+ */
+export declare function getHotCacheStats(projectPath?: string): Promise<{
+    entries: number;
+    staleEntries: number;
+    oldestEntry: number | null;
+    newestEntry: number | null;
+}>;
+//# sourceMappingURL=hot-cache.d.ts.map