cogmem 3.6.2

package/dist/assets/FileLoaders.js

@@ -0,0 +1,268 @@
+import { createHash } from 'crypto';
+import { basename, extname } from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
+const TEXT_EXTENSIONS = new Set(['.txt', '.md', '.log', '.json', '.yaml', '.yml']);
+const CODE_EXTENSIONS = new Set([
+    '.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.go', '.rs', '.rb', '.sh', '.css', '.sql'
+]);
+function extOf(filePath) {
+    return extname(filePath).toLowerCase();
+}
+function loadTextFile(input) {
+    const stat = statSync(input.filePath);
+    const text = readFileSync(input.filePath, 'utf8');
+    return {
+        text,
+        sizeBytes: stat.size,
+        mtimeMs: stat.mtimeMs,
+        contentHash: createHash('sha256').update(text).digest('hex')
+    };
+}
+function makeLoaded(input, blocks, text, mimeType) {
+    const stat = statSync(input.filePath);
+    return {
+        asset: {
+            assetId: input.assetId,
+            filePath: input.filePath,
+            originalName: basename(input.filePath),
+            mimeType: mimeType || input.mimeType,
+            sizeBytes: stat.size,
+            contentHash: createHash('sha256').update(text).digest('hex'),
+            mtimeMs: stat.mtimeMs
+        },
+        blocks,
+        warnings: []
+    };
+}
+function splitParagraphBlocks(text, kind = 'paragraph') {
+    const lines = text.split(/\r?\n/);
+    const blocks = [];
+    let current = [];
+    let startLine = 1;
+    const flush = (endLine) => {
+        const value = current.join('\n').trim();
+        if (value) {
+            blocks.push({
+                text: value,
+                kind: value.startsWith('#') ? 'heading' : kind,
+                lineStart: startLine,
+                lineEnd: endLine
+            });
+        }
+        current = [];
+    };
+    lines.forEach((line, index) => {
+        if (!line.trim()) {
+            flush(index);
+            startLine = index + 2;
+            return;
+        }
+        if (current.length === 0)
+            startLine = index + 1;
+        current.push(line);
+    });
+    flush(lines.length);
+    return blocks.length > 0 ? blocks : [{ text, kind, lineStart: 1, lineEnd: lines.length }];
+}
+export class PlainTextLoader {
+    id = 'plain_text';
+    canLoad(input) {
+        return TEXT_EXTENSIONS.has(extOf(input.filePath));
+    }
+    async load(input) {
+        const { text } = loadTextFile(input);
+        return makeLoaded(input, splitParagraphBlocks(text), text, input.mimeType || 'text/plain');
+    }
+}
+export class HtmlLoader {
+    id = 'html';
+    canLoad(input) {
+        return ['.html', '.htm'].includes(extOf(input.filePath));
+    }
+    async load(input) {
+        const { text } = loadTextFile(input);
+        const title = text.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]?.replace(/\s+/g, ' ').trim();
+        const body = text
+            .replace(/<script[\s\S]*?<\/script>/gi, '\n')
+            .replace(/<style[\s\S]*?<\/style>/gi, '\n')
+            .replace(/<\/(h[1-6]|p|div|section|article|li|tr)>/gi, '\n')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/&nbsp;/g, ' ')
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/\n{3,}/g, '\n\n');
+        const blocks = splitParagraphBlocks([title ? `Title: ${title}` : '', body].filter(Boolean).join('\n\n'));
+        return makeLoaded(input, blocks, text, 'text/html');
+    }
+}
+export class CsvLoader {
+    id = 'csv';
+    canLoad(input) {
+        return extOf(input.filePath) === '.csv';
+    }
+    async load(input) {
+        const { text } = loadTextFile(input);
+        const rows = text.split(/\r?\n/).filter((line) => line.trim());
+        const header = rows[0] || '';
+        const blocks = [];
+        const windowSize = 30;
+        for (let start = 1; start < rows.length; start += windowSize) {
+            const slice = rows.slice(start, start + windowSize);
+            blocks.push({
+                kind: 'table',
+                text: [
+                    `File: ${basename(input.filePath)}`,
+                    'Sheet: CSV',
+                    `Columns: ${header}`,
+                    `Rows: ${start + 1}-${start + slice.length}`,
+                    '',
+                    header,
+                    ...slice
+                ].join('\n'),
+                sheetName: 'CSV',
+                rowStart: start + 1,
+                rowEnd: start + slice.length
+            });
+        }
+        return makeLoaded(input, blocks.length > 0 ? blocks : splitParagraphBlocks(text, 'table'), text, 'text/csv');
+    }
+}
+export class CodeTextLoader {
+    id = 'code_text';
+    canLoad(input) {
+        return CODE_EXTENSIONS.has(extOf(input.filePath));
+    }
+    async load(input) {
+        const { text } = loadTextFile(input);
+        const lines = text.split(/\r?\n/);
+        const blocks = [];
+        const windowSize = 80;
+        const extension = extOf(input.filePath).slice(1);
+        for (let start = 0; start < lines.length; start += windowSize) {
+            const slice = lines.slice(start, start + windowSize);
+            const symbolLine = slice.find((line) => /\b(function|class|const|let|var|export|def|interface|type)\b/.test(line));
+            blocks.push({
+                kind: 'code',
+                text: [
+                    `File: ${basename(input.filePath)}`,
+                    `Language: ${extension}`,
+                    `Lines: ${start + 1}-${start + slice.length}`,
+                    '',
+                    slice.join('\n')
+                ].join('\n'),
+                lineStart: start + 1,
+                lineEnd: start + slice.length,
+                symbolName: symbolLine?.trim().slice(0, 120),
+                metadata: { language: extension }
+            });
+        }
+        return makeLoaded(input, blocks, text, `text/x-${extension}`);
+    }
+}
+export class DocxLoader {
+    id = 'docx';
+    canLoad(input) {
+        return extOf(input.filePath) === '.docx';
+    }
+    async load(input) {
+        const mammoth = await import('mammoth');
+        const result = await mammoth.extractRawText({ path: input.filePath });
+        const text = String(result.value || '');
+        const blocks = splitParagraphBlocks(text);
+        return makeLoaded(input, blocks, readFileSync(input.filePath).toString('base64'), 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+    }
+}
+export class XlsxLoader {
+    id = 'xlsx';
+    canLoad(input) {
+        return ['.xlsx', '.xls'].includes(extOf(input.filePath));
+    }
+    async load(input) {
+        const XLSX = await import('xlsx');
+        const workbook = XLSX.readFile(input.filePath);
+        const blocks = [];
+        for (const sheetName of workbook.SheetNames || []) {
+            const sheet = workbook.Sheets[sheetName];
+            const rows = XLSX.utils.sheet_to_json(sheet, { header: 1, defval: '' });
+            if (rows.length === 0)
+                continue;
+            const header = rows[0].map((cell) => String(cell)).join(', ');
+            const windowSize = 30;
+            for (let start = 1; start < rows.length; start += windowSize) {
+                const slice = rows.slice(start, start + windowSize);
+                const textRows = slice.map((row, offset) => `${start + offset + 1} | ${row.map((cell) => String(cell)).join(' | ')}`);
+                blocks.push({
+                    kind: 'table',
+                    text: [
+                        `Workbook: ${basename(input.filePath)}`,
+                        `Sheet: ${sheetName}`,
+                        `Columns: ${header}`,
+                        `Rows: ${start + 1}-${start + slice.length}`,
+                        '',
+                        ...textRows
+                    ].join('\n'),
+                    sheetName,
+                    rowStart: start + 1,
+                    rowEnd: start + slice.length,
+                    metadata: { columns: rows[0].map((cell) => String(cell)) }
+                });
+            }
+        }
+        const raw = readFileSync(input.filePath);
+        return {
+            asset: {
+                assetId: input.assetId,
+                filePath: input.filePath,
+                originalName: basename(input.filePath),
+                mimeType: extOf(input.filePath) === '.xls' ? 'application/vnd.ms-excel' : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                sizeBytes: statSync(input.filePath).size,
+                contentHash: createHash('sha256').update(raw).digest('hex'),
+                mtimeMs: statSync(input.filePath).mtimeMs
+            },
+            blocks,
+            warnings: []
+        };
+    }
+}
+export class PdfLoader {
+    id = 'pdf';
+    canLoad(input) {
+        return extOf(input.filePath) === '.pdf';
+    }
+    async load(input) {
+        const pdfjs = await import('pdfjs-dist/legacy/build/pdf.mjs');
+        const bytes = new Uint8Array(readFileSync(input.filePath));
+        const task = pdfjs.getDocument({ data: bytes, useWorkerFetch: false, isEvalSupported: false, disableFontFace: true });
+        const document = await task.promise;
+        const blocks = [];
+        for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
+            const page = await document.getPage(pageNumber);
+            const content = await page.getTextContent();
+            const text = content.items.map((item) => String(item.str || '')).join(' ').replace(/\s+/g, ' ').trim();
+            if (text) {
+                blocks.push({
+                    kind: 'paragraph',
+                    text,
+                    page: pageNumber
+                });
+            }
+        }
+        const raw = readFileSync(input.filePath);
+        return {
+            asset: {
+                assetId: input.assetId,
+                filePath: input.filePath,
+                originalName: basename(input.filePath),
+                mimeType: 'application/pdf',
+                sizeBytes: statSync(input.filePath).size,
+                contentHash: createHash('sha256').update(raw).digest('hex'),
+                mtimeMs: statSync(input.filePath).mtimeMs
+            },
+            blocks,
+            warnings: blocks.length === 0
+                ? [{ code: 'pdf_no_extractable_text', message: 'PDF has no extractable text and may require OCR.', recoverable: true }]
+                : []
+        };
+    }
+}

package/dist/assets/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types.js';
+export { FileAssetStore } from './FileAssetStore.js';
+export { FileBlockStore } from './FileBlockStore.js';
+export { FileChunkStore } from './FileChunkStore.js';
+export { FileChunker } from './FileChunker.js';
+export { FileLoaderRegistry } from './FileLoaderRegistry.js';
+export { FileAssetIngestionService } from './FileAssetIngestionService.js';
+export type { IngestFileOptions } from './FileAssetIngestionService.js';
+export type { FileUnderstandingCapabilities, FileUnderstandingCostTier, FileUnderstandingInput, FileUnderstandingPolicy, FileUnderstandingPrivacy, FileUnderstandingProvider, FileUnderstandingResult, UnderstandingProvenance } from './providers/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/assets/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export { FileAssetStore } from './FileAssetStore.js';
+export { FileBlockStore } from './FileBlockStore.js';
+export { FileChunkStore } from './FileChunkStore.js';
+export { FileChunker } from './FileChunker.js';
+export { FileLoaderRegistry } from './FileLoaderRegistry.js';
+export { FileAssetIngestionService } from './FileAssetIngestionService.js';

package/dist/assets/providers/types.d.ts

@@ -0,0 +1,47 @@
+export type FileUnderstandingPrivacy = 'local' | 'cloud';
+export type FileUnderstandingCostTier = 'free' | 'low' | 'medium' | 'high';
+export type FileUnderstandingPolicy = 'local_only' | 'cloud_allowed' | 'cloud_for_complex_only' | 'ask_before_cloud_upload';
+export interface FileUnderstandingCapabilities {
+    acceptsRawFile: boolean;
+    acceptsText: boolean;
+    acceptsImage: boolean;
+    acceptsAudio: boolean;
+    acceptsVideo: boolean;
+    supportsOCR: boolean;
+    supportsASR: boolean;
+    supportsVisionCaption: boolean;
+    maxFileSizeMb: number;
+    privacy: FileUnderstandingPrivacy;
+    costTier: FileUnderstandingCostTier;
+}
+export interface FileUnderstandingInput {
+    task: 'extract_text' | 'ocr' | 'asr' | 'caption' | 'summarize' | 'analyze' | 'modify';
+    modality: 'raw_file' | 'text' | 'image' | 'audio' | 'video';
+    filePath?: string;
+    text?: string;
+    sizeBytes?: number;
+    complexity?: 'simple' | 'complex';
+    userApprovedCloudUpload?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface UnderstandingProvenance {
+    providerId: string;
+    providerPrivacy: FileUnderstandingPrivacy;
+    inputAssetId?: string;
+    inputChunkIds?: string[];
+    inputContentHash: string;
+    generatedAt: number;
+    confidence?: number;
+    userApprovedCloudUpload?: boolean;
+}
+export interface FileUnderstandingResult {
+    text?: string;
+    metadata?: Record<string, unknown>;
+    provenance: UnderstandingProvenance;
+}
+export interface FileUnderstandingProvider {
+    id: string;
+    capabilities: FileUnderstandingCapabilities;
+    analyze(input: FileUnderstandingInput): Promise<FileUnderstandingResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/assets/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/assets/types.d.ts

@@ -0,0 +1,159 @@
+import type { Neuron } from '../types/index.js';
+export type FileAssetIngestStatus = 'tracked' | 'indexed' | 'failed' | 'ignored';
+export type FileAssetParseStatus = 'not_started' | 'text_extracted' | 'requires_ocr' | 'requires_transcription' | 'unsupported' | 'failed';
+export type FileAssetPrivacyLevel = 'local' | 'cloud_allowed' | 'ask_before_cloud';
+export type FileBlockKind = 'paragraph' | 'heading' | 'table' | 'code' | 'transcript' | 'ocr' | 'metadata';
+export interface FileAssetRecord {
+    assetId: string;
+    projectId?: string;
+    filePath: string;
+    originalName?: string;
+    mimeType?: string;
+    extension?: string;
+    sizeBytes: number;
+    contentHash: string;
+    mtimeMs: number;
+    ingestStatus: FileAssetIngestStatus;
+    parseStatus: FileAssetParseStatus;
+    privacyLevel: FileAssetPrivacyLevel;
+    createdAt: number;
+    updatedAt: number;
+    lastIndexedAt?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface FileBlockRecord {
+    blockId: string;
+    assetId: string;
+    blockIndex: number;
+    kind: FileBlockKind;
+    text: string;
+    page?: number;
+    sheetName?: string;
+    rowStart?: number;
+    rowEnd?: number;
+    columnStart?: number;
+    columnEnd?: number;
+    lineStart?: number;
+    lineEnd?: number;
+    startMs?: number;
+    endMs?: number;
+    selector?: string;
+    symbolName?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+}
+export interface FileChunkRecord {
+    chunkId: string;
+    assetId: string;
+    neuronId: string;
+    chunkIndex: number;
+    blockStartIndex: number;
+    blockEndIndex: number;
+    kind: FileBlockKind;
+    tokenEstimate?: number;
+    textHash: string;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface FileChunkEvidence extends FileChunkRecord {
+    text: string;
+    filePath: string;
+    originalName?: string;
+    mimeType?: string;
+    page?: number;
+    sheetName?: string;
+    rowStart?: number;
+    rowEnd?: number;
+    lineStart?: number;
+    lineEnd?: number;
+    startMs?: number;
+    endMs?: number;
+}
+export interface FileEvidence {
+    assetId: string;
+    filePath: string;
+    originalName?: string;
+    mimeType?: string;
+    matchedChunks: Array<{
+        neuronId: string;
+        chunkIndex: number;
+        text: string;
+        kind: FileBlockKind;
+        page?: number;
+        sheetName?: string;
+        rowStart?: number;
+        rowEnd?: number;
+        lineStart?: number;
+        lineEnd?: number;
+        startMs?: number;
+        endMs?: number;
+    }>;
+}
+export interface FileLoadProbe {
+    filePath: string;
+    extension?: string;
+    mimeType?: string;
+}
+export interface FileLoadInput {
+    assetId: string;
+    filePath: string;
+    projectId?: string;
+    mimeType?: string;
+}
+export interface LoadedFileBlock {
+    text: string;
+    kind: FileBlockKind;
+    page?: number;
+    sheetName?: string;
+    rowStart?: number;
+    rowEnd?: number;
+    columnStart?: number;
+    columnEnd?: number;
+    lineStart?: number;
+    lineEnd?: number;
+    startMs?: number;
+    endMs?: number;
+    selector?: string;
+    symbolName?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LoadedFile {
+    asset: {
+        assetId: string;
+        filePath: string;
+        originalName?: string;
+        mimeType?: string;
+        sizeBytes: number;
+        contentHash: string;
+        mtimeMs: number;
+    };
+    blocks: LoadedFileBlock[];
+    warnings: FileLoadWarning[];
+}
+export interface FileLoadWarning {
+    code: string;
+    message: string;
+    recoverable: boolean;
+}
+export interface FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export interface ChunkDraft {
+    text: string;
+    kind: FileBlockKind;
+    blockStartIndex: number;
+    blockEndIndex: number;
+    tokenEstimate: number;
+    metadata?: Record<string, unknown>;
+}
+export interface FileIngestionResult {
+    asset: FileAssetRecord;
+    blocks: FileBlockRecord[];
+    chunks: FileChunkRecord[];
+    neurons: Neuron[];
+    skipped: boolean;
+    warnings: FileLoadWarning[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/assets/types.js

@@ -0,0 +1 @@
+export {};

package/dist/atlas/ActionFrameExtractor.d.ts

@@ -0,0 +1,15 @@
+import type Database from 'bun:sqlite';
+import type { EventStore } from '../store/EventStore.js';
+import type { MemoryAtlasStore } from '../store/MemoryAtlasStore.js';
+/** Builds source-anchored action frames from raw events; bindings improve the
+ * target/topic facets but are not a prerequisite for an action to exist. */
+export declare class ActionFrameExtractor {
+    private db;
+    private eventStore;
+    private atlasStore;
+    constructor(db: Database, eventStore: EventStore, atlasStore: MemoryAtlasStore);
+    rebuild(projectId?: string): number;
+    private clear;
+    private resolveTarget;
+}
+//# sourceMappingURL=ActionFrameExtractor.d.ts.map

package/dist/atlas/ActionFrameExtractor.js

@@ -0,0 +1,135 @@
+import { createHash } from 'node:crypto';
+import { eventTextForMemory } from '../episode/CogmemBlockStripper.js';
+import { actionMarkers } from './MemoryAtlasQueryCompiler.js';
+/** Builds source-anchored action frames from raw events; bindings improve the
+ * target/topic facets but are not a prerequisite for an action to exist. */
+export class ActionFrameExtractor {
+    db;
+    eventStore;
+    atlasStore;
+    constructor(db, eventStore, atlasStore) {
+        this.db = db;
+        this.eventStore = eventStore;
+        this.atlasStore = atlasStore;
+    }
+    rebuild(projectId) {
+        this.clear(projectId);
+        const entityCache = new Map();
+        const yearEvidence = new Map();
+        let created = 0;
+        let page = 1;
+        const pageSize = 1000;
+        while (true) {
+            const result = this.eventStore.queryEvents(page, pageSize, {
+                projectId: projectId ? [projectId] : undefined,
+            });
+            for (const event of result.records) {
+                if (!event.projectId || (event.role !== 'user' && event.role !== 'tool'))
+                    continue;
+                const text = eventTextForMemory(event);
+                const markers = actionMarkers(text);
+                if (!markers.length)
+                    continue;
+                const target = this.resolveTarget(event, text, entityCache);
+                for (const marker of markers) {
+                    const actionId = createHash('sha256').update([
+                        event.projectId, event.eventId, target.entityId || '', marker.frameType, marker.action,
+                    ].join('\0')).digest('hex').slice(0, 24);
+                    const now = Date.now();
+                    const episode = this.db.prepare(`SELECT episode_id FROM memory_episode_events WHERE event_id=? LIMIT 1`).get(event.eventId);
+                    this.db.prepare(`
+            INSERT INTO memory_action_frames(
+              action_id,project_id,frame_type,action,actor,target_entity_id,target_label,
+              topic_path,episode_id,occurred_at,confidence,source_authority,created_at,updated_at
+            ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+            ON CONFLICT(action_id) DO UPDATE SET action=excluded.action,target_entity_id=excluded.target_entity_id,
+              target_label=excluded.target_label,topic_path=excluded.topic_path,episode_id=excluded.episode_id,
+              confidence=excluded.confidence,updated_at=excluded.updated_at
+          `).run(actionId, event.projectId, marker.frameType, marker.action, event.role, target.entityId || null, target.entityName || null, target.topicPath || null, episode?.episode_id || null, event.occurredAt, target.confidence, event.role === 'tool' ? 'tool_evidence' : 'raw_user_request', now, now);
+                    this.db.prepare(`INSERT OR IGNORE INTO memory_action_frame_evidence(action_id,event_id,project_id,created_at) VALUES(?,?,?,?)`)
+                        .run(actionId, event.eventId, event.projectId, now);
+                    this.atlasStore.upsertDocument({
+                        id: `action:${actionId}`, projectId: event.projectId, nodeType: 'action', memoryKind: 'action', sourceId: actionId,
+                        label: [target.entityName, marker.action].filter(Boolean).join(' ') || marker.action,
+                        summary: text.slice(0, 500), topicPath: target.topicPath,
+                        confidence: target.confidence, supportCount: 1, status: 'active', occurredAt: event.occurredAt,
+                        evidenceEventIds: [event.eventId], metadata: {
+                            frameType: marker.frameType, targetEntityId: target.entityId, actor: event.role,
+                        },
+                    });
+                    created += 1;
+                }
+                const year = new Date(event.occurredAt).getUTCFullYear();
+                const key = `${event.projectId}\0${year}`;
+                const aggregate = yearEvidence.get(key) || { projectId: event.projectId, year, eventIds: new Set() };
+                aggregate.eventIds.add(event.eventId);
+                yearEvidence.set(key, aggregate);
+            }
+            if (page * pageSize >= result.total)
+                break;
+            page += 1;
+        }
+        for (const aggregate of yearEvidence.values()) {
+            const evidenceEventIds = [...aggregate.eventIds];
+            this.atlasStore.upsertDocument({
+                id: `time:${aggregate.projectId}:${aggregate.year}`, projectId: aggregate.projectId,
+                nodeType: 'time', memoryKind: 'time', sourceId: String(aggregate.year), label: String(aggregate.year),
+                confidence: 1, supportCount: evidenceEventIds.length, status: 'active',
+                occurredAt: Date.UTC(aggregate.year, 0, 1), evidenceEventIds,
+            });
+        }
+        return created;
+    }
+    clear(projectId) {
+        if (projectId) {
+            this.db.prepare(`DELETE FROM memory_action_frame_evidence WHERE project_id=?`).run(projectId);
+            this.db.prepare(`DELETE FROM memory_action_frames WHERE project_id=?`).run(projectId);
+            this.db.prepare(`DELETE FROM memory_atlas_documents WHERE project_id=? AND node_type IN ('action','time')`).run(projectId);
+            this.db.prepare(`DELETE FROM memory_atlas_fts WHERE project_id=? AND node_type IN ('action','time')`).run(projectId);
+            return;
+        }
+        this.db.exec(`
+      DELETE FROM memory_action_frame_evidence;
+      DELETE FROM memory_action_frames;
+      DELETE FROM memory_atlas_documents WHERE node_type IN ('action','time');
+      DELETE FROM memory_atlas_fts WHERE node_type IN ('action','time');
+    `);
+    }
+    resolveTarget(event, text, cache) {
+        const projectId = event.projectId;
+        if (!projectId)
+            return { confidence: 0.65 };
+        const binding = this.db.prepare(`
+      SELECT entity_id,entity_name,topic_path,confidence FROM memory_bindings
+      WHERE project_id=? AND event_id=? AND entity_id IS NOT NULL
+      ORDER BY confidence DESC,created_at DESC LIMIT 1
+    `).get(projectId, event.eventId);
+        if (binding)
+            return {
+                entityId: String(binding.entity_id), entityName: optionalString(binding.entity_name),
+                topicPath: optionalString(binding.topic_path), confidence: Number(binding.confidence || 0.8),
+            };
+        let candidates = cache.get(projectId);
+        if (!candidates) {
+            const rows = this.db.prepare(`SELECT entity_id,canonical_name,aliases_json FROM memory_entities WHERE project_id=?`).all(projectId);
+            candidates = rows.map((row) => ({
+                entityId: String(row.entity_id), canonicalName: String(row.canonical_name), aliases: parseAliases(row.aliases_json),
+            }));
+            cache.set(projectId, candidates);
+        }
+        const normalized = normalize(text);
+        const matched = candidates.find((candidate) => candidate.aliases.some((alias) => alias.length > 1 && normalized.includes(normalize(alias))));
+        return matched ? { entityId: matched.entityId, entityName: matched.canonicalName, confidence: 0.82 } : { confidence: 0.65 };
+    }
+}
+function parseAliases(value) {
+    try {
+        const parsed = JSON.parse(String(value || '[]'));
+        return Array.from(new Set(Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : []));
+    }
+    catch {
+        return [];
+    }
+}
+function normalize(value) { return value.normalize('NFKC').toLocaleLowerCase().replace(/\s+/g, ''); }
+function optionalString(value) { return typeof value === 'string' && value ? value : undefined; }

package/dist/atlas/MemoryAtlasIndexer.d.ts

@@ -0,0 +1,32 @@
+import type Database from 'bun:sqlite';
+import type { EventStore } from '../store/EventStore.js';
+import type { MemoryAtlasStore } from '../store/MemoryAtlasStore.js';
+export declare class MemoryAtlasIndexer {
+    private db;
+    private store;
+    private readonly actions;
+    constructor(db: Database, eventStore: EventStore, store: MemoryAtlasStore);
+    rebuild(options?: {
+        projectId?: string;
+    }): {
+        documents: number;
+        actions: number;
+    };
+    ensureFresh(options: {
+        projectId: string;
+    }): {
+        documents: number;
+        actions: number;
+        refreshed: boolean;
+    };
+    ensureAllFresh(): {
+        documents: number;
+        actions: number;
+        refreshed: boolean;
+        errors: Array<{
+            projectId: string;
+            error: string;
+        }>;
+    };
+}
+//# sourceMappingURL=MemoryAtlasIndexer.d.ts.map