squish-memory 1.2.0 → 1.2.1

package/dist/core/associations.js

@@ -1,284 +0,0 @@
-/**
- * Memory Association Graph (Waypoint Graph)
- * Tracks co-occurrence and relationships between memories
- */
-import { eq, and, or, desc, inArray, sql } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { logger } from './logger.js';
-/**
- * Create or update an association between two memories
- */
-export async function createAssociation(fromMemoryId, toMemoryId, type, weight = 1) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Check if association already exists
-        const existing = await db
-            .select()
-            .from(schema.memoryAssociations)
-            .where(and(eq(schema.memoryAssociations.fromMemoryId, fromMemoryId), eq(schema.memoryAssociations.toMemoryId, toMemoryId)))
-            .limit(1);
-        if (existing.length > 0) {
-            // Update weight and coactivation count
-            await db
-                .update(schema.memoryAssociations)
-                .set({
-                weight: existing[0].weight + weight,
-                coactivationCount: existing[0].coactivationCount + 1,
-                lastCoactivatedAt: new Date(),
-            })
-                .where(eq(schema.memoryAssociations.id, existing[0].id));
-        }
-        else {
-            // Create new association
-            await db.insert(schema.memoryAssociations).values({
-                fromMemoryId,
-                toMemoryId,
-                associationType: type,
-                weight,
-                coactivationCount: 1,
-                lastCoactivatedAt: new Date(),
-            });
-        }
-    }
-    catch (error) {
-        logger.error('Error creating association', error);
-    }
-}
-/**
- * Auto-link memories that share entities
- * Called after storing a memory to link it to related memories
- */
-export async function autoLinkByEntities(newMemoryId, entityNames, projectId) {
-    if (entityNames.length === 0)
-        return 0;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Find existing memories that contain any of these entity names
-        // Use simple LIKE query for matching
-        const conditions = entityNames.slice(0, 5).map(name => sql `LOWER(m.content) LIKE ${'%' + name + '%'}`);
-        const existing = await db
-            .select({
-            id: schema.memories.id,
-            content: schema.memories.content
-        })
-            .from(schema.memories)
-            .where(and(eq(schema.memories.projectId, projectId), sql `(${conditions.join(' OR ')})`, sql `id != ${newMemoryId}`))
-            .limit(10);
-        // Create associations for matching memories
-        let linked = 0;
-        for (const mem of existing) {
-            try {
-                await createAssociation(newMemoryId, mem.id, 'relates_to', 0.5);
-                linked++;
-            }
-            catch (e) {
-                // Skip duplicates
-            }
-        }
-        return linked;
-    }
-    catch (error) {
-        logger.error('Error auto-linking by entities', error);
-        return 0;
-    }
-}
-export async function trackCoactivation(memoryIds) {
-    if (memoryIds.length < 2)
-        return;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        // Generate all pairs
-        const pairs = [];
-        for (let i = 0; i < memoryIds.length; i++) {
-            for (let j = i + 1; j < memoryIds.length; j++) {
-                pairs.push({ from: memoryIds[i], to: memoryIds[j] });
-                pairs.push({ from: memoryIds[j], to: memoryIds[i] }); // Bidirectional
-            }
-        }
-        if (pairs.length === 0)
-            return;
-        // Batch check existing associations with single SELECT
-        const pairIds = pairs.map(p => ({ from: p.from, to: p.to }));
-        // Check which pairs already exist
-        const existingPairs = await db
-            .select({ fromId: schema.memoryAssociations.fromMemoryId, toId: schema.memoryAssociations.toMemoryId })
-            .from(schema.memoryAssociations)
-            .where(or(...pairIds.map((p) => and(eq(schema.memoryAssociations.fromMemoryId, p.from), eq(schema.memoryAssociations.toMemoryId, p.to)))));
-        const existingMap = new Set(existingPairs.map((p) => `${p.fromId}:${p.toId}`));
-        // Separate into new pairs and existing pairs
-        const newPairs = [];
-        const existingPairsToUpdate = [];
-        for (const pair of pairs) {
-            const key = `${pair.from}:${pair.to}`;
-            if (existingMap.has(key)) {
-                existingPairsToUpdate.push(key);
-            }
-            else {
-                newPairs.push({
-                    fromMemoryId: pair.from,
-                    toMemoryId: pair.to,
-                    associationType: 'co_occurred',
-                    weight: 1,
-                    coactivationCount: 1,
-                    lastCoactivatedAt: now,
-                });
-            }
-        }
-        // Bulk insert new associations
-        if (newPairs.length > 0) {
-            const BATCH_SIZE = 100;
-            for (let i = 0; i < newPairs.length; i += BATCH_SIZE) {
-                const batch = newPairs.slice(i, i + BATCH_SIZE);
-                try {
-                    // For PostgreSQL with ON CONFLICT support
-                    if (db.insert && db.onConflict) {
-                        await db
-                            .insert(schema.memoryAssociations)
-                            .values(batch)
-                            .onConflict({
-                            target: [schema.memoryAssociations.fromMemoryId, schema.memoryAssociations.toMemoryId],
-                            set: {
-                                weight: sql.raw('EXCLUDED.weight'),
-                                coactivationCount: sql.raw('EXCLUDED.coactivation_count'),
-                                lastCoactivatedAt: now,
-                            },
-                        })
-                            .catch(() => {
-                            // Fallback for SQLite
-                            return db.insert(schema.memoryAssociations).values(batch);
-                        });
-                    }
-                    else {
-                        // Direct insert for SQLite
-                        await db.insert(schema.memoryAssociations).values(batch);
-                    }
-                }
-                catch (error) {
-                    logger.error('Error inserting batch of associations', { batchSize: batch.length, error });
-                }
-            }
-        }
-        // Bulk update existing associations
-        if (existingPairsToUpdate.length > 0) {
-            const BATCH_SIZE = 100;
-            for (let i = 0; i < existingPairsToUpdate.length; i += BATCH_SIZE) {
-                const batch = existingPairsToUpdate.slice(i, i + BATCH_SIZE);
-                // Extract from/to pairs for this batch
-                const batchPairs = batch.map(key => {
-                    const [from, to] = key.split(':');
-                    return { from, to };
-                });
-                try {
-                    for (const pair of batchPairs) {
-                        await db
-                            .update(schema.memoryAssociations)
-                            .set({
-                            weight: sql `${schema.memoryAssociations.weight} + 1`,
-                            coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
-                            lastCoactivatedAt: now,
-                        })
-                            .where(and(eq(schema.memoryAssociations.fromMemoryId, pair.from), eq(schema.memoryAssociations.toMemoryId, pair.to)));
-                    }
-                }
-                catch (error) {
-                    logger.error('Error updating batch of associations', { batchSize: batch.length, error });
-                }
-            }
-        }
-        logger.debug('Coactivation tracked', {
-            totalPairs: pairs.length,
-            newAssociations: newPairs.length,
-            updatedAssociations: existingPairsToUpdate.length,
-        });
-    }
-    catch (error) {
-        logger.error('Error tracking coactivation', error);
-    }
-}
-/**
- * Get related memories via the association graph
- */
-export async function getRelatedMemories(memoryId, limit = 10) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get all associated memories, sorted by weight
-        const associations = await db
-            .select()
-            .from(schema.memoryAssociations)
-            .where(or(eq(schema.memoryAssociations.fromMemoryId, memoryId), eq(schema.memoryAssociations.toMemoryId, memoryId)))
-            .orderBy(desc(schema.memoryAssociations.weight))
-            .limit(limit);
-        const relatedIds = associations.map((a) => a.fromMemoryId === memoryId ? a.toMemoryId : a.fromMemoryId);
-        if (relatedIds.length === 0)
-            return [];
-        // Fetch the actual memories
-        return await db
-            .select()
-            .from(schema.memories)
-            .where(inArray(schema.memories.id, relatedIds));
-    }
-    catch (error) {
-        logger.error('Error getting related memories', error);
-        return [];
-    }
-}
-/**
- * Prune weak associations (weight < threshold)
- */
-export async function pruneWeakAssociations(weightThreshold = 5) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const result = await db
-            .delete(schema.memoryAssociations)
-            .where(schema.memoryAssociations.weight <= weightThreshold);
-        return result?.rowCount || 0;
-    }
-    catch (error) {
-        logger.error('Error pruning weak associations', error);
-        return 0;
-    }
-}
-/**
- * Get association statistics
- */
-export async function getAssociationStats() {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const associations = await db
-            .select()
-            .from(schema.memoryAssociations);
-        const stats = {
-            totalAssociations: associations.length,
-            byType: {},
-            avgWeight: 0,
-            maxWeight: 0,
-        };
-        let totalWeight = 0;
-        for (const assoc of associations) {
-            stats.byType[assoc.associationType] = (stats.byType[assoc.associationType] || 0) + 1;
-            totalWeight += assoc.weight;
-            if (assoc.weight > stats.maxWeight)
-                stats.maxWeight = assoc.weight;
-        }
-        stats.avgWeight = associations.length > 0 ? totalWeight / associations.length : 0;
-        return stats;
-    }
-    catch (error) {
-        logger.error('Error getting association stats', error);
-        return {
-            totalAssociations: 0,
-            byType: {},
-            avgWeight: 0,
-            maxWeight: 0,
-        };
-    }
-}
-//# sourceMappingURL=associations.js.map

package/dist/core/autosave.d.ts

@@ -1,19 +0,0 @@
-export declare function getDefaultAutosaveHook(): {
-    getMessageCount: () => number;
-    updateConfig: (opts?: {
-        enabled?: boolean;
-        messageCount?: number;
-        hooks?: string[];
-    }) => void;
-    getConfig: () => {
-        enabled: boolean;
-        messageCount: number;
-        hooks: string[];
-    };
-};
-export declare function createAutosaveConfig(): {
-    enabled: boolean;
-    messageCount: number;
-    hooks: string[];
-};
-//# sourceMappingURL=autosave.d.ts.map

package/dist/core/autosave.js

@@ -1,16 +0,0 @@
-// Autosave functionality placeholder
-export function getDefaultAutosaveHook() {
-    let config = { enabled: false, messageCount: 10, hooks: [] };
-    return {
-        getMessageCount: () => 0,
-        updateConfig: (opts) => {
-            if (opts)
-                Object.assign(config, opts);
-        },
-        getConfig: () => ({ ...config })
-    };
-}
-export function createAutosaveConfig() {
-    return { enabled: false, messageCount: 10, hooks: [] };
-}
-//# sourceMappingURL=autosave.js.map

package/dist/core/beliefs/decay.d.ts

@@ -1,27 +0,0 @@
-interface DecayStats {
-    decayed: number;
-    sourceCountUpdated: number;
-    errors: string[];
-}
-export declare function applyBeliefDecay(projectId?: string): Promise<DecayStats>;
-/**
- * Get beliefs that need attention (low confidence, disputed, or stale)
- */
-export declare function getProblemBeliefs(projectId: string, options?: {
-    minDaysSinceConfirmation?: number;
-    confidenceThreshold?: number;
-}): Promise<Array<{
-    id: string;
-    type: string;
-    statement: string;
-    confidence: number;
-    status: string;
-    lastConfirmedAt: Date | null;
-    issue: string;
-}>>;
-/**
- * Reinforce a belief (increase confidence when re-referenced)
- */
-export declare function reinforceBelief(beliefId: string, boostAmount?: number): Promise<boolean>;
-export {};
-//# sourceMappingURL=decay.d.ts.map

package/dist/core/beliefs/decay.js

@@ -1,217 +0,0 @@
-import { getDbClient } from '../lib/db-client.js';
-import { logger } from './logger.js';
-/**
- * Belief Decay Engine
- *
- * Manages confidence decay for beliefs over time
- * Formula: newConfidence = oldConfidence * (1 - decayRate/100)^(daysSinceLastConfirmation / halfLife)
- * - Default 30 days half-life (belief confidence halves every 30 days without reinforcement)
- * - Disputed beliefs decay faster
- * - Beliefs with more sources decay slower
- */
-const DEFAULT_BELIEF_HALF_LIFE = 30; // days
-const DISPUTE_DECAY_MULTIPLIER = 1.5; // disputes decay 1.5x faster
-const SOURCE_BOOST_THRESHOLD = 3; // 3+ sources = slower decay
-export async function applyBeliefDecay(projectId) {
-    const stats = { decayed: 0, sourceCountUpdated: 0, errors: [] };
-    try {
-        const { raw } = await getDbClient();
-        const sqlite = raw.$client;
-        const isPg = typeof raw.query === 'function';
-        if (!sqlite && !isPg) {
-            logger.warn('No database client available for belief decay');
-            return stats;
-        }
-        const now = Date.now();
-        if (isPg) {
-            // PostgreSQL version
-            const pg = raw;
-            // Get all active beliefs
-            const beliefResult = await pg.query(`SELECT id, confidence, belief_decay_rate, last_confirmed_at, status, source_count 
-         FROM beliefs WHERE project_id = $1 AND status = 'active'`, [projectId]);
-            for (const belief of beliefResult.rows) {
-                try {
-                    const lastConfirmed = belief.last_confirmed_at ? new Date(belief.last_confirmed_at).getTime() : new Date(belief.created_at).getTime();
-                    const daysSince = Math.max(0, (now - lastConfirmed) / (24 * 60 * 60 * 1000));
-                    // Get source count for this belief
-                    const sourceResult = await pg.query(`SELECT COUNT(*) as cnt FROM belief_memory_sources WHERE belief_id = $1`, [belief.id]);
-                    const sourceCount = parseInt(sourceResult.rows[0]?.cnt ?? 1);
-                    // Calculate decay rate (disputes decay faster)
-                    const baseDecayRate = belief.belief_decay_rate ?? DEFAULT_BELIEF_HALF_LIFE;
-                    const decayMultiplier = belief.status === 'disputed' ? DISPUTE_DECAY_MULTIPLIER : 1;
-                    const sourceMultiplier = sourceCount >= SOURCE_BOOST_THRESHOLD ? 0.8 : 1;
-                    const effectiveHalfLife = baseDecayRate * decayMultiplier * sourceMultiplier;
-                    // Apply exponential decay: confidence = initial * (0.5)^(days/halfLife)
-                    const newConfidence = Math.round(belief.confidence * Math.pow(0.5, daysSince / effectiveHalfLife));
-                    if (newConfidence < belief.confidence) {
-                        await pg.query(`UPDATE beliefs SET confidence = $1, updated_at = NOW() WHERE id = $2`, [newConfidence, belief.id]);
-                        stats.decayed++;
-                    }
-                    if (sourceCount !== belief.source_count) {
-                        await pg.query(`UPDATE beliefs SET source_count = $1 WHERE id = $2`, [sourceCount, belief.id]);
-                        stats.sourceCountUpdated++;
-                    }
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    stats.errors.push(`Belief ${belief.id}: ${msg}`);
-                }
-            }
-        }
-        else if (sqlite) {
-            // SQLite version
-            const beliefs = sqlite.prepare(`
-        SELECT id, confidence, belief_decay_rate, last_confirmed_at, status, source_count, created_at
-        FROM beliefs WHERE project_id = ? AND status = 'active'
-      `).all(projectId);
-            for (const belief of beliefs) {
-                try {
-                    const lastConfirmed = belief.last_confirmed_at
-                        ? belief.last_confirmed_at
-                        : belief.created_at;
-                    const daysSince = Math.max(0, (now - lastConfirmed) / (24 * 60 * 60 * 1000));
-                    // Get source count
-                    const sourceResult = sqlite.prepare(`SELECT COUNT(*) as cnt FROM belief_memory_sources WHERE belief_id = ?`).get(belief.id);
-                    const sourceCount = sourceResult?.cnt ?? 1;
-                    // Calculate decay rate
-                    const baseDecayRate = belief.belief_decay_rate ?? DEFAULT_BELIEF_HALF_LIFE;
-                    const decayMultiplier = belief.status === 'disputed' ? DISPUTE_DECAY_MULTIPLIER : 1;
-                    const sourceMultiplier = sourceCount >= SOURCE_BOOST_THRESHOLD ? 0.8 : 1;
-                    const effectiveHalfLife = baseDecayRate * decayMultiplier * sourceMultiplier;
-                    const newConfidence = Math.round(belief.confidence * Math.pow(0.5, daysSince / effectiveHalfLife));
-                    if (newConfidence < belief.confidence) {
-                        sqlite.prepare(`
-              UPDATE beliefs SET confidence = ?, updated_at = ?
-              WHERE id = ?
-            `).run(newConfidence, Math.floor(now / 1000), belief.id);
-                        stats.decayed++;
-                    }
-                    if (sourceCount !== belief.source_count) {
-                        sqlite.prepare(`
-              UPDATE beliefs SET source_count = ? WHERE id = ?
-            `).run(sourceCount, belief.id);
-                        stats.sourceCountUpdated++;
-                    }
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    stats.errors.push(`Belief ${belief.id}: ${msg}`);
-                }
-            }
-        }
-        logger.info('Belief decay applied', stats);
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logger.error('Belief decay failed', { error: msg });
-        stats.errors.push(msg);
-    }
-    return stats;
-}
-/**
- * Get beliefs that need attention (low confidence, disputed, or stale)
- */
-export async function getProblemBeliefs(projectId, options) {
-    const problems = [];
-    try {
-        const { raw } = await getDbClient();
-        const sqlite = raw.$client;
-        const isPg = typeof raw.query === 'function';
-        const minDays = options?.minDaysSinceConfirmation ?? 30;
-        const confThreshold = options?.confidenceThreshold ?? 20;
-        const now = Date.now();
-        if (isPg) {
-            const pg = raw;
-            const result = await pg.query(`SELECT id, belief_type, statement, confidence, status, last_confirmed_at, created_at
-         FROM beliefs WHERE project_id = $1`, [projectId]);
-            for (const belief of result.rows) {
-                const lastConfirmed = belief.last_confirmed_at ? new Date(belief.last_confirmed_at) : new Date(belief.created_at);
-                const daysSince = (now - lastConfirmed.getTime()) / (24 * 60 * 60 * 1000);
-                let issue = '';
-                if (belief.status === 'disputed')
-                    issue = 'disputed';
-                else if (belief.confidence < confThreshold)
-                    issue = `low confidence (${belief.confidence})`;
-                else if (daysSince > minDays)
-                    issue = `stale (${Math.round(daysSince)} days)`;
-                if (issue) {
-                    problems.push({
-                        id: belief.id,
-                        type: belief.belief_type,
-                        statement: belief.statement,
-                        confidence: belief.confidence,
-                        status: belief.status,
-                        lastConfirmedAt: belief.last_confirmed_at,
-                        issue,
-                    });
-                }
-            }
-        }
-        else if (sqlite) {
-            const beliefs = sqlite.prepare(`
-        SELECT id, belief_type, statement, confidence, status, last_confirmed_at, created_at
-        FROM beliefs WHERE project_id = ?
-      `).all(projectId);
-            for (const belief of beliefs) {
-                const lastConfirmed = belief.last_confirmed_at
-                    ? new Date(belief.last_confirmed_at * 1000)
-                    : new Date(belief.created_at * 1000);
-                const daysSince = (now - lastConfirmed.getTime()) / (24 * 60 * 60 * 1000);
-                let issue = '';
-                if (belief.status === 'disputed')
-                    issue = 'disputed';
-                else if (belief.confidence < confThreshold)
-                    issue = `low confidence (${belief.confidence})`;
-                else if (daysSince > minDays)
-                    issue = `stale (${Math.round(daysSince)} days)`;
-                if (issue) {
-                    problems.push({
-                        id: belief.id,
-                        type: belief.belief_type,
-                        statement: belief.statement,
-                        confidence: belief.confidence,
-                        status: belief.status,
-                        lastConfirmedAt: belief.last_confirmed_at ? new Date(belief.last_confirmed_at * 1000) : null,
-                        issue,
-                    });
-                }
-            }
-        }
-    }
-    catch (error) {
-        logger.error('Failed to get problem beliefs', error);
-    }
-    return problems;
-}
-/**
- * Reinforce a belief (increase confidence when re-referenced)
- */
-export async function reinforceBelief(beliefId, boostAmount = 5) {
-    try {
-        const { raw } = await getDbClient();
-        const isPg = typeof raw.query === 'function';
-        if (isPg) {
-            await raw.query(`UPDATE beliefs SET 
-          confidence = LEAST(100, confidence + $1),
-          last_confirmed_at = NOW(),
-          updated_at = NOW()
-         WHERE id = $2`, [boostAmount, beliefId]);
-        }
-        else {
-            const sqlite = raw.$client;
-            sqlite.prepare(`
-        UPDATE beliefs SET 
-          confidence = MIN(100, confidence + ?),
-          last_confirmed_at = ?,
-          updated_at = ?
-        WHERE id = ?
-      `).run(boostAmount, Math.floor(Date.now() / 1000), Math.floor(Date.now() / 1000), beliefId);
-        }
-        return true;
-    }
-    catch (error) {
-        logger.error('Failed to reinforce belief', { beliefId, error });
-        return false;
-    }
-}
-//# sourceMappingURL=decay.js.map

package/dist/core/beliefs/extractor.d.ts

@@ -1,9 +0,0 @@
-import type { MemoryType } from '../memory/memories.js';
-import type { ExtractedBelief } from './types.js';
-export declare function extractBeliefsFromMemory(input: {
-    memoryId: string;
-    content: string;
-    type: MemoryType | string;
-    metadata?: Record<string, unknown> | null;
-}): ExtractedBelief[];
-//# sourceMappingURL=extractor.d.ts.map

package/dist/core/beliefs/extractor.js

@@ -1,113 +0,0 @@
-function cleanStatement(input) {
-    return input
-        .replace(/^(decision:|constraint:|state change:|reject(?:ed)?:|failure:|preference:)\s*/i, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function splitReason(text) {
-    const match = text.match(/^(.*?)(?:\s+because\s+|\s+due to\s+)(.+)$/i);
-    if (!match)
-        return { statement: cleanStatement(text) };
-    return {
-        statement: cleanStatement(match[1]),
-        reason: cleanStatement(match[2]),
-    };
-}
-function deriveConfidence(type, hasReason) {
-    const base = type === 'decision' ? 0.84 :
-        type === 'preference' ? 0.8 :
-            type === 'failure_cause' ? 0.82 :
-                type === 'constraint' ? 0.78 :
-                    type === 'state_change' ? 0.76 :
-                        0.74;
-    return hasReason ? Math.min(0.95, base + 0.05) : base;
-}
-export function extractBeliefsFromMemory(input) {
-    const text = input.content.trim();
-    const lowered = text.toLowerCase();
-    const beliefs = [];
-    const addBelief = (belief) => {
-        const cleanedStatement = cleanStatement(belief.statement);
-        if (!cleanedStatement || cleanedStatement.length < 8)
-            return;
-        beliefs.push({
-            ...belief,
-            statement: cleanedStatement,
-            confidence: belief.confidence ?? deriveConfidence(belief.type, Boolean(belief.reason)),
-            sourceMemoryIds: [input.memoryId],
-        });
-    };
-    if (input.type === 'decision' || /\b(decision:|decided to|we chose|going with|final decision)\b/i.test(text)) {
-        const { statement, reason } = splitReason(text);
-        addBelief({
-            type: 'decision',
-            statement,
-            reason,
-            status: 'active',
-            evidenceSummary: text,
-        });
-    }
-    if (input.type === 'preference' || /\b(prefers?|likes?|dislikes?|hates?)\b/i.test(text)) {
-        const { statement, reason } = splitReason(text);
-        addBelief({
-            type: 'preference',
-            statement,
-            reason,
-            status: 'active',
-            evidenceSummary: text,
-        });
-    }
-    const failureMatch = text.match(/\b(?:failed|failure|broke|error)\b.*?(?:because|due to)\s+(.+)/i);
-    if (failureMatch) {
-        addBelief({
-            type: 'failure_cause',
-            statement: cleanStatement(text.split(/(?:because|due to)/i)[0] ?? text),
-            reason: cleanStatement(failureMatch[1]),
-            status: 'active',
-            evidenceSummary: text,
-            edges: [{ type: 'causes', targetStatement: cleanStatement(failureMatch[1]) }],
-        });
-    }
-    if (/\b(constraint:|must not|cannot|can't|blocked by|required to|needs to)\b/i.test(text)) {
-        addBelief({
-            type: 'constraint',
-            statement: text,
-            status: 'active',
-            evidenceSummary: text,
-        });
-    }
-    const stateMatch = text.match(/\b(?:state changed from|changed from)\s+(.+?)\s+to\s+(.+?)(?:\s+after\s+(.+))?$/i);
-    if (stateMatch) {
-        addBelief({
-            type: 'state_change',
-            statement: `${cleanStatement(stateMatch[1])} -> ${cleanStatement(stateMatch[2])}`,
-            reason: stateMatch[3] ? cleanStatement(stateMatch[3]) : undefined,
-            status: 'active',
-            evidenceSummary: text,
-        });
-    }
-    const disputePatterns = [
-        /\b(reject|rejected|do not use|don't use|instead of)\b/i,
-        /\bbandaid\b/i,
-    ];
-    if (disputePatterns.some((pattern) => pattern.test(text))) {
-        const sentence = text.split(/[.!?]/).find((part) => /reject|bandaid|instead of|do not use|don't use/i.test(part)) ?? text;
-        addBelief({
-            type: 'dispute',
-            statement: sentence,
-            status: 'disputed',
-            evidenceSummary: text,
-        });
-    }
-    const deduped = new Map();
-    for (const belief of beliefs) {
-        const key = `${belief.type}:${belief.statement.toLowerCase()}`;
-        if (!deduped.has(key))
-            deduped.set(key, belief);
-    }
-    if (deduped.size === 0 && !/\b(because|due to|prefer|decision|constraint|changed from|reject)\b/.test(lowered)) {
-        return [];
-    }
-    return [...deduped.values()];
-}
-//# sourceMappingURL=extractor.js.map