@elvisw/dsh-magic-context 0.0.0-bootstrap.0 → 0.0.0-stage

package/lib/core/memory-categories.js

@@ -1,84 +0,0 @@
-/**
- * Magic Context's memory taxonomy, duplicated verbatim so the adapter can
- * write rows Magic Context will accept without importing its TypeScript.
- *
- * Source of truth (kept in sync on purpose, with the schema-version fence in
- * `memory-bridge.ts` as the tripwire): `packages/plugin/src/features/
- * magic-context/memory/constants.ts` + `normalize-hash.ts`.
- *
- * Contract version: MC storage schema v95 (see MEMORY_SCHEMA_MAX_VERSION).
- */
-/** The v2 taxonomy — the only categories new writes may use. */
-export const V2_MEMORY_CATEGORIES = [
-    'PROJECT_RULES',
-    'ARCHITECTURE',
-    'CONSTRAINTS',
-    'CONFIG_VALUES',
-    'NAMING',
-];
-/**
- * Categories the historian may promote. Legacy values stay promotable so
- * pre-v2 rows and lingering legacy writes keep working (MC: constants.ts:17).
- */
-export const PROMOTABLE_CATEGORIES = [
-    ...V2_MEMORY_CATEGORIES,
-    'ARCHITECTURE_DECISIONS',
-    'CONFIG_DEFAULTS',
-    'USER_PREFERENCES',
-    'USER_DIRECTIVES',
-    'ENVIRONMENT',
-    'WORKFLOW_RULES',
-    'KNOWN_ISSUES',
-];
-/** Render/priority order used when injecting memories (MC: CATEGORY_PRIORITY). */
-export const MEMORY_CATEGORY_PRIORITY = [
-    ...V2_MEMORY_CATEGORIES,
-    'USER_DIRECTIVES',
-    'USER_PREFERENCES',
-    'CONFIG_DEFAULTS',
-    'ARCHITECTURE_DECISIONS',
-    'ENVIRONMENT',
-    'WORKFLOW_RULES',
-    'KNOWN_ISSUES',
-];
-export const MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
-export function memoryCategoryOrder(category) {
-    const index = MEMORY_CATEGORY_PRIORITY.indexOf(category);
-    return index === -1 ? MEMORY_CATEGORY_ORDER_UNKNOWN : index;
-}
-/** TTL in ms by category; absent = permanent (MC: CATEGORY_DEFAULT_TTL). */
-export const CATEGORY_DEFAULT_TTL = {
-    WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-    KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000,
-};
-/**
- * `expires_at` for a new row: only the legacy TTL categories expire
- * (MC: promotion.ts:36-39 → `resolveExpiresAt`).
- */
-export function resolveExpiresAt(category, now) {
-    const ttl = CATEGORY_DEFAULT_TTL[category];
-    return ttl === undefined ? undefined : now + ttl;
-}
-/**
- * TTL applied to HISTORIAN-promoted rows (user decision 2026-10-16).
- *
- * The promoted pool grew monotonically and nothing bounded it: measured on the
- * live corpus, 1,941 non-domain rows, 67% of the active ones never recalled,
- * and `expires_at` non-null on exactly ZERO of them — the contract's TTL table
- * only covers two legacy categories, so the expiry pass had nothing to expire.
- * Every promoted fact now carries a 90-day window; a fact that is still being
- * re-observed refreshes it (see `promoteFacts`), so only abandoned rows age out.
- */
-export const HISTORIAN_MEMORY_TTL_MS = 90 * 24 * 60 * 60 * 1000;
-/**
- * `expires_at` for a promoted historian row: the category's own TTL when it has
- * one (shorter wins — KNOWN_ISSUES already expires at 30 days), else the
- * historian window. Unlike `resolveExpiresAt` this never returns undefined:
- * every promoted row gets a window.
- */
-export function resolveHistorianExpiresAt(category, now) {
-    return now + (CATEGORY_DEFAULT_TTL[category] ?? HISTORIAN_MEMORY_TTL_MS);
-}
-export function isPromotableCategory(category) {
-    return typeof category === 'string' && PROMOTABLE_CATEGORIES.includes(category);
-}

package/lib/core/memory-scoring.js

@@ -1,65 +0,0 @@
-/**
- * S(t) — the shared-memory decay score, borrowed from mon3stera's
- * dsh-magic-context `memory.js` and reshaped to this adapter's contracts.
- *
- *   S = clamp(0, 100, I · (1 + α·ln(1 + k)) · exp(−(ln2/τ_eff)·Δt))
- *   τ_eff = τ / (1 + β·k)
- *
- * I is the shared store's importance (1–100). Hits k SLOW the decay and boost
- * the score (LRU-style: used memories do not rot); τ is the category
- * half-life in days, null = immortal; a hit count of zero on a row we have no
- * sidecar stats for decays nothing (cold-start rows are favored, not
- * punished — the sidecar fills on the first recall anyway).
- *
- * Pure functions, no I/O and no MC import. The score gates ONLY the adapter's
- * injection ranking; it never writes the shared store (writer-contract
- * discipline): sub-threshold rows stop being injected here and stay fully
- * searchable — and a hit that lifts a row back over the threshold un-retires
- * it on the next recall.
- */
-/**
- * Half-life defaults, mon3stera's spirit translated to MC's taxonomy: durable
- * categories are immortal; exact values and names rot; legacy categories take
- * the MC TTL where one exists (KNOWN_ISSUES/WORKFLOW_RULES) or a conservative
- * middle ground otherwise.
- *
- * `enabled` defaults TRUE since the 2026-10-13 distribution decision: the
- * ranking takeover is the feature (stats alone are a dashboard), the corpus is
- * plugin-owned, and shadow telemetry showed zero regressions. An explicit
- * `false` in the profile still wins.
- */
-export const DEFAULT_MEMORY_SCORING = {
-    enabled: true,
-    alpha: 0.4,
-    beta: 0.2,
-    archiveThreshold: 2,
-    halfLives: {
-        PROJECT_RULES: null,
-        ARCHITECTURE: null,
-        CONSTRAINTS: null,
-        CONFIG_VALUES: 60,
-        NAMING: 90,
-        USER_PREFERENCES: 14,
-        WORKFLOW_RULES: 30,
-        KNOWN_ISSUES: 30,
-        ENVIRONMENT: 90,
-    },
-};
-export function halfLifeFor(config, category) {
-    const value = config.halfLives[category];
-    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
-}
-/** One memory's current score, on the shared store's 1–100 scale (clamped). */
-export function scoreMemory(memory, config, now) {
-    const importance = Number.isFinite(memory.importance) ? Math.max(0, memory.importance) : 0;
-    const hits = Number.isInteger(memory.hits) && memory.hits > 0 ? memory.hits : 0;
-    const boost = 1 + config.alpha * Math.log(1 + hits);
-    const halfLifeDays = halfLifeFor(config, memory.category);
-    let decay = 1;
-    if (halfLifeDays !== null && memory.lastHitAt !== undefined) {
-        const tauEff = halfLifeDays / (1 + config.beta * hits);
-        const dtDays = Math.max(0, (now - memory.lastHitAt) / 86_400_000);
-        decay = Math.exp(-(Math.LN2 / tauEff) * dtDays);
-    }
-    return Math.min(100, Math.max(0, importance * boost * decay));
-}

package/lib/core/memory-search.js

@@ -1,414 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import { cosineSimilarity } from "./embedding-local.js";
-import { errText } from "./types.js";
-/**
- * `ctx_search`'s memory lane — a faithful port of Magic Context's hybrid
- * retrieval (`features/magic-context/search.ts` + `memory/storage-memory-fts.ts`,
- * v0.45.0), reading the SAME shared store read-only.
- *
- * Score model (MC search.ts:49-51, 320-330, 855-901):
- *   hybrid  = SEMANTIC_WEIGHT(0.7) × cosine + FTS_WEIGHT(0.3) × reciprocal-rank
- *   single  = score × SINGLE_SOURCE_PENALTY(0.8)
- *   cosine  = clamp01; FTS order = bm25, updated_at DESC, id ASC; FTS scores
- *             are 1/(rank+1) (getFtsScores:801-803), NOT raw bm25 values.
- *   sort    = score DESC, id ASC; preview = 220 chars with `…`.
- *
- * Lanes: FTS5 (`memories_fts MATCH`, sanitize → strict AND, 0 rows → relaxed
- * OR — storage-memory-fts.ts:63-123) over the pool (domain visibility rules
- * identical to recall: own rows full, foreign rows need shareable + scope +
- * category allowlist — buildWorkspaceMemorySqlFilter:783-840), plus the
- * semantic lane over `memory_embeddings` vectors read-only.
- *
- * Candidates for semantic scoring are `ftsMatches ∪ storedVectorIds` ∩ pool
- * (MC selectSemanticCandidates:805-834). Candidates lacking a stored vector may
- * be embedded in memory, bounded per search — the adapter never writes Magic
- * Context's store (MC's own read-path backfill persists vectors instead).
- *
- * Deliberate deviations (recorded, not silent): no `visibleMemoryIds`
- * suppression (the adapter does not track which rows the current prompt already
- * carries, search.ts:877-880); in-memory embedding capped to bound latency.
- */
-const FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
-const SEMANTIC_WEIGHT = 0.7;
-const FTS_WEIGHT = 0.3;
-const SINGLE_SOURCE_PENALTY = 0.8;
-const RESULT_PREVIEW_LIMIT = 220;
-export const DEFAULT_MEMORY_SEARCH_LIMIT = 10;
-export const MAX_MEMORY_SEARCH_LIMIT = 25;
-/** Upper bound on rows embedded in memory for one search (latency guard). */
-export const MAX_IN_MEMORY_EMBEDDINGS = 32;
-const ID_SHAPED_QUERY_MAX_TOKENS = 5;
-const ID_SHAPED_TOKEN = /^#?\d+$/;
-/** MC sanitizeFtsQuery (storage-memory-fts.ts:70-80) — every whitespace token
- *  becomes a quoted literal so FTS5 operators lose their meaning. */
-export function sanitizeFtsQuery(query) {
-    const tokens = query
-        .replaceAll('\0', ' ')
-        .split(/\s+/)
-        .filter((token) => token.length > 0);
-    if (tokens.length === 0)
-        return '';
-    return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(' ');
-}
-/** MC relaxedFtsQuery (storage-memory-fts.ts:63-68) — word chars only, length
- *  > 2 or containing a digit, deduped, max 16, OR-joined. */
-export function relaxedFtsQuery(query) {
-    const tokens = [...new Set(query.match(/[\p{L}\p{N}_]+/gu) ?? [])]
-        .filter((token) => token.length > 2 || /\d/.test(token))
-        .slice(0, 16);
-    return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(' OR ');
-}
-/** MC parseIdShapedQuery (search.ts:297-321) — a query made only of id tokens
- *  (`#920`, `920 921`, max 5) is a direct lookup, not a text search. */
-export function parseIdShapedQuery(query) {
-    const trimmed = query.trim();
-    if (trimmed.length === 0)
-        return null;
-    const tokens = trimmed.split(/[\s,]+/).filter((token) => token.length > 0);
-    if (tokens.length === 0 || tokens.length > ID_SHAPED_QUERY_MAX_TOKENS)
-        return null;
-    const ids = [];
-    for (const token of tokens) {
-        if (!ID_SHAPED_TOKEN.test(token))
-            return null;
-        const parsed = Number.parseInt(token.replace(/^#/, ''), 10);
-        if (!Number.isFinite(parsed) || parsed <= 0)
-            return null;
-        ids.push(parsed);
-    }
-    return ids;
-}
-/** MC previewText (search.ts:328-333). */
-export function previewText(text) {
-    const normalized = text.replace(/\s+/g, ' ').trim();
-    if (normalized.length <= RESULT_PREVIEW_LIMIT)
-        return normalized;
-    return `${normalized.slice(0, RESULT_PREVIEW_LIMIT - 1).trimEnd()}…`;
-}
-/** MC normalizeCosineScore (search.ts:320-326). */
-function normalizeCosineScore(score) {
-    if (!Number.isFinite(score))
-        return 0;
-    return Math.min(1, Math.max(0, score));
-}
-/** Workspace visibility predicate (MC buildWorkspaceMemorySqlFilter:783-840):
- *  own identities see everything, foreign rows must be shareable + scope
- *  project/ecosystem/universe + in the active domains' category allowlist.
- *  `table` qualifies the column refs (the vector join aliases memories as m). */
-export function domainVisibilityPredicate(space, table = 'memories') {
-    const q = `${table}.`;
-    const own = [...new Set(space.ownIdentities)].filter((id) => id.length > 0);
-    const foreign = [...new Set(space.foreignIdentities)].filter((id) => id.length > 0 && !own.includes(id));
-    const share = [...new Set(space.shareCategories)];
-    const predicates = [];
-    const params = [];
-    if (own.length > 0) {
-        predicates.push(`${q}project_path IN (${own.map(() => '?').join(', ')})`);
-        params.push(...own);
-    }
-    if (foreign.length > 0 && share.length > 0) {
-        predicates.push(`(${q}project_path IN (${foreign.map(() => '?').join(', ')})`
-            + ` AND ${q}category IN (${share.map(() => '?').join(', ')})`
-            + ` AND ${q}shareable = 1`
-            + ` AND ${q}scope IN ('project','ecosystem','universe'))`);
-        params.push(...foreign, ...share);
-    }
-    if (predicates.length === 0)
-        return { clause: ' AND 0 = 1', params: [] };
-    return { clause: ` AND (${predicates.join(' OR ')})`, params };
-}
-export function openMemorySearch(options) {
-    const { logger } = options;
-    let db;
-    try {
-        db = new DatabaseSync(options.dbPath, { readOnly: true });
-    }
-    catch (error) {
-        const reason = `search store unavailable: ${errText(error)}`;
-        return {
-            search: () => Promise.resolve({ ok: false, reason }),
-            dominantEmbeddingModel: () => undefined,
-            paritySample: () => undefined,
-            close: () => { },
-        };
-    }
-    const tableExists = (name) => {
-        try {
-            return db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) !== undefined;
-        }
-        catch {
-            return false;
-        }
-    };
-    const hasMemories = tableExists('memories');
-    // Both aux lanes are optional: a store without the FTS index or the
-    // embeddings table runs with the remaining lane(s) (MC treats a failed FTS
-    // query as an empty lane, search.ts:793-798).
-    const hasFts = tableExists('memories_fts');
-    const hasVectors = tableExists('memory_embeddings');
-    const search = async (request) => {
-        const run = async () => {
-            const trimmed = request.query.trim();
-            if (trimmed.length === 0) {
-                return { ok: false, reason: 'query is required' };
-            }
-            const limit = Math.max(1, Math.min(MAX_MEMORY_SEARCH_LIMIT, Math.floor(request.limit ?? DEFAULT_MEMORY_SEARCH_LIMIT)));
-            // A3: the adapter's unified lane covers the `memory` source only; a
-            // sources list that excludes it yields zero hits (MC UnifiedSearchOptions).
-            if (request.sources !== undefined && !request.sources.includes('memory')) {
-                const empty = [];
-                return {
-                    ok: true,
-                    hits: empty,
-                    text: formatSearchResults(trimmed, empty),
-                    ftsMatches: 0,
-                    semanticMatches: 0,
-                    suppressedVisible: 0,
-                };
-            }
-            const { clause, params } = domainVisibilityPredicate(request.space);
-            // The embeddings join aliases memories as `m` — requalify the predicate.
-            const vectorVisibility = domainVisibilityPredicate(request.space, 'm');
-            // ── Direct id lookup (MC parseIdShapedQuery short-circuit) ────────────
-            const idShape = parseIdShapedQuery(trimmed);
-            if (idShape !== null) {
-                const placeholders = idShape.map(() => '?').join(', ');
-                const rows = db.prepare(`SELECT id, category, content, created_at AS createdAt FROM memories WHERE id IN (${placeholders})${clause}`
-                    + ' AND status IN (\'active\',\'permanent\')'
-                    + ' AND (expires_at IS NULL OR expires_at > ?) ORDER BY id ASC').all(...idShape, ...params, request.now);
-                const hits = rows.map((row) => ({
-                    id: row.id,
-                    category: row.category ?? '',
-                    score: 1,
-                    matchType: 'fts',
-                    preview: previewText(row.content),
-                }));
-                return {
-                    ok: true,
-                    hits,
-                    text: formatSearchResults(trimmed, hits),
-                    ftsMatches: hits.length,
-                    semanticMatches: 0,
-                    suppressedVisible: 0,
-                };
-            }
-            if (!hasMemories) {
-                return { ok: false, reason: 'memories table missing' };
-            }
-            // ── Lane 1: FTS5 (strict AND, then relaxed OR fallback) ───────────────
-            const ftsSql = (matchPlaceholder) => `SELECT memories.id AS id, memories.category AS category, memories.content AS content, memories.created_at AS createdAt`
-                + ` FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid`
-                + ` WHERE memories_fts MATCH ${matchPlaceholder}`
-                + ` AND memories.status IN ('active','permanent')`
-                + ` AND (memories.expires_at IS NULL OR memories.expires_at > ?)`
-                + clause
-                + ` ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC`
-                + ` LIMIT ?`;
-            const runFts = (matchValue) => db.prepare(ftsSql('?')).all(matchValue, request.now, ...params, FTS_SEMANTIC_CANDIDATE_LIMIT);
-            let ftsRows = [];
-            if (hasFts) {
-                try {
-                    const sanitized = sanitizeFtsQuery(trimmed);
-                    if (sanitized.length > 0)
-                        ftsRows = runFts(sanitized);
-                    if (ftsRows.length === 0) {
-                        const relaxed = relaxedFtsQuery(trimmed);
-                        if (relaxed.length > 0)
-                            ftsRows = runFts(relaxed);
-                    }
-                }
-                catch (error) {
-                    // MC getFtsMatches:793-798 — a failed FTS query is an empty lane.
-                    logger?.warn?.(`magic-context FTS lane failed: ${errText(error)}`);
-                    ftsRows = [];
-                }
-            }
-            // ── Lane 2: semantic over stored vectors (+ bounded in-memory fill) ───
-            const metaById = new Map(ftsRows.map((row) => [row.id, row]));
-            const stored = new Map();
-            const storedIds = [];
-            if (hasVectors && request.queryEmbedding !== null && request.queryModelId !== null) {
-                const rows = db.prepare(`SELECT m.id AS id, m.category AS category, m.content AS content, m.created_at AS createdAt, e.embedding AS embedding`
-                    + ` FROM memory_embeddings e INNER JOIN memories m ON m.id = e.memory_id`
-                    + ` WHERE e.model_id = ? AND m.status IN ('active','permanent')`
-                    + ` AND (m.expires_at IS NULL OR m.expires_at > ?)${vectorVisibility.clause}`).all(request.queryModelId, request.now, ...vectorVisibility.params);
-                const dims = request.queryEmbedding.length;
-                for (const row of rows) {
-                    if (row.embedding.length / 4 !== dims)
-                        continue;
-                    stored.set(row.id, new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4));
-                    storedIds.push(row.id);
-                    if (!metaById.has(row.id)) {
-                        metaById.set(row.id, { id: row.id, category: row.category, content: row.content, createdAt: row.createdAt });
-                    }
-                }
-            }
-            const semanticScores = new Map();
-            if (request.queryEmbedding !== null) {
-                const candidateIds = new Set([
-                    ...ftsRows.map((row) => row.id),
-                    ...storedIds,
-                ]);
-                // Bounded in-memory fill for candidates without a stored vector.
-                const missing = [...candidateIds]
-                    .filter((id) => !stored.has(id) && metaById.has(id))
-                    .slice(0, MAX_IN_MEMORY_EMBEDDINGS);
-                if (missing.length > 0 && request.embedTexts !== undefined) {
-                    try {
-                        const vectors = await request.embedTexts(missing.map((id) => metaById.get(id).content));
-                        if (vectors !== null) {
-                            for (let i = 0; i < missing.length; i++) {
-                                const vector = vectors[i];
-                                if (vector !== undefined)
-                                    stored.set(missing[i], vector);
-                            }
-                        }
-                    }
-                    catch {
-                        // fail-open: the stored vectors already cover the rest
-                    }
-                }
-                for (const id of candidateIds) {
-                    const vector = stored.get(id);
-                    if (vector === undefined)
-                        continue;
-                    semanticScores.set(id, normalizeCosineScore(cosineSimilarity(request.queryEmbedding, vector)));
-                }
-            }
-            // ── Merge (MC mergeMemoryResults:836-904) ─────────────────────────────
-            const ftsScores = new Map(ftsRows.map((row, rank) => [row.id, 1 / (rank + 1)]));
-            const hits = [];
-            let suppressedVisible = 0;
-            const candidateIds = new Set([...semanticScores.keys(), ...ftsScores.keys()]);
-            for (const id of candidateIds) {
-                const meta = metaById.get(id);
-                if (meta === undefined)
-                    continue;
-                // A3: created_at window (inclusive both ends).
-                if (request.from !== undefined && meta.createdAt < request.from)
-                    continue;
-                if (request.to !== undefined && meta.createdAt > request.to)
-                    continue;
-                // A2: rows the injected block already renders are suppressed from
-                // text results (MC suppressedVisibleMemoryIds; worst case without it
-                // is a redundant hit, never a correctness issue).
-                if (request.visibleMemoryIds?.has(id) === true) {
-                    suppressedVisible += 1;
-                    continue;
-                }
-                const semanticScore = semanticScores.get(id);
-                const ftsScore = ftsScores.get(id);
-                let score = 0;
-                let matchType = 'fts';
-                if (semanticScore !== undefined && ftsScore !== undefined) {
-                    score = SEMANTIC_WEIGHT * semanticScore + FTS_WEIGHT * ftsScore;
-                    matchType = 'hybrid';
-                }
-                else if (semanticScore !== undefined) {
-                    score = semanticScore * SINGLE_SOURCE_PENALTY;
-                    matchType = 'semantic';
-                }
-                else if (ftsScore !== undefined) {
-                    score = ftsScore * SINGLE_SOURCE_PENALTY;
-                    matchType = 'fts';
-                }
-                if (score <= 0)
-                    continue;
-                hits.push({
-                    id,
-                    category: meta.category ?? '',
-                    score,
-                    matchType,
-                    preview: previewText(meta.content),
-                });
-            }
-            hits.sort((left, right) => {
-                if (right.score !== left.score)
-                    return right.score - left.score;
-                return left.id - right.id;
-            });
-            const page = hits.slice(0, limit);
-            return {
-                ok: true,
-                hits: page,
-                text: formatSearchResults(trimmed, page),
-                ftsMatches: ftsRows.length,
-                semanticMatches: semanticScores.size,
-                suppressedVisible,
-            };
-        };
-        // B3 (MC single_store_reads): one deferred read transaction so the FTS
-        // lane, the vector reads and the pool probes observe ONE snapshot.
-        try {
-            if (hasMemories || hasFts || hasVectors)
-                db.exec('BEGIN');
-            try {
-                return await run();
-            }
-            finally {
-                try {
-                    db.exec('COMMIT');
-                }
-                catch {
-                    /* aborted read transaction — readonly, nothing to roll back */
-                }
-            }
-        }
-        catch (error) {
-            return {
-                ok: false,
-                reason: `memory search failed: ${errText(error)}`,
-            };
-        }
-    };
-    return {
-        search,
-        dominantEmbeddingModel: () => {
-            if (!hasVectors)
-                return undefined;
-            try {
-                const row = db.prepare(`SELECT model_id, MIN(length(embedding)) / 4 AS dims, COUNT(*) AS n`
-                    + ` FROM memory_embeddings GROUP BY model_id ORDER BY n DESC, model_id ASC LIMIT 1`).get();
-                if (row === undefined || row.model_id.length === 0)
-                    return undefined;
-                return { modelId: row.model_id, dims: row.dims ?? 0 };
-            }
-            catch {
-                return undefined;
-            }
-        },
-        paritySample: (modelId) => {
-            if (!hasVectors)
-                return undefined;
-            try {
-                const row = db.prepare(`SELECT m.content AS content, e.embedding AS embedding`
-                    + ` FROM memory_embeddings e INNER JOIN memories m ON m.id = e.memory_id`
-                    + ` WHERE e.model_id = ? ORDER BY e.rowid DESC LIMIT 1`).get(modelId);
-                if (row === undefined)
-                    return undefined;
-                return {
-                    content: row.content,
-                    embedding: new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4),
-                };
-            }
-            catch {
-                return undefined;
-            }
-        },
-        close: () => {
-            try {
-                db.close();
-            }
-            catch { /* already closed */ }
-        },
-    };
-}
-/** MC formatSearchResults (search.ts:2390-2413) restricted to the memory lane;
- *  per-hit line format is MC formatUnifiedSearchResult:2304-2311. */
-export function formatSearchResults(query, hits) {
-    if (hits.length === 0) {
-        return `No results found for "${query}" in project memories.`;
-    }
-    const body = hits.map((hit, index) => `[${index + 1}] [memory] score=${hit.score.toFixed(2)} id=${hit.id} category=${hit.category} match=${hit.matchType}\n${hit.preview}`);
-    return `Found ${hits.length} result${hits.length === 1 ? '' : 's'} for "${query}":\n\n${body.join('\n\n')}`;
-}