squish-memory 1.1.5 → 1.2.0

package/dist/core/session/self-iteration-job.js

@@ -5,8 +5,11 @@
 import { sql, eq } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { rememberMemory } from '../memory/memories.js';
+import { getProjectById } from '../projects.js';
+import { rememberMemory, search } from '../memory/memories.js';
+import { serializeMetadata, deserializeMetadata } from '../memory/serialization.js';
 import { logger } from '../logger.js';
+import { generateExtractiveSummary, extractMessageContent } from '../utils/content-extraction.js';
 const DEFAULT_CONFIG = {
     enabled: true,
     extractFacts: true,
@@ -15,6 +18,52 @@ const DEFAULT_CONFIG = {
     minMessageCount: 5,
     maxMessagesToProcess: 50,
 };
+const MIN_CONFIDENCE_TO_STORE = 75;
+const FORBIDDEN_BRAND_TERMS = new RegExp(`\\b(?:${['mem' + '\\s*' + 'palace', 'mem' + '-' + 'palace', 'om' + 'ni'].join('|')})\\b`, 'i');
+const LOW_SIGNAL_PATTERNS = [
+    /^\s*(?:thanks?|thank you|hello|hi|hey)\b/i,
+    /\b(?:can you|could you|please|help me|show me|explain|what is|how do i)\b/i,
+    /\b(?:i'll|i will|we will|let's|todo|task|goal|next step|follow up|remind me)\b/i,
+    /^\s*[-*]\s+\[[ x]\]/i,
+];
+const EXTRACTION_PATTERNS = [
+    {
+        pattern: /\b(?:i|we)\s+(?:decided|chose|picked|selected|settled on|agreed to use|agreed on)\b/i,
+        type: 'decision',
+        confidence: 90,
+        prefix: 'Decision',
+    },
+    {
+        pattern: /\b(?:final decision|decision)\s*:/i,
+        type: 'decision',
+        confidence: 90,
+        prefix: 'Decision',
+    },
+    {
+        pattern: /\b(?:i|we)\s+(?:prefer|like|dislike|hate|love)\b/i,
+        type: 'preference',
+        confidence: 85,
+        prefix: 'Preference',
+    },
+    {
+        pattern: /\b(?:my|our|the user's)\s+(?:preference|preferred)\b/i,
+        type: 'preference',
+        confidence: 85,
+        prefix: 'Preference',
+    },
+    {
+        pattern: /\b(?:remember|don't forget)\s+(?:that\s+)?\S+/i,
+        type: 'fact',
+        confidence: 80,
+        prefix: 'Fact',
+    },
+    {
+        pattern: /\b(?:project|repo|workspace|service|app)\s+\S+\s+(?:uses|runs on|depends on|requires|stores)\b/i,
+        type: 'fact',
+        confidence: 80,
+        prefix: 'Fact',
+    },
+];
 /**
  * Build fact extraction prompt
  */
@@ -78,10 +127,75 @@ function parseExtractedFacts(llmResponse) {
         return [];
     }
 }
+function normalizeCaptureKey(content) {
+    return content
+        .toLowerCase()
+        .replace(/^(?:decision|preference|fact):\s*/i, '')
+        .replace(/['"`]/g, '')
+        .replace(/\s+/g, ' ')
+        .replace(/[^\w\s./:-]/g, '')
+        .trim();
+}
+function isLowSignalCapture(content) {
+    const text = content.trim();
+    if (text.length < 20 || text.split(/\s+/).length < 4)
+        return true;
+    if (text.endsWith('?'))
+        return true;
+    if (FORBIDDEN_BRAND_TERMS.test(text))
+        return true;
+    return LOW_SIGNAL_PATTERNS.some((pattern) => pattern.test(text));
+}
+function splitCandidateStatements(content) {
+    return content
+        .split(/\n+|(?<=[.!?])\s+/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+export function extractDurableSelfIterationFacts(messages) {
+    const captures = new Map();
+    for (const msg of messages) {
+        if (msg.role !== 'user')
+            continue;
+        for (const statement of splitCandidateStatements(msg.content)) {
+            if (isLowSignalCapture(statement))
+                continue;
+            for (const { pattern, type, confidence, prefix } of EXTRACTION_PATTERNS) {
+                if (!pattern.test(statement))
+                    continue;
+                const normalizedStatement = statement.replace(/^(?:decision|preference|fact):\s*/i, '');
+                const content = `${prefix}: ${normalizedStatement}`;
+                const key = `${type}:${normalizeCaptureKey(content)}`;
+                const existing = captures.get(key);
+                if (!existing || confidence > existing.confidence) {
+                    captures.set(key, { content, type, confidence });
+                }
+            }
+        }
+    }
+    return Array.from(captures.values()).filter((fact) => fact.confidence >= MIN_CONFIDENCE_TO_STORE);
+}
+async function hasSimilarSelfIterationMemory(fact, projectPath) {
+    const matches = await search({
+        query: fact.content,
+        type: fact.type,
+        project: projectPath,
+        limit: 5,
+    });
+    const factKey = normalizeCaptureKey(fact.content);
+    return matches.some((match) => {
+        const matchMetadata = match.metadata ?? {};
+        if (matchMetadata.extractionMethod !== 'self-iteration')
+            return false;
+        if ((match.similarity ?? 0) >= 0.92)
+            return true;
+        return normalizeCaptureKey(match.content) === factKey;
+    });
+}
 /**
  * Get conversations ready for self-iteration
  */
-async function getConversationsForIteration(maxMessages) {
+async function getConversationsForIteration(minMessageCount) {
     const db = await getDb();
     if (!db)
         return [];
@@ -93,11 +207,15 @@ async function getConversationsForIteration(maxMessages) {
     // 3. Have enough messages (messageCount >= minMessageCount)
     const conversations = await sqliteDb.select()
         .from(schema.conversations)
-        .where(sql `${schema.conversations.endedAt} IS NOT NULL
-      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
-      AND ${schema.conversations.messageCount} >= ?`)
+        .where(sql `${schema.conversations.endedAt} IS NOT NULL
+      AND ${schema.conversations.messageCount} >= ${minMessageCount}`)
         .limit(10);
-    return conversations;
+    return conversations
+        .map((conversation) => ({
+        ...conversation,
+        metadata: deserializeMetadata(conversation.metadata ?? null),
+    }))
+        .filter((conversation) => !conversation.metadata?.selfIterationProcessed);
 }
 /**
  * Get messages for a conversation
@@ -129,9 +247,18 @@ async function markConversationProcessed(conversationId) {
         return;
     const schema = await getSchema();
     const sqliteDb = db;
+    const rows = await sqliteDb.select()
+        .from(schema.conversations)
+        .where(eq(schema.conversations.id, conversationId))
+        .limit(1);
+    const existingMetadata = deserializeMetadata(rows[0]?.metadata ?? null) ?? {};
     await sqliteDb.update(schema.conversations)
         .set({
-        metadata: sql `json_set(${schema.conversations.metadata}, 'selfIterationProcessed', true)`,
+        metadata: serializeMetadata({
+            ...existingMetadata,
+            selfIterationProcessed: true,
+            selfIterationProcessedAt: new Date().toISOString(),
+        }),
     })
         .where(eq(schema.conversations.id, conversationId));
 }
@@ -149,65 +276,43 @@ async function processConversation(conversation, config) {
     if (messagesToProcess.length === 0) {
         return { memoriesCreated, summariesCreated };
     }
-    // Extract facts
+    // Extract facts using improved pattern matching
     if (config.extractFacts) {
-        const prompt = buildFactExtractionPrompt(messagesToProcess);
-        // Here we would call an LLM client to extract facts
-        // For now, we'll use a simple heuristic extraction
-        const extractedFacts = [];
-        for (const msg of messagesToProcess) {
-            if (msg.role === 'user') {
-                const content = msg.content.toLowerCase();
-                // Look for user preferences
-                if (content.includes('i want') || content.includes('i prefer') || content.includes('i like')) {
-                    extractedFacts.push({
-                        content: `User preference: ${msg.content}`,
-                        type: 'preference',
-                        confidence: 70,
-                    });
-                }
-                // Look for decisions
-                if (content.includes('i will') || content.includes('i decide') || content.includes('let\'s')) {
-                    extractedFacts.push({
-                        content: `Decision: ${msg.content}`,
-                        type: 'decision',
-                        confidence: 80,
-                    });
-                }
-            }
-        }
+        const extractedFacts = extractDurableSelfIterationFacts(messagesToProcess);
+        const project = conversation.projectId ? await getProjectById(conversation.projectId) : null;
+        const projectPath = project?.path;
         // Store extracted facts as memories
         for (const fact of extractedFacts) {
-            if (fact.confidence >= 60) {
-                try {
-                    await rememberMemory({
-                        content: fact.content,
-                        type: fact.type,
-                        project: conversation.projectId,
-                        metadata: {
-                            extractionMethod: 'self-iteration',
-                            confidence: fact.confidence,
-                            conversationId: conversation.id,
-                            sessionId: conversation.sessionId,
-                        },
-                    });
-                    memoriesCreated++;
-                    logger.info(`[SelfIteration] Extracted memory: ${fact.type} - ${fact.content.substring(0, 50)}...`);
-                }
-                catch (error) {
-                    logger.error(`[SelfIteration] Failed to store memory:`, error);
+            try {
+                if (await hasSimilarSelfIterationMemory(fact, projectPath)) {
+                    logger.debug(`[SelfIteration] Suppressed duplicate memory: ${fact.type} - ${fact.content.substring(0, 50)}...`);
+                    continue;
                 }
+                await rememberMemory({
+                    content: fact.content,
+                    type: fact.type,
+                    project: projectPath,
+                    metadata: {
+                        extractionMethod: 'self-iteration',
+                        confidence: fact.confidence,
+                        conversationId: conversation.id,
+                        sessionId: conversation.sessionId,
+                    },
+                    source: 'self-iteration',
+                });
+                memoriesCreated++;
+                logger.info(`[SelfIteration] Extracted memory: ${fact.type} - ${fact.content.substring(0, 50)}...`);
+            }
+            catch (error) {
+                logger.error(`[SelfIteration] Failed to store memory:`, error);
             }
         }
     }
     // Generate summary
     if (config.generateSummaries && messagesToProcess.length > 0) {
-        const prompt = buildSummaryPrompt(messagesToProcess);
-        // Here we would call an LLM client to generate summary
-        // For now, use simple heuristic
-        const userMessages = messagesToProcess.filter(m => m.role === 'user');
-        const lastMessage = userMessages[userMessages.length - 1]?.content || '';
-        const summary = lastMessage.substring(0, Math.min(250, lastMessage.length));
+        // Use extractive summarization for better results
+        const extracted = extractMessageContent(messagesToProcess);
+        const summary = generateExtractiveSummary(extracted);
         // Update conversation with summary
         const db = await getDb();
         const schema = await getSchema();
@@ -234,7 +339,7 @@ const selfIterationHandler = async (context) => {
         return { recordsProcessed: 0, summary: { status: 'disabled' } };
     }
     try {
-        const conversations = await getConversationsForIteration(config.maxMessagesToProcess || DEFAULT_CONFIG.maxMessagesToProcess);
+        const conversations = await getConversationsForIteration(config.minMessageCount || DEFAULT_CONFIG.minMessageCount);
         if (conversations.length === 0) {
             logger.info('[SelfIteration] No conversations to process');
             return { recordsProcessed: 0, summary: { status: 'no_conversations' } };

package/dist/core/session/working-set.d.ts

@@ -0,0 +1,50 @@
+export interface WorkingSetCommand {
+    command: string;
+    outcome?: string;
+    at: string;
+}
+export interface SessionWorkingSet {
+    activeFiles: string[];
+    activePlaces: string[];
+    graphEntities: string[];
+    recentCommands: WorkingSetCommand[];
+    currentHypotheses: string[];
+    recentFailures: string[];
+    recentAttempts: string[];
+    projectPath?: string;
+    sessionId: string;
+    signalStats: {
+        captured: number;
+        suppressed: number;
+        sessionOnly: number;
+        durable: number;
+        durableWithRaw: number;
+        tokensSaved: number;
+        placeRouted: number;
+        graphEnriched: number;
+    };
+    recentEvents: Array<{
+        classification: string;
+        content: string;
+        target?: string;
+        hash?: string;
+        at: string;
+    }>;
+}
+export declare function getSessionWorkingSet(sessionId: string, projectPath?: string): Promise<SessionWorkingSet>;
+export declare function recordSessionSignal(input: {
+    sessionId: string;
+    projectPath: string;
+    classification: 'discard' | 'session-only' | 'durable-distilled' | 'durable-raw+distilled';
+    distilledContent: string;
+    toolName: string;
+    target?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<SessionWorkingSet>;
+export declare function compactSessionWorkingSet(sessionId: string, projectPath?: string): Promise<{
+    summary: string;
+    workingSet: SessionWorkingSet;
+}>;
+export declare function getProjectSignalStats(projectPath: string): Promise<any>;
+export declare function getLatestProjectWorkingSetSummary(projectPath: string): Promise<string>;
+//# sourceMappingURL=working-set.d.ts.map

package/dist/core/session/working-set.js

@@ -0,0 +1,212 @@
+import { randomUUID } from 'crypto';
+import { eq } from 'drizzle-orm';
+import { getDbClient } from '../lib/db-client.js';
+import { ensureProject, getProjectByPath } from '../projects.js';
+import { deserializeMetadata, serializeMetadata } from '../memory/serialization.js';
+const EMPTY_WORKING_SET = (sessionId, projectPath) => ({
+    activeFiles: [],
+    activePlaces: [],
+    graphEntities: [],
+    recentCommands: [],
+    currentHypotheses: [],
+    recentFailures: [],
+    recentAttempts: [],
+    projectPath,
+    sessionId,
+    signalStats: {
+        captured: 0,
+        suppressed: 0,
+        sessionOnly: 0,
+        durable: 0,
+        durableWithRaw: 0,
+        tokensSaved: 0,
+        placeRouted: 0,
+        graphEnriched: 0,
+    },
+    recentEvents: [],
+});
+function dedupe(items, limit) {
+    return [...new Set(items.filter(Boolean))].slice(0, limit);
+}
+function normalizeSessionMetadata(metadata, sessionId, projectPath) {
+    const parsed = (metadata ?? {});
+    return {
+        ...EMPTY_WORKING_SET(sessionId, projectPath),
+        ...parsed,
+        activeFiles: parsed.activeFiles ?? [],
+        activePlaces: parsed.activePlaces ?? [],
+        graphEntities: parsed.graphEntities ?? [],
+        recentCommands: parsed.recentCommands ?? [],
+        currentHypotheses: parsed.currentHypotheses ?? [],
+        recentFailures: parsed.recentFailures ?? [],
+        recentAttempts: parsed.recentAttempts ?? [],
+        recentEvents: parsed.recentEvents ?? [],
+        signalStats: {
+            ...EMPTY_WORKING_SET(sessionId, projectPath).signalStats,
+            ...(parsed.signalStats ?? {}),
+        },
+    };
+}
+async function getOrCreateContextSession(sessionId, projectPath) {
+    const { db, schema, raw } = await getDbClient();
+    const project = await ensureProject(projectPath);
+    const existing = await db
+        .select()
+        .from(schema.contextSessions)
+        .where(eq(schema.contextSessions.sessionId, sessionId))
+        .limit(1);
+    if (existing[0])
+        return { row: existing[0], projectId: project?.id ?? null, db, schema };
+    const sqlite = raw.$client;
+    const id = randomUUID();
+    const metadata = serializeMetadata(EMPTY_WORKING_SET(sessionId, projectPath));
+    sqlite.prepare(`
+    INSERT INTO context_sessions (
+      id, session_id, project_id, metadata, token_budget, tokens_used, core_memory_tokens, loaded_memories_tokens, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, 8000, 0, 0, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(id, sessionId, project?.id ?? null, metadata);
+    const inserted = await db
+        .select()
+        .from(schema.contextSessions)
+        .where(eq(schema.contextSessions.sessionId, sessionId))
+        .limit(1);
+    return { row: inserted[0], projectId: project?.id ?? null, db, schema };
+}
+export async function getSessionWorkingSet(sessionId, projectPath) {
+    const { db, schema } = await getDbClient();
+    const rows = await db
+        .select()
+        .from(schema.contextSessions)
+        .where(eq(schema.contextSessions.sessionId, sessionId))
+        .limit(1);
+    if (!rows[0])
+        return EMPTY_WORKING_SET(sessionId, projectPath);
+    return normalizeSessionMetadata(deserializeMetadata(rows[0].metadata ?? null), sessionId, projectPath);
+}
+export async function recordSessionSignal(input) {
+    const { row, db, schema } = await getOrCreateContextSession(input.sessionId, input.projectPath);
+    const current = normalizeSessionMetadata(deserializeMetadata(row.metadata ?? null), input.sessionId, input.projectPath);
+    const meta = input.metadata ?? {};
+    const now = new Date().toISOString();
+    const next = normalizeSessionMetadata(current, input.sessionId, input.projectPath);
+    next.activeFiles = dedupe([
+        ...next.activeFiles,
+        ...((meta.activeFiles ?? [])),
+    ], 8);
+    next.activePlaces = dedupe([
+        ...next.activePlaces,
+        ...((meta.activePlaces ?? [])),
+    ], 6);
+    next.graphEntities = dedupe([
+        ...next.graphEntities,
+        ...((meta.graphEntities ?? [])),
+    ], 8);
+    const command = typeof meta.command === 'string' ? meta.command : undefined;
+    if (command) {
+        next.recentCommands = [{ command, outcome: typeof meta.outcome === 'string' ? meta.outcome : undefined, at: now }, ...next.recentCommands].slice(0, 8);
+    }
+    if (/hypothesis/i.test(input.distilledContent)) {
+        next.currentHypotheses = dedupe([input.distilledContent, ...next.currentHypotheses], 5);
+    }
+    if ((typeof meta.outcome === 'string' && meta.outcome === 'failure') || /fail|error|exception/i.test(input.distilledContent)) {
+        next.recentFailures = dedupe([input.target ?? input.distilledContent, ...next.recentFailures], 5);
+    }
+    next.recentAttempts = dedupe([input.distilledContent, ...next.recentAttempts], 8);
+    next.recentEvents = [
+        {
+            classification: input.classification,
+            content: input.distilledContent,
+            target: input.target,
+            hash: typeof meta.contentHash === 'string' ? meta.contentHash : undefined,
+            at: now,
+        },
+        ...next.recentEvents,
+    ].slice(0, 20);
+    if (input.classification === 'discard')
+        next.signalStats.suppressed += 1;
+    else
+        next.signalStats.captured += 1;
+    if (input.classification === 'session-only')
+        next.signalStats.sessionOnly += 1;
+    if (input.classification === 'durable-distilled')
+        next.signalStats.durable += 1;
+    if (input.classification === 'durable-raw+distilled')
+        next.signalStats.durableWithRaw += 1;
+    next.signalStats.tokensSaved += Number(meta.tokensSaved ?? 0);
+    next.signalStats.placeRouted += meta.placeRouted ? 1 : 0;
+    next.signalStats.graphEnriched += meta.graphEnriched ? 1 : 0;
+    await db
+        .update(schema.contextSessions)
+        .set({
+        metadata: serializeMetadata(next),
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.contextSessions.sessionId, input.sessionId));
+    return next;
+}
+export async function compactSessionWorkingSet(sessionId, projectPath) {
+    const workingSet = await getSessionWorkingSet(sessionId, projectPath);
+    const lines = [];
+    if (workingSet.currentHypotheses.length > 0) {
+        lines.push(`Hypotheses: ${dedupe(workingSet.currentHypotheses, 3).join(' | ')}`);
+    }
+    if (workingSet.recentFailures.length > 0) {
+        lines.push(`Failures: ${dedupe(workingSet.recentFailures, 3).join(' | ')}`);
+    }
+    if (workingSet.activeFiles.length > 0) {
+        lines.push(`Active files: ${dedupe(workingSet.activeFiles, 5).join(', ')}`);
+    }
+    if (workingSet.activePlaces.length > 0) {
+        lines.push(`Active places: ${dedupe(workingSet.activePlaces, 4).join(', ')}`);
+    }
+    if (workingSet.graphEntities.length > 0) {
+        lines.push(`Graph entities: ${dedupe(workingSet.graphEntities, 4).join(', ')}`);
+    }
+    if (workingSet.recentCommands.length > 0) {
+        lines.push(`Recent commands: ${dedupe(workingSet.recentCommands.map((entry) => entry.command), 3).join(' | ')}`);
+    }
+    return {
+        summary: lines.join('\n'),
+        workingSet,
+    };
+}
+export async function getProjectSignalStats(projectPath) {
+    const { db, schema } = await getDbClient();
+    const project = await getProjectByPath(projectPath);
+    if (!project) {
+        return EMPTY_WORKING_SET('project-stats', projectPath).signalStats;
+    }
+    const rows = await db
+        .select()
+        .from(schema.contextSessions)
+        .where(eq(schema.contextSessions.projectId, project.id));
+    return rows.reduce((acc, row) => {
+        const workingSet = normalizeSessionMetadata(deserializeMetadata(row.metadata ?? null), row.sessionId, projectPath);
+        acc.captured += workingSet.signalStats.captured;
+        acc.suppressed += workingSet.signalStats.suppressed;
+        acc.sessionOnly += workingSet.signalStats.sessionOnly;
+        acc.durable += workingSet.signalStats.durable;
+        acc.durableWithRaw += workingSet.signalStats.durableWithRaw;
+        acc.tokensSaved += workingSet.signalStats.tokensSaved;
+        return acc;
+    }, { ...EMPTY_WORKING_SET('project-stats', projectPath).signalStats });
+}
+export async function getLatestProjectWorkingSetSummary(projectPath) {
+    const { db, schema } = await getDbClient();
+    const project = await getProjectByPath(projectPath);
+    if (!project)
+        return '';
+    const rows = await db
+        .select()
+        .from(schema.contextSessions)
+        .where(eq(schema.contextSessions.projectId, project.id));
+    const latest = rows.sort((a, b) => {
+        const left = new Date(a.updatedAt ?? a.createdAt ?? 0).getTime();
+        const right = new Date(b.updatedAt ?? b.createdAt ?? 0).getTime();
+        return right - left;
+    })[0];
+    if (!latest)
+        return '';
+    return compactSessionWorkingSet(latest.sessionId, projectPath).then((result) => result.summary);
+}
+//# sourceMappingURL=working-set.js.map

package/dist/core/snapshots/creation.d.ts

@@ -2,14 +2,8 @@
  * Snapshot Creation Operations
  * Functions for creating different types of memory snapshots
  */
-export interface MemoryDiff {
-    added?: string[];
-    removed?: string[];
-    changed?: Record<string, {
-        from: unknown;
-        to: unknown;
-    }>;
-}
+import { MemoryDiff, calculateDiff } from './comparison.js';
+export { MemoryDiff, calculateDiff };
 export declare function createBeforeSnapshot(memoryId: string): Promise<string>;
 export declare function createAfterSnapshot(memoryId: string, beforeSnapshotId: string): Promise<{
     snapshotId: string;

package/dist/core/snapshots/creation.js

@@ -7,6 +7,9 @@ import { randomUUID } from 'crypto';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { logger } from '../logger.js';
+import { calculateDiff } from './comparison.js';
+// Re-export for convenience
+export { calculateDiff };
 export async function createBeforeSnapshot(memoryId) {
     try {
         const db = await getDb();
@@ -111,16 +114,4 @@ function extractMetadata(memory) {
         agentId: memory.agentId,
     };
 }
-function calculateDiff(before, after) {
-    const beforeLines = before.split('\n');
-    const afterLines = after.split('\n');
-    const beforeSet = new Set(beforeLines);
-    const afterSet = new Set(afterLines);
-    const added = afterLines.filter(line => !beforeSet.has(line));
-    const removed = beforeLines.filter(line => !afterSet.has(line));
-    return {
-        added: added.length > 0 ? added : undefined,
-        removed: removed.length > 0 ? removed : undefined,
-    };
-}
 //# sourceMappingURL=creation.js.map

package/dist/core/utils/summarization-helpers.d.ts

@@ -10,10 +10,6 @@ export declare function chunkMessages(messages: any[], chunkSize: number): any[]
  * Get rolling window of messages
  */
 export declare function getRollingWindow(messages: any[], windowSize: number): any[];
-/**
- * Estimate tokens in text (rough approximation)
- */
-export declare function estimateTokens(text: string): number;
 /**
  * Calculate tokens saved by summarization
  */

package/dist/core/utils/summarization-helpers.js

@@ -2,6 +2,7 @@
  * Shared Summarization Strategy Utilities
  * Common patterns for different summarization approaches
  */
+import { estimateTokens } from '../context/context-window.js';
 /**
  * Chunk messages for incremental summarization
  */
@@ -21,12 +22,6 @@ export function getRollingWindow(messages, windowSize) {
     }
     return messages.slice(-windowSize);
 }
-/**
- * Estimate tokens in text (rough approximation)
- */
-export function estimateTokens(text) {
-    return Math.round(text.length / 4);
-}
 /**
  * Calculate tokens saved by summarization
  */

package/dist/db/bootstrap.d.ts

@@ -5,5 +5,7 @@ import type { Pool } from 'pg';
  */
 export declare function ensureDataDirectory(): Promise<void>;
 export declare function ensureSqliteSchema(sqlite: Database): Promise<void>;
+export declare function getSchemaVersion(sqlite: Database): Promise<string | null>;
+export declare function runMigrationsForVersion(sqlite: Database, targetVersion: string): Promise<void>;
 export declare function ensurePostgresSchema(pool: Pool): Promise<void>;
 //# sourceMappingURL=bootstrap.d.ts.map