squish-memory 1.1.5 → 1.2.0

package/dist/core/memory/importance.d.ts

@@ -3,7 +3,6 @@
  * Calculates and manages memory importance scores (0-100) with temporal decay
  */
 import type { Memory } from '../../db/drizzle/schema.js';
-import { cosineSimilarity as vectorCosineSimilarity } from '../utils/vector-operations.js';
 export interface ImportanceScore {
     score: number;
     components: {
@@ -27,16 +26,6 @@ export declare function calculateImportance(memory: Partial<Memory>): Importance
  * Used when memory is accessed or modified
  */
 export declare function updateImportanceScore(memoryId: string, incrementAccess?: boolean): Promise<number>;
-/**
- * Decay importance scores for old memories
- * Should be run periodically (e.g., daily) to reduce scores of stale memories
- *
- * This function applies exponential decay to all memories that haven't been
- * recalculated recently, keeping the system's importance scores current.
- *
- * Fixed: Uses batch update instead of N+1 individual queries
- */
-export declare function decayImportanceScores(projectId?: string): Promise<number>;
 /**
  * Get low-importance memories that are candidates for consolidation
  * These are old, rarely accessed memories with low importance scores
@@ -54,10 +43,4 @@ export declare function setImportanceScore(memoryId: string, score: number): Pro
  * Pin a memory to prevent decay and consolidation
  */
 export declare function pinMemory(memoryId: string, pinned?: boolean): Promise<void>;
-/**
- * Calculate cosine similarity between two vectors
- * Re-exported from core/utils/vector-operations.ts for backward compatibility.
- * This will be removed in v1.2.0 - import directly from core/utils/vector-operations.ts
- */
-export declare const cosineSimilarity: typeof vectorCosineSimilarity;
 //# sourceMappingURL=importance.d.ts.map

package/dist/core/memory/importance.js

@@ -3,7 +3,6 @@
  * Calculates and manages memory importance scores (0-100) with temporal decay
  */
 import { eq } from 'drizzle-orm';
-import { cosineSimilarity as vectorCosineSimilarity } from '../utils/vector-operations.js';
 import { getDbClient } from '../lib/db-client.js';
 /**
  * Type weights for importance scoring
@@ -170,57 +169,6 @@ export async function updateImportanceScore(memoryId, incrementAccess = false) {
         .where(eq(schema.memories.id, memoryId));
     return importance.score;
 }
-/**
- * Decay importance scores for old memories
- * Should be run periodically (e.g., daily) to reduce scores of stale memories
- *
- * This function applies exponential decay to all memories that haven't been
- * recalculated recently, keeping the system's importance scores current.
- *
- * Fixed: Uses batch update instead of N+1 individual queries
- */
-export async function decayImportanceScores(projectId) {
-    const { db, schema, raw } = await getDbClient();
-    // Get memories that need recalculation
-    // (those not recalculated in the last 24 hours or never)
-    const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
-    // Use raw SQL for bulk update - avoids N+1 queries - let's use raw SQL for efficiency
-    // Build a single UPDATE that sets importance to base 50 (neutral) minus decay
-    // The JS calculation is too complex to port to SQL, but we can at least
-    // use a simpler approach: just reset to default and let individual recalc happen on access
-    // For now, use a more efficient approach: bulk update with raw SQL
-    // This avoids N+1 queries while still using the JS calculation logic
-    const clientType = raw.$clientType || 'sqlite';
-    const now = new Date().toISOString();
-    if (clientType === 'sqlite') {
-        const sqliteClient = raw.$client;
-        // Single SQL update - set all non-pinned/consolidated memories to base decay
-        // Note: We can't fully replicate the JS calculation in SQL, so we apply
-        // a simple decay multiplier. Full recalculation happens on access.
-        const result = sqliteClient.prepare(`
-      UPDATE memories
-      SET importance_score = MAX(0, importance_score - 1),
-          last_importance_recalc = ?
-      WHERE (is_pinned = 0 AND is_protected = 0 AND is_consolidated = 0)
-        AND (last_importance_recalc IS NULL OR last_importance_recalc < ?)
-        ${projectId ? 'AND project_id = ?' : ''}
-    `).run(now, oneDayAgo.toISOString(), ...(projectId ? [projectId] : []));
-        return result.changes;
-    }
-    else {
-        // PostgreSQL
-        const pgClient = raw.$client;
-        const result = await pgClient.query(`
-      UPDATE memories
-      SET importance_score = GREATEST(0, importance_score - 1),
-          last_importance_recalc = $1
-      WHERE (is_pinned = FALSE AND is_protected = FALSE AND is_consolidated = FALSE)
-        AND (last_importance_recalc IS NULL OR last_importance_recalc < $2)
-        ${projectId ? 'AND project_id = $3' : ''}
-    `, [now, oneDayAgo.toISOString(), ...(projectId ? [projectId] : [])]);
-        return result.rowCount || 0;
-    }
-}
 /**
  * Get low-importance memories that are candidates for consolidation
  * These are old, rarely accessed memories with low importance scores
@@ -289,10 +237,5 @@ export async function pinMemory(memoryId, pinned = true) {
     })
         .where(eq(schema.memories.id, memoryId));
 }
-/**
- * Calculate cosine similarity between two vectors
- * Re-exported from core/utils/vector-operations.ts for backward compatibility.
- * This will be removed in v1.2.0 - import directly from core/utils/vector-operations.ts
- */
-export const cosineSimilarity = vectorCosineSimilarity;
+// cosineSimilarity has been removed - import from core/utils/vector-operations.ts directly
 //# sourceMappingURL=importance.js.map

package/dist/core/memory/index.d.ts

@@ -1,3 +1,4 @@
+export * from './normalization.js';
 export * from './memories.js';
 export * from './memory-manager.js';
 export * from './serialization.js';

package/dist/core/memory/index.js

@@ -1,4 +1,5 @@
 // Memory feature - Store and manage memories
+export * from './normalization.js';
 export * from './memories.js';
 export * from './memory-manager.js';
 export * from './serialization.js';

package/dist/core/memory/memories.d.ts

@@ -1,4 +1,4 @@
-export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference' | 'note';
+import { MemoryRecord, MemoryType } from '../lib/types.js';
 export interface RememberInput {
     content: string;
     type?: MemoryType;
@@ -12,6 +12,9 @@ export interface RememberInput {
     exceptions?: string;
     tier?: 'hot' | 'cold';
     namespaceId?: string;
+    sessionId?: string;
+    sessionStartTime?: string;
+    toolName?: string;
 }
 export interface SearchInput {
     query: string;
@@ -19,22 +22,10 @@ export interface SearchInput {
     tags?: string[];
     limit?: number;
     project?: string;
-}
-export interface MemoryRecord {
-    id: string;
-    projectId?: string | null;
-    type: MemoryType;
-    content: string;
-    summary?: string | null;
-    tags: string[];
-    metadata?: Record<string, unknown> | null;
-    createdAt?: string | null;
-    validFrom?: string | null;
-    validTo?: string | null;
-    recordedAt?: string | null;
-    similarity?: number;
-    importance?: number;
-    confidenceLevel?: 'certain' | 'speculative' | 'outdated' | null;
+    placeId?: string;
+    placeType?: string;
+    sessionId?: string;
+    sessionStartTime?: string;
 }
 export interface SearchResult extends MemoryRecord {
     similarity: number;
@@ -44,4 +35,9 @@ export declare function getMemory(id: string, incrementAccess?: boolean): Promis
 export declare function setConfidence(id: string, level: 'certain' | 'speculative' | 'outdated'): Promise<boolean>;
 export declare function getRecent(projectPath: string, limit: number): Promise<MemoryRecord[]>;
 export declare function search(input: SearchInput): Promise<SearchResult[]>;
+/**
+ * Find similar memories to prevent duplicates
+ * Returns memories with similarity >= threshold
+ */
+export declare function findSimilarMemories(content: string, threshold?: number, limit?: number): Promise<SearchResult[]>;
 //# sourceMappingURL=memories.d.ts.map

package/dist/core/memory/memories.js

@@ -15,6 +15,12 @@ import { resolveContradictions, applySupersession } from './contradiction-resolv
 import { encrypt, decrypt } from '../security/encrypt.js';
 import { estimateTokens } from '../context/context-window.js';
 import { getDbClient } from '../lib/db-client.js';
+import { extractBeliefsFromMemory } from '../beliefs/extractor.js';
+import { upsertBeliefsForMemory } from '../beliefs/store.js';
+import { extractEntityNames } from './entity-extractor.js';
+import { autoLinkByEntities } from '../associations.js';
+import { addMemoryToGraph } from '../graph/graph-builder.js';
+import { parseEmbedding } from '../lib/parse-embedding.js';
 export async function rememberMemory(input) {
     const { db, schema } = await getDbClient();
     const tags = normalizeTags(input.tags);
@@ -56,6 +62,12 @@ export async function rememberMemory(input) {
             priority: signals.priority,
             requiresConflictCheck: signals.implicit.correction,
         },
+        // Session metadata for temporal queries (Task 1)
+        sessionMetadata: {
+            sessionId: input.sessionId,
+            sessionStartTime: input.sessionStartTime,
+            toolName: input.toolName,
+        },
     };
     let metadataValue = serializeMetadata(enrichedMetadata);
     // Prepare fields for insertion, handling optional encryption
@@ -92,10 +104,58 @@ export async function rememberMemory(input) {
         insertValues.is_encrypted = false;
     }
     await db.insert(schema.memories).values(insertValues);
+    if (project?.id) {
+        try {
+            const beliefs = extractBeliefsFromMemory({
+                memoryId: id,
+                content: input.content,
+                type,
+                metadata: enrichedMetadata,
+            });
+            if (beliefs.length > 0) {
+                await upsertBeliefsForMemory({
+                    projectId: project.id,
+                    memoryId: id,
+                    beliefs,
+                });
+            }
+        }
+        catch (beliefError) {
+            logger.warn(`[Beliefs] Failed to derive beliefs for memory ${id}: ${beliefError}`);
+        }
+    }
+    // Auto-link by entity overlap (synchronous - Task 5)
+    // Now memories are immediately findable via associations after storage
+    const entityNames = extractEntityNames(input.content);
+    if (entityNames.length > 0 && project?.id) {
+        try {
+            const linked = await autoLinkByEntities(id, entityNames, project.id);
+            if (linked > 0)
+                logger.debug(`[AutoLink] Linked memory ${id} to ${linked} related memories`);
+        }
+        catch (err) {
+            logger.debug(`[AutoLink] Failed: ${err}`);
+        }
+    }
+    // Build graph for this memory (auto-build if enabled)
+    // This populates the entity_entities and entity_relations tables
+    if (config.graphAutoBuild && project?.id) {
+        try {
+            const graphResult = await addMemoryToGraph(id, {
+                preferLLM: config.llmEnabled,
+            });
+            if (graphResult.entitiesCreated > 0 || graphResult.relationsCreated > 0) {
+                logger.debug(`[Graph] Built graph for memory ${id}: ${graphResult.entitiesCreated} entities, ${graphResult.relationsCreated} relations`);
+            }
+        }
+        catch (graphError) {
+            logger.debug(`[Graph] Failed to build graph for memory ${id}: ${graphError}`);
+        }
+    }
     // Append to Obsidian vault if enabled and hot tier (NEW)
     if (config.obsidianEnabled && config.obsidianVaultPath && insertValues.tier === 'hot') {
         try {
-            const { appendToObsidianVault } = await import('../obsidian-vault.js');
+            const { appendToObsidianVault } = await import('../integrations/obsidian-vault.js');
             await appendToObsidianVault({
                 content: input.content,
                 id,
@@ -112,26 +172,6 @@ export async function rememberMemory(input) {
             logger.warn(`[Obsidian] Failed to append to vault: ${error}`);
         }
     }
-    // Write to external folder memory if enabled and hot tier
-    if (config.externalMemoryEnabled && config.externalMemoryPath && insertValues.tier === 'hot') {
-        try {
-            const { getExternalMemory } = await import('../external-folder/index.js');
-            const externalMemory = getExternalMemory();
-            const memoryRecord = {
-                id,
-                projectId: project?.id ?? null,
-                type,
-                content: input.content,
-                tags,
-                createdAt: insertValues.createdAt?.toISOString(),
-                confidenceLevel: null,
-            };
-            await externalMemory.writeMemory(externalMemory.toMarkdownFormat(memoryRecord));
-        }
-        catch (error) {
-            logger.warn(`[ExternalMemory] Failed to write: ${error}`);
-        }
-    }
     // Resolve contradictions and supersede old memories (async, non-blocking)
     resolveContradictions(input.content, type, project?.id)
         .then(async (result) => {
@@ -236,62 +276,12 @@ export async function getRecent(projectPath, limit) {
 export async function search(input) {
     const limit = clampLimit(input.limit, 10, 1, 100);
     const tags = normalizeTags(input.tags);
-    // Get results from database (hybrid search: BM25 + vectors with RRF)
-    let dbResults;
-    if (config.isTeamMode) {
-        dbResults = await searchMemoriesPostgres(input, tags, limit);
-    }
-    else {
-        // Use hybrid search for SQLite (BM25 + vectors with RRF)
-        dbResults = await hybridSearchImpl(input, { limit });
-    }
+    // Always use hybrid search for both SQLite and PostgreSQL
+    // Graph boost requires hybrid path for proper scoring
+    const dbResults = await hybridSearchImpl(input, { limit });
     return dbResults.slice(0, limit);
 }
-/**
- * Parse embedding from SQLite storage
- */
-function parseEmbedding(embeddingData) {
-    if (!embeddingData)
-        return null;
-    // If it's already an array
-    if (Array.isArray(embeddingData))
-        return embeddingData;
-    // If it's a Buffer/Uint8Array
-    if (embeddingData instanceof Uint8Array || Buffer.isBuffer(embeddingData)) {
-        // Try to parse as JSON first
-        try {
-            const json = JSON.parse(embeddingData.toString());
-            if (Array.isArray(json))
-                return json;
-        }
-        catch {
-            // Not JSON, try Float32Array
-            try {
-                const buffer = embeddingData.buffer;
-                const arrayBuffer = buffer instanceof ArrayBuffer
-                    ? buffer
-                    : buffer;
-                const floatArray = new Float32Array(arrayBuffer);
-                return Array.from(floatArray);
-            }
-            catch {
-                return null;
-            }
-        }
-    }
-    // If it's a string
-    if (typeof embeddingData === 'string') {
-        try {
-            const parsed = JSON.parse(embeddingData);
-            if (Array.isArray(parsed))
-                return parsed;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
+// parseEmbedding imported from ../lib/parse-embedding.js
 async function searchMemoriesSqlite(input, tags, limit) {
     const { db } = await getDbClient();
     const sqlite = db.$client;
@@ -446,4 +436,17 @@ function normalizeMemory(row) {
         confidenceLevel: row.confidenceLevel ?? row.confidence_level ?? null,
     };
 }
+/**
+ * Find similar memories to prevent duplicates
+ * Returns memories with similarity >= threshold
+ */
+export async function findSimilarMemories(content, threshold = 0.85, limit = 5) {
+    // Use search with high similarity
+    const results = await search({
+        query: content,
+        limit,
+    });
+    // Filter by similarity threshold
+    return results.filter(r => (r.similarity ?? 0) >= threshold);
+}
 //# sourceMappingURL=memories.js.map

package/dist/core/memory/memory-lifecycle.d.ts

@@ -1,6 +1,6 @@
-/** Promote a memory to a higher tier (hot -> warm -> cold) */
+/** Promote a memory to a higher tier (cold -> hot only, simplified from warm hierarchy) */
 export declare function promoteTier(memoryId: string): Promise<void>;
-/** Demote a memory tier or expire it based on decay */
+/** Demote a memory tier or expire it based on decay (simplified: hot -> cold only) */
 export declare function demoteTier(memoryId: string): Promise<void>;
 export declare function expireMemory(memoryId: string): Promise<void>;
 export declare function markMerged(memoryId: string, targetId: string): Promise<void>;

package/dist/core/memory/memory-lifecycle.js

@@ -2,7 +2,7 @@ import { getDb } from '../../db/index.js';
 import { memories } from '../../db/drizzle/schema.js';
 import { eq } from 'drizzle-orm';
 import { logger } from '../logger.js';
-/** Promote a memory to a higher tier (hot -> warm -> cold) */
+/** Promote a memory to a higher tier (cold -> hot only, simplified from warm hierarchy) */
 export async function promoteTier(memoryId) {
     const db = await getDb();
     // @ts-ignore - drizzle overloads
@@ -10,15 +10,12 @@ export async function promoteTier(memoryId) {
     const mem = row[0];
     if (!mem)
         return;
-    let newTier = mem.tier;
-    if (mem.tier === 'warm')
-        newTier = 'hot';
-    else if (mem.tier === 'cold')
-        newTier = 'warm';
-    // @ts-ignore
-    await db.update(memories).set({ tier: newTier }).where(eq(memories.id, memoryId));
+    // Simplified: cold -> hot (no warm tier)
+    if (mem.tier === 'cold') {
+        await db.update(memories).set({ tier: 'hot' }).where(eq(memories.id, memoryId));
+    }
 }
-/** Demote a memory tier or expire it based on decay */
+/** Demote a memory tier or expire it based on decay (simplified: hot -> cold only) */
 export async function demoteTier(memoryId) {
     const db = await getDb();
     // @ts-ignore
@@ -26,15 +23,10 @@ export async function demoteTier(memoryId) {
     const mem = row[0];
     if (!mem)
         return;
-    let updates = {};
-    if (mem.tier === 'hot')
-        updates.tier = 'warm';
-    else if (mem.tier === 'warm')
-        updates.tier = 'cold';
-    else
-        updates.status = 'expired';
-    // @ts-ignore
-    await db.update(memories).set(updates).where(eq(memories.id, memoryId));
+    // Simplified: hot -> cold (no warm tier)
+    if (mem.tier === 'hot') {
+        await db.update(memories).set({ tier: 'cold' }).where(eq(memories.id, memoryId));
+    }
 }
 export async function expireMemory(memoryId) {
     const db = await getDb();

package/dist/core/memory/normalization.d.ts

@@ -2,21 +2,6 @@
  * Memory normalization utilities
  * Shared between memories.ts and loader.ts to avoid circular dependencies
  */
-export interface MemoryRecord {
-    id: string;
-    projectId?: string | null;
-    type: string;
-    content: string;
-    summary?: string | null;
-    tags: string[];
-    metadata?: Record<string, unknown> | null;
-    createdAt?: string | null;
-    validFrom?: string | null;
-    validTo?: string | null;
-    recordedAt?: string | null;
-    similarity?: number;
-    importance?: number;
-    confidenceLevel?: 'certain' | 'speculative' | 'outdated' | null;
-}
+import type { MemoryRecord } from '../lib/types.js';
 export declare function normalizeMemory(row: any): MemoryRecord;
 //# sourceMappingURL=normalization.d.ts.map

package/dist/core/memory/path-strengthener.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Path Strengthener
+ *
+ * Strengthens association paths that led to successful retrievals and
+ * weakens paths that led to irrelevant results. This implements the
+ * "optimize" concept: the graph develops its own sense of relevance
+ * over time based on actual usage patterns.
+ *
+ * A customer support agent's graph naturally strengthens paths through
+ * product docs and refund policies while letting rarely-queried HR
+ * edges decay.
+ */
+export interface PathStrengthResult {
+    strengthened: number;
+    weakened: number;
+    pruned: number;
+}
+/**
+ * Strengthen the association path between memories that were
+ * retrieved together and found useful.
+ */
+export declare function strengthenPath(memoryIds: string[], boostAmount?: number): Promise<number>;
+/**
+ * Weaken association paths that led to irrelevant results.
+ */
+export declare function weakenPath(memoryIds: string[], decayAmount?: number): Promise<number>;
+/**
+ * Prune associations that have decayed below a threshold.
+ */
+export declare function pruneWeakAssociations(minWeight?: number, maxAge?: number): Promise<number>;
+/**
+ * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
+ * prune dead associations, and derive implicit facts.
+ */
+export declare function runPruneCycle(options?: {
+    minWeight?: number;
+    maxAge?: number;
+}): Promise<PathStrengthResult>;
+//# sourceMappingURL=path-strengthener.d.ts.map

package/dist/core/memory/path-strengthener.js

@@ -0,0 +1,150 @@
+/**
+ * Path Strengthener
+ *
+ * Strengthens association paths that led to successful retrievals and
+ * weakens paths that led to irrelevant results. This implements the
+ * "optimize" concept: the graph develops its own sense of relevance
+ * over time based on actual usage patterns.
+ *
+ * A customer support agent's graph naturally strengthens paths through
+ * product docs and refund policies while letting rarely-queried HR
+ * edges decay.
+ */
+import { eq, and, or, sql } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+/**
+ * Strengthen the association path between memories that were
+ * retrieved together and found useful.
+ */
+export async function strengthenPath(memoryIds, boostAmount = 2) {
+    if (memoryIds.length < 2)
+        return 0;
+    const db = await getDb();
+    const schema = await getSchema();
+    let strengthened = 0;
+    // Generate all pairs
+    for (let i = 0; i < memoryIds.length; i++) {
+        for (let j = i + 1; j < memoryIds.length; j++) {
+            try {
+                // Check if association exists
+                const existing = await db
+                    .select()
+                    .from(schema.memoryAssociations)
+                    .where(or(and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]), eq(schema.memoryAssociations.toMemoryId, memoryIds[j])), and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]), eq(schema.memoryAssociations.toMemoryId, memoryIds[i]))))
+                    .limit(1);
+                if (existing.length > 0) {
+                    // Strengthen existing association
+                    await db
+                        .update(schema.memoryAssociations)
+                        .set({
+                        weight: sql `${schema.memoryAssociations.weight} + ${boostAmount}`,
+                        coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
+                        lastCoactivatedAt: new Date(),
+                    })
+                        .where(eq(schema.memoryAssociations.id, existing[0].id));
+                }
+                else {
+                    // Create new association
+                    await db.insert(schema.memoryAssociations).values({
+                        fromMemoryId: memoryIds[i],
+                        toMemoryId: memoryIds[j],
+                        associationType: 'co_occurred',
+                        weight: boostAmount,
+                        coactivationCount: 1,
+                        lastCoactivatedAt: new Date(),
+                    });
+                }
+                strengthened++;
+            }
+            catch (error) {
+                logger.debug('Error strengthening path', {
+                    from: memoryIds[i],
+                    to: memoryIds[j],
+                    error: error,
+                });
+            }
+        }
+    }
+    return strengthened;
+}
+/**
+ * Weaken association paths that led to irrelevant results.
+ */
+export async function weakenPath(memoryIds, decayAmount = 0.5) {
+    if (memoryIds.length < 2)
+        return 0;
+    const db = await getDb();
+    const schema = await getSchema();
+    let weakened = 0;
+    for (let i = 0; i < memoryIds.length; i++) {
+        for (let j = i + 1; j < memoryIds.length; j++) {
+            try {
+                const existing = await db
+                    .select()
+                    .from(schema.memoryAssociations)
+                    .where(or(and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]), eq(schema.memoryAssociations.toMemoryId, memoryIds[j])), and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]), eq(schema.memoryAssociations.toMemoryId, memoryIds[i]))))
+                    .limit(1);
+                if (existing.length > 0) {
+                    // Weaken but don't remove (minimum weight of 1)
+                    await db
+                        .update(schema.memoryAssociations)
+                        .set({
+                        weight: sql `GREATEST(${schema.memoryAssociations.weight} - ${decayAmount}, 1)`,
+                    })
+                        .where(eq(schema.memoryAssociations.id, existing[0].id));
+                    weakened++;
+                }
+            }
+            catch (error) {
+                logger.debug('Error weakening path', {
+                    from: memoryIds[i],
+                    to: memoryIds[j],
+                    error: error,
+                });
+            }
+        }
+    }
+    return weakened;
+}
+/**
+ * Prune associations that have decayed below a threshold.
+ */
+export async function pruneWeakAssociations(minWeight = 2, maxAge = 90 // days
+) {
+    const db = await getDb();
+    const schema = await getSchema();
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - maxAge);
+    try {
+        // Delete associations that are weak AND old
+        const result = await db
+            .delete(schema.memoryAssociations)
+            .where(and(sql `${schema.memoryAssociations.weight} < ${minWeight}`, sql `${schema.memoryAssociations.lastCoactivatedAt} < ${cutoffDate}`));
+        const pruned = result?.rowCount ?? 0;
+        logger.info('Pruned weak associations', { pruned, minWeight, maxAge });
+        return pruned;
+    }
+    catch (error) {
+        logger.error('Error pruning weak associations', { error: error });
+        return 0;
+    }
+}
+/**
+ * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
+ * prune dead associations, and derive implicit facts.
+ */
+export async function runPruneCycle(options) {
+    const { minWeight = 2, maxAge = 90 } = options || {};
+    logger.info('Starting prune cycle', { minWeight, maxAge });
+    // Step 1: Prune weak associations
+    const pruned = await pruneWeakAssociations(minWeight, maxAge);
+    logger.info('Prune cycle completed', { pruned });
+    return {
+        strengthened: 0, // Strengthening happens via retrieval feedback
+        weakened: 0, // Weakening happens via retrieval feedback
+        pruned,
+    };
+}
+//# sourceMappingURL=path-strengthener.js.map