@vellumai/assistant 0.7.1 → 0.7.3

package/src/memory/v2/activation.ts

@@ -2,12 +2,15 @@
 // Memory v2 — Per-turn activation update
 // ---------------------------------------------------------------------------
 //
-// Implements the activation formula from §4 of the design doc:
+// Implements the activation formula from §4 of the design doc plus an
+// additive cross-encoder rerank boost on the unified top-K-by-A_o pool:
 //
 //   A_o(n, t+1) = d · A(n, t)
 //               + c_user      · sim(User_{t+1},  n)
 //               + c_assistant · sim(Assistant_t, n)
 //               + c_now       · sim(NOW.md,      n)
+//               + c_user      · α · r_norm(User_{t+1},  n)   [n ∈ topK]
+//               + c_assistant · α · r_norm(Assistant_t, n)   [n ∈ topK]
 //
 //   A(n, t+1) = [ A_o(n)
 //               + k  · Σ_{m∈in1(n)} A_o(m)
@@ -32,6 +35,7 @@
 //     for the next turn and drop below `epsilon` if no longer relevant.
 
 import type { AssistantConfig } from "../../config/types.js";
+import { applyCorrectionIfCalibrated } from "../anisotropy.js";
 import {
   embedWithBackend,
   generateSparseEmbedding,
@@ -39,23 +43,31 @@ import {
 import { clampUnitInterval } from "../validation.js";
 import type { EdgeIndex } from "./edge-index.js";
 import { hybridQueryConceptPages } from "./qdrant.js";
-import { simBatch, simSkillBatch } from "./sim.js";
-import { hybridQuerySkills } from "./skill-qdrant.js";
+import { rerankCandidates } from "./reranker.js";
+import { simBatch } from "./sim.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
 /**
- * Top-K size for the un-restricted ANN candidate query against the v2
- * concept-page collection. The design doc fixes this at 50 — small enough to
- * keep the per-turn round-trip cheap, large enough to surface relevant pages
- * outside the prior active set.
+ * Sentinel passed to Qdrant when `config.memory.v2.ann_candidate_limit` is
+ * `null` (unlimited). Qdrant's query API requires an explicit numeric
+ * `limit`, so unlimited is represented as a number large enough that any
+ * realistic concept-page collection is returned in full.
+ *
+ * Why not `Number.MAX_SAFE_INTEGER`: Qdrant's sparse-vector `SearchContext`
+ * pre-allocates `limit * 16` bytes per query, so passing `MAX_SAFE_INTEGER`
+ * triggers a ~144 PB allocation and SIGABRTs the Qdrant process. 1_000_000
+ * is ~16 MB of pre-allocation in Qdrant — generous headroom over realistic
+ * concept-page counts (low thousands today) while staying well clear of
+ * the OOM cliff. Bump explicitly via `ann_candidate_limit` if you ever
+ * outgrow it.
  */
-const ANN_CANDIDATE_LIMIT = 50;
+const UNLIMITED_ANN_CANDIDATE_LIMIT = 1_000_000;
 
 // ---------------------------------------------------------------------------
 // Candidate selection
 // ---------------------------------------------------------------------------
 
-export interface SelectCandidatesParams {
+interface SelectCandidatesParams {
   /**
    * Prior-turn activation snapshot. Slugs with activation strictly greater
    * than `config.memory.v2.epsilon` are carried forward as candidates so the
@@ -69,9 +81,10 @@ export interface SelectCandidatesParams {
   /** NOW context string (essentials/threads/recent or NOW.md). */
   nowText: string;
   config: AssistantConfig;
+  signal?: AbortSignal;
 }
 
-export interface SelectCandidatesResult {
+interface SelectCandidatesResult {
   /** Union of `fromPrior` and `fromAnn` — the per-turn candidate set. */
   candidates: Set<string>;
   /** Slugs carried forward from `priorState` because their activation > epsilon. */
@@ -96,7 +109,8 @@ export interface SelectCandidatesResult {
 export async function selectCandidates(
   params: SelectCandidatesParams,
 ): Promise<SelectCandidatesResult> {
-  const { priorState, userText, assistantText, nowText, config } = params;
+  const { priorState, userText, assistantText, nowText, config, signal } =
+    params;
 
   const fromPrior = new Set<string>();
   const fromAnn = new Set<string>();
@@ -117,14 +131,20 @@ export async function selectCandidates(
     .join("\n");
 
   if (annQueryText.length > 0) {
-    const denseResult = await embedWithBackend(config, [annQueryText]);
-    const dense = denseResult.vectors[0];
-    const sparse = generateSparseEmbedding(annQueryText);
-    const hits = await hybridQueryConceptPages(
-      dense,
-      sparse,
-      ANN_CANDIDATE_LIMIT,
+    throwIfAborted(signal);
+    const denseResult = await embedWithBackend(config, [annQueryText], {
+      signal,
+    });
+    const dense = await applyCorrectionIfCalibrated(
+      denseResult.vectors[0],
+      denseResult.provider,
+      denseResult.model,
     );
+    throwIfAborted(signal);
+    const sparse = generateSparseEmbedding(annQueryText);
+    const limit =
+      config.memory.v2.ann_candidate_limit ?? UNLIMITED_ANN_CANDIDATE_LIMIT;
+    const hits = await hybridQueryConceptPages(dense, sparse, limit);
     for (const hit of hits) fromAnn.add(hit.slug);
   }
 
@@ -137,13 +157,14 @@ export async function selectCandidates(
 // Own activation
 // ---------------------------------------------------------------------------
 
-export interface ComputeOwnActivationParams {
+interface ComputeOwnActivationParams {
   candidates: ReadonlySet<string>;
   priorState: ActivationState | null;
   userText: string;
   assistantText: string;
   nowText: string;
   config: AssistantConfig;
+  signal?: AbortSignal;
 }
 
 /**
@@ -151,18 +172,24 @@ export interface ComputeOwnActivationParams {
  * coefficient weighting is applied. Surfaced for telemetry / inspector views
  * so the UI can show how each term contributed to the final value.
  */
-export interface OwnActivationBreakdown {
+interface OwnActivationBreakdown {
   /** `d * prev(slug)` — the decayed prior-turn activation contribution. */
   priorContribution: number;
-  /** Raw `sim(user, slug)` similarity, before `c_user` weighting. */
+  /** Raw fused `sim(user, slug)`, before `c_user` weighting. */
   simUser: number;
-  /** Raw `sim(assistant, slug)` similarity, before `c_assistant` weighting. */
+  /** Raw fused `sim(assistant, slug)`, before `c_assistant` weighting. */
   simAssistant: number;
-  /** Raw `sim(now, slug)` similarity, before `c_now` weighting. */
+  /** Raw fused `sim(now, slug)`, before `c_now` weighting. */
   simNow: number;
+  /** Rerank delta `α · r_norm_u`; 0 outside the top-K pool. Applied to `A_o` weighted by `c_user`. */
+  simUserRerankBoost: number;
+  /** Rerank delta `α · r_norm_a`; 0 outside the top-K pool. Applied to `A_o` weighted by `c_assistant`. NOW skips rerank. */
+  simAssistantRerankBoost: number;
+  /** True when this slug was in the unified top-K rerank pool. Lets the inspector distinguish "cross-encoder normalised to 0" from "rerank skipped this slug." */
+  inRerankPool: boolean;
 }
 
-export interface ComputeOwnActivationResult {
+interface ComputeOwnActivationResult {
   /** Final clamped own-activation value per slug. */
   activation: Map<string, number>;
   /** Per-slug breakdown of the inputs that fed into `activation`. */
@@ -171,21 +198,34 @@ export interface ComputeOwnActivationResult {
 
 /**
  * Apply the own-activation formula
- *   A_o(n) = d · prev(n) + c_user · sim_u + c_assistant · sim_a + c_now · sim_n
- * over the candidate set. Returns a sparse map keyed by slug; slugs whose
- * computed value rounds to 0 are still included so callers can see the
- * candidate set explicitly. Also returns a per-slug breakdown of the raw
- * inputs (decayed prior + raw sims) so callers can render contribution
- * diagnostics without re-running the math.
+ *   A_o(n) = d · prev(n)
+ *          + c_user · sim_u + c_assistant · sim_a + c_now · sim_n
+ *          + c_user · α · r_norm_u + c_assistant · α · r_norm_a
+ * over the candidate set, where the rerank terms only fire for slugs that
+ * land in the unified top-K-by-pre-rerank-A_o window. Returns a sparse map
+ * keyed by slug; slugs whose computed value rounds to 0 are still included
+ * so callers can see the candidate set explicitly. Also returns a per-slug
+ * breakdown of the raw inputs (decayed prior + raw sims + rerank deltas) so
+ * callers can render contribution diagnostics without re-running the math.
  *
  * The three `simBatch` calls run concurrently — they hit independent named
- * vectors and embed independent query texts.
+ * vectors and embed independent query texts. Cross-encoder rerank then runs
+ * once on the unified top-K (selected by pre-rerank A_o, not per-channel
+ * fused sim) so an entry strong in both channels can't double-boost itself
+ * past entries that only land in one channel.
  */
 export async function computeOwnActivation(
   params: ComputeOwnActivationParams,
 ): Promise<ComputeOwnActivationResult> {
-  const { candidates, priorState, userText, assistantText, nowText, config } =
-    params;
+  const {
+    candidates,
+    priorState,
+    userText,
+    assistantText,
+    nowText,
+    config,
+    signal,
+  } = params;
 
   const activation = new Map<string, number>();
   const breakdown = new Map<string, OwnActivationBreakdown>();
@@ -194,35 +234,127 @@ export async function computeOwnActivation(
   const { d, c_user, c_assistant, c_now } = config.memory.v2;
   const slugList = [...candidates];
 
+  // NOW context is structured (timestamps, current focus) — outside the
+  // cross-encoder's training distribution, so it never participates in rerank.
   const [simUser, simAssistant, simNow] = await Promise.all([
-    simBatch(userText, slugList, config),
-    simBatch(assistantText, slugList, config),
-    simBatch(nowText, slugList, config),
+    simBatch(userText, slugList, config, { signal }),
+    simBatch(assistantText, slugList, config, { signal }),
+    simBatch(nowText, slugList, config, { signal }),
   ]);
 
-  for (const slug of slugList) {
+  interface SlugInputs {
+    slug: string;
+    priorContribution: number;
+    simU: number;
+    simA: number;
+    simN: number;
+    /** Pre-rerank A_o; ranking signal for the unified rerank pool. */
+    preRerank: number;
+  }
+  const inputs: SlugInputs[] = slugList.map((slug) => {
     const prev = priorState?.state[slug] ?? 0;
     const simU = simUser.get(slug) ?? 0;
     const simA = simAssistant.get(slug) ?? 0;
     const simN = simNow.get(slug) ?? 0;
-    const value = d * prev + c_user * simU + c_assistant * simA + c_now * simN;
-    activation.set(slug, clampUnitInterval(value));
-    breakdown.set(slug, {
-      priorContribution: d * prev,
-      simUser: simU,
-      simAssistant: simA,
-      simNow: simN,
+    const priorContribution = d * prev;
+    return {
+      slug,
+      priorContribution,
+      simU,
+      simA,
+      simN,
+      preRerank:
+        priorContribution + c_user * simU + c_assistant * simA + c_now * simN,
+    };
+  });
+
+  // Unified top-K by pre-rerank A_o. Both channels rerank against the **same**
+  // slug set, so a slug strong on user can't crowd out one strong on assistant
+  // by virtue of appearing in both per-channel top-Ks. Both channel queries
+  // ride in a single `rerankCandidates` call so the worker tokenizes and
+  // forward-passes them together — half the per-call overhead of two
+  // serialised round-trips.
+  let userRerankBoost: ReadonlyMap<string, number> = new Map();
+  let assistantRerankBoost: ReadonlyMap<string, number> = new Map();
+  let inPoolSet: ReadonlySet<string> = new Set();
+  const rerankCfg = config.memory.v2.rerank;
+  if (rerankCfg?.enabled) {
+    throwIfAborted(signal);
+    const topSlugs = inputs
+      .slice()
+      .sort((a, b) => b.preRerank - a.preRerank)
+      .slice(0, rerankCfg.top_k)
+      .map((e) => e.slug);
+    if (topSlugs.length > 0) {
+      inPoolSet = new Set(topSlugs);
+      const [userScores, assistantScores] = await rerankCandidates(
+        [userText, assistantText],
+        topSlugs,
+        config,
+      );
+      throwIfAborted(signal);
+      userRerankBoost = normalizeRerankScores(userScores, rerankCfg.alpha);
+      assistantRerankBoost = normalizeRerankScores(
+        assistantScores,
+        rerankCfg.alpha,
+      );
+    }
+  }
+
+  for (const e of inputs) {
+    const boostU = userRerankBoost.get(e.slug) ?? 0;
+    const boostA = assistantRerankBoost.get(e.slug) ?? 0;
+    activation.set(
+      e.slug,
+      clampUnitInterval(e.preRerank + c_user * boostU + c_assistant * boostA),
+    );
+    breakdown.set(e.slug, {
+      priorContribution: e.priorContribution,
+      simUser: e.simU,
+      simAssistant: e.simA,
+      simNow: e.simN,
+      simUserRerankBoost: boostU,
+      simAssistantRerankBoost: boostA,
+      inRerankPool: inPoolSet.has(e.slug),
     });
   }
 
   return { activation, breakdown };
 }
 
+/**
+ * Per-batch normalisation: divide raw cross-encoder scores by the channel's
+ * own max and return `alpha · r_norm` per slug. Empty input or all-zero
+ * scores yield an empty Map so the channel contributes 0 boost.
+ */
+function normalizeRerankScores(
+  rawScores: ReadonlyMap<string, number>,
+  alpha: number,
+): Map<string, number> {
+  const out = new Map<string, number>();
+  if (rawScores.size === 0) return out;
+  let maxScore = 0;
+  for (const v of rawScores.values()) {
+    if (v > maxScore) maxScore = v;
+  }
+  if (maxScore === 0) return out;
+  for (const [slug, raw] of rawScores) {
+    out.set(slug, alpha * (raw / maxScore));
+  }
+  return out;
+}
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Spreading activation
 // ---------------------------------------------------------------------------
 
-export interface SpreadActivationResult {
+interface SpreadActivationResult {
   /** Final activation value per slug after spreading. */
   final: Map<string, number>;
   /**
@@ -239,20 +371,25 @@ export interface SpreadActivationResult {
  * Apply 2-hop spreading activation with neighborhood normalization. Edges are
  * directed: an edge A→B means A's activation contributes to B's final value.
  *
- *   A(n) = [ A_o(n) + k · Σ_{m∈in1(n)} A_o(m) + k² · Σ_{m∈in2(n)} A_o(m) ]
- *        / (1 + k · #in1(n) + k² · #in2(n))
+ *   A(n) = [ A_o(n) + Σ_{r: |active_inR(n)| > 0} k^r · L2(active_inR(n)) ]
+ *        / [ 1     + Σ_{r: |active_inR(n)| > 0} k^r ]
+ *
+ * `active_inR(n)` is the subset of structural predecessors at hop `r` that
+ * also appear in `ownActivation` (i.e. made the candidate set). `L2(.)` is
+ * the quadratic mean √(mean(A_o²)) — a mild bias toward strong outliers
+ * compared to the arithmetic mean, without letting a single high-cosine
+ * predecessor dominate the way `max` would.
  *
- * For each candidate slug `n`, BFS walks `incoming` adjacency to gather
- * predecessors at distance 1, 2 (i.e. nodes from which a directed path of
- * that length leads into `n`). The denominator counts those structural
- * predecessors at each hop (whether or not they appear in `ownActivation`)
- * so a pure source — no incoming edges — collapses to `A == A_o`. Missing
- * predecessors contribute 0 to the numerator.
+ * Hops with **no** active predecessors are dropped from BOTH numerator and
+ * denominator so a high-in-degree hub with mostly-inactive neighbors stays
+ * near `A_o` instead of being crushed by the structural count. A pure
+ * source (no incoming edges, or every edge points at a non-candidate)
+ * collapses to `A == A_o`.
  *
- * Bounded in [0, 1]: with `A_o ∈ [0, 1]` and `k ∈ [0, 1]`, the numerator is
- * at most `1 + k · #in1 + k² · #in2` — exactly the denominator — so the
- * ratio is at most 1. `clampUnitInterval` guards against numerical drift
- * and out-of-range inputs.
+ * Bounded in [0, 1]: every `L2` term ≤ max active A_o ≤ 1, so the numerator
+ * is at most `1 + Σ k^r` — exactly the denominator — so the ratio is at most
+ * 1. `clampUnitInterval` guards against numerical drift and out-of-range
+ * inputs.
  *
  * Pure function — no I/O. Reads the precomputed `incoming` map from
  * `edgeIndex` and runs a per-source BFS bounded by `hops`.
@@ -282,22 +419,28 @@ export function spreadActivation(
     // hop-0 only via `numerator = ownValue`.
     const distance = bfsPredecessorDistances(edgeIndex.incoming, slug, hops);
 
+    // Bucket only predecessors that are in `ownActivation` (the candidate
+    // set). Structural predecessors that didn't make the cut contribute
+    // nothing — neither to the numerator nor the denominator — so hub
+    // in-degree alone never penalizes a node.
+    const ringActiveCounts: number[] = new Array(hops + 1).fill(0);
+    const ringSquareSums: number[] = new Array(hops + 1).fill(0);
+    for (const [predecessor, hop] of distance) {
+      const predValue = ownActivation.get(predecessor);
+      if (predValue === undefined) continue;
+      ringActiveCounts[hop] += 1;
+      ringSquareSums[hop] += predValue * predValue;
+    }
+
     let numerator = ownValue;
     let denominator = 1;
     let kPow = 1;
-    // Accumulate per-hop contributions in a single pass. We need per-hop
-    // counts to weight by k^r, so bucket as we go.
-    const ringCounts: number[] = new Array(hops + 1).fill(0);
-    const ringSums: number[] = new Array(hops + 1).fill(0);
-    for (const [predecessor, hop] of distance) {
-      ringCounts[hop] += 1;
-      ringSums[hop] += ownActivation.get(predecessor) ?? 0;
-    }
     for (let r = 1; r <= hops; r++) {
       kPow *= k;
-      if (ringCounts[r] === 0) continue;
-      numerator += kPow * ringSums[r];
-      denominator += kPow * ringCounts[r];
+      if (ringActiveCounts[r] === 0) continue;
+      const rms = Math.sqrt(ringSquareSums[r] / ringActiveCounts[r]);
+      numerator += kPow * rms;
+      denominator += kPow;
     }
 
     const finalValue = clampUnitInterval(numerator / denominator);
@@ -347,7 +490,7 @@ function bfsPredecessorDistances(
 // Injection selection
 // ---------------------------------------------------------------------------
 
-export interface SelectInjectionsParams {
+interface SelectInjectionsParams {
   /** Final activation map after spread. */
   A: ReadonlyMap<string, number>;
   /** Slugs already attached to a prior user message (with their turn). */
@@ -356,7 +499,7 @@ export interface SelectInjectionsParams {
   topK: number;
 }
 
-export interface SelectInjectionsResult {
+interface SelectInjectionsResult {
   /** Top-K slugs by activation (descending), used for the cached top-now view. */
   topNow: string[];
   /**
@@ -390,172 +533,3 @@ export function selectInjections(
 
   return { topNow, toInject };
 }
-
-// ---------------------------------------------------------------------------
-// Skill autoinjection — candidate / activation / injection selection
-// ---------------------------------------------------------------------------
-//
-// Skills are stateless: there is no decay carry-over (`d · prev`), no
-// spreading activation, and no `everInjected` dedup. The agent re-presents
-// the top-K active skills every turn so it can drop or pick them up freely.
-// The pipeline therefore reduces to:
-//   1. ANN candidate selection against the dedicated skills collection.
-//   2. Pure similarity-only activation: A_skill = c_user·sim_u +
-//      c_assistant·sim_a + c_now·sim_n, clamped to [0, 1].
-//   3. Top-K by activation, lexicographic tie-break, no injection delta.
-//
-// The activation coefficients are reused from `config.memory.v2.{c_user,
-// c_assistant, c_now}` — the design doc (§9) deliberately shares them with
-// concept-page activation rather than introducing parallel knobs.
-
-export interface SelectSkillCandidatesParams {
-  userText: string;
-  assistantText: string;
-  nowText: string;
-  config: AssistantConfig;
-  /** Top-K size for the ANN query against `memory_v2_skills`. */
-  topK: number;
-}
-
-/**
- * ANN top-K against the skills collection using the concatenated turn text.
- * Runs a single embedding pass over `concat(user, assistant, now)` and a
- * single hybrid Qdrant query — there is no prior-state carry-forward (skills
- * are stateless).
- *
- * Returns a `Set<string>` of skill ids that hit either channel. Empty when
- * the joined text is empty or `topK <= 0`.
- */
-export async function selectSkillCandidates(
-  params: SelectSkillCandidatesParams,
-): Promise<Set<string>> {
-  const { userText, assistantText, nowText, config, topK } = params;
-
-  const candidates = new Set<string>();
-  if (topK <= 0) return candidates;
-
-  const annQueryText = [userText, assistantText, nowText]
-    .filter((s) => s.length > 0)
-    .join("\n");
-  if (annQueryText.length === 0) return candidates;
-
-  const denseResult = await embedWithBackend(config, [annQueryText]);
-  const dense = denseResult.vectors[0];
-  const sparse = generateSparseEmbedding(annQueryText);
-  const hits = await hybridQuerySkills(dense, sparse, topK);
-  for (const hit of hits) candidates.add(hit.id);
-
-  return candidates;
-}
-
-export interface ComputeSkillActivationParams {
-  candidates: ReadonlySet<string>;
-  userText: string;
-  assistantText: string;
-  nowText: string;
-  config: AssistantConfig;
-}
-
-/**
- * Per-skill breakdown of the raw similarity inputs, captured before any
- * coefficient weighting. Skills have no decay term, so the breakdown is just
- * the three raw sims. Surfaced for telemetry / inspector views.
- */
-export interface SkillActivationBreakdown {
-  /** Raw `sim(user, skill)` similarity, before `c_user` weighting. */
-  simUser: number;
-  /** Raw `sim(assistant, skill)` similarity, before `c_assistant` weighting. */
-  simAssistant: number;
-  /** Raw `sim(now, skill)` similarity, before `c_now` weighting. */
-  simNow: number;
-}
-
-export interface ComputeSkillActivationResult {
-  /** Final clamped skill-activation value per id. */
-  activation: Map<string, number>;
-  /** Per-skill breakdown of the raw sim inputs that fed into `activation`. */
-  breakdown: Map<string, SkillActivationBreakdown>;
-}
-
-/**
- * Apply the skill-side activation formula (no decay carry-over, no spread):
- *   A_skill(s) = clamp01(c_user · sim_u + c_assistant · sim_a + c_now · sim_n)
- *
- * Reuses the activation coefficients from `config.memory.v2`. The three
- * `simSkillBatch` calls run concurrently — they hit independent named
- * vectors and embed independent query texts. Returns a per-skill breakdown
- * of the raw sims alongside the activation map so callers can render
- * contribution diagnostics without re-running the math.
- *
- * Empty candidates short-circuits to an empty map without touching the
- * embedding backend or Qdrant.
- */
-export async function computeSkillActivation(
-  params: ComputeSkillActivationParams,
-): Promise<ComputeSkillActivationResult> {
-  const { candidates, userText, assistantText, nowText, config } = params;
-
-  const activation = new Map<string, number>();
-  const breakdown = new Map<string, SkillActivationBreakdown>();
-  if (candidates.size === 0) return { activation, breakdown };
-
-  const { c_user, c_assistant, c_now } = config.memory.v2;
-  const idList = [...candidates];
-
-  const [simUser, simAssistant, simNow] = await Promise.all([
-    simSkillBatch(userText, idList, config),
-    simSkillBatch(assistantText, idList, config),
-    simSkillBatch(nowText, idList, config),
-  ]);
-
-  for (const id of idList) {
-    const simU = simUser.get(id) ?? 0;
-    const simA = simAssistant.get(id) ?? 0;
-    const simN = simNow.get(id) ?? 0;
-    const value = c_user * simU + c_assistant * simA + c_now * simN;
-    activation.set(id, clampUnitInterval(value));
-    breakdown.set(id, { simUser: simU, simAssistant: simA, simNow: simN });
-  }
-
-  return { activation, breakdown };
-}
-
-export interface SelectSkillInjectionsParams {
-  /** Final skill activation map. */
-  A: ReadonlyMap<string, number>;
-  /** Cap on the per-turn skill slate, e.g. `config.memory.v2.skills_top_k`. */
-  topK: number;
-}
-
-export interface SelectSkillInjectionsResult {
-  /**
-   * Top-K skill ids by activation (descending), tie-broken lexicographically.
-   * Skills are re-presented every turn — no `toInject` delta — so the caller
-   * uses this list verbatim to render the skill slate.
-   */
-  topNow: string[];
-}
-
-/**
- * Pick the top-K skill ids by activation (descending; stable on ties via id
- * lexicographic order). Skills are stateless — there is no `everInjected`
- * dedup, so the same id can appear on consecutive turns.
- *
- * Returns `{ topNow: [] }` for an empty activation map or `topK <= 0`.
- */
-export function selectSkillInjections(
-  params: SelectSkillInjectionsParams,
-): SelectSkillInjectionsResult {
-  const { A, topK } = params;
-  if (A.size === 0 || topK <= 0) {
-    return { topNow: [] };
-  }
-
-  const ranked = [...A.entries()].sort(([idA, valA], [idB, valB]) => {
-    if (valB !== valA) return valB - valA; // higher activation first
-    return idA < idB ? -1 : idA > idB ? 1 : 0; // stable tie-break
-  });
-
-  const topNow = ranked.slice(0, topK).map(([id]) => id);
-  return { topNow };
-}