@oscharko-dev/keiko 0.2.0-beta.6 → 0.2.0-beta.8

package/node_modules/@oscharko-dev/keiko-server/dist/memory-embedding.js

@@ -14,6 +14,7 @@
 // function is inert (embedMemoryText -> null, embedAndStoreMemory -> no-op) and the caller keeps
 // its pre-semantic behaviour byte-for-byte.
 import { requestOpenAIEmbedding, } from "@oscharko-dev/keiko-model-gateway";
+import { randomUUID } from "node:crypto";
 import { currentGatewayConfig } from "./deps.js";
 import { selectEmbeddingModelId } from "./local-knowledge-handlers.js";
 const MEMORY_VECTOR_METRIC = "cosine";
@@ -135,3 +136,129 @@ export function cosineSimilarity(a, b) {
         return 0;
     return cosine > 1 ? 1 : cosine;
 }
+// ─── Semantic novelty gate at capture (#204, O-F1) ──────────────────────────────
+// Lexical Jaccard dedup at capture misses semantic restatements ("I use Postgres" vs "my database is
+// PostgreSQL"). This catches them BEFORE a second copy is stored: embed the candidate once, compare
+// to the in-scope stored vectors, and if it is NEAR-IDENTICAL to an existing memory, reinforce that
+// canonical memory instead of duplicating it.
+//
+// SAFETY: the threshold is deliberately HIGH (0.95) and the gate is applied ONLY to the low-stakes
+// salience firehose — NOT to explicit user instructions. A pure cosine signal cannot tell a
+// paraphrase ("uses PostgreSQL") from a value-change ("region is eu-central-1" vs "us-east-1"), so a
+// lower threshold could merge a contradicting update. At 0.95 only near-verbatim restatements merge;
+// value-changes (differing entities/numbers) stay below it and are inserted normally, where
+// consolidation's conflict detection backstops them. Merging reinforces the canonical rather than
+// deleting, so even a false merge loses no stored fact. Graceful: with no embedder the candidate
+// embedding is null and the gate is inert (prior lexical-only behaviour, byte-for-byte).
+export const SEMANTIC_DEDUP_COSINE_THRESHOLD = 0.95;
+// Pure: the id of the nearest in-scope memory whose cosine to the candidate is at/above the
+// threshold, or null (no candidate embedding, no neighbours, or none similar enough). First-max wins
+// on ties so the result is deterministic for a fixed neighbour iteration order.
+export function findSemanticDuplicate(candidate, neighbors, threshold = SEMANTIC_DEDUP_COSINE_THRESHOLD) {
+    if (candidate === null)
+        return null;
+    let bestId = null;
+    let bestSim = -1;
+    for (const [id, row] of neighbors) {
+        const sim = cosineSimilarity(candidate.vector, row.vector);
+        if (sim > bestSim) {
+            bestSim = sim;
+            bestId = id;
+        }
+    }
+    return bestSim >= threshold ? bestId : null;
+}
+// ─── Semantic auto-linking at capture (#204, O-P4) ──────────────────────────────
+// A-MEM (2502.12110) self-organises memory by LINKING a new note to its semantic neighbours at
+// write time, so associative recall has structure to traverse immediately. Memoria Viva already
+// runs graph-proximity recall live (the ranker's `graph` subscore), but until now the only edges
+// were supersedes/correction links and the batch consolidation pass — a fresh capture had no
+// associations. This forms them deterministically from the SAME embedding used for the novelty
+// gate: a novel capture is linked to its nearest in-scope neighbours that fall in a "related" band
+// (similar enough to associate, below the dedup threshold so they are not the same fact). No model
+// call, no non-determinism — a pure cosine band over vectors already in hand.
+// Lower bound of the related band. Above this two memory bodies are topically associated; below it
+// the link would be noise. Conservative starting point for text-embedding-3-large; tunable per the
+// opt-in flag before it is switched on by default.
+export const RELATED_LINK_COSINE_THRESHOLD = 0.82;
+// At most this many associations per capture, so the graph stays sparse and traversal stays cheap.
+export const MAX_AUTO_LINKS = 3;
+// Pure: the in-scope neighbours whose cosine to the candidate falls in the band [lower, upper) —
+// associated but not a duplicate — ranked by similarity desc (id asc tiebreak) and capped at
+// maxLinks. Empty for a null candidate or when nothing lands in the band. Deterministic for a fixed
+// neighbour set.
+export function findRelatedNeighbors(candidate, neighbors, lower = RELATED_LINK_COSINE_THRESHOLD, upper = SEMANTIC_DEDUP_COSINE_THRESHOLD, maxLinks = MAX_AUTO_LINKS) {
+    if (candidate === null)
+        return [];
+    const scored = [];
+    for (const [id, row] of neighbors) {
+        const similarity = cosineSimilarity(candidate.vector, row.vector);
+        if (similarity >= lower && similarity < upper)
+            scored.push({ id, similarity });
+    }
+    scored.sort((a, b) => a.similarity !== b.similarity ? b.similarity - a.similarity : a.id.localeCompare(b.id));
+    return scored.slice(0, maxLinks).map((n) => n.id);
+}
+// Opt-in (KEIKO_MEMORY_AUTO_LINK=1, default off => byte-identical: no edges, no behaviour change).
+// Best-effort: a rejected edge insert must never break the capture that already succeeded.
+function autoLinkRelatedMemories(deps, vault, fromId, embedding, neighbors) {
+    if (deps.env.KEIKO_MEMORY_AUTO_LINK !== "1")
+        return;
+    const relatedIds = findRelatedNeighbors(embedding, neighbors);
+    if (relatedIds.length === 0)
+        return;
+    const nowMs = Date.now();
+    for (const toId of relatedIds) {
+        try {
+            vault.insertEdge({
+                id: randomUUID(),
+                schemaVersion: "1",
+                fromMemoryId: fromId,
+                toMemoryId: toId,
+                kind: "related",
+                createdAt: nowMs,
+                provenanceSummary: "semantic auto-link",
+            });
+        }
+        catch {
+            // Validator / storage rejection — association enrichment is best-effort, never fatal.
+        }
+    }
+}
+// Bounds the neighbour set so the cosine sweep stays cheap on a large vault (mirrors the lexical
+// dedup corpus bound). Scope-local list preserves cross-scope isolation.
+const MAX_DEDUP_NEIGHBORS = 200;
+function gatherScopeEmbeddings(vault, scope) {
+    const ids = vault
+        .listMemoriesByScope(scope)
+        .slice(0, MAX_DEDUP_NEIGHBORS)
+        .map((record) => record.id);
+    return ids.length === 0 ? new Map() : vault.getEmbeddings(ids);
+}
+// Insert a freshly-built salience capture record UNLESS it is a semantic near-duplicate of an
+// existing in-scope memory, in which case reinforce the canonical (recordAccess) and skip the
+// duplicate. Embeds the body exactly ONCE (reused for both the novelty check and storage), so this
+// replaces — not adds to — the prior best-effort embed-on-capture call. Never throws past the
+// vault's own guards; a null embedding degrades to a plain insert.
+export async function insertSalienceMemoryWithNoveltyGate(deps, vault, record) {
+    const embedding = await embedMemoryText(deps, record.body);
+    const neighbors = gatherScopeEmbeddings(vault, record.scope);
+    const duplicateOf = findSemanticDuplicate(embedding, neighbors);
+    if (duplicateOf !== null) {
+        vault.recordAccess([duplicateOf], Date.now());
+        return { inserted: null, mergedInto: duplicateOf };
+    }
+    const inserted = vault.insertMemory(record);
+    if (embedding !== null) {
+        try {
+            vault.upsertEmbedding(inserted.id, embedding);
+        }
+        catch {
+            // gateEmbeddingInput / storage rejection — capture already succeeded; drop the embedding.
+        }
+        // A-MEM-style associative linking (#204, O-P4). Reuses the neighbour set already fetched for the
+        // novelty gate — no extra IO. Opt-in (default off => no edges, byte-identical).
+        autoLinkRelatedMemories(deps, vault, inserted.id, embedding, neighbors);
+    }
+    return { inserted, mergedInto: null };
+}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-handlers.d.ts","sourceRoot":"","sources":["../src/memory-handlers.ts"],"names":[],"mappings":"AAkBA,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,kCAAkC,CAAC;AAoC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAY,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA6SvE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CA8BtF;AAID,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAmB5F;AAID,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAqBnF;AAwDD,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA+BtB;AAID,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CA6BnF;AAID,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CA6BrF;AAID,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAsCtB;AAkND,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA0BtB;AAED,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAiBtB;AAKD,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAkCtB;AAsMD,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAiBtB;AA8GD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA8CtB;AA0ID,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAc9F;AAyBD,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAgCtB;AAOD,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACnC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,kCAAkC,EAAE,WAAW,KAAK,IAAI,EACvF,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GACjD,gBAAgB,CASlB"}
+{"version":3,"file":"memory-handlers.d.ts","sourceRoot":"","sources":["../src/memory-handlers.ts"],"names":[],"mappings":"AAkBA,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,kCAAkC,CAAC;AAqC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAY,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA6SvE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CA8BtF;AAID,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAmB5F;AAID,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAqBnF;AAwDD,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA+BtB;AAID,wBAAgB,eAAe,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CA6BnF;AAID,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CA6BrF;AAID,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAsCtB;AAkND,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA0BtB;AAED,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAiBtB;AAKD,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAkCtB;AAkND,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAiBtB;AA8GD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA8CtB;AAyJD,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAc9F;AAyBD,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAoCtB;AAOD,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACnC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,kCAAkC,EAAE,WAAW,KAAK,IAAI,EACvF,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GACjD,gBAAgB,CASlB"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-handlers.js

@@ -15,7 +15,7 @@
 // Every response is redacted through `deps.redactor` before serialisation to honour D9.
 import { randomUUID } from "node:crypto";
 import { createMemoryVault, MemoryStorageError, } from "@oscharko-dev/keiko-memory-vault";
-import { GovernanceError, buildArchiveOperation, buildConflictTransitions, buildCorrection, buildForgetOperations, buildPinOperation, buildUnpinOperation, detectConflictPair, selectMemoriesForForget, } from "@oscharko-dev/keiko-memory-governance";
+import { GovernanceError, buildArchiveOperation, buildConflictTransitions, buildCorrection, buildForgetOperations, buildPinOperation, buildUnpinOperation, detectConflictPair, selectMemoriesForForget, supersededValidity, } from "@oscharko-dev/keiko-memory-governance";
 import { checkStatusTransition, MEMORY_SCOPE_KINDS, MEMORY_STATUSES, MEMORY_TYPES, MEMORY_SENSITIVITIES, validateMemoryScope, } from "@oscharko-dev/keiko-contracts";
 import { errorBody } from "./routes.js";
 import { auditRunIdFor, recordMemoryAudit } from "./memory-audit-handler.js";
@@ -826,7 +826,12 @@ function findMemoryById(memories, id) {
 }
 function persistConflictTransitions(vault, resolution, reason) {
     for (const transition of resolution.statusTransitions) {
-        vault.updateMemory(transition.memoryId, { status: transition.to, staleReason: reason }, transition.transitionedAt);
+        // Bi-temporal-lite (#204, C1): a record losing a conflict and being SUPERSEDED gets its belief
+        // window closed at the transition time, same as the correction path. Other transitions (e.g.
+        // the winner re-accepted) leave validity untouched.
+        const existing = transition.to === "superseded" ? vault.getMemory(transition.memoryId) : undefined;
+        const validity = existing !== undefined ? supersededValidity(existing, transition.transitionedAt) : null;
+        vault.updateMemory(transition.memoryId, { status: transition.to, staleReason: reason, ...(validity !== null ? { validity } : {}) }, transition.transitionedAt);
     }
 }
 function persistConflictSupersessions(vault, deps, memories, supersessions, nowMs) {
@@ -851,6 +856,11 @@ function executeConflictResolution(vault, deps, input) {
     const resolution = buildConflictTransitions(memories, { winner: input.winner, losers: input.losers }, { reviewerId: DEFAULT_REVIEWER_ID, nowMs });
     persistConflictTransitions(vault, resolution, input.reason);
     const edgeIds = persistConflictSupersessions(vault, deps, memories, resolution.supersessions, nowMs);
+    // Outcome-driven forgetting (#204, O-V1): the winner proved more correct (utility 1), the losers
+    // proved wrong (utility 0). These bias the maintenance utility factor toward keeping the winner
+    // and forgetting the superseded losers.
+    vault.recordOutcome([input.winner], 1, nowMs);
+    vault.recordOutcome(input.losers, 0, nowMs);
     return {
         resolved: true,
         winner: input.winner,
@@ -1054,14 +1064,21 @@ function buildAcceptProposalPatch(origins) {
 function buildCorrectionAcceptanceUpdates(proposalId, acceptPatch, origins, nowMs) {
     return [
         { id: proposalId, patch: acceptPatch, nowMs },
-        ...origins.map(({ edge, original }) => ({
-            id: original.id,
-            patch: {
-                status: "superseded",
-                staleReason: edge.provenanceSummary ?? "accepted correction",
-            },
-            nowMs,
-        })),
+        ...origins.map(({ edge, original }) => {
+            // Bi-temporal-lite (#204, C1): close the superseded fact's belief window at acceptance time so
+            // it drops out of default retrieval and "as of date T" stays answerable. Additive — only when
+            // it forms a valid, non-extending interval.
+            const validity = supersededValidity(original, nowMs);
+            return {
+                id: original.id,
+                patch: {
+                    status: "superseded",
+                    staleReason: edge.provenanceSummary ?? "accepted correction",
+                    ...(validity !== null ? { validity } : {}),
+                },
+                nowMs,
+            };
+        }),
     ];
 }
 function recordCorrectionSupersessionAudits(deps, acceptedCorrection, origins, nowMs) {
@@ -1093,6 +1110,14 @@ function acceptMemoryProposal(vault, deps, id) {
     if (updated === undefined) {
         throw new GovernanceError("invalid-resolution", "acceptance update produced no records");
     }
+    // Outcome-driven forgetting (#204, O-V1): acceptance is a positive retention outcome for the
+    // proposal; any origin it supersedes proved wrong (utility 0). Both feed the maintenance utility
+    // factor so the kept memory resists disuse decay and the corrected-away origin fades sooner.
+    vault.recordOutcome([id], 1, nowMs);
+    const supersededOriginIds = origins.map((origin) => origin.original.id);
+    if (supersededOriginIds.length > 0) {
+        vault.recordOutcome(supersededOriginIds, 0, nowMs);
+    }
     recordCorrectionSupersessionAudits(deps, updated, origins, nowMs);
     return { status: 200, body: { memory: redactMemory(deps, updated) } };
 }
@@ -1146,7 +1171,11 @@ export async function handleRejectMemoryProposal(ctx, deps) {
         const existing = ensureRejectableMemory(vault.getMemory(id));
         if (isRouteResult(existing))
             return existing;
-        const updated = vault.updateMemory(id, { status: "rejected", staleReason: reason }, Date.now());
+        const nowMs = Date.now();
+        const updated = vault.updateMemory(id, { status: "rejected", staleReason: reason }, nowMs);
+        // Outcome-driven forgetting (#204, O-V1): a user rejection is a negative retention outcome
+        // (utility 0), so the rejected memory fades faster under maintenance instead of lingering.
+        vault.recordOutcome([id], 0, nowMs);
         return { status: 200, body: { memory: redactMemory(deps, updated) } };
     }
     catch (err) {

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.d.ts

@@ -5,8 +5,6 @@ import type { UiHandlerDeps } from "./deps.js";
 import type { RouteContext, RouteResult } from "./routes.js";
 export interface MaintenanceCounts {
     promoted: number;
-    reinforced: number;
-    decayed: number;
     archived: number;
     forgotten: number;
     superseded: number;
@@ -17,6 +15,21 @@ export interface MaintenanceCounts {
 export interface MaintenanceResult extends MaintenanceCounts {
     readonly reviewItems: readonly ReviewItem[];
 }
-export declare function runMemoryMaintenance(vault: MemoryVaultStore, evidenceStore?: EvidenceStore): MaintenanceResult;
+export interface RunMaintenanceOptions {
+    /** Injected clock. Defaults to Date.now(). Pass a fixed value to make the pass replay-stable. */
+    readonly nowMs?: number;
+}
+export declare function runMemoryMaintenance(vault: MemoryVaultStore, evidenceStore?: EvidenceStore, options?: RunMaintenanceOptions): MaintenanceResult;
+export declare const MEMORY_AUTO_MAINTENANCE_MIN_INTERVAL_MS: number;
+export declare function isMaintenanceDue(lastRunAtMs: number | undefined, nowMs: number, minIntervalMs?: number): boolean;
+export interface AutoMaintenanceState {
+    lastRunAtMs?: number;
+}
+export interface MaybeRunAutoMaintenanceOptions {
+    readonly nowMs: number;
+    readonly enabled: boolean;
+    readonly minIntervalMs?: number;
+}
+export declare function maybeRunAutoMaintenance(vault: MemoryVaultStore, evidenceStore: EvidenceStore | undefined, state: AutoMaintenanceState, options: MaybeRunAutoMaintenanceOptions): MaintenanceResult | null;
 export declare function handleRunMaintenance(ctx: RouteContext, deps: UiHandlerDeps): RouteResult;
 //# sourceMappingURL=memory-maintenance-handlers.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-maintenance-handlers.d.ts","sourceRoot":"","sources":["../src/memory-maintenance-handlers.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAc7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI7D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAkND,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,EACvB,aAAa,CAAC,EAAE,aAAa,GAC5B,iBAAiB,CAuBnB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAWxF"}
+{"version":3,"file":"memory-maintenance-handlers.d.ts","sourceRoot":"","sources":["../src/memory-maintenance-handlers.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAc7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI7D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAuMD,MAAM,WAAW,qBAAqB;IACpC,iGAAiG;IACjG,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,EACvB,aAAa,CAAC,EAAE,aAAa,EAC7B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,iBAAiB,CAkCnB;AAQD,eAAO,MAAM,uCAAuC,QAAqB,CAAC;AAI1E,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,KAAK,EAAE,MAAM,EACb,aAAa,GAAE,MAAgD,GAC9D,OAAO,CAIT;AAGD,MAAM,WAAW,oBAAoB;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAMD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,gBAAgB,EACvB,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,KAAK,EAAE,oBAAoB,EAC3B,OAAO,EAAE,8BAA8B,GACtC,iBAAiB,GAAG,IAAI,CAS1B;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,WAAW,CAWxF"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.js

@@ -6,8 +6,10 @@
 //   2. Run consolidation on the accepted subset; persist auto-applicable relationship edges and
 //      return unresolved review items for MemoriaViva or CLI operators. Conflict and merge review
 //      items are NEVER auto-applied here.
-//   3. Compute the maintenance plan and apply it: promote (-> accepted), reinforce / decay
-//      (confidence patch), archive (-> archived), forget (vault delete + tombstone + reason).
+//   3. Compute the maintenance plan and apply it: promote (-> accepted), archive (-> archived),
+//      forget (vault delete + tombstone + reason). Confidence is immutable provenance and is never
+//      patched here (O-V2): reuse strengthens memories live in retrieval ranking, and disuse-decay
+//      is computed on the fly via the strength curve that gates archive/forget.
 //   4. Emit one audit event per applied effect and return the counts.
 //
 // CSRF: the server dispatch layer enforces x-keiko-csrf for POST, so this route is guarded without
@@ -21,8 +23,6 @@ import { recordMemoryAudit } from "./memory-audit-handler.js";
 function emptyCounts() {
     return {
         promoted: 0,
-        reinforced: 0,
-        decayed: 0,
         archived: 0,
         forgotten: 0,
         superseded: 0,
@@ -44,24 +44,20 @@ function resolveVault(deps) {
     }
     return deps.memoryVault;
 }
-function emitAudit(evidenceStore, kind, surface, summary, extra) {
+function emitAudit(evidenceStore, nowMs, kind, surface, summary, extra) {
     if (evidenceStore === undefined)
         return;
     const event = {
         schemaVersion: "1",
         kind,
         eventId: randomUUID(),
-        occurredAt: Date.now(),
+        occurredAt: nowMs,
         initiatorSurface: surface,
         summary,
         ...extra,
     };
     recordMemoryAudit({ evidenceStore }, event);
 }
-// Patch a record's confidence by rebuilding the provenance envelope (confidence lives there).
-function patchConfidence(vault, record, confidence) {
-    vault.updateMemory(record.id, { provenance: { ...record.provenance, confidence } }, Date.now());
-}
 function recordsById(records) {
     const map = new Map();
     for (const record of records)
@@ -82,9 +78,9 @@ function applyEdges(vault, edges) {
     }
     return created;
 }
-function runConsolidationPass(vault, records, counts) {
+function runConsolidationPass(vault, nowMs, records, counts) {
     const result = runConsolidation(records, {
-        nowMs: Date.now(),
+        nowMs,
         newEdgeId: () => randomUUID(),
         newReviewItemId: () => randomUUID(),
     });
@@ -94,48 +90,41 @@ function runConsolidationPass(vault, records, counts) {
     counts.reviewItems.push(...result.reviewItems);
 }
 // ─── Plan application ──────────────────────────────────────────────────────────
-// Applies the reinforce / decay / archive / forget effects on the post-consolidation snapshot.
-// Promotions are applied SEPARATELY and BEFORE consolidation (see runMemoryMaintenance) so that
-// freshly-accepted memories are visible to conflict detection within the same maintenance pass.
-function applyDecayEffects(vault, evidenceStore, plan, byId, counts) {
-    applyConfidencePatches(vault, plan.reinforce, byId, (n) => (counts.reinforced += n));
-    applyConfidencePatches(vault, plan.decay, byId, (n) => (counts.decayed += n));
-    applyArchives(vault, evidenceStore, plan.archive, byId, counts);
-    applyForgets(vault, evidenceStore, plan.forget, byId, counts);
-}
-function applyPromotions(vault, evidenceStore, ids, byId, counts) {
+// Applies the archive / forget effects on the post-consolidation snapshot. Promotions are applied
+// SEPARATELY and BEFORE consolidation (see runMemoryMaintenance) so that freshly-accepted memories
+// are visible to conflict detection within the same maintenance pass.
+//
+// Confidence is NEVER mutated here (#204, O-V2): reinforcement-on-reuse is realised live in
+// retrieval ranking, and disuse-decay is computed on the fly via the strength curve that already
+// gates archive/forget — so provenance stays intact and every run is idempotent.
+function applyFadeEffects(vault, evidenceStore, nowMs, plan, byId, counts) {
+    applyArchives(vault, evidenceStore, nowMs, plan.archive, byId, counts);
+    applyForgets(vault, evidenceStore, nowMs, plan.forget, byId, counts);
+}
+function applyPromotions(vault, evidenceStore, nowMs, ids, byId, counts) {
     for (const id of ids) {
         const record = byId.get(id);
         if (record === undefined)
             continue;
-        vault.updateMemory(id, { status: "accepted" }, Date.now());
+        vault.updateMemory(id, { status: "accepted" }, nowMs);
         counts.promoted += 1;
-        emitAudit(evidenceStore, "memory:accepted", "memory-center", "Promoted a strong proposed memory.", { memoryId: id, scope: record.scope });
-    }
-}
-function applyConfidencePatches(vault, patches, byId, bump) {
-    for (const patch of patches) {
-        const record = byId.get(patch.id);
-        if (record === undefined)
-            continue;
-        patchConfidence(vault, record, patch.confidence);
-        bump(1);
+        emitAudit(evidenceStore, nowMs, "memory:accepted", "memory-center", "Promoted a strong proposed memory.", { memoryId: id, scope: record.scope });
     }
 }
-function applyArchives(vault, evidenceStore, ids, byId, counts) {
+function applyArchives(vault, evidenceStore, nowMs, ids, byId, counts) {
     for (const id of ids) {
         const record = byId.get(id);
         if (record === undefined)
             continue;
-        vault.updateMemory(id, { status: "archived" }, Date.now());
+        vault.updateMemory(id, { status: "archived" }, nowMs);
         counts.archived += 1;
-        emitAudit(evidenceStore, "memory:archived", "retention", "Archived a faded memory.", {
+        emitAudit(evidenceStore, nowMs, "memory:archived", "retention", "Archived a faded memory.", {
             memoryId: id,
             scope: record.scope,
         });
     }
 }
-function applyForgets(vault, evidenceStore, forgets, byId, counts) {
+function applyForgets(vault, evidenceStore, nowMs, forgets, byId, counts) {
     for (const forget of forgets) {
         const record = byId.get(forget.id);
         if (record === undefined)
@@ -144,20 +133,21 @@ function applyForgets(vault, evidenceStore, forgets, byId, counts) {
             tombstone: true,
             forgetterSurface: "memory-maintenance",
             reason: forget.reason,
-            nowMs: Date.now(),
+            nowMs,
         });
         counts.forgotten += 1;
-        emitAudit(evidenceStore, "memory:forgotten", "retention", `Forgot a memory (${forget.reason}).`, {
+        emitAudit(evidenceStore, nowMs, "memory:forgotten", "retention", `Forgot a memory (${forget.reason}).`, {
             memoryId: forget.id,
             scope: record.scope,
             tombstoned: true,
         });
     }
 }
-// Reusable maintenance core. Drives consolidation + the governance plan against a vault, emitting
-// audit events when an evidence store is supplied. Exported so both the BFF route handler and the
-// `keiko memory maintain` CLI run the SAME pass — no duplicated orchestration.
-export function runMemoryMaintenance(vault, evidenceStore) {
+export function runMemoryMaintenance(vault, evidenceStore, options) {
+    // ONE clock for the whole pass: both plan phases and every vault write / audit timestamp use the
+    // same nowMs, so selection is consistent within a run and fully replay-stable when nowMs is
+    // injected (the deterministic-verification invariant the rest of the stack honours).
+    const nowMs = options?.nowMs ?? Date.now();
     const counts = emptyCounts();
     // Phase 1 — promote strong `proposed` memories FIRST. Consolidation and conflict detection only
     // inspect `accepted` records, so without this a vault full of freshly-captured `proposed`
@@ -165,22 +155,54 @@ export function runMemoryMaintenance(vault, evidenceStore) {
     // resolved. Promoting up front makes a single "Run maintenance" fully effective.
     const beforePromote = vault.listMemories({ includeExpired: true });
     const promoteStats = vault.getAccessStats();
-    const promotePlan = planMemoryMaintenance(beforePromote, promoteStats, { nowMs: Date.now() });
-    applyPromotions(vault, evidenceStore, promotePlan.promote, recordsById(beforePromote), counts);
+    const promotePlan = planMemoryMaintenance(beforePromote, promoteStats, { nowMs });
+    applyPromotions(vault, evidenceStore, nowMs, promotePlan.promote, recordsById(beforePromote), counts);
     // Phase 2 — consolidate the now-accepted set: link safe near-duplicate metadata and surface
     // conflicts / merges as explicit review items. Status mutations require a later governed review.
     const accepted = vault
         .listMemories({ includeExpired: true })
         .filter((record) => record.status === "accepted");
-    runConsolidationPass(vault, accepted, counts);
-    // Phase 3 — reinforce / decay / archive / forget on the post-consolidation snapshot. The access
-    // stats feed the strength model.
+    runConsolidationPass(vault, nowMs, accepted, counts);
+    // Phase 3 — archive / forget on the post-consolidation snapshot. The access stats feed the
+    // strength model; confidence itself is never mutated (O-V2).
     const all = vault.listMemories({ includeExpired: true });
     const accessStats = vault.getAccessStats();
-    const plan = planMemoryMaintenance(all, accessStats, { nowMs: Date.now() });
-    applyDecayEffects(vault, evidenceStore, plan, recordsById(all), counts);
+    const plan = planMemoryMaintenance(all, accessStats, { nowMs });
+    applyFadeEffects(vault, evidenceStore, nowMs, plan, recordsById(all), counts);
     return counts;
 }
+// ─── Bounded autonomous maintenance (#204, O-V4) ───────────────────────────────
+// The strength/decay/forget pass only "lives" if it actually runs. Rather than a free-running
+// background loop (forbidden by the no-unbounded-hidden-activity invariant), maintenance is fired
+// opportunistically — once memory is used — and rate-limited to at most once per interval. The pass
+// itself is already bounded (maxForgetPerRun) and audited, so an autonomous fire is governed.
+export const MEMORY_AUTO_MAINTENANCE_MIN_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+// Pure: due iff never run, or the interval has elapsed. A non-finite/negative interval is treated as
+// "never auto-run" so a misconfiguration can only DISABLE, never spin.
+export function isMaintenanceDue(lastRunAtMs, nowMs, minIntervalMs = MEMORY_AUTO_MAINTENANCE_MIN_INTERVAL_MS) {
+    if (!Number.isFinite(minIntervalMs) || minIntervalMs <= 0)
+        return false;
+    if (lastRunAtMs === undefined)
+        return true;
+    return nowMs - lastRunAtMs >= minIntervalMs;
+}
+// Runs ONE bounded maintenance pass iff enabled AND due, advancing the cursor BEFORE running so a
+// re-entrant call within the same tick cannot double-fire. Returns the result, or null when skipped.
+// Never throws: a maintenance fault must not break the caller (e.g. a chat turn); it is swallowed
+// after advancing the cursor so a persistently-failing pass cannot hot-loop.
+export function maybeRunAutoMaintenance(vault, evidenceStore, state, options) {
+    if (!options.enabled)
+        return null;
+    if (!isMaintenanceDue(state.lastRunAtMs, options.nowMs, options.minIntervalMs))
+        return null;
+    state.lastRunAtMs = options.nowMs;
+    try {
+        return runMemoryMaintenance(vault, evidenceStore, { nowMs: options.nowMs });
+    }
+    catch {
+        return null;
+    }
+}
 export function handleRunMaintenance(ctx, deps) {
     void ctx;
     const vault = resolveVault(deps);

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retrieval-signals.d.ts

@@ -0,0 +1,12 @@
+import type { MemoryId, MemoryScope } from "@oscharko-dev/keiko-contracts/memory";
+import { type RankingFusionMode } from "@oscharko-dev/keiko-memory-retrieval";
+import type { MemoryVaultStore } from "@oscharko-dev/keiko-memory-vault";
+import type { UiHandlerDeps } from "./deps.js";
+export declare function conversationFusionMode(deps: UiHandlerDeps): RankingFusionMode;
+export interface ConversationRetrievalSignals {
+    readonly semanticById?: ReadonlyMap<MemoryId, number> | undefined;
+    readonly strengthById: ReadonlyMap<MemoryId, number>;
+    readonly embeddingById: ReadonlyMap<MemoryId, Float32Array>;
+}
+export declare function buildConversationRetrievalSignals(deps: UiHandlerDeps, vault: MemoryVaultStore, queryText: string | undefined, scopes: readonly MemoryScope[], nowMs: number, safeForSecondaryModel: boolean): Promise<ConversationRetrievalSignals>;
+//# sourceMappingURL=memory-retrieval-signals.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retrieval-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-retrieval-signals.d.ts","sourceRoot":"","sources":["../src/memory-retrieval-signals.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,QAAQ,EAAgB,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAChG,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAE7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAwD/C,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,iBAAiB,CAE7E;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAClE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAIrD,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;CAC7D;AAED,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,KAAK,EAAE,MAAM,EACb,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,4BAA4B,CAAC,CAkBvC"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retrieval-signals.js

@@ -0,0 +1,84 @@
+// Shared conversation-retrieval signal builder (#204, O-F4).
+//
+// Both conversation retrieval surfaces — the desktop chat path (chat-handlers) and the BFF
+// /api/memory/context route (memory-conv-handlers) — need the same two model/usage-derived ranking
+// signals on top of the pure lexical ranker:
+//   - semanticById: per-memory cosine of the query embedding to each candidate's stored vector
+//     (embedding-based recall), gated by the secondary-model egress check.
+//   - strengthById: per-memory reinforcement strength from the vault's access counters (O-P1).
+// Previously only the chat path built them; the BFF route silently ran lexical-only. Centralising
+// them here keeps the two surfaces from drifting (the same class of duplication C3 guards for
+// suppression) and gives any future consumer of the route the stronger embedding signal by default.
+//
+// Pure of policy: the caller decides whether the query is egress-safe and passes that in. Graceful:
+// no embedding model => semanticById undefined (byte-identical lexical fallback); empty access
+// history => strengthById empty (the ranker zeroes its weight).
+import { buildStrengthById, DEFAULT_LIST_BY_SCOPE_MAX_RESULTS, DEFAULT_STALE_CONFIDENCE_THRESHOLD, isMemorySuppressed, } from "@oscharko-dev/keiko-memory-retrieval";
+import { cosineSimilarity, embedMemoryText } from "./memory-embedding.js";
+// A candidate is worth scoring iff the ranker could surface it. A superset of the ranked set is
+// harmless: ids the ranker filters out simply never read their semantic score.
+function isSemanticRetrievalCandidate(record, nowMs) {
+    if (record.status === "superseded")
+        return false;
+    return !isMemorySuppressed(record, nowMs, DEFAULT_STALE_CONFIDENCE_THRESHOLD).suppressed;
+}
+function gatherCandidateIds(vault, scopes, nowMs) {
+    const ids = [];
+    const seen = new Set();
+    for (const scope of scopes) {
+        for (const record of vault.listMemoriesByScope(scope, {
+            includeExpired: true,
+            limit: DEFAULT_LIST_BY_SCOPE_MAX_RESULTS,
+        })) {
+            if (!isSemanticRetrievalCandidate(record, nowMs))
+                continue;
+            if (seen.has(record.id))
+                continue;
+            seen.add(record.id);
+            ids.push(record.id);
+        }
+    }
+    return ids;
+}
+// Per-memory semantic score map for the candidate set, or undefined when no embedding model is
+// configured (query embedding null) — that undefined drives the byte-identical lexical fallback in
+// the ranker. A candidate whose stored vector is missing is omitted (semantic subscore 0 for it).
+// Query-cosine scores for the candidate set, computed from the already-fetched embeddings. Gated by
+// the egress check (it embeds the query). Returns undefined when no model / no query embedding.
+async function semanticScoresFrom(deps, queryText, candidateIds, embeddings) {
+    const queryEmbedding = await embedMemoryText(deps, queryText);
+    if (queryEmbedding === null)
+        return undefined;
+    const scores = new Map();
+    for (const id of candidateIds) {
+        const stored = embeddings.get(id);
+        if (stored === undefined)
+            continue;
+        scores.set(id, cosineSimilarity(queryEmbedding.vector, stored.vector));
+    }
+    return scores;
+}
+// Signal-fusion mode for the conversation retrieval surfaces (#204, O-F2). Opt-in via env to keep
+// the release on the byte-identical weighted-sum default; set KEIKO_MEMORY_FUSION=rrf to enable
+// rank-based Reciprocal Rank Fusion across both the chat and BFF paths.
+export function conversationFusionMode(deps) {
+    return deps.env.KEIKO_MEMORY_FUSION === "rrf" ? "rrf" : "weighted-sum";
+}
+export async function buildConversationRetrievalSignals(deps, vault, queryText, scopes, nowMs, safeForSecondaryModel) {
+    const strengthById = buildStrengthById(vault.getAccessStats(), nowMs);
+    const candidateIds = gatherCandidateIds(vault, scopes, nowMs);
+    const embeddings = candidateIds.length > 0
+        ? vault.getEmbeddings(candidateIds)
+        : new Map();
+    const embeddingById = new Map();
+    for (const [id, row] of embeddings)
+        embeddingById.set(id, row.vector);
+    const semanticById = safeForSecondaryModel && queryText !== undefined && queryText.length > 0 && embeddings.size > 0
+        ? await semanticScoresFrom(deps, queryText, candidateIds, embeddings)
+        : undefined;
+    return {
+        strengthById,
+        embeddingById,
+        ...(semanticById !== undefined ? { semanticById } : {}),
+    };
+}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-salience.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-salience.d.ts","sourceRoot":"","sources":["../src/memory-salience.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAU3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kCAAkC,CAAC;AAqH1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAID,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC,CA2ClD"}
+{"version":3,"file":"memory-salience.d.ts","sourceRoot":"","sources":["../src/memory-salience.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAU3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kCAAkC,CAAC;AA0H1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAID,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC,CA2ClD"}