squish-memory 1.1.5 → 1.2.0

package/dist/core/mcp/tools.js

@@ -1,6 +1,5 @@
 import { hybridSearch } from '../memory/hybrid-retrieval.js';
 import { rememberMemory, getMemory } from '../memory/memories.js';
-import { getEmbedding } from '../embeddings.js';
 import { getQMDClient } from '../embeddings/qmd-client.js';
 import { logger } from '../logger.js';
 function textResult(text) {
@@ -172,90 +171,6 @@ export const squishRecallTool = {
         }
     },
 };
-export const squishEmbedTool = {
-    tool: {
-        name: 'squish_embed',
-        description: 'Generate embeddings for text using configured provider (supports multimodal)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                text: {
-                    type: 'string',
-                    description: 'Text to embed',
-                },
-            },
-            required: ['text'],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { text } = args;
-            if (!text) {
-                return errorResult('Text is required');
-            }
-            const embedding = await getEmbedding(text);
-            if (!embedding) {
-                return errorResult('Failed to generate embedding');
-            }
-            return textResult(JSON.stringify({
-                dimensions: embedding.length,
-                preview: embedding.slice(0, 5),
-            }, null, 2));
-        }
-        catch (error) {
-            logger.error('Embed error:', error);
-            return errorResult(error instanceof Error ? error.message : 'Failed to generate embedding');
-        }
-    },
-};
-export const squishQMDSearchTool = {
-    tool: {
-        name: 'squish_qmd_search',
-        description: 'Search markdown files using QMD (local, fast BM25 + vector)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query',
-                },
-                collection: {
-                    type: 'string',
-                    description: 'QMD collection name (optional)',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results (default: 10)',
-                },
-            },
-            required: ['query'],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { query, collection, limit = 10 } = args;
-            if (!query) {
-                return errorResult('Query is required');
-            }
-            const client = await getQMDClient();
-            const available = await client.isAvailable();
-            if (!available) {
-                return errorResult('QMD not available');
-            }
-            const results = await client.search({
-                query,
-                collection,
-                limit: limit || 10
-            });
-            const formatted = results.map((r, i) => `${i + 1}. ${r.path || r.file} (score: ${r.score?.toFixed(2)})\n   ${r.content?.substring(0, 150)}...`).join('\n\n');
-            return textResult(`QMD found ${results.length} results:\n\n${formatted}`);
-        }
-        catch (error) {
-            logger.error('QMD search error:', error);
-            return errorResult(error instanceof Error ? error.message : 'QMD search failed');
-        }
-    },
-};
 export const squishHealthTool = {
     tool: {
         name: 'squish_health',
@@ -355,8 +270,6 @@ export function getAllSquishTools() {
         squishSearchTool,
         squishRememberTool,
         squishRecallTool,
-        squishEmbedTool,
-        squishQMDSearchTool,
         squishHealthTool,
         squishGetSearchTracesTool,
         squishGetTraceByIdTool,

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

@@ -3,302 +3,74 @@ export declare const MCPToolSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    inputSchema: Record<string, any>;
-}, {
-    name: string;
-    description: string;
-    inputSchema: Record<string, any>;
-}>;
+}, z.core.$strip>;
 export declare const MCPToolCallSchema: z.ZodObject<{
     name: z.ZodString;
     arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    arguments: Record<string, any>;
-}, {
-    name: string;
-    arguments: Record<string, any>;
-}>;
+}, z.core.$strip>;
 export declare const MCPToolResultSchema: z.ZodObject<{
     content: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<["text", "image", "resource"]>;
+        type: z.ZodEnum<{
+            text: "text";
+            image: "image";
+            resource: "resource";
+        }>;
         text: z.ZodOptional<z.ZodString>;
         data: z.ZodOptional<z.ZodString>;
         mimeType: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }, {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }>, "many">;
+    }, z.core.$strip>>;
     isError: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    content: {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }[];
-    isError?: boolean | undefined;
-}, {
-    content: {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }[];
-    isError?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare const MCPCapabilitiesSchema: z.ZodObject<{
     tools: z.ZodOptional<z.ZodObject<{
         listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        listChanged?: boolean | undefined;
-    }, {
-        listChanged?: boolean | undefined;
-    }>>;
+    }, z.core.$strip>>;
     resources: z.ZodOptional<z.ZodObject<{
         subscribe: z.ZodOptional<z.ZodBoolean>;
         listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    }, {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    }>>;
+    }, z.core.$strip>>;
     prompts: z.ZodOptional<z.ZodObject<{
         listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        listChanged?: boolean | undefined;
-    }, {
-        listChanged?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    tools?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    prompts?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    resources?: {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    } | undefined;
-}, {
-    tools?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    prompts?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    resources?: {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const MCPInitializeRequestSchema: z.ZodObject<{
     protocolVersion: z.ZodString;
     capabilities: z.ZodObject<{
         tools: z.ZodOptional<z.ZodObject<{
             listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
+        }, z.core.$strip>>;
         resources: z.ZodOptional<z.ZodObject<{
             subscribe: z.ZodOptional<z.ZodBoolean>;
             listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }>>;
+        }, z.core.$strip>>;
         prompts: z.ZodOptional<z.ZodObject<{
             listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     clientInfo: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        version: string;
-        name: string;
-    }, {
-        version: string;
-        name: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    clientInfo: {
-        version: string;
-        name: string;
-    };
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-}, {
-    clientInfo: {
-        version: string;
-        name: string;
-    };
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const MCPInitializeResponseSchema: z.ZodObject<{
     protocolVersion: z.ZodString;
     capabilities: z.ZodObject<{
         tools: z.ZodOptional<z.ZodObject<{
             listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
+        }, z.core.$strip>>;
         resources: z.ZodOptional<z.ZodObject<{
             subscribe: z.ZodOptional<z.ZodBoolean>;
             listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }>>;
+        }, z.core.$strip>>;
         prompts: z.ZodOptional<z.ZodObject<{
             listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     serverInfo: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        version: string;
-        name: string;
-    }, {
-        version: string;
-        name: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-    serverInfo: {
-        version: string;
-        name: string;
-    };
-}, {
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-    serverInfo: {
-        version: string;
-        name: string;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type MCPTool = z.infer<typeof MCPToolSchema>;
 export type MCPToolCall = z.infer<typeof MCPToolCallSchema>;
 export type MCPToolResult = z.infer<typeof MCPToolResultSchema>;

package/dist/core/mcp/types.js

@@ -2,11 +2,11 @@ import { z } from 'zod';
 export const MCPToolSchema = z.object({
     name: z.string(),
     description: z.string(),
-    inputSchema: z.record(z.any()),
+    inputSchema: z.record(z.string(), z.any()),
 });
 export const MCPToolCallSchema = z.object({
     name: z.string(),
-    arguments: z.record(z.any()),
+    arguments: z.record(z.string(), z.any()),
 });
 export const MCPToolResultSchema = z.object({
     content: z.array(z.object({

package/dist/core/memory/categorizer.js

@@ -81,6 +81,7 @@ export async function categorizeMemory(content, existingTags = []) {
         context: 0,
         preference: 0,
         note: 0,
+        task: 0,
     };
     for (const { type, patterns, weight } of MEMORY_TYPE_PATTERNS) {
         for (const pattern of patterns) {

package/dist/core/memory/consolidation.js

@@ -6,7 +6,8 @@ import { eq, inArray } from 'drizzle-orm';
 import { createDatabaseClient } from '../storage/database.js';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { cosineSimilarity } from './importance.js';
+import { cosineSimilarity } from '../utils/vector-operations.js';
+import { parseEmbedding } from '../lib/parse-embedding.js';
 import { getLowImportanceMemories } from './importance.js';
 import { rememberMemory } from './memories.js';
 import { logger } from '../logger.js';
@@ -98,33 +99,6 @@ async function calculateMemorySimilarity(memory1, memory2) {
     }
     return cosineSimilarity(embedding1, embedding2);
 }
-/**
- * Parse embedding from storage
- */
-function parseEmbedding(embeddingData) {
-    if (!embeddingData)
-        return null;
-    if (Array.isArray(embeddingData))
-        return embeddingData;
-    if (typeof embeddingData === 'string') {
-        try {
-            return JSON.parse(embeddingData);
-        }
-        catch {
-            return null;
-        }
-    }
-    if (Buffer.isBuffer(embeddingData)) {
-        try {
-            const floatArray = new Float32Array(embeddingData.buffer || embeddingData);
-            return Array.from(floatArray);
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
 /**
  * Simple text similarity as fallback (Jaccard similarity of word sets)
  */

package/dist/core/memory/entity-extractor.d.ts

@@ -13,6 +13,10 @@ export interface ExtractedEntity {
     context: string;
     normalized?: string;
 }
+/**
+ * Extract unique entity names for auto-linking
+ */
+export declare function extractEntityNames(content: string): string[];
 /**
  * Extract entities from content
  */

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/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