@oscharko-dev/keiko 0.2.0-beta.7 → 0.2.0-beta.9

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

@@ -19,6 +19,32 @@ import { graphProximityScore } from "./graph.js";
 import { recencyScore } from "./recency.js";
 import { lexicalRelevance } from "./relevance.js";
 const DEFAULT_GRAPH_HIGH_RANK_COUNT = 8;
+// Internal invariant guard. The subscore / rank maps below are built with exactly one entry per
+// memory in `memories`, so a lookup keyed by a memory from that same list is always present. This
+// makes the invariant explicit instead of asserting it away with `!` — a miss is a programmer error,
+// not a recoverable input, so it fails loud rather than silently scoring against a wrong value.
+function requireEntry(map, key) {
+    const value = map.get(key);
+    if (value === undefined) {
+        throw new Error("ranking invariant violated: missing map entry for a known memory");
+    }
+    return value;
+}
+// Frozen source-authority importance (#204, O-F5). A deterministic function of the immutable capture
+// provenance: a fact the user stated outright outranks one passively inferred by the system, at equal
+// relevance. Reproducible and caller-input-free.
+const SOURCE_IMPORTANCE = {
+    "explicit-user-instruction": 1,
+    "accepted-correction": 0.85,
+    "workflow-outcome": 0.6,
+    consolidation: 0.5,
+    "system-default": 0.4,
+};
+export function sourceImportance(record) {
+    // SOURCE_IMPORTANCE is total over MemorySourceKind, so a new source kind in contracts surfaces here
+    // as a compile error rather than silently defaulting.
+    return SOURCE_IMPORTANCE[record.provenance.sourceKind];
+}
 function baselineSubscores(record, query) {
     return {
         relevance: lexicalRelevance(query.queryText, record),
@@ -30,6 +56,8 @@ function baselineSubscores(record, query) {
             : 0,
         graph: 0,
         semantic: query.semanticById?.get(record.id) ?? 0,
+        strength: query.strengthById?.get(record.id) ?? 0,
+        importance: sourceImportance(record),
     };
 }
 function weightedScore(s, w) {
@@ -39,8 +67,18 @@ function weightedScore(s, w) {
         s.pinned * w.pinned +
         s.correction * w.correction +
         s.graph * w.graph +
-        s.semantic * w.semantic;
-    const totalWeight = w.relevance + w.recency + w.confidence + w.pinned + w.correction + w.graph + w.semantic;
+        s.semantic * w.semantic +
+        s.strength * w.strength +
+        s.importance * w.importance;
+    const totalWeight = w.relevance +
+        w.recency +
+        w.confidence +
+        w.pinned +
+        w.correction +
+        w.graph +
+        w.semantic +
+        w.strength +
+        w.importance;
     if (totalWeight <= 0)
         return 0;
     return raw / totalWeight;
@@ -52,9 +90,13 @@ function topContributor(s, w) {
         // Semantic before relevance/recency/confidence so the stronger embedding signal wins a tie
         // against the lexical signals; pinned/correction stay above it as today.
         { key: "semantic", value: s.semantic * w.semantic },
+        // Reinforcement sits just below semantic: a heavily-reused memory wins a tie against the lexical
+        // signals but not against an explicit pin, a fresh correction, or a strong embedding match.
+        { key: "strength", value: s.strength * w.strength },
         { key: "relevance", value: s.relevance * w.relevance },
         { key: "recency", value: s.recency * w.recency },
         { key: "confidence", value: s.confidence * w.confidence },
+        { key: "importance", value: s.importance * w.importance },
         { key: "graph", value: s.graph * w.graph },
     ];
     let bestKey = "recency";
@@ -78,6 +120,8 @@ function inclusionReasonText(key, value) {
         correction: "recent correction overrides older facts",
         graph: "graph proximity to other top memories",
         semantic: "semantic similarity to query",
+        strength: "frequently recalled (reinforced)",
+        importance: "authoritative source",
     };
     return `top signal: ${label[key]}`;
 }
@@ -115,10 +159,97 @@ function sortByRank(entries, recordById) {
 // every score, reason, and ordering is identical to the pre-semantic lexical ranker. Only when
 // `semanticById` is present does the configured semantic weight participate.
 function effectiveWeights(query) {
+    // Each optional signal zeroes its own weight when the caller supplied no scores for it, so the
+    // weighted sum AND its denominator are untouched and the output is byte-identical to the behaviour
+    // before that signal existed. The two conditions are independent.
+    let weights = query.weights;
     if (query.semanticById === undefined) {
-        return { ...query.weights, semantic: 0 };
+        weights = { ...weights, semantic: 0 };
+    }
+    if (query.strengthById === undefined) {
+        weights = { ...weights, strength: 0 };
+    }
+    return weights;
+}
+// Reciprocal Rank Fusion constant (Cormack et al. 2009). 60 is the field-standard k; larger flattens
+// the rank advantage, smaller sharpens it.
+export const RRF_K = 60;
+const SUBSCORE_KEYS = [
+    "relevance",
+    "recency",
+    "confidence",
+    "pinned",
+    "correction",
+    "graph",
+    "semantic",
+    "strength",
+    "importance",
+];
+// Final subscores per memory: baseline + (when edges are supplied) the graph layer. The graph
+// high-rank set is the WEIGHTED-SUM baseline top-N, so graph proximity is computed identically
+// regardless of the final fusion mode (and the weighted-sum path stays byte-identical to before).
+function computeFinalSubscores(memories, query, weights, options, recordById) {
+    const map = new Map();
+    for (const m of memories)
+        map.set(m.id, baselineSubscores(m, query));
+    if (options.edgesByMemory === undefined)
+        return map;
+    const baselineSorted = sortByRank(memories.map((m) => entryFor(m, requireEntry(map, m.id), weights)), recordById);
+    const highRankCount = options.graphHighRankCount ?? DEFAULT_GRAPH_HIGH_RANK_COUNT;
+    const highRankIds = new Set(baselineSorted.slice(0, highRankCount).map((e) => e.memoryId));
+    const edges = options.edgesByMemory;
+    for (const m of memories) {
+        const base = requireEntry(map, m.id);
+        map.set(m.id, { ...base, graph: graphProximityScore(m.id, edges, highRankIds) });
     }
-    return query.weights;
+    return map;
+}
+// Reciprocal Rank Fusion (#204, O-F2): for each positive-weight signal, rank the memories by that
+// subscore (desc, id tiebreak) and fuse score = Σ w/(RRF_K + rank). Rank-based, so heterogeneous
+// score scales (Jaccard ~[0,0.3] vs cosine [0,1]) need no normalization, and agreement across signals
+// compounds. The fused value is normalized to [0,1] (best possible = rank 1 in every signal) to
+// honour the documented score range; ordering uses the shared (score desc, updatedAt desc, id asc) sort.
+function rrfRank(memories, subscoresById, weights, recordById) {
+    const signals = SUBSCORE_KEYS.filter((k) => weights[k] > 0);
+    const firstSignal = signals[0];
+    if (firstSignal === undefined) {
+        return sortByRank(memories.map((m) => entryFor(m, requireEntry(subscoresById, m.id), weights)), recordById);
+    }
+    const rankBySignal = new Map();
+    for (const sig of signals) {
+        const ordered = [...memories].sort((a, b) => {
+            const av = requireEntry(subscoresById, a.id)[sig];
+            const bv = requireEntry(subscoresById, b.id)[sig];
+            if (av !== bv)
+                return bv - av;
+            return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+        });
+        const ranks = new Map();
+        ordered.forEach((m, i) => ranks.set(m.id, i + 1));
+        rankBySignal.set(sig, ranks);
+    }
+    const maxFused = signals.reduce((sum, sig) => sum + weights[sig] / (RRF_K + 1), 0);
+    const entries = memories.map((m) => {
+        let fused = 0;
+        let bestSig = firstSignal;
+        let bestContrib = -1;
+        for (const sig of signals) {
+            const rank = requireEntry(requireEntry(rankBySignal, sig), m.id);
+            const contrib = weights[sig] / (RRF_K + rank);
+            fused += contrib;
+            if (contrib > bestContrib) {
+                bestContrib = contrib;
+                bestSig = sig;
+            }
+        }
+        return {
+            memoryId: m.id,
+            score: maxFused > 0 ? fused / maxFused : 0,
+            subscores: requireEntry(subscoresById, m.id),
+            inclusionReason: inclusionReasonText(bestSig, bestContrib),
+        };
+    });
+    return sortByRank(entries, recordById);
 }
 export function rankMemories(memories, query, options = {}) {
     if (memories.length === 0)
@@ -127,21 +258,9 @@ export function rankMemories(memories, query, options = {}) {
     for (const m of memories)
         recordById.set(m.id, m);
     const weights = effectiveWeights(query);
-    // Pass 1 — baseline.
-    const baseline = memories.map((m) => entryFor(m, baselineSubscores(m, query), weights));
-    const baselineSorted = sortByRank(baseline, recordById);
-    // No edges supplied → skip pass 2 entirely (cost saving + identical result).
-    if (options.edgesByMemory === undefined)
-        return baselineSorted;
-    // Pass 2 — graph layer.
-    const highRankCount = options.graphHighRankCount ?? DEFAULT_GRAPH_HIGH_RANK_COUNT;
-    const highRankIds = new Set(baselineSorted.slice(0, highRankCount).map((e) => e.memoryId));
-    const edges = options.edgesByMemory;
-    const layered = memories.map((m) => {
-        const base = baselineSubscores(m, query);
-        const graph = graphProximityScore(m.id, edges, highRankIds);
-        const subscores = { ...base, graph };
-        return entryFor(m, subscores, weights);
-    });
-    return sortByRank(layered, recordById);
+    const subscoresById = computeFinalSubscores(memories, query, weights, options, recordById);
+    if (query.fusion === "rrf") {
+        return rrfRank(memories, subscoresById, weights, recordById);
+    }
+    return sortByRank(memories.map((m) => entryFor(m, requireEntry(subscoresById, m.id), weights)), recordById);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"recency.d.ts","sourceRoot":"","sources":["../src/recency.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,oBAAoB,QAAiB,CAAC;AAGnD,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOrE"}
+{"version":3,"file":"recency.d.ts","sourceRoot":"","sources":["../src/recency.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,oBAAoB,QAAiB,CAAC;AAEnD,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIrE"}

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

@@ -7,17 +7,11 @@
 // runs the previous week; consolidation (#208) will collapse older records into semantic
 // facts whose recency continues to refresh on every update. The constant is exported so
 // callers (e.g. an audit dashboard) can reproduce the score deterministically.
+import { exponentialDecay } from "./decay.js";
 const MS_PER_DAY = 86_400_000;
 export const RECENCY_HALF_LIFE_MS = 7 * MS_PER_DAY;
-const LN_2 = Math.LN2;
 export function recencyScore(updatedAt, nowMs) {
-    const ageMs = nowMs - updatedAt;
-    if (ageMs <= 0)
-        return 1;
-    const decay = Math.exp(-(LN_2 * ageMs) / RECENCY_HALF_LIFE_MS);
-    if (decay < 0)
-        return 0;
-    if (decay > 1)
-        return 1;
-    return decay;
+    // Edit-recency: decays since the record was last UPDATED. (Reuse-recency, which decays since last
+    // ACCESS at a different half-life, lives in strength.ts — both share the kernel in decay.ts.)
+    return exponentialDecay(nowMs - updatedAt, RECENCY_HALF_LIFE_MS);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"retrieve.d.ts","sourceRoot":"","sources":["../src/retrieve.ts"],"names":[],"mappings":"AAmCA,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAG3B,MAAM,YAAY,CAAC;AAwPpB,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,eAAe,GACpB,qBAAqB,CA8BvB"}
+{"version":3,"file":"retrieve.d.ts","sourceRoot":"","sources":["../src/retrieve.ts"],"names":[],"mappings":"AAoCA,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAG3B,MAAM,YAAY,CAAC;AA0PpB,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,eAAe,GACpB,qBAAqB,CA0CvB"}

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

@@ -21,6 +21,7 @@
 // responses + identical request -> identical output. The cross-scope isolation test pins
 // this with a spy port that records every listByScope call.
 import { assembleContextBlock } from "./context.js";
+import { DEFAULT_MMR_LAMBDA, reorderByMmr } from "./diversity.js";
 import { RetrievalError } from "./errors.js";
 import { tokenize } from "./relevance.js";
 import { rankMemories } from "./ranking.js";
@@ -50,6 +51,8 @@ function resolveWeights(request) {
         correction: request.correctionBoost ?? DEFAULT_RANKING_WEIGHTS.correction,
         graph: request.graphProximityBoost ?? DEFAULT_RANKING_WEIGHTS.graph,
         semantic: request.semanticWeight ?? DEFAULT_RANKING_WEIGHTS.semantic,
+        strength: request.strengthWeight ?? DEFAULT_RANKING_WEIGHTS.strength,
+        importance: request.importanceWeight ?? DEFAULT_RANKING_WEIGHTS.importance,
     };
 }
 function assertNonNegativeWeights(weights) {
@@ -231,10 +234,17 @@ export function retrieveMemoryContext(request, port) {
         weights: resolved.weights,
         ...(request.queryText === undefined ? {} : { queryText: request.queryText }),
         ...(request.semanticById === undefined ? {} : { semanticById: request.semanticById }),
+        ...(request.strengthById === undefined ? {} : { strengthById: request.strengthById }),
+        ...(request.fusion === undefined ? {} : { fusion: request.fusion }),
     };
     const ranked = rankMemories(filtered.candidates, rankQuery, edgesByMemory === undefined ? {} : { edgesByMemory });
     const thresholded = applyRelevanceFloor(ranked, request);
-    const assembled = assembleContextBlock(thresholded.ranked, filtered.candidates, {
+    // MMR diversity (#204, O-F3): re-order the ranked candidates so near-duplicates do not all consume
+    // the token budget. Inert (byte-identical greedy-by-rank) when the caller supplies no embeddings.
+    const selectionOrder = request.embeddingById === undefined
+        ? thresholded.ranked
+        : reorderByMmr(thresholded.ranked, request.embeddingById, request.mmrLambda ?? DEFAULT_MMR_LAMBDA);
+    const assembled = assembleContextBlock(selectionOrder, filtered.candidates, {
         budgetTokens: resolved.budgetTokens,
         maxIncluded: resolved.maxIncluded,
     });

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

@@ -0,0 +1,9 @@
+export declare const STRENGTH_HALF_LIFE_MS: number;
+export declare const STRENGTH_FREQUENCY_SATURATION = 8;
+export interface MemoryAccessStat {
+    readonly accessCount: number;
+    readonly lastAccessedAt: number;
+}
+export declare function reinforcementStrength(stat: MemoryAccessStat | undefined, nowMs: number): number;
+export declare function buildStrengthById<K>(statsById: ReadonlyMap<K, MemoryAccessStat>, nowMs: number): ReadonlyMap<K, number>;
+//# sourceMappingURL=strength.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strength.d.ts","sourceRoot":"","sources":["../src/strength.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,qBAAqB,QAAkB,CAAC;AAKrD,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAI/C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAGD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAW/F;AAID,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,SAAS,EAAE,WAAW,CAAC,CAAC,EAAE,gBAAgB,CAAC,EAC3C,KAAK,EAAE,MAAM,GACZ,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,CAOxB"}

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

@@ -0,0 +1,51 @@
+// Reinforcement-strength primitive (#204 plasticity). Turns a memory's access history — how OFTEN
+// and how RECENTLY it has been recalled — into a [0,1] re-ranking signal so a frequently-reused
+// memory is surfaced ahead of a never-touched one. This realises the core plasticity promise ("a
+// memory gets stronger when reused") at retrieval time; the maintenance pass already strengthens on
+// a slower cadence, but ranking is where reuse must change what the user actually sees.
+//
+// Cognitive basis (ACT-R base-level activation, simplified): activation rises with practice
+// frequency and decays with disuse. Two bounded, deterministic factors, multiplied:
+//   accessRecency = exp(-ln2 * (now - lastAccessedAt) / HALF_LIFE)   disuse decay, 45-day half-life
+//   frequency     = 1 - exp(-accessCount / SATURATION)              saturating practice gain
+// A NEVER-accessed memory scores 0 (no reinforcement yet) so this subscore only ever ADDS signal for
+// genuine reuse and never perturbs a fresh memory's existing relevance/recency/confidence ranking.
+//
+// Pure: no clock (now is passed in), no IO, no randomness. Same inputs => same output, so the
+// retrieval layer stays replay-stable and the deterministic eval can pin it.
+import { exponentialDecay } from "./decay.js";
+const MS_PER_DAY = 86_400_000;
+// Disuse half-life. Matches the maintenance strength curve (keiko-memory-governance maintenance.ts)
+// so "recency of use" decays at one consistent rate across ranking and the decay/forget cycle.
+export const STRENGTH_HALF_LIFE_MS = 45 * MS_PER_DAY;
+// Access count at which the frequency factor reaches ~0.63 of its ceiling. Logarithmic-feeling
+// saturation: 1 recall ≈ 0.12, 8 ≈ 0.63, 24 ≈ 0.95 — heavy reuse keeps mattering with diminishing
+// returns, matching the practice-curve intuition without an unbounded count term.
+export const STRENGTH_FREQUENCY_SATURATION = 8;
+// Reinforcement strength in [0,1]. `undefined` stat (memory never accessed) => 0.
+export function reinforcementStrength(stat, nowMs) {
+    if (stat === undefined)
+        return 0;
+    // Reuse-recency: decays since last ACCESS (future-dated clamps to full recency). Shares the kernel
+    // in decay.ts with edit-recency (recency.ts), which decays since last UPDATE at a different half-life.
+    const accessRecency = exponentialDecay(nowMs - stat.lastAccessedAt, STRENGTH_HALF_LIFE_MS);
+    const count = stat.accessCount > 0 ? stat.accessCount : 0;
+    const frequency = 1 - Math.exp(-count / STRENGTH_FREQUENCY_SATURATION);
+    const strength = frequency * accessRecency;
+    if (strength < 0)
+        return 0;
+    if (strength > 1)
+        return 1;
+    return strength;
+}
+// Convenience: build the per-memory strength map the ranker consumes from a map of access stats.
+// Lives here (next to the formula) so callers cannot drift from the canonical computation.
+export function buildStrengthById(statsById, nowMs) {
+    const out = new Map();
+    for (const [id, stat] of statsById) {
+        const strength = reinforcementStrength(stat, nowMs);
+        if (strength > 0)
+            out.set(id, strength);
+    }
+    return out;
+}

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

@@ -21,12 +21,15 @@ export interface RankingWeights {
     readonly correction: number;
     readonly graph: number;
     readonly semantic: number;
+    readonly strength: number;
+    readonly importance: number;
 }
 export declare const DEFAULT_RANKING_WEIGHTS: RankingWeights;
 export declare const DEFAULT_BUDGET_TOKENS = 1500;
 export declare const DEFAULT_MAX_INCLUDED = 12;
 export declare const DEFAULT_STALE_CONFIDENCE_THRESHOLD = 0.3;
 export declare const DEFAULT_LIST_BY_SCOPE_MAX_RESULTS = 500;
+export type RankingFusionMode = "weighted-sum" | "rrf";
 export interface MemoryRetrievalRequest {
     readonly scopes: readonly MemoryScope[];
     readonly queryText?: string;
@@ -45,6 +48,12 @@ export interface MemoryRetrievalRequest {
     /** Audit/debug opt-in. Active context retrieval suppresses superseded memories by default. */
     readonly includeSuperseded?: boolean;
     readonly semanticById?: ReadonlyMap<MemoryId, number>;
+    readonly strengthById?: ReadonlyMap<MemoryId, number>;
+    readonly strengthWeight?: number;
+    readonly importanceWeight?: number;
+    readonly embeddingById?: ReadonlyMap<MemoryId, Float32Array>;
+    readonly mmrLambda?: number;
+    readonly fusion?: RankingFusionMode;
 }
 export interface MemoryContextBlockEntry {
     readonly memoryId: MemoryId;
@@ -71,6 +80,8 @@ export interface IncludedSubscores {
     readonly correction: number;
     readonly graph: number;
     readonly semantic: number;
+    readonly strength: number;
+    readonly importance: number;
 }
 export interface IncludedMemory {
     readonly memoryId: MemoryId;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

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

@@ -26,6 +26,13 @@ export const DEFAULT_RANKING_WEIGHTS = Object.freeze({
     correction: 0.1,
     graph: 0.15,
     semantic: 0.25,
+    // Reinforcement weight (#204). Sits between recency and semantic: reuse is a strong signal but must
+    // not override an explicit pin or a fresh correction. Only participates when the caller supplies
+    // per-memory strength scores; otherwise the ranker forces it to 0 (byte-identical legacy behaviour).
+    strength: 0.2,
+    // Source-authority importance weight (#204, O-F5). Default 0 (opt-in): always computed but inert
+    // until an operator sets a non-zero weight, so legacy ranking is byte-identical.
+    importance: 0,
 });
 export const DEFAULT_BUDGET_TOKENS = 1500;
 export const DEFAULT_MAX_INCLUDED = 12;

package/node_modules/@oscharko-dev/keiko-memory-retrieval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oscharko-dev/keiko-memory-retrieval",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.9",
   "private": true,
   "type": "module",
   "license": "Apache-2.0",