@vellumai/assistant 0.7.2 → 0.8.0

package/src/memory/v2/__tests__/static-context.test.ts

@@ -1,8 +1,6 @@
 /**
  * Tests for `readMemoryV2StaticContent` — the loader that powers the
- * `memory-v2-static` user-message auto-injection. Mirrors the coverage that
- * lived in the deprecated `system-prompt-memory-v2.test.ts`:
- *   - Returns null when the v2 flag is off.
+ * `memory-v2-static` user-message auto-injection.
  *   - Returns null when `config.memory.v2.enabled` is off.
  *   - Reads the four files in canonical order and joins them under headings.
  *   - Skips empty / missing files.
@@ -47,9 +45,8 @@ mock.module("../../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
-const { readMemoryV2StaticContent } = await import("../static-context.js");
+const { readMemoryV2StaticContent, shouldLoadMemoryV2Static } =
+  await import("../static-context.js");
 
 const MEMORY_FILES = [
   "essentials.md",
@@ -74,18 +71,10 @@ describe("readMemoryV2StaticContent", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
     configMemoryV2Enabled = true;
-    _setOverridesForTesting({ "memory-v2-enabled": true });
   });
 
   afterEach(() => {
     cleanupMemoryDir();
-    _setOverridesForTesting({});
-  });
-
-  test("returns null when the feature flag is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    for (const file of MEMORY_FILES) writeMemoryFile(file, `Content ${file}`);
-    expect(readMemoryV2StaticContent()).toBeNull();
   });
 
   test("returns null when config.memory.v2.enabled is off", () => {
@@ -150,3 +139,77 @@ describe("readMemoryV2StaticContent", () => {
     expect(readMemoryV2StaticContent()).toBeNull();
   });
 });
+
+describe("shouldLoadMemoryV2Static", () => {
+  test("blocks all turns until the cadence gate fires", () => {
+    expect(
+      shouldLoadMemoryV2Static({
+        shouldInjectNowAndPkb: false,
+        sourceChannel: "vellum",
+        isTrustedActor: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("allows guardian-trusted local conversations", () => {
+    expect(
+      shouldLoadMemoryV2Static({
+        shouldInjectNowAndPkb: true,
+        sourceChannel: "vellum",
+        isTrustedActor: true,
+      }),
+    ).toBe(true);
+  });
+
+  test("allows local-channel conversations even when trust class is unknown (analyze runs, dev)", () => {
+    expect(
+      shouldLoadMemoryV2Static({
+        shouldInjectNowAndPkb: true,
+        sourceChannel: "vellum",
+        isTrustedActor: false,
+      }),
+    ).toBe(true);
+  });
+
+  test("allows turns with no trust context (work-item task runs, internal background)", () => {
+    expect(
+      shouldLoadMemoryV2Static({
+        shouldInjectNowAndPkb: true,
+        sourceChannel: undefined,
+        isTrustedActor: false,
+      }),
+    ).toBe(true);
+  });
+
+  const REMOTE_CHANNELS = [
+    "phone",
+    "slack",
+    "telegram",
+    "whatsapp",
+    "email",
+  ] as const;
+
+  test("allows guardian-trusted remote channels (user's own phone/Slack)", () => {
+    for (const channel of REMOTE_CHANNELS) {
+      expect(
+        shouldLoadMemoryV2Static({
+          shouldInjectNowAndPkb: true,
+          sourceChannel: channel,
+          isTrustedActor: true,
+        }),
+      ).toBe(true);
+    }
+  });
+
+  test("blocks non-guardian remote-channel actors (the leak this gate exists to prevent)", () => {
+    for (const channel of REMOTE_CHANNELS) {
+      expect(
+        shouldLoadMemoryV2Static({
+          shouldInjectNowAndPkb: true,
+          sourceChannel: channel,
+          isTrustedActor: false,
+        }),
+      ).toBe(false);
+    }
+  });
+});

package/src/memory/v2/__tests__/sweep-job.test.ts

@@ -1,10 +1,11 @@
 /**
  * Tests for `assistant/src/memory/v2/sweep-job.ts`.
  *
- * Coverage matrix (from PR 18 acceptance criteria):
- *   - Flag off → no provider/DB calls, returns 0 (early bail).
- *   - Flag on + no recent messages → no provider call, returns 0.
- *   - Flag on + recent messages → provider invoked with rendered prompt;
+ * Coverage matrix:
+ *   - v2 disabled in config → no provider/DB calls, returns 0 (early bail).
+ *   - sweep_enabled off → no provider call, returns 0.
+ *   - v2 on + no recent messages → no provider call, returns 0.
+ *   - v2 on + recent messages → provider invoked with rendered prompt;
  *     each entry is appended to `memory/buffer.md` AND today's archive.
  *   - Tool-call response shape mismatch → returns 0 without writes.
  *   - Empty entries are skipped (the model can't pad the buffer).
@@ -24,7 +25,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -85,23 +85,20 @@ afterAll(() => {
 const { resetDb, getDb } = await import("../../db-connection.js");
 const { initializeDb } = await import("../../db-init.js");
 const { messages, conversations } = await import("../../schema.js");
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
 const { memoryV2SweepJob } = await import("../sweep-job.js");
 
-// `isAssistantFeatureFlagEnabled` ignores the `config` argument it receives
-// (resolution is purely from the overrides + registry caches), so we hand
-// the handler a minimal stand-in instead of materializing the full default
+// The handler reads `config.memory.v2.enabled` and `sweep_enabled`, so we
+// hand it a minimal stand-in instead of materializing the full default
 // config — which would otherwise pull in heavy schemas this test doesn't
-// exercise. The handler reads `config.memory.v2.sweep_enabled`, so the
-// `flag on` cases need the field set; the `flag off` case bails before
-// the check and uses the bare empty stand-in.
+// exercise.
 const CONFIG = {
-  memory: { v2: { sweep_enabled: true } },
+  memory: { v2: { enabled: true, sweep_enabled: true } },
+} as Parameters<typeof memoryV2SweepJob>[1];
+const CONFIG_V2_OFF = {
+  memory: { v2: { enabled: false, sweep_enabled: true } },
 } as Parameters<typeof memoryV2SweepJob>[1];
-const CONFIG_FLAG_OFF = {} as Parameters<typeof memoryV2SweepJob>[1];
 const CONFIG_SWEEP_OFF = {
-  memory: { v2: { sweep_enabled: false } },
+  memory: { v2: { enabled: true, sweep_enabled: false } },
 } as Parameters<typeof memoryV2SweepJob>[1];
 
 function makeJob(): Parameters<typeof memoryV2SweepJob>[0] {
@@ -205,18 +202,13 @@ beforeEach(() => {
   providerStub = null;
 });
 
-afterEach(() => {
-  _setOverridesForTesting({});
-});
-
 // ---------------------------------------------------------------------------
 
-describe("memoryV2SweepJob — flag off", () => {
-  test("returns 0 without invoking the provider when flag is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
+describe("memoryV2SweepJob — v2 disabled", () => {
+  test("returns 0 without invoking the provider when memory.v2.enabled is false", async () => {
     providerStub = makeEntriesProvider(["should-not-be-written"]);
 
-    const written = await memoryV2SweepJob(makeJob(), CONFIG_FLAG_OFF);
+    const written = await memoryV2SweepJob(makeJob(), CONFIG_V2_OFF);
 
     expect(written).toBe(0);
     expect(providerCalls).toHaveLength(0);
@@ -224,9 +216,8 @@ describe("memoryV2SweepJob — flag off", () => {
   });
 });
 
-describe("memoryV2SweepJob — flag on, sweep_enabled off", () => {
+describe("memoryV2SweepJob — sweep_enabled off", () => {
   test("returns 0 without invoking the provider when sweep_enabled is false", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     // No message seeding required — the sweep_enabled bail short-circuits
     // before any DB or workspace reads.
     providerStub = makeEntriesProvider(["should-not-be-written"]);
@@ -239,11 +230,7 @@ describe("memoryV2SweepJob — flag on, sweep_enabled off", () => {
   });
 });
 
-describe("memoryV2SweepJob — flag on, no recent messages", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-  });
-
+describe("memoryV2SweepJob — no recent messages", () => {
   test("returns 0 when no messages exist in the recent window", async () => {
     providerStub = makeEntriesProvider(["should-not-be-written"]);
 
@@ -273,9 +260,8 @@ describe("memoryV2SweepJob — flag on, no recent messages", () => {
 // DB intact long enough for the SQL inserts here to clash.
 let convCounter = 0;
 
-describe("memoryV2SweepJob — flag on, recent messages", () => {
+describe("memoryV2SweepJob — recent messages", () => {
   beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     seedMessages(`conv-${++convCounter}`, [
       {
         role: "user",

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)
@@ -40,7 +43,8 @@ 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 { rerankCandidates } from "./reranker.js";
+import { simBatch } from "./sim.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
 /**
@@ -77,6 +81,7 @@ interface SelectCandidatesParams {
   /** NOW context string (essentials/threads/recent or NOW.md). */
   nowText: string;
   config: AssistantConfig;
+  signal?: AbortSignal;
 }
 
 interface SelectCandidatesResult {
@@ -104,7 +109,8 @@ 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>();
@@ -125,12 +131,16 @@ export async function selectCandidates(
     .join("\n");
 
   if (annQueryText.length > 0) {
-    const denseResult = await embedWithBackend(config, [annQueryText]);
+    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;
@@ -154,6 +164,7 @@ interface ComputeOwnActivationParams {
   assistantText: string;
   nowText: string;
   config: AssistantConfig;
+  signal?: AbortSignal;
 }
 
 /**
@@ -164,12 +175,18 @@ interface ComputeOwnActivationParams {
 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;
 }
 
 interface ComputeOwnActivationResult {
@@ -181,21 +198,34 @@ 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>();
@@ -204,30 +234,122 @@ 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
 // ---------------------------------------------------------------------------
@@ -411,132 +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.
-
-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.
- */
-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;
-}
-
-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 };
-}
-
-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;
-}
-
-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 };
-}