squish-memory 1.0.2 → 1.2.0

package/dist/core/beliefs/store.js

@@ -0,0 +1,466 @@
+import { randomUUID } from 'crypto';
+import { getDbClient } from '../lib/db-client.js';
+import { deserializeMetadata, serializeMetadata } from '../memory/serialization.js';
+import { runBeliefMigrations } from '../../db/migrations/beliefs.js';
+/**
+ * Ensure belief tables exist by running migrations if needed.
+ * Delegates table creation to the migrations system.
+ */
+async function ensureBeliefTables() {
+    const { raw } = await getDbClient();
+    // For SQLite - check if table exists and run migrations if missing
+    const sqlite = raw.$client;
+    if (sqlite && typeof sqlite.prepare === 'function') {
+        const tableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='beliefs'").get();
+        if (!tableCheck) {
+            await runBeliefMigrations(sqlite);
+        }
+        return;
+    }
+    // For PostgreSQL - check if table exists (migrations are run elsewhere for PG)
+    if (typeof raw.query === 'function') {
+        const result = await raw.query("SELECT table_name FROM information_schema.tables WHERE table_name = 'beliefs' LIMIT 1");
+        if (!result.rows[0]) {
+            // For PostgreSQL, we assume migrations are run during bootstrap
+            throw new Error('Beliefs table does not exist for PostgreSQL. Run database migrations.');
+        }
+    }
+}
+function normalizeBeliefKey(belief) {
+    return `${belief.type}:${belief.statement.toLowerCase().replace(/\s+/g, ' ').trim()}`;
+}
+export async function upsertBeliefsForMemory(input) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    if (!sqlite && typeof raw.query !== 'function')
+        return [];
+    const stored = [];
+    if (!sqlite && typeof raw.query === 'function') {
+        const pg = raw;
+        for (const belief of input.beliefs) {
+            const normalizedKey = normalizeBeliefKey(belief);
+            const existingResult = await pg.query(`SELECT * FROM beliefs WHERE project_id = $1 AND normalized_key = $2 LIMIT 1`, [input.projectId, normalizedKey]);
+            const existing = existingResult.rows[0];
+            const beliefId = existing?.id ?? randomUUID();
+            const nextStatus = existing
+                ? (belief.type === 'dispute' ? 'disputed' : existing.status || belief.status)
+                : belief.status;
+            if (existing) {
+                await pg.query(`UPDATE beliefs
+           SET confidence = $1, status = $2, reason = $3, context = $4, evidence_summary = $5, metadata = $6, updated_at = NOW()
+           WHERE id = $7`, [
+                    Math.max(Number(existing.confidence ?? 0.5), belief.confidence),
+                    nextStatus,
+                    belief.reason ?? null,
+                    belief.context ?? null,
+                    belief.evidenceSummary ?? null,
+                    { edges: belief.edges ?? [] },
+                    beliefId,
+                ]);
+            }
+            else {
+                await pg.query(`INSERT INTO beliefs (id, project_id, belief_type, statement, normalized_key, confidence, status, reason, context, evidence_summary, metadata)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [
+                    beliefId,
+                    input.projectId,
+                    belief.type,
+                    belief.statement,
+                    normalizedKey,
+                    belief.confidence,
+                    belief.status,
+                    belief.reason ?? null,
+                    belief.context ?? null,
+                    belief.evidenceSummary ?? null,
+                    { edges: belief.edges ?? [] },
+                ]);
+            }
+            await pg.query(`INSERT INTO belief_memory_sources (id, belief_id, memory_id)
+         VALUES ($1, $2, $3)
+         ON CONFLICT (belief_id, memory_id) DO NOTHING`, [randomUUID(), beliefId, input.memoryId]);
+            stored.push({
+                id: beliefId,
+                projectId: input.projectId,
+                normalizedKey,
+                ...belief,
+                status: nextStatus,
+            });
+        }
+        return stored;
+    }
+    for (const belief of input.beliefs) {
+        const normalizedKey = normalizeBeliefKey(belief);
+        const existing = sqlite.prepare(`
+      SELECT * FROM beliefs WHERE project_id = ? AND normalized_key = ? LIMIT 1
+    `).get(input.projectId, normalizedKey);
+        let beliefId = existing?.id ?? randomUUID();
+        let status = belief.status;
+        if (existing) {
+            const nextStatus = belief.type === 'dispute' ? 'disputed'
+                : existing.belief_type === belief.type && existing.statement !== belief.statement ? 'superseded'
+                    : existing.status || belief.status;
+            sqlite.prepare(`
+        UPDATE beliefs
+        SET confidence = ?, status = ?, reason = ?, context = ?, evidence_summary = ?, metadata = ?, updated_at = (strftime('%s','now'))
+        WHERE id = ?
+      `).run(Math.max(existing.confidence ?? 0.5, belief.confidence), nextStatus, belief.reason ?? null, belief.context ?? null, belief.evidenceSummary ?? null, serializeMetadata({ edges: belief.edges ?? [] }), beliefId);
+            status = nextStatus;
+        }
+        else {
+            sqlite.prepare(`
+        INSERT INTO beliefs (id, project_id, belief_type, statement, normalized_key, confidence, status, reason, context, evidence_summary, metadata)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(beliefId, input.projectId, belief.type, belief.statement, normalizedKey, belief.confidence, belief.status, belief.reason ?? null, belief.context ?? null, belief.evidenceSummary ?? null, serializeMetadata({ edges: belief.edges ?? [] }));
+        }
+        sqlite.prepare(`
+      INSERT OR IGNORE INTO belief_memory_sources (id, belief_id, memory_id)
+      VALUES (?, ?, ?)
+    `).run(randomUUID(), beliefId, input.memoryId);
+        stored.push({
+            id: beliefId,
+            projectId: input.projectId,
+            normalizedKey,
+            ...belief,
+            status,
+        });
+    }
+    for (const belief of stored) {
+        const edgeMetadata = deserializeMetadata(sqlite.prepare(`SELECT metadata FROM beliefs WHERE id = ?`).get(belief.id)?.metadata ?? null);
+        const edges = Array.isArray(edgeMetadata?.edges) ? edgeMetadata.edges : [];
+        for (const edge of edges) {
+            const target = stored.find((candidate) => candidate.statement === edge.targetStatement);
+            if (!target || target.id === belief.id)
+                continue;
+            sqlite.prepare(`
+        INSERT OR IGNORE INTO belief_edges (id, from_belief_id, to_belief_id, edge_type, metadata)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(randomUUID(), belief.id, target.id, edge.type, serializeMetadata({}));
+        }
+    }
+    return stored;
+}
+export async function getBeliefsForMemory(memoryId) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    if (!sqlite && typeof raw.query !== 'function')
+        return [];
+    if (!sqlite && typeof raw.query === 'function') {
+        const result = await raw.query(`
+      SELECT b.*, array_agg(bms.memory_id) as source_memory_ids
+      FROM beliefs b
+      JOIN belief_memory_sources bms ON bms.belief_id = b.id
+      WHERE b.id IN (
+        SELECT belief_id FROM belief_memory_sources WHERE memory_id = $1
+      )
+      GROUP BY b.id
+      ORDER BY b.updated_at DESC
+    `, [memoryId]);
+        return result.rows.map((row) => ({
+            id: row.id,
+            projectId: row.project_id,
+            type: row.belief_type,
+            statement: row.statement,
+            normalizedKey: row.normalized_key,
+            confidence: Number(row.confidence ?? 0.5),
+            status: row.status,
+            reason: row.reason ?? undefined,
+            context: row.context ?? undefined,
+            evidenceSummary: row.evidence_summary ?? undefined,
+            sourceMemoryIds: row.source_memory_ids ?? [],
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    const rows = sqlite.prepare(`
+    SELECT b.*, group_concat(bms.memory_id) as source_memory_ids
+    FROM beliefs b
+    JOIN belief_memory_sources bms ON bms.belief_id = b.id
+    WHERE b.id IN (
+      SELECT belief_id FROM belief_memory_sources WHERE memory_id = ?
+    )
+    GROUP BY b.id
+    ORDER BY b.updated_at DESC
+  `).all(memoryId);
+    return rows.map((row) => ({
+        id: row.id,
+        projectId: row.project_id,
+        type: row.belief_type,
+        statement: row.statement,
+        normalizedKey: row.normalized_key,
+        confidence: Number(row.confidence ?? 0.5),
+        status: row.status,
+        reason: row.reason ?? undefined,
+        context: row.context ?? undefined,
+        evidenceSummary: row.evidence_summary ?? undefined,
+        sourceMemoryIds: String(row.source_memory_ids ?? '').split(',').filter(Boolean),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    }));
+}
+/**
+ * Get all beliefs for a project
+ */
+export async function getAllBeliefs(projectId, options) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    const isPg = typeof raw.query === 'function';
+    if (!sqlite && !isPg)
+        return [];
+    const limit = options?.limit ?? 100;
+    const conditions = ['project_id = ?'];
+    const params = [projectId];
+    if (options?.type) {
+        conditions.push('belief_type = ?');
+        params.push(options.type);
+    }
+    if (options?.status) {
+        conditions.push('status = ?');
+        params.push(options.status);
+    }
+    if (options?.minConfidence !== undefined) {
+        conditions.push('confidence >= ?');
+        params.push(options.minConfidence);
+    }
+    const whereClause = conditions.join(' AND ');
+    const sql = `
+    SELECT * FROM beliefs 
+    WHERE ${whereClause}
+    ORDER BY confidence DESC, updated_at DESC
+    LIMIT ?
+  `;
+    params.push(limit);
+    if (isPg) {
+        const result = await raw.query(sql, params);
+        return result.rows.map((row) => ({
+            id: row.id,
+            projectId: row.project_id,
+            type: row.belief_type,
+            statement: row.statement,
+            normalizedKey: row.normalized_key,
+            confidence: Number(row.confidence ?? 0.5),
+            status: row.status,
+            reason: row.reason ?? undefined,
+            context: row.context ?? undefined,
+            evidenceSummary: row.evidence_summary ?? undefined,
+            sourceMemoryIds: [],
+            lastConfirmedAt: row.last_confirmed_at,
+            sourceCount: row.source_count,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    const rows = sqlite.prepare(sql).all(...params);
+    return rows.map((row) => ({
+        id: row.id,
+        projectId: row.project_id,
+        type: row.belief_type,
+        statement: row.statement,
+        normalizedKey: row.normalized_key,
+        confidence: Number(row.confidence ?? 0.5),
+        status: row.status,
+        reason: row.reason ?? undefined,
+        context: row.context ?? undefined,
+        evidenceSummary: row.evidence_summary ?? undefined,
+        sourceMemoryIds: [],
+        lastConfirmedAt: row.last_confirmed_at,
+        sourceCount: row.source_count,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    }));
+}
+/**
+ * Search beliefs by statement content
+ */
+export async function searchBeliefs(projectId, query, options) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    const isPg = typeof raw.query === 'function';
+    if (!sqlite && !isPg)
+        return [];
+    const limit = options?.limit ?? 50;
+    const conditions = ['project_id = ?', 'statement LIKE ?'];
+    const params = [projectId, `%${query}%`];
+    if (options?.type) {
+        conditions.push('belief_type = ?');
+        params.push(options.type);
+    }
+    if (options?.minConfidence !== undefined) {
+        conditions.push('confidence >= ?');
+        params.push(options.minConfidence);
+    }
+    const whereClause = conditions.join(' AND ');
+    const sql = `
+    SELECT * FROM beliefs 
+    WHERE ${whereClause}
+    ORDER BY confidence DESC
+    LIMIT ?
+  `;
+    params.push(limit);
+    if (isPg) {
+        const result = await raw.query(sql, params);
+        return result.rows.map((row) => ({
+            id: row.id,
+            projectId: row.project_id,
+            type: row.belief_type,
+            statement: row.statement,
+            normalizedKey: row.normalized_key,
+            confidence: Number(row.confidence ?? 0.5),
+            status: row.status,
+            reason: row.reason ?? undefined,
+            context: row.context ?? undefined,
+            evidenceSummary: row.evidence_summary ?? undefined,
+            sourceMemoryIds: [],
+            sourceCount: row.source_count,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    const rows = sqlite.prepare(sql).all(...params);
+    return rows.map((row) => ({
+        id: row.id,
+        projectId: row.project_id,
+        type: row.belief_type,
+        statement: row.statement,
+        normalizedKey: row.normalized_key,
+        confidence: Number(row.confidence ?? 0.5),
+        status: row.status,
+        reason: row.reason ?? undefined,
+        context: row.context ?? undefined,
+        evidenceSummary: row.evidence_summary ?? undefined,
+        sourceMemoryIds: [],
+        sourceCount: row.source_count,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    }));
+}
+/**
+ * Get active constraint beliefs for session boot
+ * Returns beliefs that should shape next actions
+ */
+export async function getActiveConstraints(projectId) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    const isPg = typeof raw.query === 'function';
+    if (!sqlite && !isPg)
+        return [];
+    const sql = `
+    SELECT * FROM beliefs
+    WHERE project_id = ? AND belief_type = 'constraint' AND status = 'active'
+    ORDER BY confidence DESC, updated_at DESC
+    LIMIT 20
+  `;
+    if (isPg) {
+        const result = await raw.query(sql, [projectId]);
+        return result.rows.map((row) => mapRowToBelief(row));
+    }
+    const rows = sqlite.prepare(sql).all(projectId);
+    return rows.map(mapRowToBelief);
+}
+/**
+ * Get active decision beliefs for session boot
+ * Returns decisions that should guide next actions
+ */
+export async function getActiveDecisions(projectId) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    const isPg = typeof raw.query === 'function';
+    if (!sqlite && !isPg)
+        return [];
+    const sql = `
+    SELECT * FROM beliefs
+    WHERE project_id = ? AND belief_type = 'decision' AND status = 'active'
+    ORDER BY confidence DESC, updated_at DESC
+    LIMIT 20
+  `;
+    if (isPg) {
+        const result = await raw.query(sql, [projectId]);
+        return result.rows.map((row) => mapRowToBelief(row));
+    }
+    const rows = sqlite.prepare(sql).all(projectId);
+    return rows.map(mapRowToBelief);
+}
+/**
+ * Get recent failure beliefs for session boot
+ * Returns failure_cause beliefs to avoid repeating mistakes
+ * @param count - Number of recent failures to return (default 10)
+ */
+export async function getRecentFailures(projectId, count = 10) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    const isPg = typeof raw.query === 'function';
+    if (!sqlite && !isPg)
+        return [];
+    const sql = `
+    SELECT * FROM beliefs
+    WHERE project_id = ? AND belief_type = 'failure_cause' AND status = 'active'
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `;
+    if (isPg) {
+        const result = await raw.query(sql, [projectId, count]);
+        return result.rows.map((row) => mapRowToBelief(row));
+    }
+    const rows = sqlite.prepare(sql).all(projectId, count);
+    return rows.map(mapRowToBelief);
+}
+/**
+ * Get beliefs relevant to a task/query for session boot
+ * Used to inject relevant beliefs at session start
+ */
+export async function getRelevantBeliefs(projectId, taskQuery, limit = 10) {
+    await ensureBeliefTables();
+    const { raw } = await getDbClient();
+    const sqlite = raw.$client;
+    const isPg = typeof raw.query === 'function';
+    if (!sqlite && !isPg)
+        return [];
+    // Match against statement, context, or normalized_key
+    const searchPattern = `%${taskQuery}%`;
+    const sql = `
+    SELECT * FROM beliefs
+    WHERE project_id = ?
+    AND status = 'active'
+    AND (
+      statement LIKE ? OR
+      context LIKE ? OR
+      normalized_key LIKE ?
+    )
+    ORDER BY confidence DESC, updated_at DESC
+    LIMIT ?
+  `;
+    const params = [projectId, searchPattern, searchPattern, searchPattern, limit];
+    if (isPg) {
+        const result = await raw.query(sql, params);
+        return result.rows.map((row) => mapRowToBelief(row));
+    }
+    const rows = sqlite.prepare(sql).all(...params);
+    return rows.map(mapRowToBelief);
+}
+/**
+ * Helper to map DB row to StoredBelief
+ */
+function mapRowToBelief(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        type: row.belief_type,
+        statement: row.statement,
+        normalizedKey: row.normalized_key,
+        confidence: Number(row.confidence ?? 0.5),
+        status: row.status,
+        reason: row.reason ?? undefined,
+        context: row.context ?? undefined,
+        evidenceSummary: row.evidence_summary ?? undefined,
+        sourceMemoryIds: [],
+        sourceCount: row.source_count,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+//# sourceMappingURL=store.js.map

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

@@ -0,0 +1,28 @@
+export type BeliefType = 'decision' | 'preference' | 'failure_cause' | 'constraint' | 'state_change' | 'dispute';
+export type BeliefStatus = 'active' | 'superseded' | 'disputed';
+export type BeliefEdgeType = 'causes' | 'supports' | 'rejects' | 'supersedes' | 'depends_on';
+export interface ExtractedBelief {
+    type: BeliefType;
+    statement: string;
+    confidence: number;
+    sourceMemoryIds: string[];
+    status: BeliefStatus;
+    reason?: string;
+    context?: string;
+    evidenceSummary?: string;
+    edges?: Array<{
+        type: BeliefEdgeType;
+        targetStatement: string;
+    }>;
+}
+export interface StoredBelief extends ExtractedBelief {
+    id: string;
+    projectId: string;
+    normalizedKey: string;
+    createdAt?: Date | string | number | null;
+    updatedAt?: Date | string | number | null;
+    lastConfirmedAt?: Date | string | number | null;
+    sourceCount?: number;
+    beliefDecayRate?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/beliefs/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/commands/mcp-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/core/commands/mcp-server.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+// Compatibility entrypoint for generated adapter configs that still reference
+// dist/core/commands/mcp-server.js. The implementation lives in packages/mcp.
+await import('../../packages/mcp/src/index.js');
+//# sourceMappingURL=mcp-server.js.map

package/dist/core/commands/remember.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Remember Command - Unified memory write
+ *
+ * Single implementation for both CLI and MCP.
+ */
+export interface CommandResult {
+    ok: boolean;
+    [key: string]: any;
+}
+export interface RememberOptions {
+    content: string;
+    project?: string;
+    tags?: string;
+    tier?: 'hot' | 'cold';
+    type?: string;
+    learningType?: 'success' | 'failure' | 'fix' | 'insight';
+    confidence?: string;
+    source?: 'cli' | 'voice' | 'chat' | 'document';
+    route?: 'auto' | 'memory' | 'learning' | 'note';
+    pin?: boolean;
+    unpin?: boolean;
+}
+export declare function executeRemember(options: RememberOptions): Promise<CommandResult>;
+//# sourceMappingURL=remember.d.ts.map

package/dist/core/commands/remember.js

@@ -0,0 +1,144 @@
+/**
+ * Remember Command - Unified memory write
+ *
+ * Single implementation for both CLI and MCP.
+ */
+import { rememberMemory, findSimilarMemories } from '../memory/memories.js';
+import { createLearning } from '../ingestion/learnings.js';
+import { pinMemory, unpinMemory } from '../security/governance.js';
+import { detectMemorySignals } from '../memory/trigger-detector.js';
+export async function executeRemember(options) {
+    const { content, project, tags, tier, type, learningType, source, route, pin, unpin } = options;
+    const signals = detectMemorySignals(content);
+    let routing = "memory";
+    let inferredType = type || signals.suggestedType;
+    let routingReason = "";
+    // Check for learning patterns if auto mode
+    if (route === "auto" || !route) {
+        const hasLessonPattern = /(\bfailed\s+because\b|\blesson\s+learned\b|\bnext\s+time\b|\broot\s+cause\b|\bsuccess\b.*\bbecause\b|\bi\s+learned\b|\binsight\b)/i.test(content);
+        const hasLearningType = /(\bsuccess\b|\bfailure\b|\bfix\b|\binsight\b)/i.test(content);
+        const hasHackPattern = /(\bHACK\b|\bworkaround\b|\btemporary\s+fix\b)/i.test(content);
+        const hasFixmePattern = /(\bFIXME\b|\bXXX\b|\bbug\b.*\bfix\b)/i.test(content);
+        if (hasLessonPattern || hasLearningType || hasHackPattern || hasFixmePattern) {
+            routing = "learning";
+            if (hasHackPattern || hasFixmePattern) {
+                routingReason = "Detected code pattern (HACK/FIXME)";
+            }
+            else {
+                routingReason = "Detected learning pattern in content";
+            }
+        }
+        else if (signals.suggestedType === 'task') {
+            routing = "memory";
+            routingReason = "Detected TODO pattern";
+        }
+        else if (signals.suggestedType === 'observation' && /\b(note|note\s+that|log|remember)\b/i.test(content)) {
+            routing = "note";
+            routingReason = "Detected note pattern";
+        }
+        else {
+            routing = "memory";
+            routingReason = `Detected as ${inferredType}`;
+        }
+    }
+    else if (route === "learning") {
+        routing = "learning";
+        routingReason = "Override: forced to learning";
+    }
+    else if (route === "note") {
+        routing = "note";
+        routingReason = "Override: forced to note";
+    }
+    else {
+        routing = "memory";
+        routingReason = "Override: forced to memory";
+    }
+    let result;
+    const parsedTags = tags ? tags.split(',').map((t) => t.trim()) : [];
+    const parsedTier = tier === "cold" ? "cold" : "hot";
+    if (routing === "learning") {
+        let parsedLearningType = "insight";
+        if (learningType) {
+            parsedLearningType = learningType;
+        }
+        else {
+            if (/(\bsuccess\b|\bworked\b|\bfinished\b)/i.test(content))
+                parsedLearningType = "success";
+            else if (/(\bfailed\b|\berror\b|\bbroke\b)/i.test(content))
+                parsedLearningType = "failure";
+            else if (/(\bfix\b|\b workaround\b|\bsolved\b)/i.test(content))
+                parsedLearningType = "fix";
+        }
+        const learning = await createLearning({
+            type: parsedLearningType,
+            content,
+            project,
+            autoLink: true
+        });
+        result = { id: learning.id, type: "learning", learningType: parsedLearningType, content };
+    }
+    else {
+        // Check for similar memories to avoid duplicates (deduplication)
+        const similarMemories = await findSimilarMemories(content, 0.85, 3);
+        const memory = await rememberMemory({
+            content,
+            type: inferredType,
+            tags: parsedTags,
+            project,
+            tier: parsedTier,
+            source: source || 'cli'
+        });
+        // If found similar memories, create association instead of duplicate
+        if (similarMemories.length > 0) {
+            const { createAssociation } = await import('../associations.js');
+            for (const similar of similarMemories) {
+                await createAssociation(memory.id, similar.id, 'duplicate', similar.similarity ?? 0.85);
+            }
+            memory.similarTo = similarMemories.map(s => s.id);
+        }
+        if (pin) {
+            await pinMemory(memory.id);
+        }
+        else if (unpin) {
+            await unpinMemory(memory.id);
+        }
+        result = { id: memory.id, type: "memory", memoryType: inferredType, tier: parsedTier, content, pinned: pin };
+        // Auto-update knowledge graph (fire-and-forget, don't fail remember on graph error)
+        const { addMemoryToGraph } = await import('../graph/graph-builder.js');
+        const graphResult = await addMemoryToGraph(memory.id).catch((e) => {
+            console.warn('[Graph] Auto-update failed:', e.message);
+            return null;
+        });
+        if (graphResult) {
+            result.graph = { entities: graphResult.entitiesCreated, relations: graphResult.relationsCreated };
+        }
+        // Auto-assign to place (fire-and-forget)
+        const { autoAssignMemory } = await import('../places/memory-places.js');
+        const projectId = memory.projectId || project;
+        const placeResult = await autoAssignMemory({
+            memoryId: memory.id,
+            projectId: projectId,
+            content: content,
+            tags: parsedTags,
+            memoryType: inferredType
+        }).catch((e) => {
+            console.warn('[Places] Auto-assign failed:', e.message);
+            return null;
+        });
+        if (placeResult?.assigned && placeResult.placeId) {
+            result.place = { id: placeResult.placeId, type: placeResult.placeType ?? 'inbox' };
+        }
+    }
+    return {
+        ok: true,
+        id: result.id,
+        routing,
+        type: routing === "learning" ? result.learningType : result.memoryType,
+        tier: routing === "memory" ? parsedTier : 'N/A',
+        priority: signals.priority,
+        confidence: signals.confidence,
+        pinned: result.pinned,
+        reason: routingReason
+    };
+}
+//# sourceMappingURL=remember.js.map