@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/memory/api.js

@@ -5,42 +5,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChannelSummary = exports.upsertChannelSummary = exports.LEXICAL_STOPWORDS = void 0;
 exports.buildDecisionId = buildDecisionId;
+exports.readMemoryRecordsInScopes = readMemoryRecordsInScopes;
+exports.readMemoryRecordById = readMemoryRecordById;
 exports.getLexicalQueryTokens = getLexicalQueryTokens;
 exports.topicAffinityBoost = topicAffinityBoost;
 exports.loadEdgesForIds = loadEdgesForIds;
 exports.saveMemory = saveMemory;
-exports.saveMemoryWithTrustedProvenance = saveMemoryWithTrustedProvenance;
+exports.saveJudgmentRecord = saveJudgmentRecord;
+exports.boundReadScopesFor = boundReadScopesFor;
+exports.saveLegacyMemory = saveLegacyMemory;
 exports.promoteMemoryStatus = promoteMemoryStatus;
+exports.retireMemoryRecord = retireMemoryRecord;
 exports.buildProfile = buildProfile;
 exports.recallMemory = recallMemory;
 exports.ingestMemory = ingestMemory;
-exports.ingestWithTrustedProvenance = ingestWithTrustedProvenance;
 exports.evolveMemory = evolveMemory;
 exports.buildMemoryBootstrap = buildMemoryBootstrap;
 exports.createAuditAck = createAuditAck;
 exports.recordMemoryAudit = recordMemoryAudit;
-exports.setExtractionFn = setExtractionFn;
 exports.ingestConversation = ingestConversation;
-exports.ingestConversationWithTrustedProvenance = ingestConversationWithTrustedProvenance;
+exports.expandWithGraphInAdapter = expandWithGraphInAdapter;
+exports.suggestInAdapter = suggestInAdapter;
+exports.listDecisionsInAdapter = listDecisionsInAdapter;
+exports.updateOutcomeInAdapter = updateOutcomeInAdapter;
+exports.readMemoryStatsInAdapter = readMemoryStatsInAdapter;
+exports.saveCheckpointInAdapter = saveCheckpointInAdapter;
+exports.loadCheckpointInAdapter = loadCheckpointInAdapter;
+exports.listCheckpointsInAdapter = listCheckpointsInAdapter;
 const node_crypto_1 = __importDefault(require("node:crypto"));
+const canonicalize_js_1 = require("../canonicalize.js");
 const db_manager_js_1 = require("../db-manager.js");
-const embeddings_js_1 = require("../embeddings.js");
-const wiki_page_index_js_1 = require("../cases/wiki-page-index.js");
+const write_adapters_js_1 = require("./write-adapters.js");
+const decision_formatter_js_1 = require("../decision-formatter.js");
+const debug_logger_js_1 = require("../debug-logger.js");
+const graph_query_js_1 = require("../knowledge/graph-query.js");
+const case_search_rollup_js_1 = require("../knowledge/case-search-rollup.js");
+const ranker_rescore_js_1 = require("../knowledge/ranker-rescore.js");
+const ranker_features_js_1 = require("../knowledge/ranker-features.js");
+const search_js_1 = require("../knowledge/search.js");
+const embedder_js_1 = require("../embedding/embedder.js");
+const index_js_1 = require("../knowledge/index.js");
+const write_adapters_js_2 = require("./write-adapters.js");
 const profile_builder_js_1 = require("./profile-builder.js");
 const bootstrap_builder_js_1 = require("./bootstrap-builder.js");
 const evolution_engine_js_1 = require("./evolution-engine.js");
 const channel_summary_state_store_js_1 = require("./channel-summary-state-store.js");
-const debug_logger_js_1 = require("../debug-logger.js");
-const extraction_prompt_js_1 = require("./extraction-prompt.js");
+const debug_logger_js_2 = require("../debug-logger.js");
+const secret_filter_js_1 = require("./secret-filter.js");
 const types_js_1 = require("./types.js");
 const channel_summary_store_js_1 = require("./channel-summary-store.js");
 Object.defineProperty(exports, "getChannelSummary", { enumerable: true, get: function () { return channel_summary_store_js_1.getChannelSummary; } });
 Object.defineProperty(exports, "upsertChannelSummary", { enumerable: true, get: function () { return channel_summary_store_js_1.upsertChannelSummary; } });
-const recall_bridge_js_1 = require("../entities/recall-bridge.js");
-const read_identity_js_1 = require("../entities/read-identity.js");
-const search_quality_js_1 = require("../search/search-quality.js");
-const event_store_js_1 = require("./event-store.js");
+const search_quality_js_1 = require("../knowledge/search-quality.js");
 const provenance_js_1 = require("./provenance.js");
+const judgments_js_1 = require("../knowledge/judgments.js");
+const record_identity_js_1 = require("../registry/record-identity.js");
 function buildDecisionId(topic) {
     // Non-ASCII topics (Korean etc.) used to collapse into bare underscore runs
     // ("decision_______<ts>") - unreadable and near-colliding. Collapse the runs
@@ -76,12 +95,35 @@ function toMemoryRecord(row, scopes, fallbackSource) {
         }
     }
     const savedSource = trustContext?.source;
+    let guidance = {};
+    if (typeof row.payload_json === 'string') {
+        try {
+            const payload = JSON.parse(row.payload_json);
+            if (payload.guidance &&
+                typeof payload.guidance === 'object' &&
+                !Array.isArray(payload.guidance)) {
+                guidance = payload.guidance;
+            }
+        }
+        catch {
+            /* malformed payloads do not become guidance */
+        }
+    }
+    const steps = Array.isArray(guidance.steps)
+        ? guidance.steps.filter((step) => typeof step === 'string')
+        : undefined;
+    const evidenceChecks = Array.isArray(guidance.evidence_checks)
+        ? guidance.evidence_checks.filter((check) => typeof check === 'string')
+        : undefined;
     return {
         id: String(row.id),
         topic: String(row.topic),
         kind: row.kind ?? 'decision',
         summary: String(row.summary ?? row.decision ?? ''),
         details: String(row.reasoning ?? row.decision ?? ''),
+        ...(typeof guidance.applies_when === 'string' ? { applies_when: guidance.applies_when } : {}),
+        ...(steps === undefined ? {} : { steps }),
+        ...(evidenceChecks === undefined ? {} : { evidence_checks: evidenceChecks }),
         confidence: Number(row.confidence ?? 0.5),
         status: row.status ?? 'active',
         scopes,
@@ -92,124 +134,71 @@ function toMemoryRecord(row, scopes, fallbackSource) {
         event_datetime: typeof row.event_datetime === 'number' && Number.isFinite(row.event_datetime)
             ? row.event_datetime
             : null,
+        outcome: row.outcome ?? null,
     };
 }
-function loadEventDateTimeForObservations(adapter, observationIds) {
-    const uniqueIds = Array.from(new Set(observationIds.filter(Boolean)));
-    if (uniqueIds.length === 0) {
-        return null;
-    }
-    const placeholders = uniqueIds.map(() => '?').join(', ');
-    const row = adapter
-        .prepare(`
-        SELECT MAX(COALESCE(timestamp_observed, created_at)) AS event_datetime
-        FROM entity_observations
-        WHERE id IN (${placeholders})
-      `)
-        .get(...uniqueIds);
-    return typeof row?.event_datetime === 'number' && Number.isFinite(row.event_datetime)
-        ? row.event_datetime
-        : null;
+function scopeBoundRowsClause(scopes, alias = 'd') {
+    if (scopes.length === 0)
+        return { sql: '0', params: [] };
+    const alternatives = scopes.map(() => '(s.kind = ? AND s.external_id = ?)').join(' OR ');
+    return {
+        sql: `EXISTS (
+      SELECT 1 FROM memory_scope_bindings b
+      JOIN memory_scopes s ON s.id = b.scope_id
+      WHERE b.memory_id = ${alias}.id AND (${alternatives})
+    )`,
+        params: scopes.flatMap((scope) => [scope.kind, scope.id]),
+    };
 }
-function getTimelineEntityKindPriority(kind) {
-    switch (kind) {
-        case 'work_item':
-            return 0;
-        case 'project':
-            return 1;
-        case 'organization':
-            return 2;
-        case 'person':
-            return 3;
-        default:
-            return 99;
+/** Read complete memory records whose stored scopes intersect the admitted scopes. */
+async function readMemoryRecordsInScopes(adapter, scopes, options = {}) {
+    const scopeClause = scopeBoundRowsClause(scopes);
+    const conditions = [scopeClause.sql];
+    const params = [...scopeClause.params];
+    const kinds = options.kind === undefined ? [] : Array.isArray(options.kind) ? options.kind : [options.kind];
+    if (kinds.length > 0) {
+        conditions.push(`d.kind IN (${kinds.map(() => '?').join(', ')})`);
+        params.push(...kinds);
     }
-}
-function resolveTimelineTargetEntityIdFromObservations(adapter, observationIds) {
-    const uniqueIds = Array.from(new Set(observationIds.filter(Boolean)));
-    if (uniqueIds.length === 0) {
-        return null;
+    const statuses = options.status === undefined
+        ? []
+        : Array.isArray(options.status)
+            ? options.status
+            : [options.status];
+    if (statuses.length > 0) {
+        conditions.push(`COALESCE(d.status, 'active') IN (${statuses.map(() => '?').join(', ')})`);
+        params.push(...statuses);
     }
-    const placeholders = uniqueIds.map(() => '?').join(', ');
     const rows = adapter
-        .prepare(`
-        SELECT
-          n.id AS entity_id,
-          n.kind AS entity_kind,
-          COUNT(*) AS matched_observations
-        FROM entity_lineage_links l
-        JOIN entity_nodes n
-          ON n.id = l.canonical_entity_id
-        WHERE l.entity_observation_id IN (${placeholders})
-          AND l.status = 'active'
-          AND n.status = 'active'
-          AND n.merged_into IS NULL
-        GROUP BY n.id, n.kind
-      `)
-        .all(...uniqueIds);
-    rows.sort((left, right) => {
-        const kindDelta = getTimelineEntityKindPriority(left.entity_kind) -
-            getTimelineEntityKindPriority(right.entity_kind);
-        if (kindDelta !== 0) {
-            return kindDelta;
-        }
-        if (right.matched_observations !== left.matched_observations) {
-            return right.matched_observations - left.matched_observations;
-        }
-        return left.entity_id.localeCompare(right.entity_id);
-    });
-    return rows[0]?.entity_id ?? null;
+        .prepare(`SELECT d.id, d.topic, d.decision, d.reasoning, d.confidence, d.created_at, d.updated_at,
+              d.trust_context, d.kind, d.status, d.summary, d.event_date, d.event_datetime,
+              d.outcome, d.payload_json
+       FROM decisions d
+       WHERE ${conditions.join(' AND ')}
+       ORDER BY d.created_at ASC, d.id ASC`)
+        .all(...params);
+    const scopesById = batchLoadScopes(adapter, rows.map((row) => String(row.id)));
+    const fallbackSource = { package: 'mama-core', source_type: 'db' };
+    return rows.map((row) => toMemoryRecord(row, scopesById.get(String(row.id)) ?? [], fallbackSource));
 }
-function buildTimelineEventForSave(adapter, memoryId, topic, entityObservationIds, timelineEvent) {
-    if (!timelineEvent) {
+/** Read one complete record only when at least one stored scope is admitted. */
+async function readMemoryRecordById(adapter, memoryId, scopes) {
+    const id = memoryId.trim();
+    const scopeClause = scopeBoundRowsClause(scopes);
+    if (!id || scopes.length === 0)
         return null;
-    }
-    const resolvedEntityId = timelineEvent.entity_id ??
-        resolveTimelineTargetEntityIdFromObservations(adapter, entityObservationIds);
-    if (!resolvedEntityId) {
+    const row = adapter
+        .prepare(`SELECT d.id, d.topic, d.decision, d.reasoning, d.confidence, d.created_at, d.updated_at,
+              d.trust_context, d.kind, d.status, d.summary, d.event_date, d.event_datetime,
+              d.outcome, d.payload_json
+       FROM decisions d
+       WHERE d.id = ? AND ${scopeClause.sql}
+       LIMIT 1`)
+        .get(id, ...scopeClause.params);
+    if (!row)
         return null;
-    }
-    return {
-        id: timelineEvent.id ?? `et_${node_crypto_1.default.randomUUID()}`,
-        entity_id: resolvedEntityId,
-        event_type: timelineEvent.event_type,
-        role: timelineEvent.role ?? null,
-        valid_from: timelineEvent.valid_from ?? null,
-        valid_to: timelineEvent.valid_to ?? null,
-        observed_at: timelineEvent.observed_at ?? null,
-        source_ref: timelineEvent.source_ref ?? `decision:${memoryId}`,
-        summary: timelineEvent.summary,
-        details: timelineEvent.details ??
-            JSON.stringify({
-                memory_id: memoryId,
-                topic,
-            }),
-    };
-}
-function insertTimelineEventForSave(adapter, event, createdAt) {
-    adapter
-        .prepare(`
-        INSERT INTO entity_timeline_events (
-          id, entity_id, event_type, role, valid_from, valid_to, observed_at,
-          source_ref, summary, details, created_at
-        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `)
-        .run(event.id, event.entity_id, event.event_type, event.role, event.valid_from, event.valid_to, event.observed_at, event.source_ref, event.summary, event.details, createdAt);
-}
-function cleanupFailedMemorySave(adapter, memoryId) {
-    const row = adapter.prepare(`SELECT rowid FROM decisions WHERE id = ?`).get(memoryId);
-    if (!row) {
-        return;
-    }
-    const cleanup = () => {
-        adapter.prepare(`DELETE FROM embeddings WHERE rowid = ?`).run(row.rowid);
-        adapter.prepare(`DELETE FROM decisions WHERE id = ?`).run(memoryId);
-    };
-    const txResult = adapter.transaction(cleanup);
-    if (typeof txResult === 'function') {
-        txResult();
-    }
+    const recordScopes = batchLoadScopes(adapter, [id]).get(id) ?? [];
+    return toMemoryRecord(row, recordScopes, { package: 'mama-core', source_type: 'db' });
 }
 function batchLoadScopes(adapter, memoryIds) {
     const scopeMap = new Map();
@@ -232,28 +221,27 @@ function batchLoadScopes(adapter, memoryIds) {
     }
     return scopeMap;
 }
-async function loadScopedMemories(scopes) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
+async function loadScopedMemories(adapter, scopes) {
     const fallbackSource = { package: 'mama-core', source_type: 'db' };
     let rows;
     if (scopes.length === 0) {
         rows = adapter
             .prepare(`
           SELECT id, topic, decision, reasoning, confidence, created_at, updated_at, trust_context,
-                 kind, status, summary, event_date, event_datetime
+                 kind, status, summary, event_date, event_datetime, outcome, payload_json
           FROM decisions
           ORDER BY COALESCE(event_datetime, created_at) DESC, created_at DESC
         `)
             .all();
     }
     else {
-        const scopeIds = await Promise.all(scopes.map((scope) => (0, db_manager_js_1.ensureMemoryScope)(scope.kind, scope.id)));
+        const scopeIds = await Promise.all(scopes.map((scope) => (0, db_manager_js_1.ensureMemoryScope)(adapter, scope.kind, scope.id)));
         const placeholders = scopeIds.map(() => '?').join(', ');
         rows = adapter
             .prepare(`
           SELECT DISTINCT d.id, d.topic, d.decision, d.reasoning, d.confidence, d.created_at,
-                 d.updated_at, d.trust_context, d.kind, d.status, d.summary, d.event_date, d.event_datetime
+                 d.updated_at, d.trust_context, d.kind, d.status, d.summary, d.event_date, d.event_datetime,
+                 d.outcome, d.payload_json
           FROM decisions d
           JOIN memory_scope_bindings msb ON msb.memory_id = d.id
           WHERE msb.scope_id IN (${placeholders})
@@ -400,12 +388,25 @@ function buildLexicalCandidates(records, query) {
         return { memory: record, score };
     })
         .filter((candidate) => candidate.score > 0)
-        .sort((left, right) => {
-        if (right.score !== left.score) {
-            return right.score - left.score;
-        }
-        return Number(right.memory.created_at) - Number(left.memory.created_at);
-    });
+        .sort(compareLexicalCandidates);
+}
+function lexicalEventTime(record) {
+    if (typeof record.event_datetime === 'number' && Number.isFinite(record.event_datetime)) {
+        return record.event_datetime;
+    }
+    const numericCreated = Number(record.created_at);
+    if (Number.isFinite(numericCreated)) {
+        return numericCreated;
+    }
+    const parsedCreated = Date.parse(String(record.created_at));
+    return Number.isFinite(parsedCreated) ? parsedCreated : 0;
+}
+function compareLexicalCandidates(left, right) {
+    // Relevance wins; equally relevant history follows event time, not import or
+    // commit order. FTS rowid order is not an event-time judgment.
+    return (right.score - left.score ||
+        lexicalEventTime(right.memory) - lexicalEventTime(left.memory) ||
+        left.memory.id.localeCompare(right.memory.id));
 }
 function lexicalScoreToConfidence(score) {
     return Math.min(0.95, 0.45 + score * 0.05);
@@ -460,11 +461,9 @@ function _mergeRecallCandidates(primary, lexical) {
     })
         .map((candidate) => candidate.memory);
 }
-async function loadEdgesForIds(ids) {
+async function loadEdgesForIds(adapter, ids) {
     if (ids.length === 0)
         return [];
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
     const placeholders = ids.map(() => '?').join(', ');
     const rows = adapter
         .prepare(`SELECT from_id, to_id, relationship AS type, reason
@@ -479,223 +478,221 @@ async function loadEdgesForIds(ids) {
         reason: row.reason ?? undefined,
     }));
 }
-async function saveMemoryInternal(input, options) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
-    const id = buildDecisionId(input.topic);
-    const now = Date.now();
-    const provenance = (0, provenance_js_1.normalizeMemoryWriteProvenance)(options);
-    const targetStatus = input.status ?? 'active';
-    const shouldApplyEvolution = targetStatus === 'active';
-    // Find evolution candidates: exact topic match first, then semantic search fallback
-    const primaryScope = input.scopes.length > 0 ? input.scopes[0] : null;
-    const excludeIds = new Set(input.excludeIds ?? []);
-    let existingCandidates;
-    if (!shouldApplyEvolution) {
-        existingCandidates = [];
-    }
-    else if (primaryScope) {
-        const scopeId = await (0, db_manager_js_1.ensureMemoryScope)(primaryScope.kind, primaryScope.id);
-        existingCandidates = adapter
-            .prepare(`
-          SELECT d.id, d.topic, d.summary, d.kind
-          FROM decisions d
-          JOIN memory_scope_bindings msb ON msb.memory_id = d.id
-          WHERE d.topic = ? AND msb.scope_id = ?
-            AND (d.status = 'active' OR d.status IS NULL)
-            AND d.superseded_by IS NULL
-          ORDER BY d.created_at DESC
-          LIMIT 5
-        `)
-            .all(input.topic, scopeId).filter((c) => !excludeIds.has(c.id));
-    }
-    else {
-        existingCandidates = adapter
-            .prepare(`
-          SELECT id, topic, summary, kind
-          FROM decisions
-          WHERE topic = ?
-            AND (status = 'active' OR status IS NULL)
-            AND superseded_by IS NULL
-          ORDER BY created_at DESC
-          LIMIT 5
-        `)
-            .all(input.topic).filter((c) => !excludeIds.has(c.id));
+const GUIDANCE_MEMORY_KINDS = new Set([
+    'lesson',
+    'preference',
+    'constraint',
+    'workflow',
+]);
+function oneLineGuidanceText(value) {
+    return value.trim().replace(/\s+/g, ' ');
+}
+function guidancePayloadFor(input) {
+    if (!GUIDANCE_MEMORY_KINDS.has(input.kind))
+        return undefined;
+    const appliesWhen = typeof input.appliesWhen === 'string' ? oneLineGuidanceText(input.appliesWhen) : '';
+    if (!appliesWhen) {
+        throw new judgments_js_1.JudgmentError('INVALID_INPUT', `memory.save kind '${input.kind}' requires an appliesWhen line`);
     }
-    // Semantic fallback: if no exact topic match, find similar memories via vector search
-    if (shouldApplyEvolution && existingCandidates.length === 0) {
-        try {
-            const queryText = `${input.topic} ${input.summary}`;
-            const embedding = await (0, embeddings_js_1.generateEmbedding)(queryText, 'query');
-            // Exclude superseded history so a dense supersede chain cannot fill all 3
-            // candidate slots and hide the prior ACTIVE decision (which would break the
-            // evolution link and create an active duplicate).
-            const semanticResults = await (0, db_manager_js_1.vectorSearch)(embedding, 3, 0.82, undefined, Array.from(EXCLUDED_STATUSES));
-            // Scope-filter semantic candidates when a primary scope is available
-            let scopeFiltered = semanticResults;
-            if (primaryScope) {
-                const semIds = semanticResults.map((r) => String(r.id));
-                const semScopeMap = batchLoadScopes(adapter, semIds);
-                const scopeKey = `${primaryScope.kind}:${primaryScope.id}`;
-                scopeFiltered = semanticResults.filter((r) => {
-                    const scopes = semScopeMap.get(String(r.id)) ?? [];
-                    return scopes.length === 0 || scopes.some((s) => `${s.kind}:${s.id}` === scopeKey);
-                });
+    const guidance = { applies_when: appliesWhen };
+    if (input.kind === 'workflow') {
+        const steps = Array.isArray(input.steps) ? input.steps.map(oneLineGuidanceText) : [];
+        if (steps.length === 0 || steps.some((step) => step.length === 0)) {
+            throw new judgments_js_1.JudgmentError('INVALID_INPUT', 'memory.save kind workflow requires one or more ordered steps');
+        }
+        guidance.steps = steps;
+        if (input.evidenceChecks !== undefined) {
+            if (!Array.isArray(input.evidenceChecks)) {
+                throw new judgments_js_1.JudgmentError('INVALID_INPUT', 'memory.save evidenceChecks must be a list');
             }
-            existingCandidates = scopeFiltered
-                .filter((r) => {
-                const status = String(r.status || '');
-                return !status || status === 'active' || status === '';
-            })
-                .filter((c) => !excludeIds.has(String(c.id)))
-                .map((r) => ({
-                id: String(r.id),
-                topic: String(r.topic || ''),
-                summary: String(r.decision || ''),
-                kind: 'fact',
-                _semanticMatch: true,
-            }));
-        }
-        catch {
-            // Semantic search unavailable — proceed with empty candidates
+            const checks = input.evidenceChecks.map(oneLineGuidanceText);
+            if (checks.some((check) => check.length === 0)) {
+                throw new judgments_js_1.JudgmentError('INVALID_INPUT', 'memory.save evidenceChecks cannot contain an empty line');
+            }
+            guidance.evidence_checks = checks;
         }
     }
-    const evolution = shouldApplyEvolution
-        ? (0, evolution_engine_js_1.resolveMemoryEvolution)({
-            incoming: { topic: input.topic, summary: input.summary, kind: input.kind },
-            existing: existingCandidates.map((c) => ({
-                ...c,
-                kind: (c.kind || 'fact'),
-            })),
-        })
-        : { edges: [] };
-    const supersedesTarget = evolution.edges.find((edge) => edge.type === 'supersedes')?.to_id ?? null;
-    const entityObservationIds = Array.from(new Set(input.entityObservationIds ?? []));
-    const eventDateTime = typeof input.eventDateTime === 'number'
-        ? input.eventDateTime
-        : loadEventDateTimeForObservations(adapter, entityObservationIds);
-    const timelineEvent = buildTimelineEventForSave(adapter, id, input.topic, entityObservationIds, input.timelineEvent);
-    await (0, db_manager_js_1.insertDecisionWithEmbedding)({
-        id,
+    return { guidance };
+}
+async function saveMemoryInternal(adapter, input, provenance, access, trustedEnvelope, legacy, commandIdOverride) {
+    const targetStatus = input.status ?? 'active';
+    const requestedScopes = input.scopes ?? [];
+    const payload = guidancePayloadFor(input);
+    const eventDateTime = typeof input.eventDateTime === 'number' ? input.eventDateTime : null;
+    // Fail before any write: identity references and relationship targets are
+    // checked against the same admitted scopes the command will carry.
+    (0, record_identity_js_1.validateRecordIdentityReferences)(adapter, {
+        itemId: input.itemId,
+        actors: input.actors,
+        scopes: input.scopes,
+    });
+    const commandId = commandIdOverride ?? `save:${buildDecisionId(input.topic)}`;
+    const recordId = (0, index_js_1.judgmentRecordId)(commandId);
+    // Relationships are persisted only when the caller names their target ids
+    // explicitly. Matching topic text or vector similarity is evidence for
+    // retrieval, not identity.
+    const explicitRelationships = Array.from(new Map((legacy?.relationships ?? []).flatMap((relationship) => relationship.targetIds.map((targetId) => [
+        `${relationship.type}:${targetId}`,
+        { type: relationship.type, targetId },
+    ]))).values());
+    (0, write_adapters_js_2.assertRelationshipTargetsVisible)(adapter, explicitRelationships.map((relationship) => relationship.targetId), access.scopes, trustedEnvelope);
+    const { links, replaces, decisionEdges, supersedeTargets } = (0, write_adapters_js_2.relationshipsToCommandFields)(explicitRelationships, { trusted: trustedEnvelope });
+    const authoredLinks = [...links, ...(input.links ?? [])];
+    const authoredReplacements = [...replaces, ...(input.replaces ?? [])];
+    const allSupersedeTargets = [
+        ...new Set([
+            ...supersedeTargets,
+            ...(input.replaces ?? []).map((replacement) => replacement.id),
+        ]),
+    ];
+    const embeddingDecision = {
+        id: recordId,
         topic: input.topic,
         decision: input.summary,
         reasoning: input.details,
         confidence: input.confidence ?? 0.5,
-        supersedes: supersedesTarget,
-        created_at: now,
-        updated_at: now,
-        trust_context: JSON.stringify({ source: input.source }),
         event_date: input.eventDate ?? null,
         event_datetime: eventDateTime,
-        agent_id: provenance.agent_id,
-        model_run_id: provenance.model_run_id,
-        envelope_hash: provenance.envelope_hash,
-        gateway_call_id: provenance.gateway_call_id,
-        source_refs_json: JSON.stringify(provenance.source_refs),
-        provenance_json: JSON.stringify(provenance.provenance),
-    });
-    // Pre-resolve scope IDs before the synchronous transaction
-    const resolvedScopeIds = [];
-    for (const [index, scope] of input.scopes.entries()) {
-        const scopeId = await (0, db_manager_js_1.ensureMemoryScope)(scope.kind, scope.id);
-        resolvedScopeIds.push({ scopeId, isPrimary: index === 0 });
-    }
-    // Wrap all post-insert mutations in a transaction for atomicity
-    try {
-        adapter.transaction(() => {
-            adapter
-                .prepare(`
-            UPDATE decisions
-            SET kind = ?, status = ?, summary = ?, is_static = ?, trust_context = ?, updated_at = ?
-            WHERE id = ?
-          `)
-                .run(input.kind, targetStatus, input.summary, input.kind === 'preference' || input.kind === 'constraint' ? 1 : 0, JSON.stringify({ source: input.source }), now, id);
-            for (const { scopeId, isPrimary } of resolvedScopeIds) {
-                adapter
-                    .prepare(`
-              INSERT OR REPLACE INTO memory_scope_bindings (memory_id, scope_id, is_primary)
-              VALUES (?, ?, ?)
-            `)
-                    .run(id, scopeId, isPrimary ? 1 : 0);
-            }
-            (0, event_store_js_1.insertMemoryEventInTransaction)(adapter, {
-                event_type: 'save',
-                actor: provenance.actor,
-                source_turn_id: provenance.source_turn_id ?? undefined,
-                memory_id: id,
-                topic: input.topic,
-                scope_refs: input.scopes,
-                evidence_refs: provenance.source_refs,
-                reason: buildSaveEventReason(provenance.tool_name, provenance.gateway_call_id),
-                created_at: now,
-            });
-            for (const entityObservationId of entityObservationIds) {
-                adapter
-                    .prepare(`
-              INSERT OR IGNORE INTO decision_entity_sources (
-                decision_id, entity_observation_id, relation_type, created_at
-              ) VALUES (?, ?, ?, ?)
-            `)
-                    .run(id, entityObservationId, 'support', now);
-            }
-            if (timelineEvent) {
-                insertTimelineEventForSave(adapter, timelineEvent, now);
-            }
-            for (const edge of evolution.edges) {
-                if (edge.type === 'supersedes') {
-                    adapter
-                        .prepare(`UPDATE decisions SET superseded_by = ?, status = 'superseded', updated_at = ? WHERE id = ?`)
-                        .run(id, now, edge.to_id);
+    };
+    const command = {
+        commandId,
+        topic: input.topic,
+        summary: input.summary,
+        reasoning: input.details,
+        recordKind: 'judgment',
+        confidence: input.confidence ?? 0.5,
+        eventDate: input.eventDate ?? null,
+        eventDatetime: eventDateTime,
+        outcome: legacy?.outcome ?? null,
+        failureReason: legacy?.failureReason ?? null,
+        limitation: legacy?.limitation ?? null,
+        sourceRefs: provenance.source_refs,
+        provenance: provenance.provenance,
+        ...(payload === undefined ? {} : { payload }),
+        agentId: provenance.agent_id,
+        modelRunId: provenance.model_run_id,
+        envelopeHash: provenance.envelope_hash,
+        gatewayCallId: provenance.gateway_call_id,
+        scopes: [...requestedScopes],
+        links: authoredLinks,
+        replaces: authoredReplacements,
+        record: {
+            kind: input.kind,
+            status: targetStatus,
+            summary: input.summary,
+            isStatic: legacy?.isStatic ?? (input.kind === 'preference' || input.kind === 'constraint' ? 1 : 0),
+            userInvolvement: legacy?.userInvolvement ?? null,
+            trustContext: JSON.stringify({ source: input.source }),
+        },
+        event: {
+            actor: provenance.actor,
+            ...(provenance.source_turn_id ? { sourceTurnId: provenance.source_turn_id } : {}),
+            evidenceRefs: provenance.source_refs,
+            reason: buildSaveEventReason(provenance.tool_name, provenance.gateway_call_id),
+        },
+        projections: {
+            decisionEdges,
+            ...(allSupersedeTargets.length > 0 ? { supersedeTargets: allSupersedeTargets } : {}),
+            ...(input.itemId !== undefined || input.actors !== undefined
+                ? {
+                    recordIdentity: { itemId: input.itemId ?? null, actors: input.actors ?? [] },
                 }
-                adapter
-                    .prepare(`
-              INSERT OR REPLACE INTO decision_edges (from_id, to_id, relationship, reason, weight, created_at)
-              VALUES (?, ?, ?, ?, ?, ?)
-            `)
-                    .run(id, edge.to_id, edge.type, edge.reason ?? null, 1.0, now);
-            }
+                : {}),
+        },
+    };
+    let receipt;
+    try {
+        receipt = await (0, index_js_1.appendJudgment)(command, access, {
+            adapter,
+            embedder: (0, write_adapters_js_2.commandEmbedder)(embeddingDecision),
         });
     }
     catch (error) {
-        cleanupFailedMemorySave(adapter, id);
         const rollbackError = (error instanceof Error ? error : new Error(String(error)));
-        rollbackError.memoryId = id;
+        rollbackError.memoryId = recordId;
         throw rollbackError;
     }
-    // Sync the adapter's status cache for every row whose status changed in the
-    // post-insert transaction: the saved row itself (status is written AFTER
-    // insertEmbedding populated the cache) and any rows just superseded. This makes
-    // the vectorSearch pre-filter correct within this session, not only after reload.
-    if (adapter.refreshDecisionStatusCache) {
-        const changedIds = [
-            id,
-            ...evolution.edges.filter((e) => e.type === 'supersedes').map((e) => e.to_id),
-        ];
-        const ridStmt = adapter.prepare('SELECT rowid FROM decisions WHERE id = ?');
-        for (const changedId of changedIds) {
-            const ridRow = ridStmt.get(changedId);
-            if (ridRow) {
-                adapter.refreshDecisionStatusCache(ridRow.rowid);
-            }
-        }
-    }
     return {
         success: true,
-        id,
-        saved_decision_id: id,
-        timeline_event_id: timelineEvent?.id ?? null,
-        timeline_event_ids: timelineEvent ? [timelineEvent.id] : [],
+        id: receipt.recordId,
+        saved_decision_id: receipt.recordId,
     };
 }
-async function saveMemory(input) {
-    return saveMemoryInternal((0, provenance_js_1.sanitizePublicSaveMemoryInput)(input));
+async function saveMemory(adapter, input) {
+    const clean = (0, provenance_js_1.sanitizePublicSaveMemoryInput)(input);
+    const provenance = (0, provenance_js_1.normalizeMemoryWriteProvenance)();
+    const access = (0, write_adapters_js_2.writeAccessForProvenance)(provenance, clean.scopes ?? []);
+    return saveMemoryInternal(adapter, clean, provenance, access, false);
+}
+/**
+ * The unified `memory.save` action path. Access IS the call authority — the
+ * command's scopes are checked against it inside `appendJudgment`, and the
+ * record's provenance is composed from it plus the session facts the host
+ * attests (never from caller input). `commandId` is the caller's operationId,
+ * so a retried call replays the original receipt.
+ */
+async function saveJudgmentRecord(adapter, input, access, commandId, session) {
+    // An omitted scope request writes under the full admitted scopes — the same
+    // default the gateway's trusted path applied via the context packet.
+    const clean = (0, provenance_js_1.sanitizePublicSaveMemoryInput)({
+        ...input,
+        scopes: input.scopes ?? access.scopes,
+    });
+    const provenance = (0, provenance_js_1.normalizeMemoryWriteProvenance)({
+        actor: session?.actor ?? 'main_agent',
+        agent_id: access.agentId,
+        model_run_id: session?.modelRunId,
+        envelope_hash: session?.envelopeHash,
+        tool_name: session?.toolName,
+        gateway_call_id: session?.gatewayCallId,
+        context_packet_id: session?.contextPacketId,
+        source_turn_id: session?.sourceTurnId,
+        source_message_ref: session?.sourceMessageRef,
+        source_refs: session?.sourceRefs ? [...session.sourceRefs] : undefined,
+    });
+    return saveMemoryInternal(adapter, clean, provenance, access, true, undefined, commandId);
+}
+/**
+ * The read-side scope rule for memory actions — the same bound `appendJudgment`
+ * applies to writes. An omitted request reads under the full admitted scopes;
+ * an explicit request must be a subset of them. An empty admitted set admits an
+ * empty corpus: a caller with no scopes can see no scoped record (reads never
+ * fall back to an unbounded scan — the legacy `scopes: []` = read-all behavior
+ * is exactly what this bound removes).
+ */
+function boundReadScopesFor(access, requested) {
+    const readable = [...access.scopes, ...(access.readScopes ?? [])];
+    const scopeKey = (scope) => JSON.stringify([scope.kind, scope.id]);
+    const admitted = new Map(readable.map((scope) => [scopeKey(scope), scope]));
+    const effective = requested ?? [...admitted.values()];
+    const seen = new Set();
+    return effective.map((scope) => {
+        if (typeof scope !== 'object' ||
+            scope === null ||
+            typeof scope.kind !== 'string' ||
+            scope.kind.trim().length === 0 ||
+            typeof scope.id !== 'string' ||
+            scope.id.trim().length === 0) {
+            throw new judgments_js_1.JudgmentError('INVALID_SCOPE', 'scope kind is invalid');
+        }
+        const key = scopeKey(scope);
+        if (seen.has(key)) {
+            throw new judgments_js_1.JudgmentError('INVALID_SCOPE', 'Read scopes must be unique');
+        }
+        seen.add(key);
+        if (!admitted.has(key)) {
+            throw new judgments_js_1.JudgmentError('SCOPE_DENIED', 'Read scope is outside the admitted access');
+        }
+        return scope;
+    });
 }
-async function saveMemoryWithTrustedProvenance(input, options) {
-    return saveMemoryInternal((0, provenance_js_1.sanitizePublicSaveMemoryInput)(input), options);
+async function saveLegacyMemory(adapter, input, legacy, access) {
+    const clean = (0, provenance_js_1.sanitizePublicSaveMemoryInput)(input);
+    const provenance = (0, provenance_js_1.normalizeMemoryWriteProvenance)();
+    const effectiveAccess = access ?? (0, write_adapters_js_2.writeAccessForProvenance)(provenance, clean.scopes ?? []);
+    return saveMemoryInternal(adapter, clean, provenance, effectiveAccess, access !== undefined, legacy);
 }
-async function promoteMemoryStatus(input) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
+async function promoteMemoryStatus(adapter, input) {
     const memoryId = input.memoryId;
     const now = input.nowMs ?? Date.now();
     const targetStatus = input.status;
@@ -718,7 +715,7 @@ async function promoteMemoryStatus(input) {
         const primaryScope = scopes[0] ?? null;
         let existingCandidates;
         if (primaryScope) {
-            const scopeId = await (0, db_manager_js_1.ensureMemoryScope)(primaryScope.kind, primaryScope.id);
+            const scopeId = (0, db_manager_js_1.ensureMemoryScope)(adapter, primaryScope.kind, primaryScope.id);
             existingCandidates = adapter
                 .prepare(`
             SELECT d.id, d.topic, d.summary, d.kind
@@ -748,10 +745,10 @@ async function promoteMemoryStatus(input) {
         if (existingCandidates.length === 0) {
             try {
                 const queryText = `${topic} ${summary}`;
-                const embedding = await (0, embeddings_js_1.generateEmbedding)(queryText, 'query');
+                const embedding = await (0, embedder_js_1.generateEmbedding)(queryText, 'query');
                 // Same exclusion as saveMemoryInternal's fallback: superseded history must
                 // not crowd out the prior ACTIVE decision from the 3 candidate slots.
-                const semanticResults = await (0, db_manager_js_1.vectorSearch)(embedding, 3, 0.82, undefined, Array.from(EXCLUDED_STATUSES));
+                const semanticResults = await (0, search_js_1.vectorSearch)(adapter, embedding, 3, 0.82, undefined, Array.from(EXCLUDED_STATUSES));
                 let scopeFiltered = semanticResults;
                 if (primaryScope) {
                     const semIds = semanticResults.map((result) => String(result.id));
@@ -792,46 +789,104 @@ async function promoteMemoryStatus(input) {
     const existingSupersedesTarget = typeof row.supersedes === 'string' && row.supersedes.length > 0 ? row.supersedes : null;
     const supersedesTarget = evolution.edges.find((edge) => edge.type === 'supersedes')?.to_id ??
         (targetStatus === 'active' ? existingSupersedesTarget : null);
-    adapter.transaction(() => {
-        const updated = adapter
-            .prepare('UPDATE decisions SET status = ?, supersedes = ?, updated_at = ? WHERE id = ?')
-            .run(targetStatus, supersedesTarget, now, memoryId);
-        if (updated.changes !== 1) {
-            throw new Error(`Cannot promote missing memory ${memoryId}`);
-        }
-        for (const edge of evolution.edges) {
-            if (edge.type === 'supersedes') {
-                adapter
-                    .prepare(`UPDATE decisions SET superseded_by = ?, status = 'superseded', updated_at = ? WHERE id = ?`)
-                    .run(memoryId, now, edge.to_id);
-            }
-            adapter
-                .prepare(`
-            INSERT OR REPLACE INTO decision_edges (from_id, to_id, relationship, reason, weight, created_at)
-            VALUES (?, ?, ?, ?, ?, ?)
-          `)
-                .run(memoryId, edge.to_id, edge.type, edge.reason ?? null, 1.0, now);
-        }
-    });
-    // Sync the adapter's status cache for every row whose status changed above.
-    // Without this, a row promoted OUT of an excluded status (e.g. stale->active)
-    // stays invisible to the vectorSearch pre-filter until the next full reload.
-    if (adapter.refreshDecisionStatusCache) {
-        const changedIds = [
-            memoryId,
-            ...evolution.edges.filter((e) => e.type === 'supersedes').map((e) => e.to_id),
-        ];
-        const ridStmt = adapter.prepare('SELECT rowid FROM decisions WHERE id = ?');
-        for (const id of changedIds) {
-            const ridRow = ridStmt.get(id);
-            if (ridRow) {
-                adapter.refreshDecisionStatusCache(ridRow.rowid);
-            }
-        }
+    // The status change is an authored amendment: one append-only judgment record
+    // carries it, and the target row's projection columns move in the same
+    // transaction. A replayed command (same id, same payload) returns the stored
+    // receipt instead of rewriting.
+    const commandId = `promote:${memoryId}:${node_crypto_1.default
+        .createHash('sha256')
+        .update((0, canonicalize_js_1.canonicalizeJSON)({
+        status: targetStatus,
+        supersedes: supersedesTarget,
+        edges: evolution.edges.map((edge) => `${edge.type}:${edge.to_id}`),
+        now,
+    }))
+        .digest('hex')
+        .slice(0, 16)}`;
+    const supersedesEdges = evolution.edges.filter((edge) => edge.type === 'supersedes');
+    const command = {
+        commandId,
+        // Audit records link to the amended memory instead of sharing its topic,
+        // keeping them out of the topic's evolution candidate pool.
+        topic: `judgment/${memoryId}`,
+        summary: `Status '${targetStatus}' applied to ${memoryId}`,
+        recordKind: 'judgment',
+        payload: {
+            amended: memoryId,
+            status: targetStatus,
+            supersedes: supersedesTarget,
+            edges: evolution.edges.map((edge) => ({ type: edge.type, to_id: edge.to_id })),
+        },
+        scopes,
+        agentId: null,
+        links: [{ relation: 'amends', target: { kind: 'memory', id: memoryId } }],
+        amends: [
+            // supersedes is included only when a target resolved: applyAmendment
+            // writes a column for every key present, so a null here would clear the
+            // target's predecessor pointer on non-active promotions.
+            {
+                target: { kind: 'memory', id: memoryId },
+                status: targetStatus,
+                ...(supersedesTarget !== null ? { supersedes: supersedesTarget } : {}),
+            },
+            ...supersedesEdges.map((edge) => ({
+                target: { kind: 'memory', id: edge.to_id },
+                supersededBy: memoryId,
+                status: 'superseded',
+            })),
+        ],
+        projections: {
+            decisionEdges: evolution.edges.map((edge) => ({
+                fromId: memoryId,
+                targetId: edge.to_id,
+                relationship: edge.type,
+                reason: edge.reason ?? null,
+                weight: 1,
+            })),
+        },
+        record: {
+            kind: 'fact',
+            status: 'active',
+            summary: `Status '${targetStatus}' applied to ${memoryId}`,
+        },
+        recordedAt: now,
+        event: { reason: `promote ${memoryId} to '${targetStatus}'` },
+    };
+    await (0, index_js_1.appendJudgment)(command, (0, write_adapters_js_2.unsignedWriteAccess)(scopes), { adapter });
+}
+/** Append an access-checked status amendment for one stored memory record. */
+async function retireMemoryRecord(adapter, input, access, commandId) {
+    const id = input.memoryId.trim();
+    const reason = input.reason.trim();
+    if (!id)
+        throw new judgments_js_1.JudgmentError('INVALID_INPUT', 'memory.retire requires memory_id');
+    if (!reason)
+        throw new judgments_js_1.JudgmentError('INVALID_INPUT', 'memory.retire requires a reason');
+    if (input.status !== 'stale' && input.status !== 'superseded') {
+        throw new judgments_js_1.JudgmentError('INVALID_INPUT', 'memory.retire status must be stale or superseded');
     }
+    const record = await readMemoryRecordById(adapter, id, access.scopes);
+    if (!record) {
+        throw new judgments_js_1.JudgmentError('REFERENCE_NOT_FOUND', 'Memory record is unavailable in the admitted scopes');
+    }
+    const admittedScopes = record.scopes.filter((recordScope) => access.scopes.some((scope) => scope.kind === recordScope.kind && scope.id === recordScope.id));
+    const summary = `Status '${input.status}' applied to ${id}: ${reason}`;
+    const receipt = await (0, index_js_1.appendJudgment)({
+        commandId,
+        topic: `judgment/${id}`,
+        summary,
+        recordKind: 'judgment',
+        payload: { amended: id, status: input.status, reason },
+        scopes: admittedScopes,
+        links: [{ relation: 'amends', target: { kind: 'memory', id } }],
+        amends: [{ target: { kind: 'memory', id }, status: input.status }],
+        record: { kind: 'fact', status: 'active', summary },
+        event: { reason: `Retired ${id} as ${input.status}: ${reason}` },
+    }, access, { adapter });
+    return { success: true, id, status: input.status, reason, receiptId: receipt.recordId };
 }
-async function buildProfile(scopes) {
-    const records = await loadScopedMemories(scopes);
+async function buildProfile(adapter, scopes) {
+    const records = await loadScopedMemories(adapter, scopes);
     return (0, profile_builder_js_1.classifyProfileEntries)(records);
 }
 const EXCLUDED_STATUSES = new Set([
@@ -840,14 +895,17 @@ const EXCLUDED_STATUSES = new Set([
     'contradicted',
     'stale',
 ]);
-async function recallMemory(query, options = {}) {
+async function recallMemory(adapter, query, options = {}) {
     const bundle = (0, types_js_1.createEmptyRecallBundle)(query);
     const searchOptions = (0, search_quality_js_1.normalizeSearchQualityOptions)(options);
+    const matchesKind = (kind) => options.kind === undefined ||
+        (Array.isArray(options.kind)
+            ? options.kind.some((value) => value === kind)
+            : kind === options.kind);
     const diagnostics = {
         candidate_counts: {
             vector: 0,
             lexical: 0,
-            entity: 0,
             graph_expanded: 0,
             vector_only: 0,
             rejected_by_strictness: 0,
@@ -858,14 +916,12 @@ async function recallMemory(query, options = {}) {
     let matched = [];
     let fusedHits = [];
     let retrievalSource = 'none';
-    const projectionMode = process.env.MAMA_ENTITY_PROJECTION_MODE ?? 'shadow';
     const vectorSimilarityById = new Map();
     const lexicalScoreById = new Map();
-    const entitySupportIds = new Set();
     let _lexicalRecords = null;
     const loadLexical = async () => {
         if (_lexicalRecords === null) {
-            _lexicalRecords = await loadScopedMemories(options.scopes ?? []);
+            _lexicalRecords = await loadScopedMemories(adapter, options.scopes ?? []);
         }
         return _lexicalRecords;
     };
@@ -888,25 +944,27 @@ async function recallMemory(query, options = {}) {
         }
     }
     // Hybrid search: vector + BM25/lexical in parallel, fused with RRF
-    await (0, db_manager_js_1.initDB)();
+    // One adapter for the whole retrieval: generateEmbedding yields, and a reset
+    // between two adapter lookups would fuse candidates from two databases.
+    const searchAdapter = adapter;
     // Channel 1: Vector search (semantic similarity) — run all sub-queries
     const vectorMatched = [];
     let primaryQueryEmbedding = null;
     try {
         for (const sq of subQueries) {
-            const queryEmbedding = await (0, embeddings_js_1.generateEmbedding)(sq, 'query');
+            const queryEmbedding = await (0, embedder_js_1.generateEmbedding)(sq, 'query');
             if (sq === query && primaryQueryEmbedding === null) {
                 primaryQueryEmbedding = queryEmbedding;
             }
-            const vectorResults = await (0, db_manager_js_1.vectorSearch)(queryEmbedding, vectorLimit, searchOptions.threshold, searchOptions.topicPrefix, 
+            const vectorResults = await (0, search_js_1.vectorSearch)(searchAdapter, queryEmbedding, vectorLimit, searchOptions.threshold, searchOptions.topicPrefix, 
             // Keep superseded history out of the candidate top-K at search time; the
             // post-filter below stays the authority (and includeHistory restores it).
-            options.includeHistory ? undefined : Array.from(EXCLUDED_STATUSES));
+            options.includeHistory ? undefined : Array.from(EXCLUDED_STATUSES), options.kind);
             let filtered = vectorResults;
             let vectorScopeMap = new Map();
             if (options.scopes && options.scopes.length > 0) {
                 const vectorIds = vectorResults.map((r) => String(r.id));
-                vectorScopeMap = batchLoadScopes((0, db_manager_js_1.getAdapter)(), vectorIds);
+                vectorScopeMap = batchLoadScopes(adapter, vectorIds);
                 const requestedScopes = new Set(options.scopes.map((s) => `${s.kind}:${s.id}`));
                 filtered = vectorResults.filter((r) => {
                     const scopes = vectorScopeMap.get(String(r.id)) ?? [];
@@ -924,7 +982,7 @@ async function recallMemory(query, options = {}) {
                 vectorMatched.push({
                     id: String(result.id),
                     topic: String(result.topic || ''),
-                    kind: 'decision',
+                    kind: (result.kind ?? 'decision'),
                     summary: String(result.decision || ''),
                     details: String(result.reasoning || ''),
                     confidence: result.similarity ?? 0.5,
@@ -935,6 +993,7 @@ async function recallMemory(query, options = {}) {
                     updated_at: result.created_at ?? Date.now(),
                     event_date: result.event_date ?? null,
                     event_datetime: result.event_datetime ?? null,
+                    outcome: result.outcome ?? null,
                 });
                 diagnostics.candidate_counts.vector += 1;
                 if (typeof result.similarity === 'number' && Number.isFinite(result.similarity)) {
@@ -944,7 +1003,7 @@ async function recallMemory(query, options = {}) {
         } // end sub-query loop
     }
     catch (vectorErr) {
-        (0, debug_logger_js_1.warn)(`[recallMemory] Vector search failed: ${vectorErr instanceof Error ? vectorErr.message : String(vectorErr)}`);
+        (0, debug_logger_js_2.warn)(`[recallMemory] Vector search failed: ${vectorErr instanceof Error ? vectorErr.message : String(vectorErr)}`);
     }
     // Deduplicate vector results from multiple sub-queries
     const seenIds = new Set();
@@ -1013,9 +1072,9 @@ async function recallMemory(query, options = {}) {
                 .map((t) => stemToken(t))
                 .filter((t) => !FTS5_NOISE_WORDS.has(t));
             const ftsQuery = ftsTokens.length > 0 ? ftsTokens.join(' OR ') : query;
-            const ftsResults = await (0, db_manager_js_1.fts5Search)(ftsQuery, lexicalLimit);
+            const ftsResults = await (0, search_js_1.fts5Search)(searchAdapter, ftsQuery, lexicalLimit, options.kind);
             if (ftsResults.length > 0) {
-                const adapter = (0, db_manager_js_1.getAdapter)();
+                const adapter = searchAdapter;
                 const fallbackSource = {
                     package: 'mama-core',
                     source_type: 'fts5',
@@ -1025,7 +1084,7 @@ async function recallMemory(query, options = {}) {
                 for (const ftsRow of ftsResults) {
                     const row = adapter
                         .prepare(`SELECT id, topic, decision, reasoning, confidence, created_at, updated_at,
-                    trust_context, kind, status, summary, event_date, event_datetime
+                    trust_context, kind, status, summary, event_date, event_datetime, outcome
              FROM decisions WHERE id = ?`)
                         .get(ftsRow.id);
                     if (!row)
@@ -1042,6 +1101,8 @@ async function recallMemory(query, options = {}) {
                     // Topic prefix filtering (matches vectorSearch behavior)
                     if (searchOptions.topicPrefix && !record.topic.startsWith(searchOptions.topicPrefix))
                         continue;
+                    if (!matchesKind(record.kind))
+                        continue;
                     // Scope filtering
                     if (options.scopes && options.scopes.length > 0) {
                         const requestedScopes = new Set(options.scopes.map((s) => `${s.kind}:${s.id}`));
@@ -1070,14 +1131,14 @@ async function recallMemory(query, options = {}) {
             for (const candidate of lexicalCandidates) {
                 candidate.score += topicAffinityBoost(candidate.memory.topic, boostTokens, boostQuery);
             }
-            lexicalCandidates.sort((left, right) => right.score - left.score);
+            lexicalCandidates.sort(compareLexicalCandidates);
         }
         // Fallback: in-memory lexical if FTS5 returned nothing
         if (lexicalCandidates.length === 0) {
             let lexicalRecords = await loadLexical();
             if (options.scopes && options.scopes.length > 0) {
                 const lexicalIds = lexicalRecords.map((r) => r.id);
-                const scopeMap = batchLoadScopes((0, db_manager_js_1.getAdapter)(), lexicalIds);
+                const scopeMap = batchLoadScopes(adapter, lexicalIds);
                 const requestedScopes = new Set(options.scopes.map((s) => `${s.kind}:${s.id}`));
                 lexicalRecords = lexicalRecords.filter((r) => {
                     const scopes = scopeMap.get(r.id) ?? [];
@@ -1090,6 +1151,9 @@ async function recallMemory(query, options = {}) {
             if (searchOptions.topicPrefix) {
                 lexicalRecords = lexicalRecords.filter((r) => r.topic.startsWith(searchOptions.topicPrefix));
             }
+            if (options.kind !== undefined) {
+                lexicalRecords = lexicalRecords.filter((r) => matchesKind(r.kind));
+            }
             lexicalCandidates = buildLexicalCandidates(lexicalRecords, query);
             if (subQueries.length > 1) {
                 for (const sq of subQueries.slice(1)) {
@@ -1100,7 +1164,7 @@ async function recallMemory(query, options = {}) {
                         }
                     }
                 }
-                lexicalCandidates.sort((a, b) => b.score - a.score);
+                lexicalCandidates.sort(compareLexicalCandidates);
             }
         }
     } // end needsLexical
@@ -1149,56 +1213,6 @@ async function recallMemory(query, options = {}) {
         record: entry.record,
         fused_rank_score: entry.score,
     }));
-    let hasWikiHits = false;
-    const wikiScores = new Map();
-    const wikiVectorRankMap = new Map();
-    const wikiVectorScoreById = new Map();
-    try {
-        const adapter = (0, db_manager_js_1.getAdapter)();
-        const wikiFtsHits = (0, wiki_page_index_js_1.ftsSearchWikiPages)(adapter, query, requestedLimit * 2);
-        let wikiVectorHits = [];
-        if (primaryQueryEmbedding) {
-            try {
-                wikiVectorHits = (0, wiki_page_index_js_1.vectorSearchWikiPages)(adapter, primaryQueryEmbedding, requestedLimit * 2);
-            }
-            catch (wikiVectorErr) {
-                (0, debug_logger_js_1.warn)(`[recallMemory] Wiki vector search failed: ${wikiVectorErr instanceof Error ? wikiVectorErr.message : String(wikiVectorErr)}`);
-            }
-        }
-        for (let i = 0; i < wikiVectorHits.length; i++) {
-            wikiVectorRankMap.set(wikiVectorHits[i].record.id, i);
-            wikiVectorScoreById.set(wikiVectorHits[i].record.id, wikiVectorHits[i].raw_score);
-        }
-        diagnostics.candidate_counts.lexical += wikiFtsHits.length;
-        diagnostics.candidate_counts.vector += wikiVectorHits.length;
-        for (let i = 0; i < wikiFtsHits.length; i++) {
-            const hit = wikiFtsHits[i];
-            const lexScore = 1 / (RRF_K + i + 1);
-            const vecRank = wikiVectorRankMap.get(hit.record.id);
-            const vecBoost = vecRank !== undefined ? 0.2 * (1 / (RRF_K + vecRank + 1)) : 0;
-            wikiScores.set(hit.record.id, {
-                record: hit.record,
-                score: lexScore + vecBoost,
-                lexicalSupport: true,
-                vectorSimilarity: wikiVectorScoreById.get(hit.record.id) ?? null,
-            });
-        }
-        for (let i = 0; i < wikiVectorHits.length; i++) {
-            const hit = wikiVectorHits[i];
-            if (wikiScores.has(hit.record.id)) {
-                continue;
-            }
-            wikiScores.set(hit.record.id, {
-                record: hit.record,
-                score: 0.15 * (1 / (RRF_K + i + 1)),
-                lexicalSupport: false,
-                vectorSimilarity: hit.raw_score,
-            });
-        }
-    }
-    catch (wikiFtsErr) {
-        (0, debug_logger_js_1.warn)(`[recallMemory] Wiki FTS search failed: ${wikiFtsErr instanceof Error ? wikiFtsErr.message : String(wikiFtsErr)}`);
-    }
     fusedHits = decisionFusedHits;
     // Normalize RRF scores to 0-1 range so downstream consumers (threshold filters,
     // similarity displays) get meaningful values.  The raw RRF score for K=60 tops out
@@ -1217,34 +1231,6 @@ async function recallMemory(query, options = {}) {
     else if (lexicalCandidates.length > 0) {
         retrievalSource = 'lexical_search';
     }
-    let canonicalMatched = [];
-    if (projectionMode !== 'off') {
-        try {
-            canonicalMatched = await (0, recall_bridge_js_1.queryCanonicalEntities)(query, options.scopes ?? [], { limit: 10 });
-            diagnostics.candidate_counts.entity = canonicalMatched.length;
-            for (const canonical of canonicalMatched) {
-                entitySupportIds.add(canonical.id);
-            }
-            if (projectionMode === 'dual-write' && canonicalMatched.length > 0) {
-                const seenIds = new Set(matched.map((item) => item.id));
-                for (const canonical of canonicalMatched) {
-                    if (!seenIds.has(canonical.id)) {
-                        matched.push(canonical);
-                        seenIds.add(canonical.id);
-                    }
-                }
-                retrievalSource =
-                    retrievalSource === 'none' ? 'entity_canonical' : `${retrievalSource}+entity_canonical`;
-            }
-            else if (projectionMode === 'shadow' && canonicalMatched.length > 0) {
-                retrievalSource =
-                    retrievalSource === 'none' ? 'shadow_entity_probe' : `${retrievalSource}+shadow_probe`;
-            }
-        }
-        catch (canonicalErr) {
-            (0, debug_logger_js_1.warn)(`[recallMemory] Canonical entity recall failed: ${canonicalErr instanceof Error ? canonicalErr.message : String(canonicalErr)}`);
-        }
-    }
     const requestedScopeKeys = new Set((options.scopes ?? []).map((scope) => `${scope.kind}:${scope.id}`));
     const hasRequestedScopeSupport = (record) => {
         if (requestedScopeKeys.size === 0) {
@@ -1276,160 +1262,19 @@ async function recallMemory(query, options = {}) {
         // (when itself a single token) appears as a complete word in the query.
         return topicTokens.includes(normalizedQuery) || queryTokens.includes(normalizedTopic);
     };
-    const hasExactWikiSupport = (record) => {
-        const normalizedQuery = query.trim().toLowerCase();
-        if (!normalizedQuery || normalizedQuery.length < EXACT_TOPIC_MIN_QUERY_LENGTH) {
-            return false;
-        }
-        const normalizedTitle = record.title.trim().toLowerCase();
-        if (!normalizedTitle) {
-            return false;
-        }
-        if (normalizedQuery === normalizedTitle) {
-            return true;
-        }
-        const queryTokens = tokenizeForExactTopic(normalizedQuery);
-        const titleTokens = tokenizeForExactTopic(normalizedTitle);
-        // Wiki exact_topic uses TITLE only — page body matches are too lenient
-        // for an "exact" signal and remain available through other diagnostics.
-        return titleTokens.includes(normalizedQuery) || queryTokens.includes(normalizedTitle);
-    };
-    const wikiDecisionIdCache = new Map();
-    const normalizeWikiDecisionSourceId = (sourceId) => {
-        const trimmed = sourceId.trim();
-        if (!trimmed) {
-            return null;
-        }
-        if (trimmed.startsWith('decision://')) {
-            const id = trimmed.slice('decision://'.length).trim();
-            return id || null;
-        }
-        if (trimmed.startsWith('decision:')) {
-            const id = trimmed.slice('decision:'.length).trim();
-            return id || null;
-        }
-        if (/^[A-Za-z][A-Za-z0-9_-]*:/.test(trimmed)) {
-            return null;
-        }
-        return trimmed;
-    };
-    const loadWikiDecisionIds = (record) => {
-        const cached = wikiDecisionIdCache.get(record.id);
-        if (cached) {
-            return cached;
-        }
-        const ids = new Set();
-        for (const sourceId of record.source_ids) {
-            const decisionId = normalizeWikiDecisionSourceId(sourceId);
-            if (decisionId) {
-                ids.add(decisionId);
-            }
-        }
-        if (record.case_id) {
-            const rows = (0, db_manager_js_1.getAdapter)()
-                .prepare(`
-            SELECT source_id
-            FROM case_memberships
-            WHERE case_id = ?
-              AND source_type = 'decision'
-              AND status = 'active'
-          `)
-                .all(record.case_id);
-            for (const row of rows) {
-                if (row.source_id) {
-                    ids.add(row.source_id);
-                }
-            }
-        }
-        const decisionIds = Array.from(ids);
-        wikiDecisionIdCache.set(record.id, decisionIds);
-        return decisionIds;
-    };
-    const wikiScopeSupportCache = new Map();
-    const hasRequestedWikiScopeSupport = (record) => {
-        if (requestedScopeKeys.size === 0) {
-            return true;
-        }
-        const cached = wikiScopeSupportCache.get(record.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const decisionIds = loadWikiDecisionIds(record);
-        if (decisionIds.length === 0) {
-            wikiScopeSupportCache.set(record.id, false);
-            return false;
-        }
-        const scopeMap = batchLoadScopes((0, db_manager_js_1.getAdapter)(), decisionIds);
-        const supported = decisionIds.some((id) => (scopeMap.get(id) ?? []).some((scope) => requestedScopeKeys.has(`${scope.kind}:${scope.id}`)));
-        wikiScopeSupportCache.set(record.id, supported);
-        return supported;
-    };
     // Combined check used for the wiki *filter* path: a wiki entry must have at
     // least one linked decision that matches BOTH the requested scope AND the
     // requested topicPrefix. Without this, the page passes when scope matches
     // decision A and topic matches decision B — i.e., neither single decision
     // satisfies the caller's filter. Diagnostics reporting (which only signals
     // scope confirmation) keeps using hasRequestedWikiScopeSupport.
-    const wikiCombinedSupportCache = new Map();
-    const hasWikiDecisionWithScopeAndTopic = (record) => {
-        const requiresScope = requestedScopeKeys.size > 0;
-        const requiresTopic = !!searchOptions.topicPrefix;
-        if (!requiresScope && !requiresTopic) {
-            return true;
-        }
-        const cached = wikiCombinedSupportCache.get(record.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const decisionIds = loadWikiDecisionIds(record);
-        if (decisionIds.length === 0) {
-            wikiCombinedSupportCache.set(record.id, false);
-            return false;
-        }
-        const adapter = (0, db_manager_js_1.getAdapter)();
-        const scopeMap = requiresScope ? batchLoadScopes(adapter, decisionIds) : null;
-        const topicByDecisionId = new Map();
-        if (requiresTopic) {
-            const IN_CHUNK_SIZE = 900;
-            for (let i = 0; i < decisionIds.length; i += IN_CHUNK_SIZE) {
-                const chunk = decisionIds.slice(i, i + IN_CHUNK_SIZE);
-                const placeholders = chunk.map(() => '?').join(', ');
-                const rows = adapter
-                    .prepare(`SELECT id, topic FROM decisions WHERE id IN (${placeholders})`)
-                    .all(...chunk);
-                for (const row of rows) {
-                    topicByDecisionId.set(row.id, String(row.topic ?? ''));
-                }
-            }
-        }
-        const supported = decisionIds.some((id) => {
-            if (requiresScope) {
-                const scopes = scopeMap?.get(id) ?? [];
-                const scopeOk = scopes.some((scope) => requestedScopeKeys.has(`${scope.kind}:${scope.id}`));
-                if (!scopeOk) {
-                    return false;
-                }
-            }
-            if (requiresTopic) {
-                const topic = topicByDecisionId.get(id) ?? '';
-                if (!topic.startsWith(searchOptions.topicPrefix)) {
-                    return false;
-                }
-            }
-            return true;
-        });
-        wikiCombinedSupportCache.set(record.id, supported);
-        return supported;
-    };
     const buildDiagnostics = (record, graphSource) => {
         const vectorSimilarity = vectorSimilarityById.get(record.id) ?? null;
         const lexicalSupport = lexicalScoreById.has(record.id);
-        const entitySupport = entitySupportIds.has(record.id);
         const exactTopicSupport = hasExactTopicSupport(record);
         const scopeSupport = hasRequestedScopeSupport(record);
         const confirmationSignals = [
             lexicalSupport ? 'lexical' : null,
-            entitySupport ? 'entity' : null,
             exactTopicSupport ? 'exact_topic' : null,
         ].filter((signal) => signal !== null);
         const metadataSignals = [
@@ -1443,14 +1288,11 @@ async function recallMemory(query, options = {}) {
                 ? 'vector_search'
                 : lexicalSupport
                     ? 'lexical_search'
-                    : entitySupport
-                        ? 'entity_canonical'
-                        : String(record.source.source_type || 'unknown');
+                    : String(record.source.source_type || 'unknown');
         return {
             retrieval_source: retrievalSourceForRecord,
             vector_similarity: vectorSimilarity,
             lexical_support: lexicalSupport,
-            entity_support: entitySupport,
             scope_support: scopeSupport,
             graph_source: graphSource,
             is_vector_only: vectorSimilarity !== null && confirmationSignals.length === 0,
@@ -1459,41 +1301,6 @@ async function recallMemory(query, options = {}) {
             candidate_threshold_used: searchOptions.threshold,
         };
     };
-    const buildWikiDiagnostics = (entry) => {
-        const lexicalSupport = entry.lexicalSupport;
-        const exactTopicSupport = hasExactWikiSupport(entry.record);
-        const scopeSupport = hasRequestedWikiScopeSupport(entry.record);
-        const confirmationSignals = [
-            lexicalSupport ? 'lexical' : null,
-            exactTopicSupport ? 'exact_topic' : null,
-        ].filter((signal) => signal !== null);
-        // Only attribute 'scope' when the caller actually requested a scope filter.
-        // hasRequestedWikiScopeSupport() returns true by default for unscoped searches,
-        // so without this guard the diagnostics would overstate why the wiki hit passed.
-        const metadataSignals = [
-            requestedScopeKeys.size > 0 && scopeSupport ? 'scope' : null,
-            'graph_primary',
-        ].filter((signal) => signal !== null);
-        const retrievalSourceForRecord = entry.vectorSimilarity !== null && lexicalSupport
-            ? 'wiki_hybrid_rrf'
-            : entry.vectorSimilarity !== null
-                ? 'wiki_vector_search'
-                : lexicalSupport
-                    ? 'wiki_lexical_search'
-                    : 'wiki_page';
-        return {
-            retrieval_source: retrievalSourceForRecord,
-            vector_similarity: entry.vectorSimilarity,
-            lexical_support: lexicalSupport,
-            entity_support: false,
-            scope_support: scopeSupport,
-            graph_source: 'primary',
-            is_vector_only: entry.vectorSimilarity !== null && confirmationSignals.length === 0,
-            confirmation_signals: confirmationSignals,
-            metadata_signals: metadataSignals,
-            candidate_threshold_used: searchOptions.threshold,
-        };
-    };
     const passesStrictness = (hitDiagnostics) => {
         if (searchOptions.strictness === 'recall') {
             return true;
@@ -1504,9 +1311,7 @@ async function recallMemory(query, options = {}) {
         if (!searchOptions.minLexicalSupport) {
             return true;
         }
-        return (hitDiagnostics.lexical_support ||
-            hitDiagnostics.entity_support ||
-            hitDiagnostics.confirmation_signals.includes('exact_topic'));
+        return (hitDiagnostics.lexical_support || hitDiagnostics.confirmation_signals.includes('exact_topic'));
     };
     const acceptedPrimaryIds = new Set();
     matched = matched.flatMap((record) => {
@@ -1535,54 +1340,11 @@ async function recallMemory(query, options = {}) {
         const cappedIds = new Set(matched.map((record) => record.id));
         fusedHits = fusedHits.filter((hit) => hit.source_type !== 'decision' || cappedIds.has(hit.source_id));
     }
-    const acceptedWikiFusedHits = Array.from(wikiScores.values())
-        .sort((a, b) => b.score - a.score)
-        .flatMap((entry) => {
-        if (!hasWikiDecisionWithScopeAndTopic(entry.record)) {
-            return [];
-        }
-        const wikiDiagnostics = buildWikiDiagnostics(entry);
-        if (wikiDiagnostics.is_vector_only) {
-            diagnostics.candidate_counts.vector_only += 1;
-        }
-        if (!passesStrictness(wikiDiagnostics)) {
-            diagnostics.candidate_counts.rejected_by_strictness += 1;
-            return [];
-        }
-        return [
-            {
-                source_type: 'wiki_page',
-                source_id: entry.record.source_locator,
-                record: searchOptions.diagnostics
-                    ? { ...entry.record, retrieval_diagnostics: wikiDiagnostics }
-                    : entry.record,
-                fused_rank_score: entry.score,
-                ...(searchOptions.diagnostics ? { retrieval_diagnostics: wikiDiagnostics } : {}),
-                ...(entry.record.page_type === 'case' ? { page_type: 'case' } : {}),
-                ...(entry.record.case_id ? { case_id: entry.record.case_id } : {}),
-            },
-        ];
-    });
-    hasWikiHits = acceptedWikiFusedHits.length > 0;
-    fusedHits = [...fusedHits, ...acceptedWikiFusedHits].sort((left, right) => right.fused_rank_score - left.fused_rank_score);
-    if (hasWikiHits) {
-        retrievalSource = retrievalSource === 'none' ? 'wiki_page' : `${retrievalSource}+wiki_page`;
-    }
-    if (matched.length > 0) {
-        const readIdentityIndex = await (0, read_identity_js_1.loadDecisionReadIdentityIndex)(matched.filter((record) => !record.read_identity).map((record) => record.id));
-        for (const record of matched) {
-            if (record.read_identity) {
-                continue;
-            }
-            record.read_identity = (0, read_identity_js_1.resolveReadIdentity)(record, readIdentityIndex.get(record.id) ?? []);
-        }
-    }
     // Enrich active records with summaries from their superseded predecessors.
     // When ingestConversation extracts multiple facts under the same topic, only
     // the last survives as "active" — the earlier ones become superseded and are
     // excluded from search.  This recovers their key information so it is not lost.
     if (matched.length > 0) {
-        const adapter = (0, db_manager_js_1.getAdapter)();
         const stmtChain = adapter.prepare(`SELECT id, summary, decision FROM decisions WHERE superseded_by = ?`);
         for (const record of matched) {
             const predecessors = stmtChain.all(record.id);
@@ -1613,24 +1375,29 @@ async function recallMemory(query, options = {}) {
                 created_at: m.created_at,
                 similarity: m.confidence ?? 0.5,
             }));
-            const mamaApiModule = await import('../mama-api.js');
-            const mamaDefault = mamaApiModule.default;
-            const expanded = await mamaDefault.expandWithGraph(candidates);
+            const expanded = await expandWithGraphInAdapter(adapter, candidates);
             const primaryIds = new Set(matched.map((m) => m.id));
             let expandedOnly = expanded.filter((e) => !primaryIds.has(e.id));
             let expandedScopeMap = new Map();
             // Re-filter expanded results: apply status and scope checks
             if (!options.includeHistory) {
                 expandedOnly = expandedOnly.filter((e) => {
-                    const adapter = (0, db_manager_js_1.getAdapter)();
-                    const row = adapter.prepare(`SELECT status FROM decisions WHERE id = ?`).get(e.id);
+                    const row = adapter
+                        .prepare(`SELECT kind, status FROM decisions WHERE id = ?`)
+                        .get(e.id);
                     const status = row?.status || '';
-                    return !status || !EXCLUDED_STATUSES.has(status);
+                    return matchesKind(row?.kind) && (!status || !EXCLUDED_STATUSES.has(status));
+                });
+            }
+            else if (options.kind !== undefined) {
+                expandedOnly = expandedOnly.filter((e) => {
+                    const row = adapter.prepare(`SELECT kind FROM decisions WHERE id = ?`).get(e.id);
+                    return matchesKind(row?.kind);
                 });
             }
             if (options.scopes && options.scopes.length > 0) {
                 const expandedIds = expandedOnly.map((e) => e.id);
-                expandedScopeMap = batchLoadScopes((0, db_manager_js_1.getAdapter)(), expandedIds);
+                expandedScopeMap = batchLoadScopes(adapter, expandedIds);
                 const requestedScopes = new Set(options.scopes.map((s) => `${s.kind}:${s.id}`));
                 expandedOnly = expandedOnly.filter((e) => {
                     const scopes = expandedScopeMap.get(e.id) ?? [];
@@ -1640,10 +1407,11 @@ async function recallMemory(query, options = {}) {
                 });
             }
             bundle.graph_context.expanded = expandedOnly.flatMap((e) => {
+                const kindRow = adapter.prepare(`SELECT kind FROM decisions WHERE id = ?`).get(e.id);
                 const expandedRecord = {
                     id: String(e.id),
                     topic: String(e.topic || ''),
-                    kind: 'decision',
+                    kind: (kindRow?.kind ?? 'decision'),
                     summary: String(e.decision || ''),
                     details: '',
                     confidence: e.graph_rank ?? 0.5,
@@ -1695,12 +1463,11 @@ async function recallMemory(query, options = {}) {
             // never point at nodes that never made it into the graph payload.
             const acceptedExpandedIds = bundle.graph_context.expanded.map((record) => record.id);
             const allIds = [...matched.map((m) => m.id), ...acceptedExpandedIds];
-            const allEdges = await loadEdgesForIds(allIds);
+            const allEdges = await loadEdgesForIds(adapter, allIds);
             // Filter out edges pointing to decisions with excluded statuses
             const activeIds = new Set(allIds);
             const edgesToCheck = allEdges.filter((e) => !activeIds.has(e.to_id) || !activeIds.has(e.from_id));
             if (edgesToCheck.length > 0) {
-                const adapter = (0, db_manager_js_1.getAdapter)();
                 const checkIds = [
                     ...new Set(edgesToCheck.flatMap((e) => [e.from_id, e.to_id]).filter((id) => !activeIds.has(id))),
                 ];
@@ -1726,176 +1493,1199 @@ async function recallMemory(query, options = {}) {
         bundle.search_meta.diagnostics = diagnostics;
     }
     if (options.includeProfile) {
-        bundle.profile = await buildProfile(options.scopes ?? []);
+        bundle.profile = await buildProfile(adapter, options.scopes ?? []);
     }
     return bundle;
 }
-async function ingestMemoryInternal(input, options) {
-    const normalized = input.content.trim();
-    return saveMemoryInternal({
-        topic: normalized
-            .slice(0, 40)
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '_')
-            .replace(/^_+|_+$/g, '') || 'ingested_memory',
-        kind: 'fact',
-        summary: normalized.slice(0, 200),
-        details: normalized,
-        scopes: input.scopes ?? [],
+async function ingestMemoryInternal(adapter, input) {
+    // Raw evidence goes through source.ingest: exactly one immutable observation
+    // per request, no judgment row, no extraction.
+    const normalized = input.content;
+    const provenance = (0, provenance_js_1.normalizeMemoryWriteProvenance)();
+    const requestedScopes = input.scopes ?? [];
+    const access = (0, write_adapters_js_2.writeAccessForProvenance)(provenance, requestedScopes);
+    const commandId = `source:${node_crypto_1.default
+        .createHash('sha256')
+        .update((0, canonicalize_js_1.canonicalizeJSON)({
+        content: normalized,
+        scopes: requestedScopes,
         source: input.source,
-        eventDate: input.eventDate,
-        eventDateTime: input.eventDateTime,
-    }, options);
-}
-async function ingestMemory(input) {
-    return ingestMemoryInternal((0, provenance_js_1.sanitizePublicIngestMemoryInput)(input));
+        eventDate: input.eventDate ?? null,
+        eventDateTime: input.eventDateTime ?? null,
+        provenance: provenance.provenance,
+    }))
+        .digest('hex')
+        .slice(0, 24)}`;
+    const receipt = await (0, index_js_1.ingestSource)({
+        commandId,
+        source: {
+            connector: input.source.source_type ?? 'ingest',
+            id: commandId,
+        },
+        body: normalized,
+        sourceAt: typeof input.eventDateTime === 'number'
+            ? input.eventDateTime
+            : input.eventDate
+                ? Date.parse(input.eventDate)
+                : null,
+        metadata: {
+            source: input.source,
+            eventDate: input.eventDate ?? null,
+            eventDateTime: input.eventDateTime ?? null,
+        },
+        scopes: [...requestedScopes],
+        event: {
+            actor: provenance.actor,
+            ...(provenance.source_turn_id ? { sourceTurnId: provenance.source_turn_id } : {}),
+            ...(provenance.source_refs.length > 0 ? { evidenceRefs: provenance.source_refs } : {}),
+            reason: 'ingest memory',
+        },
+    }, access, { adapter });
+    return { success: true, id: receipt.observationId };
 }
-async function ingestWithTrustedProvenance(input, options) {
-    return ingestMemoryInternal((0, provenance_js_1.sanitizePublicIngestMemoryInput)(input), options);
+async function ingestMemory(adapter, input) {
+    return ingestMemoryInternal(adapter, (0, provenance_js_1.sanitizePublicIngestMemoryInput)(input));
 }
 async function evolveMemory(input) {
     return (0, evolution_engine_js_1.resolveMemoryEvolution)(input);
 }
-async function buildMemoryBootstrap(params) {
-    return (0, bootstrap_builder_js_1.buildMemoryAgentBootstrap)(params);
+async function buildMemoryBootstrap(adapter, params) {
+    return (0, bootstrap_builder_js_1.buildMemoryAgentBootstrap)(adapter, params);
 }
 function createAuditAck(input) {
     return (0, types_js_1.createMemoryAuditAck)(input);
 }
-async function recordMemoryAudit(input) {
-    return (0, channel_summary_state_store_js_1.recordChannelAudit)(input);
-}
-async function callExtractionLLM(prompt, options) {
-    const model = options.model ?? 'claude-sonnet-4-6';
-    const baseUrl = options.baseUrl ?? 'https://api.anthropic.com';
-    // Security: only send ANTHROPIC_API_KEY to Anthropic's own domain
-    const isAnthropicDomain = /^https?:\/\/([^/]*\.)?anthropic\.com(\/|$)/i.test(baseUrl);
-    const apiKey = isAnthropicDomain
-        ? (options.apiKey ?? process.env.ANTHROPIC_API_KEY)
-        : options.apiKey; // custom baseUrl must supply its own key explicitly
-    if (!apiKey) {
-        throw new Error(isAnthropicDomain
-            ? 'ANTHROPIC_API_KEY is required for extraction'
-            : 'apiKey must be provided explicitly when using a custom baseUrl');
-    }
-    const res = await fetch(`${baseUrl}/v1/messages`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'x-api-key': apiKey,
-            'anthropic-version': '2023-06-01',
-        },
-        body: JSON.stringify({
-            model,
-            max_tokens: 4096,
-            messages: [{ role: 'user', content: prompt }],
-        }),
-    });
-    if (!res.ok) {
-        const errorBody = await res.text().catch(() => 'unknown');
-        throw new Error(`Anthropic API error ${res.status}: ${errorBody}`);
-    }
-    const data = (await res.json());
-    const text = data.content?.find((c) => c.type === 'text')?.text ?? '';
-    return (0, extraction_prompt_js_1.parseExtractionResponse)(text);
-}
-let extractionFn = callExtractionLLM;
-function setExtractionFn(fn) {
-    extractionFn = fn ?? callExtractionLLM;
+async function recordMemoryAudit(adapter, input) {
+    return (0, channel_summary_state_store_js_1.recordChannelAudit)(adapter, input);
 }
-async function ingestConversationInternal(input, options) {
+async function ingestConversationInternal(adapter, input) {
     if (!input.messages || input.messages.length === 0) {
         throw new Error('messages array must not be empty');
     }
+    // Extraction was removed from the write boundary: conversations are stored as
+    // raw evidence only. The option is rejected before any write so a caller can
+    // never mistake a raw observation for an extracted judgment.
+    if (input.extract !== undefined) {
+        throw new Error('ingestConversation() no longer supports the extract option; ' +
+            'conversations are stored as raw source observations without judgment writes');
+    }
     const conversationText = input.messages.map((m) => `${m.role}: ${m.content}`).join('\n');
     const topicPrefix = input.topicPrefix || '';
-    const rawResult = await ingestMemoryInternal({
-        content: topicPrefix ? `${topicPrefix}${conversationText}` : conversationText,
-        scopes: input.scopes,
+    const body = topicPrefix ? `${topicPrefix}${conversationText}` : conversationText;
+    const provenance = (0, provenance_js_1.normalizeMemoryWriteProvenance)();
+    const requestedScopes = input.scopes ?? [];
+    const access = (0, write_adapters_js_2.writeAccessForProvenance)(provenance, requestedScopes);
+    // No observedAt in the command: it must hash identically on a retry so the
+    // same commandId replays its stored receipt instead of conflicting.
+    const commandId = `source-conv:${node_crypto_1.default
+        .createHash('sha256')
+        .update((0, canonicalize_js_1.canonicalizeJSON)({
+        body,
+        scopes: requestedScopes,
         source: input.source,
-        eventDate: input.sessionDate,
-    }, options);
-    const result = {
-        rawId: rawResult.id,
-        extractedMemories: [],
+        sessionDate: input.sessionDate ?? null,
+        provenance: provenance.provenance,
+    }))
+        .digest('hex')
+        .slice(0, 24)}`;
+    const receipt = await (0, index_js_1.ingestSource)({
+        commandId,
+        source: {
+            connector: `conversation:${input.source.source_type ?? 'unknown'}`,
+            id: commandId,
+        },
+        body,
+        sourceAt: input.sessionDate ? Date.parse(input.sessionDate) : null,
+        metadata: {
+            message_count: input.messages.length,
+            roles: input.messages.map((m) => m.role),
+            session_date: input.sessionDate ?? null,
+            topic_prefix: topicPrefix || null,
+            source: input.source,
+        },
+        scopes: [...requestedScopes],
+        event: {
+            actor: provenance.actor,
+            ...(provenance.source_turn_id ? { sourceTurnId: provenance.source_turn_id } : {}),
+            ...(provenance.source_refs.length > 0 ? { evidenceRefs: provenance.source_refs } : {}),
+            reason: 'ingest conversation',
+        },
+    }, access, { adapter });
+    return { rawId: receipt.observationId, extractedMemories: [] };
+}
+async function ingestConversation(adapter, input) {
+    return ingestConversationInternal(adapter, (0, provenance_js_1.sanitizePublicIngestConversationInput)(input));
+}
+// ── Adapter-bound reads and writes the catalog actions call ─────────────────
+//
+// These were `mama-api.ts`'s, beside an ambient-handle facade for callers who
+// did not hold a database. The catalog holds one and calls these directly, so
+// they live with the rest of the memory API. What stays in `mama-api.ts` is the
+// facade and the formatting the CLI still uses (W22).
+function numberOrNull(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return null;
+    }
+    return value;
+}
+function resultRecord(result) {
+    if (typeof result.record === 'object' &&
+        result.record !== null &&
+        !Array.isArray(result.record)) {
+        return result.record;
+    }
+    return {};
+}
+function stringOrNull(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return String(value);
+}
+function confidenceValue(record, fallback) {
+    const numeric = numberOrNull(record.confidence);
+    if (numeric !== null) {
+        return numeric;
+    }
+    switch (record.confidence) {
+        case 'high':
+            return 0.9;
+        case 'medium':
+            return 0.6;
+        case 'low':
+            return 0.3;
+        default:
+            return fallback;
+    }
+}
+async function expandWithGraphInAdapter(adapter, candidates) {
+    const graphEnhanced = new Map(); // Use Map for deduplication by ID
+    const primaryIds = new Set(candidates.map((c) => c.id)); // Track primary candidates
+    // Process each candidate
+    for (const candidate of candidates) {
+        // Add primary candidate with higher rank
+        if (!graphEnhanced.has(candidate.id)) {
+            graphEnhanced.set(candidate.id, {
+                ...candidate,
+                graph_source: 'primary', // Mark as primary result
+                graph_rank: 1.0, // Highest rank
+            });
+        }
+        // 1. Add supersedes chain (evolution history)
+        try {
+            const chain = await (0, graph_query_js_1.queryDecisionGraph)(adapter, candidate.topic, candidate.id);
+            for (const decision of chain) {
+                if (!graphEnhanced.has(decision.id)) {
+                    graphEnhanced.set(decision.id, {
+                        ...decision,
+                        graph_source: 'supersedes_chain',
+                        graph_rank: 0.8, // Lower rank than primary
+                        similarity: (candidate.similarity ?? 0) * 0.9, // Inherit similarity, slightly reduced
+                        related_to: candidate.id, // Track relationship
+                    });
+                }
+            }
+        }
+        catch (error) {
+            (0, debug_logger_js_1.warn)(`Failed to get supersedes chain for ${candidate.topic}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // 2. Add semantic edges (refines, contradicts, builds_on, debates, synthesizes)
+        try {
+            const rawEdges = (await (0, graph_query_js_1.querySemanticEdges)(adapter, [candidate.id])) || {};
+            const edges = {
+                refines: rawEdges.refines || [],
+                refined_by: rawEdges.refined_by || [],
+                contradicts: rawEdges.contradicts || [],
+                contradicted_by: rawEdges.contradicted_by || [],
+                builds_on: rawEdges.builds_on || [],
+                built_on_by: rawEdges.built_on_by || [],
+                debates: rawEdges.debates || [],
+                debated_by: rawEdges.debated_by || [],
+                synthesizes: rawEdges.synthesizes || [],
+                synthesized_by: rawEdges.synthesized_by || [],
+            };
+            // Helper to add edge to graph
+            const addEdge = (edge, idField, source, rank, simFactor) => {
+                const id = edge[idField];
+                if (!graphEnhanced.has(id)) {
+                    graphEnhanced.set(id, {
+                        id: id,
+                        topic: edge.topic,
+                        decision: edge.decision,
+                        confidence: edge.confidence,
+                        created_at: edge.created_at,
+                        graph_source: source,
+                        graph_rank: rank,
+                        similarity: (candidate.similarity ?? 0) * simFactor,
+                        related_to: candidate.id,
+                        edge_reason: edge.reason,
+                    });
+                }
+            };
+            // Add refines edges
+            for (const edge of edges.refines) {
+                addEdge(edge, 'to_id', 'refines', 0.7, 0.85);
+            }
+            // Add refined_by edges
+            for (const edge of edges.refined_by) {
+                addEdge(edge, 'from_id', 'refined_by', 0.7, 0.85);
+            }
+            // Add contradicts edges (lower rank, but still relevant)
+            for (const edge of edges.contradicts) {
+                addEdge(edge, 'to_id', 'contradicts', 0.6, 0.8);
+            }
+            // Story 2.1: Add builds_on edges (high relevance - extending prior work)
+            for (const edge of edges.builds_on) {
+                addEdge(edge, 'to_id', 'builds_on', 0.75, 0.9);
+            }
+            // Add built_on_by edges (someone built on this decision)
+            for (const edge of edges.built_on_by) {
+                addEdge(edge, 'from_id', 'built_on_by', 0.75, 0.9);
+            }
+            // Add debates edges (alternative view)
+            for (const edge of edges.debates) {
+                addEdge(edge, 'to_id', 'debates', 0.65, 0.85);
+            }
+            // Add debated_by edges
+            for (const edge of edges.debated_by) {
+                addEdge(edge, 'from_id', 'debated_by', 0.65, 0.85);
+            }
+            // Add synthesizes edges (unified approach)
+            for (const edge of edges.synthesizes) {
+                addEdge(edge, 'to_id', 'synthesizes', 0.7, 0.88);
+            }
+            // Add synthesized_by edges
+            for (const edge of edges.synthesized_by) {
+                addEdge(edge, 'from_id', 'synthesized_by', 0.7, 0.88);
+            }
+        }
+        catch (error) {
+            (0, debug_logger_js_1.warn)(`Failed to get semantic edges for ${candidate.id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // 3. Convert Map to Array
+    const allResults = Array.from(graphEnhanced.values());
+    // 4. Sort: Interleave expanded results after their related primary
+    // This ensures edge-connected decisions appear near their source
+    const primaryResults = allResults
+        .filter((r) => primaryIds.has(r.id))
+        .sort((a, b) => {
+        const scoreA = a.final_score || a.similarity || 0;
+        const scoreB = b.final_score || b.similarity || 0;
+        return scoreB - scoreA;
+    });
+    const expandedResults = allResults.filter((r) => !primaryIds.has(r.id));
+    // Build final results: each primary followed by its related expanded results
+    const results = [];
+    for (const primary of primaryResults) {
+        results.push(primary);
+        // Find expanded results related to this primary
+        const relatedExpanded = expandedResults.filter((e) => e.related_to === primary.id);
+        // Sort related by graph_rank (higher first)
+        relatedExpanded.sort((a, b) => (b.graph_rank || 0) - (a.graph_rank || 0));
+        // Add related expanded results right after their primary
+        results.push(...relatedExpanded);
+    }
+    // Add any orphaned expanded results (shouldn't happen, but safety net)
+    const includedIds = new Set(results.map((r) => r.id));
+    const orphaned = expandedResults.filter((e) => !includedIds.has(e.id));
+    results.push(...orphaned);
+    return results;
+}
+function applyRecencyBoost(results, options = {}) {
+    const { recencyWeight = 0.3, recencyScale = 7, recencyDecay = 0.5, disableRecency = false, } = options;
+    if (disableRecency || recencyWeight === 0) {
+        return results;
+    }
+    const now = Date.now(); // Current timestamp in milliseconds
+    return results
+        .map((r) => {
+        // created_at is stored in milliseconds in the database
+        const createdAt = typeof r.created_at === 'number' ? r.created_at : Date.parse(r.created_at || '0');
+        const ageInDays = (now - createdAt) / (86400 * 1000);
+        // Gaussian Decay: exp(-((age / scale)^2) / (2 * ln(1 / decay)))
+        // At scale days: score = decay (e.g., 7 days = 50%)
+        const gaussianDecay = Math.exp(-Math.pow(ageInDays / recencyScale, 2) / (2 * Math.log(1 / recencyDecay)));
+        // Combine semantic similarity with recency
+        const similarity = r.similarity ?? 0;
+        const finalScore = similarity * (1 - recencyWeight) + gaussianDecay * recencyWeight;
+        return {
+            ...r,
+            recency_score: gaussianDecay,
+            recency_age_days: Math.round(ageInDays * 10) / 10,
+            final_score: finalScore,
+        };
+    })
+        .sort((a, b) => (b.final_score ?? 0) - (a.final_score ?? 0));
+}
+/** Phase 3 Task 33: learned-ranker meta attached to mama.suggest response. */
+function buildRankerMeta(applied, modelId, skippedReason) {
+    const meta = {
+        model_id: modelId,
+        feature_set_version: ranker_features_js_1.SEARCH_RANKER_FEATURE_SET_VERSION,
+        applied,
+        mode: 'offline',
+    };
+    if (skippedReason) {
+        meta.skipped_reason = skippedReason;
+    }
+    return meta;
+}
+function mapRolledUpResult(result) {
+    const record = resultRecord(result);
+    const retrievalDiagnostics = result.retrieval_diagnostics;
+    const topic = stringOrNull(record.topic ?? record.title) ?? result.source_id;
+    // For wiki_page leaves, prefer the markdown body (`content`) in `decision` so
+    // downstream consumers see the meaningful body rather than the short title.
+    // Decision/checkpoint records use their own fields (summary/decision).
+    const isWikiPageLeaf = result.source_type === 'wiki_page';
+    const decision = isWikiPageLeaf
+        ? (stringOrNull(record.content ?? record.summary ?? record.decision ?? record.title) ??
+            result.source_id)
+        : (stringOrNull(record.summary ?? record.decision ?? record.title ?? record.content) ??
+            result.source_id);
+    const reasoning = stringOrNull(record.details ?? record.reasoning ?? record.status_reason ?? record.content) ??
+        '';
+    return {
+        id: result.source_id,
+        topic,
+        decision,
+        reasoning,
+        confidence: confidenceValue(record, result.score),
+        // NOT similarity. `result.score` is normalized Reciprocal Rank Fusion
+        // (RRF_K = 60, divided by the top hit), so the second result scores 61/62
+        // and the third 61/63 whatever they say -- rank, not likeness. Mirroring it
+        // into `similarity` made every save warn "High similarity (98%)" against
+        // something unrelated, which teaches the reader to ignore the check. The
+        // rollup path already says this and returns null; this one now agrees.
+        similarity: null,
+        retrieval_score: result.score,
+        created_at: record.created_at ?? null,
+        event_date: record.event_date ?? null,
+        event_datetime: record.event_datetime ?? null,
+        graph_source: retrievalDiagnostics?.graph_source ?? 'primary',
+        graph_rank: 1,
+        related_to: null,
+        edge_reason: null,
+        case_id: result.case_id,
+        source_type: result.source_type,
+        kind: stringOrNull(record.kind) ?? 'decision',
+        contributing_leaves: result.contributing_leaves ?? null,
+        ...(result.contributing_leaf_diagnostics
+            ? { contributing_leaf_diagnostics: result.contributing_leaf_diagnostics }
+            : {}),
+        ...(retrievalDiagnostics ? { retrieval_diagnostics: retrievalDiagnostics } : {}),
     };
-    if (!input.extract?.enabled) {
-        return result;
+}
+async function suggestInAdapter(adapter, userQuestion, options = {}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!userQuestion || typeof userQuestion !== 'string') {
+        throw new Error('mama.suggest() requires userQuestion (string)');
     }
-    let units;
+    const { format = 'json', limit = 5, threshold, useReranking = false, rerankWithLearned = false, 
+    // Recency boosting parameters (Gaussian Decay - Elasticsearch style)
+    recencyWeight = 0.3, // 0-1: How much to weight recency (0.3 = 70% semantic, 30% recency)
+    recencyScale = 7, // Days until recency score drops to 50%
+    recencyDecay = 0.5, // Score at scale point (0.5 = 50%)
+    disableRecency = false, // Set true to disable recency boosting entirely
+    strict, strictness, includeRelated, minLexicalSupport, diagnostics: includeDiagnostics, kind, } = options;
+    const normalizedSearchOptions = (0, search_quality_js_1.normalizeSearchQualityOptions)({
+        threshold,
+        strict,
+        strictness,
+        disableRecency,
+        includeRelated,
+        topicPrefix: options.topicPrefix,
+        minLexicalSupport,
+        diagnostics: includeDiagnostics,
+    });
+    const memoryV2QualityContractRequested = threshold !== undefined ||
+        strict !== undefined ||
+        strictness !== undefined ||
+        includeRelated !== undefined ||
+        minLexicalSupport !== undefined ||
+        includeDiagnostics === true ||
+        options.topicPrefix !== undefined ||
+        options.scopes !== undefined ||
+        options.kind !== undefined;
+    const rerankPoolLimit = rerankWithLearned ? Math.max(limit * 4, limit + 5) : limit;
     try {
-        // Fetch existing topics so LLM can reuse them (enables supersedes edges)
-        await (0, db_manager_js_1.initDB)();
-        const adapter = (0, db_manager_js_1.getAdapter)();
-        let existingTopics;
-        if (input.scopes && input.scopes.length > 0) {
-            const scopeIds = await Promise.all(input.scopes.map((scope) => (0, db_manager_js_1.ensureMemoryScope)(scope.kind, scope.id)));
-            const placeholders = scopeIds.map(() => '?').join(', ');
-            existingTopics = adapter
-                .prepare(`SELECT DISTINCT d.topic FROM decisions d
-           JOIN memory_scope_bindings msb ON msb.memory_id = d.id
-           WHERE msb.scope_id IN (${placeholders})
-             AND (d.status = 'active' OR d.status IS NULL)
-           ORDER BY d.created_at DESC LIMIT 200`)
-                .all(...scopeIds);
+        // `recallMemoryInAdapter` was mama-api's alias for this file's own
+        // `recallMemory`. Inside it, the function has its name.
+        const bundle = await recallMemory(adapter, userQuestion, {
+            includeProfile: false,
+            topicPrefix: options.topicPrefix,
+            limit: rerankPoolLimit,
+            threshold,
+            strict,
+            strictness,
+            disableRecency,
+            includeRelated,
+            minLexicalSupport,
+            diagnostics: includeDiagnostics,
+            kind,
+            ...(options.scopes && { scopes: options.scopes }),
+        });
+        const diagnosticsByMemoryId = new Map(bundle.memories
+            .filter((memory) => memory.retrieval_diagnostics)
+            .map((memory) => [memory.id, memory.retrieval_diagnostics]));
+        const rawFusedHits = bundle.fused_hits ?? [];
+        const fusedHits = rawFusedHits.map((hit) => {
+            if (hit.source_type !== 'decision') {
+                return hit;
+            }
+            const recordDiagnostics = typeof hit.record === 'object' && hit.record !== null && !Array.isArray(hit.record)
+                ? hit.record.retrieval_diagnostics
+                : undefined;
+            const retrievalDiagnostics = diagnosticsByMemoryId.get(hit.source_id) ?? recordDiagnostics;
+            if (!retrievalDiagnostics) {
+                return hit;
+            }
+            const record = typeof hit.record === 'object' && hit.record !== null && !Array.isArray(hit.record)
+                ? { ...hit.record, retrieval_diagnostics: retrievalDiagnostics }
+                : hit.record;
+            return {
+                ...hit,
+                record,
+                retrieval_diagnostics: retrievalDiagnostics,
+            };
+        });
+        const rolledUp = fusedHits.length > 0 ? (0, case_search_rollup_js_1.rollUpSearchHits)({ fusedHits, adapter }) : [];
+        const diagnosticsResponse = includeDiagnostics === true ? { diagnostics: bundle.search_meta.diagnostics ?? null } : {};
+        // Phase 3 Task 33: compute base ranker meta once so every return path
+        // (rolledUp, memories fallback, vector-search fallback) can attach it.
+        // rerankWithLearned-driven rescoring still only applies to result arrays
+        // that match the ranker's expected shape (id + source_type + case_id).
+        const baseRankerMeta = useReranking
+            ? buildRankerMeta(false, null, 'llm_reranking_requested')
+            : rerankWithLearned
+                ? null // marker: rescoring requested, actual meta set per-path after rescore
+                : buildRankerMeta(false, null, 'feature_disabled');
+        const applyLearnedRanker = (results) => {
+            if (baseRankerMeta !== null) {
+                return { results, meta: baseRankerMeta };
+            }
+            // Phase 3 Task 33: the caller opted in via rerankWithLearned, but the
+            // runtime `search_ranker_enabled` gate still has final say. This lets
+            // operators disable the learned ranker globally during rollback without
+            // touching any caller code.
+            let runtimeEnabled = true;
+            try {
+                runtimeEnabled = (0, ranker_rescore_js_1.isSearchRankerEnabled)(adapter);
+            }
+            catch (err) {
+                (0, debug_logger_js_1.warn)(`[mama.suggest] isSearchRankerEnabled check failed: ${String(err)}`);
+            }
+            if (!runtimeEnabled) {
+                return { results, meta: buildRankerMeta(false, null, 'feature_disabled') };
+            }
+            try {
+                const rescored = (0, ranker_rescore_js_1.rescoreSearchResults)(adapter, {
+                    query: userQuestion,
+                    results,
+                });
+                return {
+                    results: rescored.results,
+                    meta: buildRankerMeta(rescored.skipped_reason === undefined, rescored.model_id, rescored.skipped_reason),
+                };
+            }
+            catch (err) {
+                (0, debug_logger_js_1.warn)(`[mama.suggest] learned-ranker rescore failed: ${String(err)}`);
+                return { results, meta: buildRankerMeta(false, null, 'rescore_error') };
+            }
+        };
+        const summarizeGraphExpansion = (rows) => {
+            const sources = {
+                primary: 0,
+                supersedes_chain: 0,
+                refines: 0,
+                refined_by: 0,
+                contradicts: 0,
+            };
+            let expandedCount = 0;
+            for (const row of rows) {
+                const graphSource = row.graph_source ?? 'primary';
+                if (graphSource === 'primary') {
+                    sources.primary += 1;
+                    continue;
+                }
+                expandedCount += 1;
+                if (graphSource in sources) {
+                    const key = graphSource;
+                    sources[key] += 1;
+                }
+            }
+            return {
+                total_results: rows.length,
+                primary_count: sources.primary,
+                expanded_count: expandedCount,
+                sources,
+            };
+        };
+        if (rolledUp.length > 0) {
+            const filteredResults = rolledUp.slice(0, rerankPoolLimit);
+            const { results: mappedResults, meta: rankerMeta } = applyLearnedRanker(filteredResults.map(mapRolledUpResult));
+            const limitedResults = mappedResults.slice(0, limit);
+            if (format === 'markdown') {
+                const context = limitedResults
+                    .map((result, index) => `${index + 1}. [${result.topic}] ${result.decision}\n   ${result.reasoning}`)
+                    .join('\n');
+                return `🔍 Search method: memory_v2\n${context}`;
+            }
+            return {
+                query: userQuestion,
+                results: limitedResults,
+                ...diagnosticsResponse,
+                meta: {
+                    count: limitedResults.length,
+                    search_method: 'memory_v2',
+                    threshold: normalizedSearchOptions.threshold,
+                    recency_boost: disableRecency
+                        ? null
+                        : {
+                            weight: recencyWeight,
+                            scale: recencyScale,
+                            decay: recencyDecay,
+                        },
+                    graph_expansion: summarizeGraphExpansion(limitedResults),
+                    ranker: rankerMeta,
+                },
+            };
         }
-        else {
-            existingTopics = adapter
-                .prepare(`SELECT DISTINCT topic FROM decisions
-           WHERE (status = 'active' OR status IS NULL)
-           ORDER BY created_at DESC LIMIT 200`)
-                .all();
+        if (bundle.memories.length > 0) {
+            // recallMemory uses RRF fusion — confidence is overwritten with the normalized
+            // retrieval score (0-1 range, where 1.0 = best match in this result set).
+            // The original stored confidence is lost after RRF normalization.
+            // We capture the retrieval score separately so `similarity` reflects search
+            // relevance while `confidence` is passed through as-is from the bundle.
+            const filteredMemories = bundle.memories.slice(0, rerankPoolLimit);
+            const baseRows = filteredMemories.map((memory) => ({
+                id: memory.id,
+                topic: memory.topic,
+                decision: memory.summary,
+                reasoning: memory.details,
+                confidence: memory.confidence,
+                // recallMemory currently normalizes fused retrieval rank into `confidence`.
+                // Keep that value visible as retrieval_score, but do not pretend it is
+                // semantic similarity; save-time warning logic keys off `similarity`.
+                similarity: null,
+                retrieval_score: memory.confidence ?? null,
+                final_score: memory.confidence ?? null,
+                created_at: memory.created_at,
+                event_date: memory.event_date ?? null,
+                event_datetime: memory.event_datetime ?? null,
+                graph_source: memory.retrieval_diagnostics?.graph_source ?? 'primary',
+                graph_rank: 1,
+                related_to: null,
+                edge_reason: null,
+                case_id: null,
+                source_type: memory.kind ??
+                    memory.source?.source_type ??
+                    memory.source_type ??
+                    memory.type ??
+                    'decision',
+                kind: memory.kind,
+                ...(memory.retrieval_diagnostics
+                    ? { retrieval_diagnostics: memory.retrieval_diagnostics }
+                    : {}),
+            }));
+            const { results: rankedRows, meta: rankerMeta } = applyLearnedRanker(baseRows);
+            const limitedRows = rankedRows.slice(0, limit);
+            if (format === 'markdown') {
+                const context = limitedRows
+                    .map((row, index) => `${index + 1}. [${row.topic}] ${row.decision}\n   ${row.reasoning}`)
+                    .join('\n');
+                return `🔍 Search method: memory_v2\n${context}`;
+            }
+            return {
+                query: userQuestion,
+                results: limitedRows,
+                ...diagnosticsResponse,
+                meta: {
+                    count: limitedRows.length,
+                    search_method: 'memory_v2',
+                    threshold: normalizedSearchOptions.threshold,
+                    recency_boost: disableRecency
+                        ? null
+                        : {
+                            weight: recencyWeight,
+                            scale: recencyScale,
+                            decay: recencyDecay,
+                        },
+                    graph_expansion: summarizeGraphExpansion(limitedRows),
+                    ranker: rankerMeta,
+                },
+            };
         }
-        const topicList = existingTopics.map((r) => r.topic);
-        const prompt = (0, extraction_prompt_js_1.buildExtractionPrompt)(input.messages, topicList);
-        units = await extractionFn(prompt, input.extract);
-    }
-    catch (err) {
-        (0, debug_logger_js_1.warn)(`[memory] extraction failed: ${err instanceof Error ? err.message : String(err)}`);
-        return result;
-    }
-    const adapter = (0, db_manager_js_1.getAdapter)();
-    const EXTRACTION_EDGE_RELATIONSHIP = 'builds_on';
-    const EXTRACTION_EDGE_REASON = 'Extracted from conversation';
-    // Track IDs saved in this batch so sibling facts don't supersede each other.
-    // Without this, when ingestConversation extracts multiple facts under the same topic,
-    // each subsequent save supersedes the previous one, losing independent information.
-    const batchSavedIds = [];
-    for (const unit of units) {
+        if (memoryV2QualityContractRequested) {
+            const emptyRows = [];
+            const { meta: rankerMeta } = applyLearnedRanker(emptyRows);
+            if (format === 'markdown') {
+                return '🔍 Search method: memory_v2\n';
+            }
+            return {
+                query: userQuestion,
+                results: emptyRows,
+                ...diagnosticsResponse,
+                meta: {
+                    count: 0,
+                    search_method: 'memory_v2',
+                    threshold: normalizedSearchOptions.threshold,
+                    recency_boost: disableRecency
+                        ? null
+                        : {
+                            weight: recencyWeight,
+                            scale: recencyScale,
+                            decay: recencyDecay,
+                        },
+                    graph_expansion: summarizeGraphExpansion(emptyRows),
+                    ranker: rankerMeta,
+                },
+            };
+        }
+        // 1. Try vector search first (if sqlite-vss is available)
+        // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-explicit-any
+        let results = [];
+        let searchMethod = 'vector';
         try {
-            const saved = await saveMemoryInternal({
-                topic: topicPrefix ? `${topicPrefix}${unit.topic}` : unit.topic,
-                kind: unit.kind,
-                summary: unit.summary,
-                details: unit.details,
-                confidence: unit.confidence,
-                scopes: input.scopes,
-                source: input.source,
-                excludeIds: batchSavedIds,
-                eventDate: input.sessionDate,
-            }, (0, provenance_js_1.appendProvenanceSourceRefs)(options, [`raw_memory:${rawResult.id}`]));
-            const now = Date.now();
-            adapter
-                .prepare(`INSERT OR REPLACE INTO decision_edges (from_id, to_id, relationship, reason, weight, created_at)
-           VALUES (?, ?, ?, ?, ?, ?)`)
-                .run(saved.id, rawResult.id, EXTRACTION_EDGE_RELATIONSHIP, EXTRACTION_EDGE_REASON, 1.0, now);
-            batchSavedIds.push(saved.id);
-            result.extractedMemories.push({
-                id: saved.id,
-                kind: unit.kind,
-                topic: unit.topic,
-            });
+            // Generate query embedding
+            const queryEmbedding = await (0, embedder_js_1.generateEmbedding)(userQuestion, 'query');
+            // Adaptive threshold (shorter queries need higher confidence)
+            const wordCount = userQuestion.split(/\s+/).length;
+            const adaptiveThreshold = threshold !== undefined ? threshold : wordCount < 3 ? 0.7 : 0.6;
+            // Vector search
+            results = await (0, search_js_1.vectorSearch)(adapter, queryEmbedding, rerankPoolLimit * 2, 0.5, undefined, undefined, kind); // Get more candidates
+            // Filter by adaptive threshold
+            results = results.filter((r) => r.similarity >= adaptiveThreshold);
+            // Stage 1.4: Temporal boost — detect time-related queries and boost matching results
+            {
+                const temporalPatterns = [
+                    // English
+                    /\b(yesterday|today|last\s+(?:week|month|year)|(\d+)\s+(?:days?|weeks?|months?)\s+ago)\b/i,
+                    /\b(before|after|since|until|during)\s+\w+/i,
+                    /\b(how\s+long|when\s+did|what\s+date|what\s+day)\b/i,
+                    // Korean
+                    /(?:어제|오늘|그제|지난\s*(?:주|달|해)|(\d+)\s*(?:일|주|달|개월)\s*(?:전|후|뒤))/, // Korean: temporal query detection
+                    /(?:언제|얼마나|며칠|몇\s*(?:일|주|달|개월))/, // Korean: temporal query detection
+                ];
+                const isTemporalQuery = temporalPatterns.some((p) => p.test(userQuestion));
+                if (isTemporalQuery && results.length > 0) {
+                    // Boost results that contain date/time references in their content
+                    const datePatterns = [
+                        /\d{4}[-/]\d{1,2}[-/]\d{1,2}/,
+                        /(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\w*\s+\d/i,
+                        /\d+\s*(?:일|월|년|주|시간|분)/, // Korean: date reference in content
+                        /(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)/i,
+                        /(?:월요일|화요일|수요일|목요일|금요일|토요일|일요일)/, // Korean: date reference in content
+                    ];
+                    for (const result of results) {
+                        const content = `${result.decision || ''} ${result.reasoning || ''}`;
+                        const hasDateRef = datePatterns.some((p) => p.test(content));
+                        if (hasDateRef) {
+                            result.similarity = Math.min(1.0, (result.similarity || 0) + 0.1);
+                        }
+                    }
+                    results.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
+                }
+            }
+            // Stage 1.5: Apply recency boosting (Gaussian Decay)
+            // Allows Claude to adjust search strategy (recent vs historical)
+            if (results.length > 0 && !disableRecency) {
+                results = applyRecencyBoost(results, {
+                    recencyWeight,
+                    recencyScale,
+                    recencyDecay,
+                    disableRecency,
+                });
+                searchMethod = 'vector+recency';
+            }
+            // Stage 1.7: FTS5 hybrid merge (Haiku Memory Layer)
+            {
+                try {
+                    const ftsResults = await (0, search_js_1.fts5Search)(adapter, userQuestion, rerankPoolLimit * 2, kind);
+                    if (ftsResults.length > 0) {
+                        // Normalize FTS5 ranks (BM25 returns negative values, closer to 0 = better)
+                        const maxRank = Math.max(...ftsResults.map((r) => Math.abs(r.rank)));
+                        const ftsMap = new Map(ftsResults.map((r) => [r.id, maxRank > 0 ? 1 - Math.abs(r.rank) / maxRank : 0.5]));
+                        // Tunable hybrid weights (env: MAMA_VECTOR_WEIGHT, MAMA_FTS5_WEIGHT)
+                        const vectorWeight = parseFloat(process.env.MAMA_VECTOR_WEIGHT || '0.6');
+                        const fts5Weight = parseFloat(process.env.MAMA_FTS5_WEIGHT || '0.4');
+                        // Merge: boost existing results that also matched FTS5
+                        for (const result of results) {
+                            const ftsScore = ftsMap.get(result.id);
+                            if (ftsScore !== undefined) {
+                                result.similarity = vectorWeight * result.similarity + fts5Weight * ftsScore;
+                                ftsMap.delete(result.id);
+                            }
+                        }
+                        // Add FTS5-only results (not in embedding results)
+                        for (const [id, ftsScore] of ftsMap) {
+                            const ftsResult = ftsResults.find((r) => r.id === id);
+                            if (ftsResult) {
+                                // Need to get full decision record
+                                const stmt = adapter.prepare('SELECT * FROM decisions WHERE id = ? AND superseded_by IS NULL');
+                                const decision = stmt.get(id);
+                                if (decision && (kind === undefined || decision.kind === kind)) {
+                                    results.push({
+                                        ...decision,
+                                        similarity: fts5Weight * ftsScore, // Only FTS5 score component
+                                        graph_source: 'fts5',
+                                    });
+                                }
+                            }
+                        }
+                        // Re-sort by similarity
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        results.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
+                        searchMethod = disableRecency ? 'vector+fts5' : 'vector+recency+fts5';
+                    }
+                }
+                catch {
+                    // FTS5 not available, continue with embedding-only results
+                }
+            }
+            // Stage 2: Graph expansion (NEW - Phase 1)
+            // Expand candidates with supersedes chain and semantic edges
+            if (results.length > 0) {
+                const graphEnhanced = await expandWithGraphInAdapter(adapter, results);
+                results = graphEnhanced;
+                searchMethod = disableRecency ? 'vector+graph' : 'vector+recency+graph';
+            }
+            // Stage 2.5: is_static boost (after graph expansion to preserve sort order)
+            for (const result of results) {
+                if (result.is_static === 1) {
+                    result.final_score = Math.min(1.0, (result.final_score ?? result.similarity ?? 0) + 0.2);
+                }
+            }
+            // Re-sort by final_score after is_static boost
+            results.sort((a, b) => (b.final_score ?? b.similarity ?? 0) - (a.final_score ?? a.similarity ?? 0));
+        }
+        catch (vectorError) {
+            // Fallback to keyword search if vector search unavailable
+            (0, debug_logger_js_1.warn)(`Vector search failed: ${vectorError instanceof Error ? vectorError.message : String(vectorError)}, falling back to keyword search`);
+            searchMethod = 'keyword';
+            // Keyword search fallback
+            const keywords = userQuestion
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((w) => w.length > 2); // Filter short words
+            if (keywords.length === 0) {
+                if (format === 'markdown') {
+                    return `💡 Hint: Please be more specific.\nExample: "Railway Volume settings" or "mesh parameter optimization"`;
+                }
+                return null; // JSON mode returns null for empty/invalid queries
+            }
+            // Build LIKE query for each keyword
+            const likeConditions = keywords.map(() => '(topic LIKE ? OR decision LIKE ?)').join(' OR ');
+            const likeParams = keywords.flatMap((k) => [`%${k}%`, `%${k}%`]);
+            const kindClause = kind === undefined ? '' : 'AND kind = ?';
+            const stmt = adapter.prepare(`
+        SELECT * FROM decisions
+        WHERE ${likeConditions}
+        AND superseded_by IS NULL
+        ${kindClause}
+        ORDER BY created_at DESC
+        LIMIT ?
+      `);
+            const rows = (await stmt.all(...likeParams, ...(kind === undefined ? [] : [kind]), rerankPoolLimit));
+            results = rows.map((row) => ({
+                ...row,
+                similarity: 0.75, // Assign moderate similarity for keyword matches
+            }));
+            // Stage 2: Graph expansion for keyword results (Phase 1)
+            if (results.length > 0) {
+                const graphEnhanced = await expandWithGraphInAdapter(adapter, results);
+                results = graphEnhanced;
+                searchMethod = 'keyword+graph';
+            }
         }
-        catch (err) {
-            (0, debug_logger_js_1.warn)(`[memory] failed to save extracted unit topic=${unit.topic} kind=${unit.kind}: ${err instanceof Error ? err.message : String(err)}`);
+        if (results.length === 0) {
+            if (format === 'markdown') {
+                const wordCount = userQuestion.split(/\s+/).length;
+                if (wordCount < 3) {
+                    return `💡 Hint: Please be more specific.\nExample: "Why did we choose COMPLEX mesh structure?" or "What parameters are used for large layers?"`;
+                }
+            }
+            return null;
         }
+        // 5. Optional: LLM re-ranking (only if requested)
+        if (useReranking) {
+            results = await rerankWithLLM(options.runner, userQuestion, results);
+        }
+        const rerankCandidateResults = results.slice(0, rerankPoolLimit);
+        const vectorRows = rerankCandidateResults.map((r) => ({
+            id: r.id,
+            topic: r.topic,
+            decision: r.decision,
+            reasoning: r.reasoning,
+            confidence: r.confidence,
+            similarity: r.similarity,
+            created_at: r.created_at,
+            event_date: r.event_date ?? null,
+            event_datetime: r.event_datetime ?? null,
+            kind: r.kind ?? 'decision',
+            // Recency metadata (NEW - Gaussian Decay)
+            recency_score: r.recency_score,
+            recency_age_days: r.recency_age_days,
+            final_score: r.final_score || r.similarity, // Falls back to similarity if no recency
+            retrieval_score: r.similarity ?? null,
+            // Graph metadata (NEW - Phase 1)
+            graph_source: r.graph_source || 'primary',
+            graph_rank: r.graph_rank || 1.0,
+            related_to: r.related_to || null,
+            edge_reason: r.edge_reason || null,
+            case_id: null,
+            source_type: 'decision',
+        }));
+        const { results: rankedVectorRows, meta: rankerMeta } = applyLearnedRanker(vectorRows);
+        const finalResults = rankedVectorRows.slice(0, limit);
+        // Markdown format (for human display)
+        if (format === 'markdown') {
+            const context = (0, decision_formatter_js_1.formatContext)(finalResults, { maxTokens: 500 });
+            // Add graph expansion summary if applicable
+            let graphSummary = '';
+            if (searchMethod.includes('graph')) {
+                const primaryCount = finalResults.filter((r) => r.graph_source === 'primary').length;
+                const expandedCount = finalResults.filter((r) => r.graph_source !== 'primary').length;
+                graphSummary = `\n📊 Graph expansion: ${primaryCount} primary + ${expandedCount} related (supersedes/refines/contradicts)\n`;
+            }
+            return `🔍 Search method: ${searchMethod}${graphSummary}\n${context}`;
+        }
+        // Calculate graph expansion stats
+        const graphStats = {
+            total_results: finalResults.length,
+            primary_count: finalResults.filter((r) => r.graph_source === 'primary').length,
+            expanded_count: finalResults.filter((r) => r.graph_source !== 'primary').length,
+            sources: {
+                primary: finalResults.filter((r) => r.graph_source === 'primary').length,
+                supersedes_chain: finalResults.filter((r) => r.graph_source === 'supersedes_chain').length,
+                refines: finalResults.filter((r) => r.graph_source === 'refines').length,
+                refined_by: finalResults.filter((r) => r.graph_source === 'refined_by').length,
+                contradicts: finalResults.filter((r) => r.graph_source === 'contradicts').length,
+            },
+        };
+        return {
+            query: userQuestion,
+            results: finalResults,
+            meta: {
+                count: finalResults.length,
+                search_method: searchMethod,
+                threshold: threshold || 'adaptive',
+                // Recency boosting config (NEW - Gaussian Decay)
+                recency_boost: disableRecency
+                    ? null
+                    : {
+                        weight: recencyWeight,
+                        scale: recencyScale,
+                        decay: recencyDecay,
+                    },
+                // Graph expansion stats (NEW - Phase 1)
+                graph_expansion: searchMethod.includes('graph') ? graphStats : null,
+                ranker: rankerMeta,
+            },
+        };
+    }
+    catch (error) {
+        // Graceful degradation
+        (0, debug_logger_js_1.warn)(`mama.suggest() failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Re-rank search results using local LLM (optional enhancement)
+ *
+ * @param {string} userQuestion - User's question
+ * @param {Array} results - Vector search results
+ * @returns {Promise<Array>} Re-ranked results
+ */
+async function rerankWithLLM(runner, userQuestion, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+results
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!runner) {
+        // No model was stated for this runtime, so there is nothing to ask. The
+        // ranking already computed stands, which is what an unreachable model
+        // produced before — said once, here, rather than discovered as a failure.
+        (0, debug_logger_js_1.warn)('Re-ranking skipped: this runtime states no model runner; using vector ranking');
+        return results;
+    }
+    try {
+        const prompt = `User asked: "${userQuestion}"
+
+Found decisions (ranked by vector similarity):
+${results.map((r, i) => `${i + 1}. [${(r.similarity ?? 0).toFixed(3)}] ${r.topic}: ${r.decision.substring(0, 60)}...`).join('\n')}
+
+Re-rank these by actual relevance to the user's intent (not just keyword similarity).
+Return JSON: { "ranking": [index1, index2, ...] } (0-based indices)
+
+Example: { "ranking": [2, 0, 4, 1, 3] } means 3rd is most relevant, then 1st, then 5th...`;
+        const response = await runner(prompt, {
+            format: 'json',
+            temperature: 0.3,
+            maxTokens: 100,
+            timeoutMs: 3000,
+        });
+        const parsed = typeof response === 'string' ? JSON.parse(response) : response;
+        // Reorder results based on LLM ranking
+        return parsed.ranking.map((idx) => results[idx]).filter(Boolean);
     }
-    return result;
+    catch (error) {
+        (0, debug_logger_js_1.warn)(`Re-ranking failed: ${error instanceof Error ? error.message : String(error)}, using vector ranking`);
+        return results; // Fallback to vector ranking
+    }
+}
+/** `LIKE ? ESCAPE '\\'` pattern that matches topics starting with `prefix`, metacharacters literal. */
+function topicPrefixLikePattern(prefix) {
+    return `${prefix.replace(/[\\%_]/g, (ch) => `\\${ch}`)}%`;
 }
-async function ingestConversation(input) {
-    return ingestConversationInternal((0, provenance_js_1.sanitizePublicIngestConversationInput)(input));
+async function listDecisionsInAdapter(adapter, options = {}) {
+    const { limit = 10, format = 'json' } = options;
+    try {
+        let decisions;
+        const topicPrefix = typeof options.topicPrefix === 'string' ? options.topicPrefix.trim() : '';
+        // A prefix read keeps superseded rows: they are the item's earlier rounds.
+        const currency = topicPrefix ? '' : 'AND d.superseded_by IS NULL';
+        const kindClause = options.kind === undefined ? '' : 'AND d.kind = ?';
+        const prefixClause = topicPrefix ? "AND d.topic LIKE ? ESCAPE '\\'" : '';
+        const prefixParams = topicPrefix ? [topicPrefixLikePattern(topicPrefix)] : [];
+        const kindParams = options.kind === undefined ? [] : [options.kind];
+        if (options.scopes && options.scopes.length > 0) {
+            // Scope-filtered query: JOIN memory_scope_bindings + memory_scopes
+            const scopeIds = await Promise.all(options.scopes.map((s) => (0, db_manager_js_1.ensureMemoryScope)(adapter, s.kind, s.id)));
+            const placeholders = scopeIds.map(() => '?').join(', ');
+            const stmt = adapter.prepare(`
+        SELECT DISTINCT d.* FROM decisions d
+        JOIN memory_scope_bindings msb ON msb.memory_id = d.id
+        WHERE msb.scope_id IN (${placeholders})
+          ${currency}
+          ${kindClause}
+          ${prefixClause}
+        ORDER BY COALESCE(d.event_datetime, d.created_at) DESC, d.created_at DESC
+        LIMIT ?
+      `);
+            decisions = await stmt.all(...scopeIds, ...kindParams, ...prefixParams, limit);
+        }
+        else {
+            const stmt = adapter.prepare(`
+        SELECT d.* FROM decisions d
+        WHERE 1 = 1
+          ${currency}
+          ${kindClause}
+          ${prefixClause}
+        ORDER BY COALESCE(d.event_datetime, d.created_at) DESC, d.created_at DESC
+        LIMIT ?
+      `);
+            decisions = await stmt.all(...kindParams, ...prefixParams, limit);
+        }
+        if (format === 'markdown') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return (0, decision_formatter_js_1.formatList)(decisions);
+        }
+        return decisions;
+    }
+    catch (error) {
+        throw new Error(`mama.listDecisions() failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
-async function ingestConversationWithTrustedProvenance(input, options) {
-    return ingestConversationInternal((0, provenance_js_1.sanitizePublicIngestConversationInput)(input), options);
+async function updateOutcomeInAdapter(adapter, decisionId, { outcome, failure_reason, limitation }) {
+    if (!decisionId || typeof decisionId !== 'string') {
+        throw new Error('mama.updateOutcome() requires decisionId (string)');
+    }
+    // AX Improvement: Be forgiving with case sensitivity
+    const normalizedOutcome = outcome ? outcome.toUpperCase() : null;
+    if (!normalizedOutcome || !['SUCCESS', 'FAILED', 'PARTIAL'].includes(normalizedOutcome)) {
+        throw new Error('mama.updateOutcome() outcome must be "SUCCESS", "FAILED", or "PARTIAL"');
+    }
+    try {
+        // Append-only: one judgment record carries the outcome change; the
+        // maintained decisions projection columns move in the same transaction.
+        await (0, write_adapters_js_1.appendOutcomeAmendment)(decisionId, {
+            outcome: normalizedOutcome,
+            failureReason: failure_reason || null,
+            limitation: limitation || null,
+            eventReason: `mama.updateOutcome(${decisionId})`,
+        }, { adapter });
+        return;
+    }
+    catch (error) {
+        throw new Error(`mama.updateOutcome() failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Counts over the admitted corpus.
+ *
+ * Every count answers the same question the scope filter answers for a listing:
+ * a decision this caller may not read is not a decision it may count. An
+ * admitted-empty caller counts zero rather than counting everything — the same
+ * fail-closed reading the listing gives.
+ */
+async function readMemoryStatsInAdapter(adapter, scopes) {
+    const empty = {
+        total: 0,
+        thisWeek: 0,
+        thisMonth: 0,
+        checkpoints: 0,
+        outcomes: {},
+        topTopics: [],
+    };
+    if (scopes.length === 0) {
+        return empty;
+    }
+    const scopeIds = await Promise.all(scopes.map((scope) => (0, db_manager_js_1.ensureMemoryScope)(adapter, scope.kind, scope.id)));
+    const placeholders = scopeIds.map(() => '?').join(', ');
+    const admitted = `
+    JOIN memory_scope_bindings msb ON msb.memory_id = d.id
+    WHERE msb.scope_id IN (${placeholders})
+  `;
+    const now = Date.now();
+    const countSince = async (since) => {
+        const stmt = adapter.prepare(`
+      SELECT COUNT(DISTINCT d.id) as count FROM decisions d
+      ${admitted}
+      ${since === undefined ? '' : 'AND d.created_at > ?'}
+    `);
+        const row = (await stmt.get(...scopeIds, ...(since === undefined ? [] : [since])));
+        return row?.count ?? 0;
+    };
+    const day = 24 * 60 * 60 * 1000;
+    const [total, thisWeek, thisMonth] = await Promise.all([
+        countSince(),
+        countSince(now - 7 * day),
+        countSince(now - 30 * day),
+    ]);
+    const outcomeRows = (await adapter
+        .prepare(`SELECT d.outcome as outcome, COUNT(DISTINCT d.id) as count FROM decisions d
+       ${admitted} AND d.outcome IS NOT NULL
+       GROUP BY d.outcome`)
+        .all(...scopeIds));
+    const outcomes = {};
+    for (const row of outcomeRows) {
+        outcomes[row.outcome?.toLowerCase() ?? 'unknown'] = row.count;
+    }
+    const topTopics = (await adapter
+        .prepare(`SELECT d.topic as topic, COUNT(DISTINCT d.id) as count FROM decisions d
+       ${admitted} AND d.topic IS NOT NULL
+       GROUP BY d.topic
+       ORDER BY count DESC
+       LIMIT 5`)
+        .all(...scopeIds));
+    // Checkpoints carry no scope binding, and `memory.checkpoint.load` reads them
+    // under the same authority: the count is of what that read can reach.
+    const checkpointRow = (await adapter
+        .prepare('SELECT COUNT(*) as count FROM checkpoints')
+        .get());
+    return {
+        total,
+        thisWeek,
+        thisMonth,
+        checkpoints: checkpointRow?.count ?? 0,
+        outcomes,
+        topTopics,
+    };
+}
+/**
+ * Save current session checkpoint (New Feature: Session Continuity)
+ *
+ * @param {string} summary - Summary of current session state
+ * @param {Array<string>} openFiles - List of currently open files
+ * @param {string} nextSteps - Next steps to be taken
+ * @returns {Promise<number>} Checkpoint ID
+ */
+async function saveCheckpointInAdapter(adapter, summary, openFiles = [], nextSteps = '', 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+recentConversation = []) {
+    if (!summary) {
+        throw new Error('Summary is required for checkpoint');
+    }
+    const scan = (0, secret_filter_js_1.scanMemoryWriteInput)({
+        summary,
+        open_files: openFiles,
+        next_steps: nextSteps,
+        recent_conversation: recentConversation,
+    });
+    if (!scan.clean)
+        throw new secret_filter_js_1.SecretMaterialRefusedError(scan.matches);
+    if (scan.warnings.length > 0)
+        (0, debug_logger_js_2.warn)(`Checkpoint content warnings: ${scan.warnings.join(', ')}`);
+    try {
+        const stmt = adapter.prepare(`
+      INSERT INTO checkpoints (timestamp, summary, open_files, next_steps, recent_conversation, status)
+      VALUES (?, ?, ?, ?, ?, 'active')
+    `);
+        const result = stmt.run(Date.now(), summary, JSON.stringify(openFiles), nextSteps, JSON.stringify(recentConversation || []));
+        return result.lastInsertRowid;
+    }
+    catch (error) {
+        throw new Error(`Failed to save checkpoint: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function loadCheckpointInAdapter(adapter) {
+    try {
+        const stmt = adapter.prepare(`
+      SELECT * FROM checkpoints
+      WHERE status = 'active'
+      ORDER BY timestamp DESC
+      LIMIT 1
+    `);
+        const checkpoint = stmt.get();
+        if (checkpoint) {
+            try {
+                checkpoint.open_files =
+                    typeof checkpoint.open_files === 'string'
+                        ? JSON.parse(checkpoint.open_files)
+                        : checkpoint.open_files || [];
+            }
+            catch {
+                checkpoint.open_files = [];
+            }
+            try {
+                checkpoint.recent_conversation =
+                    typeof checkpoint.recent_conversation === 'string'
+                        ? JSON.parse(checkpoint.recent_conversation || '[]')
+                        : checkpoint.recent_conversation || [];
+            }
+            catch {
+                checkpoint.recent_conversation = [];
+            }
+        }
+        return checkpoint || null;
+    }
+    catch (error) {
+        throw new Error(`Failed to load checkpoint: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function listCheckpointsInAdapter(adapter, limit = 10) {
+    try {
+        const stmt = adapter.prepare(`
+      SELECT * FROM checkpoints
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `);
+        const checkpoints = stmt.all(limit);
+        return checkpoints.map((c) => {
+            try {
+                c.open_files =
+                    typeof c.open_files === 'string' ? JSON.parse(c.open_files) : c.open_files || [];
+            }
+            catch {
+                c.open_files = [];
+            }
+            try {
+                c.recent_conversation =
+                    typeof c.recent_conversation === 'string'
+                        ? JSON.parse(c.recent_conversation)
+                        : c.recent_conversation || [];
+            }
+            catch {
+                c.recent_conversation = [];
+            }
+            return c;
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to list checkpoints: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 //# sourceMappingURL=api.js.map