squish-memory 1.0.2 → 1.2.0

package/dist/core/memory/entity-extractor.js

@@ -9,29 +9,43 @@ import { eq, and } from 'drizzle-orm';
 import { logger } from '../../core/logger.js';
 // Regex patterns for entity detection
 const PATTERNS = {
-    // File paths: src/components/Button.tsx, ./config.json, /var/log/app.log
+    // File paths: src/components/Button.tsx
     filePath: /(?:^|[^\w])(?:\.?\/[\w.-]*[\w.-]*(?:\/[\w.-]+)*|[\w.-]+\.(?:ts|tsx|js|jsx|py|rb|go|java|cpp|c|h|json|yaml|yml|env|md|txt|csv|sql|graphql))\b/gm,
-    // Functions/methods: `functionName()`, `object.method()`, `Class.staticMethod()`
+    // Functions/methods
     functionCall: /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g,
-    // Classes: `class ClassName`, `new ClassName()`, `extends ClassName`
+    // Classes
     className: /\b(?:class|new|extends|implements)\s+([A-Z][a-zA-Z0-9_$]*)\b/g,
-    // Common names (capitalized words not at sentence start)
+    // Common names
     personName: /(?:^|[^.\w])\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\b(?![^.\w])/g,
-    // Capitalized concepts: `Machine Learning`, `React Hooks`
-    concept: /\b(?:[A-Z][a-z]+\s+)+(?:System|Architecture|Pattern|Model|Algorithm|Framework|Library|Process|Concept|Theory|Method)\b/g,
-    // Technologies/Tools: React, Node.js, PostgreSQL, Docker, Kubernetes
-    tool: /\b(?:React|Vue|Angular|Node\.?js?|Express|Django|Flask|FastAPI|PostgreSQL|MongoDB|Redis|Docker|Kubernetes|Terraform|AWS|Azure|GCP|GitHub|GitLab|Jenkins|Figma|Sketch|Adobe|Webpack|Vite|npm|yarn|pnpm|TypeScript|JavaScript|Python|Go|Rust|Java|C\+\+|C#)\b/g,
-    // Design patterns: `singleton pattern`, `factory method`, `observer pattern`
-    designPattern: /\b(?:abstract\s+)?(?:factory|singleton|observer|decorator|strategy|adapter|bridge|facade|proxy|chain\s+of\s+responsibility|composite|template\s+method|visitor|builder|prototype|memento|interpreter|command|state|mediator)\s+(?:pattern|method)\b/gi,
-    // Techniques/Methodologies: `memoization`, `caching`, `lazy loading`, `debouncing`
-    technique: /\b(?:memoization|caching|lazy\s+loading|debouncing|throttling|currying|composition|recursion|iteration|hashing|indexing|sharding|replication|optimization|refactoring|testing|debugging|profiling|monitoring|logging)\b/gi,
-    // Quoted concepts and important terms
-    quotedConcept: /["`]([^"`]+)["`]/g,
+    // Capitalized concepts
+    concept: /\b(?:[A-Z][a-z]+\s+)+(?:System|Architecture|Pattern|Model|Algorithm|Framework|Library|Process|Concept|Method)\b/g,
+    // Tools
+    tool: /\b(?:React|Vue|Angular|Node\.?js?|Express|Django|Flask|FastAPI|PostgreSQL|MongoDB|Redis|Docker|Kubernetes)\b/g,
+    // Design patterns
+    designPattern: /\b(?:abstract\s+)?(?:factory|singleton|observer|decorator|strategy|adapter)\s+(?:pattern|method)\b/gi,
+    // Techniques
+    technique: /\b(?:memoization|caching|lazy\s+loading|debouncing|throttling)\b/gi,
     // ISO dates
     date: /\b(\d{4}-\d{2}-\d{2})(?:T\d{2}:\d{2}:\d{2})?\b/g,
-    // Common code keywords and variables
-    codeVariable: /\b(?:const|let|var|function|async|await|return|import|export|class|interface|type|enum)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g,
 };
+/**
+ * Extract unique entity names for auto-linking
+ */
+export function extractEntityNames(content) {
+    const names = new Set();
+    // Extract person names
+    const namePattern = /(?:^|[^.\w])\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\b(?![^.\w])/g;
+    let match;
+    while ((match = namePattern.exec(content)) !== null) {
+        names.add(match[1].toLowerCase());
+    }
+    // Extract capitalized concepts
+    const conceptPattern = /\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+\b/g;
+    while ((match = conceptPattern.exec(content)) !== null) {
+        names.add(match[0].toLowerCase());
+    }
+    return Array.from(names).slice(0, 10);
+}
 /**
  * Extract entities from content
  */

package/dist/core/memory/entity-resolver.js

@@ -3,13 +3,13 @@
  * NO FALLBACKS - real extraction or throw
  */
 export async function extractQueryEntities(query, callClaudeFn) {
-    const prompt = `Extract entities from this question. Return ONLY JSON:
-{
-  "primary": ["Alice", "project name"],
-  "secondary": ["team", "budget"],
-  "queryType": "factual"
-}
-
+    const prompt = `Extract entities from this question. Return ONLY JSON:
+{
+  "primary": ["Alice", "project name"],
+  "secondary": ["team", "budget"],
+  "queryType": "factual"
+}
+
 Question: ${query}`;
     const response = await callClaudeFn(prompt, 500);
     const jsonMatch = response.match(/\{[\s\S]*\}/);

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

@@ -0,0 +1,18 @@
+import type { StoredBelief } from '../beliefs/types.js';
+export interface MemoryInspection {
+    id: string;
+    type: string;
+    classification: string;
+    reasons: string[];
+    rawFallbackSnapshotId?: string | null;
+    nuanceSuppressed: boolean;
+    place?: string | null;
+    placeType?: string | null;
+    graphStatus?: string | null;
+    content: string;
+    legacyMetadata: boolean;
+    beliefs?: StoredBelief[];
+}
+export declare function summarizeInspection(input: MemoryInspection): string;
+export declare function explainMemory(id: string): Promise<MemoryInspection | null>;
+//# sourceMappingURL=explain.d.ts.map

package/dist/core/memory/explain.js

@@ -0,0 +1,92 @@
+import { eq } from 'drizzle-orm';
+import { getDbClient } from '../lib/db-client.js';
+import { deserializeMetadata } from './serialization.js';
+import { getMemorySnapshot } from '../snapshots/retrieval.js';
+import { getMemoryPlace } from '../places/memory-places.js';
+import { getPlace } from '../places/places.js';
+import { getBeliefsForMemory } from '../beliefs/store.js';
+export function summarizeInspection(input) {
+    const lines = [
+        `Memory ${input.id}`,
+        `Type: ${input.type}`,
+        `Classification: ${input.classification}`,
+        `Reasons: ${input.reasons.join('; ') || 'n/a'}`,
+        `Raw fallback: ${input.rawFallbackSnapshotId ?? 'none'}`,
+        `nuance suppressed: ${input.nuanceSuppressed ? 'yes' : 'no'}`,
+        `Place: ${input.place ?? 'none'}${input.placeType ? ` (${input.placeType})` : ''}`,
+        `Graph: ${input.graphStatus ?? 'none'}`,
+        `Content: ${input.content}`,
+        `Legacy metadata: ${input.legacyMetadata ? 'yes' : 'no'}`,
+    ];
+    if (input.beliefs && input.beliefs.length > 0) {
+        lines.push('Beliefs:');
+        for (const belief of input.beliefs) {
+            const confidence = typeof belief.confidence === 'number' ? belief.confidence.toFixed(1) : '?';
+            const sourceCount = belief.sourceMemoryIds?.length ?? 1;
+            const origin = sourceCount > 1 ? `derived from ${sourceCount} memories` : 'derived from 1 memory';
+            const evidence = belief.evidenceSummary
+                ? `\n  Evidence: ${belief.evidenceSummary.slice(0, 100)}${belief.evidenceSummary.length > 100 ? '...' : ''}`
+                : '';
+            lines.push(`- [${belief.type}] ${belief.statement}`);
+            lines.push(`  Status: ${belief.status}, Confidence: ${confidence}/100, ${origin}${evidence}`);
+            if (belief.status === 'superseded') {
+                lines.push(`  Note: This belief supersedes a previous version`);
+            }
+            if (belief.status === 'disputed') {
+                lines.push(`  Warning: This belief has been disputed`);
+            }
+        }
+    }
+    else {
+        lines.push(`Beliefs: ${input.legacyMetadata ? 'No derived beliefs available for this legacy record' : 'none derived'}`);
+    }
+    return lines.join('\n');
+}
+export async function explainMemory(id) {
+    const { db, schema } = await getDbClient();
+    const rows = await db.select().from(schema.memories).where(eq(schema.memories.id, id)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return null;
+    const metadata = deserializeMetadata(row.metadata ?? null);
+    const rawClassification = metadata?.signal?.classification ?? metadata?.classification ?? null;
+    const classification = typeof rawClassification === 'string' && rawClassification.trim().length > 0
+        ? rawClassification
+        : 'legacy-durable';
+    const reasons = Array.isArray(metadata?.signal?.reasons)
+        ? metadata?.signal?.reasons
+        : Array.isArray(metadata?.reasons)
+            ? metadata?.reasons
+            : ['This record predates signal tracking, so detailed ingestion metadata is unavailable.'];
+    const rawFallbackSnapshotId = typeof metadata?.rawFallbackSnapshotId === 'string'
+        ? metadata.rawFallbackSnapshotId
+        : null;
+    const nuanceSuppressed = Boolean(metadata?.signal?.nuanceSuppressed ?? metadata?.nuanceSuppressed);
+    const graphStatus = typeof metadata?.graphStatus === 'string'
+        ? metadata.graphStatus
+        : typeof metadata?.graph === 'object' && metadata.graph
+            ? JSON.stringify(metadata.graph)
+            : 'Unavailable for this legacy record';
+    const legacyMetadata = rawClassification == null;
+    const placeId = await getMemoryPlace(id);
+    const place = placeId ? await getPlace(placeId) : null;
+    if (rawFallbackSnapshotId) {
+        await getMemorySnapshot(rawFallbackSnapshotId);
+    }
+    const beliefs = await getBeliefsForMemory(id);
+    return {
+        id: row.id,
+        type: row.type,
+        classification,
+        reasons,
+        rawFallbackSnapshotId,
+        nuanceSuppressed,
+        place: place?.name ?? null,
+        placeType: place?.placeType ?? null,
+        graphStatus,
+        content: row.content,
+        legacyMetadata,
+        beliefs,
+    };
+}
+//# sourceMappingURL=explain.js.map

package/dist/core/memory/fact-deriver.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fact Deriver
+ *
+ * Derives implicit facts from existing relationships in the knowledge graph.
+ * Example: works_on(A, X) + uses(X, Y) -> depends_on(A, Y)
+ */
+import type { RelationType } from '../graph/llm-entity-extractor.js';
+export interface DerivedFact {
+    fromEntityId: string;
+    fromEntityName: string;
+    toEntityId: string;
+    toEntityName: string;
+    relationType: RelationType;
+    rule: string;
+    confidence: number;
+    isDerived: boolean;
+}
+/**
+ * Derive implicit facts from existing relationships in the knowledge graph.
+ * Applies transitivity and causal rules to find new relationships.
+ */
+export declare function deriveFacts(projectId: string, options?: {
+    maxDerivations?: number;
+    minConfidence?: number;
+    storeResults?: boolean;
+}): Promise<DerivedFact[]>;
+/**
+ * Get all derived facts for a project.
+ */
+export declare function getDerivedFacts(projectId: string): Promise<DerivedFact[]>;
+//# sourceMappingURL=fact-deriver.d.ts.map

package/dist/core/memory/fact-deriver.js

@@ -0,0 +1,236 @@
+/**
+ * Fact Deriver
+ *
+ * Derives implicit facts from existing relationships in the knowledge graph.
+ * Example: works_on(A, X) + uses(X, Y) -> depends_on(A, Y)
+ */
+import { eq, and, or } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+const DERIVATION_RULES = [
+    // Transitivity rules
+    {
+        name: 'works_on_uses_depends_on',
+        fromType: 'works_on',
+        toType: 'uses',
+        derivedType: 'depends_on',
+        description: 'If A works on X and X uses Y, then A depends on Y',
+        confidence: 0.8,
+    },
+    {
+        name: 'manages_works_oversees',
+        fromType: 'manages',
+        toType: 'works_on',
+        derivedType: 'oversees',
+        description: 'If A manages B and B works on X, then A oversees X',
+        confidence: 0.75,
+    },
+    {
+        name: 'caused_affects_may_affect',
+        fromType: 'caused',
+        toType: 'affects',
+        derivedType: 'may_affect',
+        description: 'If X caused Y and Y affects Z, then X may affect Z',
+        confidence: 0.7,
+    },
+    {
+        name: 'part_of_contains',
+        fromType: 'part_of',
+        toType: 'contains',
+        derivedType: 'related_to',
+        description: 'If A is part of X and X contains B, then A is related to B',
+        confidence: 0.6,
+    },
+    {
+        name: 'uses_depends_on',
+        fromType: 'uses',
+        toType: 'depends_on',
+        derivedType: 'depends_on',
+        description: 'If A uses X and X depends on Y, then A depends on Y',
+        confidence: 0.85,
+    },
+    {
+        name: 'created_resolved',
+        fromType: 'created',
+        toType: 'resolved',
+        derivedType: 'related_to',
+        description: 'If A created X and X was resolved by B, then A is related to B',
+        confidence: 0.5,
+    },
+    {
+        name: 'blocks_depends_on',
+        fromType: 'blocks',
+        toType: 'depends_on',
+        derivedType: 'blocks',
+        description: 'If X blocks A and A depends on Y, then X may block Y',
+        confidence: 0.65,
+    },
+];
+// ─── Main Derivation Function ─────────────────────────────────────────────────
+/**
+ * Derive implicit facts from existing relationships in the knowledge graph.
+ * Applies transitivity and causal rules to find new relationships.
+ */
+export async function deriveFacts(projectId, options) {
+    const { maxDerivations = 50, minConfidence = 0.6, storeResults = true } = options || {};
+    const db = await getDb();
+    const schema = await getSchema();
+    // Get all entities for this project
+    const entities = await db
+        .select()
+        .from(schema.entities)
+        .where(eq(schema.entities.projectId, projectId));
+    if (entities.length < 2)
+        return [];
+    const entityMap = new Map(entities.map((e) => [e.id, e]));
+    const derivedFacts = [];
+    // Get all relations for this project's entities
+    const entityIds = entities.map((e) => e.id);
+    const allRelations = [];
+    // Fetch in batches to avoid query size limits
+    const batchSize = 100;
+    for (let i = 0; i < entityIds.length; i += batchSize) {
+        const batch = entityIds.slice(i, i + batchSize);
+        const relations = await db
+            .select()
+            .from(schema.entityRelations)
+            .where(or(...batch.map((id) => eq(schema.entityRelations.fromEntityId, id))));
+        allRelations.push(...relations);
+    }
+    // Build adjacency list for fast lookup
+    const outgoing = new Map();
+    for (const rel of allRelations) {
+        if (!outgoing.has(rel.fromEntityId)) {
+            outgoing.set(rel.fromEntityId, new Map());
+        }
+        outgoing.get(rel.fromEntityId).set(rel.toEntityId, {
+            relationType: rel.type,
+            weight: rel.weight || 1,
+        });
+    }
+    // Apply derivation rules
+    for (const rule of DERIVATION_RULES) {
+        if (derivedFacts.length >= maxDerivations)
+            break;
+        if (rule.confidence < minConfidence)
+            continue;
+        // Find all pairs where fromType matches
+        for (const [fromId, targets] of outgoing) {
+            if (derivedFacts.length >= maxDerivations)
+                break;
+            for (const [midId, fromRel] of targets) {
+                if (fromRel.relationType !== rule.fromType)
+                    continue;
+                // Check if midId has outgoing toType relations
+                const midTargets = outgoing.get(midId);
+                if (!midTargets)
+                    continue;
+                for (const [toId, toRel] of midTargets) {
+                    if (toRel.relationType !== rule.toType)
+                        continue;
+                    // Found a derivation: fromId --fromType--> midId --toType--> toId
+                    // Derive: fromId --derivedType--> toId
+                    const fromEntity = entityMap.get(fromId);
+                    const toEntity = entityMap.get(toId);
+                    if (!fromEntity || !toEntity)
+                        continue;
+                    // Check if this derived relation already exists
+                    const existing = await db
+                        .select()
+                        .from(schema.entityRelations)
+                        .where(and(eq(schema.entityRelations.fromEntityId, fromId), eq(schema.entityRelations.toEntityId, toId), eq(schema.entityRelations.type, rule.derivedType)))
+                        .limit(1);
+                    if (existing.length > 0)
+                        continue; // Already exists
+                    const derivedFact = {
+                        fromEntityId: fromId,
+                        fromEntityName: fromEntity.name,
+                        toEntityId: toId,
+                        toEntityName: toEntity.name,
+                        relationType: rule.derivedType,
+                        rule: rule.name,
+                        confidence: rule.confidence,
+                        isDerived: true,
+                    };
+                    derivedFacts.push(derivedFact);
+                    // Store the derived fact if requested
+                    if (storeResults) {
+                        try {
+                            await db.insert(schema.entityRelations).values({
+                                fromEntityId: fromId,
+                                toEntityId: toId,
+                                type: rule.derivedType,
+                                weight: Math.round(rule.confidence * 10),
+                                properties: {
+                                    derived: true,
+                                    rule: rule.name,
+                                    confidence: rule.confidence,
+                                    description: rule.description,
+                                },
+                            });
+                        }
+                        catch (error) {
+                            logger.debug('Error storing derived fact', {
+                                rule: rule.name,
+                                from: fromEntity.name,
+                                to: toEntity.name,
+                                error: error,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    logger.info('Fact derivation completed', {
+        projectId,
+        derivedCount: derivedFacts.length,
+        rulesApplied: DERIVATION_RULES.length,
+    });
+    return derivedFacts;
+}
+/**
+ * Get all derived facts for a project.
+ */
+export async function getDerivedFacts(projectId) {
+    const db = await getDb();
+    const schema = await getSchema();
+    // Get all entities for this project
+    const entities = await db
+        .select()
+        .from(schema.entities)
+        .where(eq(schema.entities.projectId, projectId));
+    const entityIds = entities.map((e) => e.id);
+    if (entityIds.length === 0)
+        return [];
+    // Get all derived relations
+    const derivedRelations = [];
+    const batchSize = 100;
+    for (let i = 0; i < entityIds.length; i += batchSize) {
+        const batch = entityIds.slice(i, i + batchSize);
+        const relations = await db
+            .select()
+            .from(schema.entityRelations)
+            .where(or(...batch.map((id) => eq(schema.entityRelations.fromEntityId, id))));
+        for (const rel of relations) {
+            const props = rel.properties;
+            if (props && props.derived === true) {
+                const fromEntity = entities.find((e) => e.id === rel.fromEntityId);
+                const toEntity = entities.find((e) => e.id === rel.toEntityId);
+                derivedRelations.push({
+                    fromEntityId: rel.fromEntityId,
+                    fromEntityName: fromEntity?.name || 'Unknown',
+                    toEntityId: rel.toEntityId,
+                    toEntityName: toEntity?.name || 'Unknown',
+                    relationType: rel.type,
+                    rule: props.rule || 'unknown',
+                    confidence: props.confidence || 0.5,
+                    isDerived: true,
+                });
+            }
+        }
+    }
+    return derivedRelations;
+}
+//# sourceMappingURL=fact-deriver.js.map

package/dist/core/memory/fact-extractor.js

@@ -13,18 +13,18 @@ export async function extractFacts(text, callClaude) {
             entities: []
         };
     }
-    const prompt = `Extract atomic facts from this conversation. 
-
-Requirements:
-- Extract specific, verifiable facts (names, dates, numbers, relationships)
-- Each fact should be a standalone statement
-- Identify entities (people, organizations, projects, locations)
-- Note temporal information and relationships
-
-Return ONLY valid JSON in this exact format:
-{"facts":[{"content":"fact statement","confidence":0.95,"entities":["Name"],"relation":"optional"}],"summary":"brief summary","entities":["all","entities"]}
-
-Text to analyze:
+    const prompt = `Extract atomic facts from this conversation. 
+
+Requirements:
+- Extract specific, verifiable facts (names, dates, numbers, relationships)
+- Each fact should be a standalone statement
+- Identify entities (people, organizations, projects, locations)
+- Note temporal information and relationships
+
+Return ONLY valid JSON in this exact format:
+{"facts":[{"content":"fact statement","confidence":0.95,"entities":["Name"],"relation":"optional"}],"summary":"brief summary","entities":["all","entities"]}
+
+Text to analyze:
 ${text.substring(0, 4000)}`;
     const response = await callClaude(prompt, 2000);
     // Extract JSON - look for the first { and last }

package/dist/core/memory/feedback-tracker.js

@@ -2,7 +2,7 @@
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 import { getDb } from '../../db/index.js';
-import { memoryFeedback, memories } from '../../drizzle/schema-sqlite.js';
+import { memoryFeedback, memories } from '../../db/drizzle/schema-sqlite.js';
 import { eq, and } from 'drizzle-orm';
 import { analyzeResponseForMemoryReferences, mightContainMemoryReferences } from './response-analyzer.js';
 const injectionTracker = new Map();

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

@@ -0,0 +1,88 @@
+/**
+ * Memory Lifecycle Hooks
+ *
+ * Provides event hooks for memory operations:
+  * - memoryCreated: When a memory is stored (DB or markdown files)
+ * - memoryUpdated: When a memory is updated
+ * - memoryDeleted: When a memory is deleted
+ * - tierChange: When memory tier changes (hot/warm/cold)
+ * - decayApplied: When decay score is updated
+ *
+ * Each hook can have sync and async handlers.
+ * Usage: Register handlers to auto-capture, sync to external systems, etc.
+ */
+export type HookEvent = 'memoryCreated' | 'memoryUpdated' | 'memoryDeleted' | 'tierChange' | 'decayApplied';
+export interface MemoryHookContext {
+    memoryId: string;
+    content: string;
+    type: string;
+    tags: string[];
+    project?: string;
+    source?: string;
+    tier?: string;
+    importance?: number;
+    oldContent?: string;
+}
+export interface TierChangeContext extends MemoryHookContext {
+    oldTier: string;
+    newTier: string;
+}
+export interface DecayContext extends MemoryHookContext {
+    oldScore: number;
+    newScore: number;
+}
+export type HookHandler<T = MemoryHookContext> = (context: T) => void | Promise<void>;
+/**
+ * Register a hook handler for a specific event
+ */
+export declare function registerHook(event: HookEvent, handler: HookHandler, priority?: number): void;
+/**
+ * Unregister a hook handler
+ */
+export declare function unregisterHook(event: HookEvent, handler: HookHandler): void;
+/**
+ * Clear all hooks for an event
+ */
+export declare function clearHooks(event?: HookEvent): void;
+/**
+ * Get registered hooks for an event
+ */
+export declare function getHooks(event: HookEvent): HookHandler[];
+/**
+ * List all registered hooks (for debugging)
+ */
+export declare function listHooks(): {
+    event: HookEvent;
+    priority: number;
+}[];
+/**
+ * Trigger memoryCreated hooks
+ * Called when a memory is stored in DB or markdown files
+ */
+export declare function triggerMemoryCreated(context: MemoryHookContext): Promise<void>;
+/**
+ * Trigger memoryUpdated hooks
+ * Called when a memory content/tags/etc changes
+ */
+export declare function triggerMemoryUpdated(context: MemoryHookContext, oldContent?: string): Promise<void>;
+/**
+ * Trigger memoryDeleted hooks
+ * Called when a memory is deleted
+ */
+export declare function triggerMemoryDeleted(context: MemoryHookContext): Promise<void>;
+/**
+ * Trigger tierChange hooks
+ * Called when memory tier changes
+ */
+export declare function triggerTierChange(context: TierChangeContext): Promise<void>;
+/**
+ * Trigger decayApplied hooks
+ * Called when memory decay score changes
+ */
+export declare function triggerDecayApplied(context: DecayContext): Promise<void>;
+/**
+ * Built-in hook: Auto-save to memory files when storing to DB
+ * Use this to have dual storage (DB + markdown files)
+ */
+export declare function createMarkdownAutoSyncHook(): (context: MemoryHookContext) => Promise<void>;
+//# sourceMappingURL=hooks.d.ts.map