@vellumai/assistant 0.10.3 → 0.10.4-dev.202607010028.1a4efcc

package/src/plugins/defaults/memory-v3-shadow/hot-set.test.ts

@@ -1,138 +0,0 @@
-/**
- * Tests for the frecency hot-set lane (`hot-set.ts`) and its config schema.
- *
- * `computeHotSet` takes the db handle directly (no module mocks needed):
- * each test seeds an in-memory SQLite db with `memory_v3_selections` rows
- * (via the real migration) and asserts the decayed-frequency ranking.
- */
-
-import { Database } from "bun:sqlite";
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { drizzle } from "drizzle-orm/bun-sqlite";
-
-import { MemoryV3ConfigSchema } from "../../../config/schemas/memory-v3.js";
-import { migrateAddMemoryV3Selections } from "../../../memory/migrations/268-add-memory-v3-selections.js";
-import * as schema from "../../../memory/schema.js";
-import { computeHotSet, type HotSetOptions } from "./hot-set.js";
-
-const HALF_LIFE_MS = 1000;
-const NOW = 100_000;
-
-let sqlite: Database;
-let db: ReturnType<typeof drizzle<typeof schema>>;
-
-beforeEach(() => {
-  sqlite = new Database(":memory:");
-  db = drizzle(sqlite, { schema });
-  migrateAddMemoryV3Selections(db);
-});
-
-let nextTurn = 0;
-/** Insert one selection row per createdAt (distinct turns keep the PK unique). */
-function seed(slug: string, createdAts: number[]): void {
-  const stmt = sqlite.query(
-    `INSERT INTO memory_v3_selections (conversation_id, turn, slug, source, pinned, created_at) VALUES (?, ?, ?, ?, ?, ?)`,
-  );
-  for (const createdAt of createdAts) {
-    stmt.run("conv-1", nextTurn++, slug, "needle", 0, createdAt);
-  }
-}
-
-function hotSet(overrides: Partial<HotSetOptions> = {}) {
-  return computeHotSet(
-    { db },
-    {
-      k: 10,
-      halfLifeMs: HALF_LIFE_MS,
-      now: NOW,
-      excludeSlugs: new Set<string>(),
-      ...overrides,
-    },
-  );
-}
-
-describe("computeHotSet", () => {
-  test("empty table yields empty result", () => {
-    expect(hotSet()).toEqual([]);
-  });
-
-  test("newer selections outweigh older ones at the same count", () => {
-    seed("page-old", [NOW - 10 * HALF_LIFE_MS, NOW - 10 * HALF_LIFE_MS]);
-    seed("page-new", [NOW, NOW]);
-    const result = hotSet();
-    expect(result.map((e) => e.slug)).toEqual(["page-new", "page-old"]);
-    expect(result[0]!.score).toBeGreaterThan(result[1]!.score);
-  });
-
-  test("decay halves at exactly one half-life", () => {
-    seed("page-a", [NOW]);
-    seed("page-b", [NOW - HALF_LIFE_MS]);
-    const result = hotSet();
-    const bySlug = new Map(result.map((e) => [e.slug, e.score]));
-    expect(bySlug.get("page-a")).toBeCloseTo(1, 10);
-    expect(bySlug.get("page-b")).toBeCloseTo(0.5, 10);
-  });
-
-  test("scores sum across a slug's selections", () => {
-    seed("page-a", [NOW, NOW - HALF_LIFE_MS]);
-    expect(hotSet()[0]!.score).toBeCloseTo(1.5, 10);
-  });
-
-  test("k cut keeps only the top-k", () => {
-    seed("page-a", [NOW, NOW, NOW]);
-    seed("page-b", [NOW, NOW]);
-    seed("page-c", [NOW]);
-    expect(hotSet({ k: 2 }).map((e) => e.slug)).toEqual(["page-a", "page-b"]);
-  });
-
-  test("excludeSlugs filters before the k cut", () => {
-    seed("page-a", [NOW, NOW, NOW]);
-    seed("page-b", [NOW, NOW]);
-    seed("page-c", [NOW]);
-    const result = hotSet({ k: 2, excludeSlugs: new Set(["page-a"]) });
-    expect(result.map((e) => e.slug)).toEqual(["page-b", "page-c"]);
-  });
-
-  test("ties break deterministically by slug ascending", () => {
-    seed("page-b", [NOW]);
-    seed("page-a", [NOW]);
-    seed("page-c", [NOW]);
-    expect(hotSet().map((e) => e.slug)).toEqual(["page-a", "page-b", "page-c"]);
-  });
-
-  test("deterministic for fixed inputs", () => {
-    seed("page-a", [NOW, NOW - 3 * HALF_LIFE_MS]);
-    seed("page-b", [NOW - HALF_LIFE_MS]);
-    expect(hotSet()).toEqual(hotSet());
-  });
-
-  test("future-dated rows are clamped to weight 1", () => {
-    seed("page-a", [NOW + 50 * HALF_LIFE_MS]);
-    expect(hotSet()[0]!.score).toBeCloseTo(1, 10);
-  });
-});
-
-describe("MemoryV3ConfigSchema hotSet", () => {
-  test("defaults apply when omitted", () => {
-    const config = MemoryV3ConfigSchema.parse({});
-    expect(config.hotSet).toEqual({ k: 40, halfLifeDays: 14 });
-  });
-
-  test("explicit values parse", () => {
-    const config = MemoryV3ConfigSchema.parse({
-      hotSet: { k: 5, halfLifeDays: 7 },
-    });
-    expect(config.hotSet).toEqual({ k: 5, halfLifeDays: 7 });
-  });
-
-  test("rejects negative k", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ hotSet: { k: -1 } })).toThrow();
-  });
-
-  test("rejects negative halfLifeDays", () => {
-    expect(() =>
-      MemoryV3ConfigSchema.parse({ hotSet: { halfLifeDays: -1 } }),
-    ).toThrow();
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/hot-set.ts

@@ -1,85 +0,0 @@
-/**
- * Frecency hot-set lane.
- *
- * Scores every page slug in `memory_v3_selections` (all conversations) by its
- * exponentially-decayed selection count and returns the top-K. The hot set is
- * the lane that keeps *seasonally recurrent* pages in the candidate pool even
- * when the current message gives the finder lanes nothing to match on; the
- * curated core set (a separate lane) covers the associative-texture class
- * frecency cannot discriminate.
- *
- * Each selection row contributes `2^(−age / halfLifeMs)` to its slug's score,
- * so a selection exactly one half-life old counts half as much as one made
- * now. Slugs in `excludeSlugs` (the core set) are dropped before the K cut —
- * the hot lane never duplicates core.
- */
-
-import {
-  type DrizzleDb,
-  getSqliteFrom,
-} from "../../../memory/db-connection.js";
-import type { Slug } from "./types.js";
-
-export interface HotSetDeps {
-  /** Handle to the database containing `memory_v3_selections`. */
-  db: DrizzleDb;
-}
-
-export interface HotSetOptions {
-  /** Maximum number of slugs returned. */
-  k: number;
-  /** Decay half-life in milliseconds: a selection this old scores 0.5. */
-  halfLifeMs: number;
-  /** Reference timestamp (ms epoch) ages are measured against. */
-  now: number;
-  /** Slugs excluded from the result (the core set — hot never duplicates core). */
-  excludeSlugs: Set<string>;
-}
-
-export interface HotSetEntry {
-  slug: Slug;
-  score: number;
-}
-
-interface SelectionAgeRow {
-  slug: string;
-  created_at: number;
-}
-
-/**
- * Compute the top-`k` hot slugs by exponentially-decayed selection frequency.
- *
- * Deterministic for fixed inputs: ties break score desc, then slug asc. The
- * decay sum runs in TS over `(slug, created_at)` pairs — the selections table
- * is small enough that reading it directly beats pushing the math into SQL.
- */
-export function computeHotSet(
-  deps: HotSetDeps,
-  opts: HotSetOptions,
-): HotSetEntry[] {
-  const { k, halfLifeMs, now, excludeSlugs } = opts;
-  if (k <= 0) return [];
-
-  const rows = getSqliteFrom(deps.db)
-    .query(
-      /*sql*/ `
-      SELECT slug, created_at FROM memory_v3_selections
-    `,
-    )
-    .all() as SelectionAgeRow[];
-
-  const scores = new Map<Slug, number>();
-  for (const row of rows) {
-    if (excludeSlugs.has(row.slug)) continue;
-    // Clamp future-dated rows (clock skew) to "now" rather than letting them
-    // score above 1 per selection.
-    const age = Math.max(0, now - row.created_at);
-    const weight = 2 ** (-age / halfLifeMs);
-    scores.set(row.slug, (scores.get(row.slug) ?? 0) + weight);
-  }
-
-  return [...scores.entries()]
-    .map(([slug, score]) => ({ slug, score }))
-    .sort((a, b) => b.score - a.score || (a.slug < b.slug ? -1 : 1))
-    .slice(0, k);
-}

package/src/plugins/defaults/memory-v3-shadow/injector.ts

@@ -1,453 +0,0 @@
-/**
- * The memory-v3 {@link Injector}s: frozen net-new cards + ephemeral spotlight.
- *
- * Two injectors share one orchestration result per turn (memoized via
- * {@link observeTurnOnce} so re-entry assemblies — overflow convergence,
- * post-compaction re-injection — reuse the turn's selections instead of
- * re-running the selector):
- *
- *  - {@link memoryV3Injector} (id `memory-v3`, `after-memory-prefix`): the
- *    PERSISTENT layer. Renders only this turn's NET-NEW selections — selections
- *    not already in the everInjected store — as compact cards inside one
- *    `<memory>` block and returns the block. The everInjected store write
- *    (`recordInjected`) and the prune-valve schedule are DEFERRED to a commit
- *    callback the block carries (`meta[MEMORY_V3_COMMIT_META_KEY]`): runtime
- *    assembly invokes it only when the turn's tail is a user message — the
- *    same gate as metadata capture — so a turn whose block silently fails to
- *    attach never claims its cards in the store (which would suppress them
- *    until compaction). Runtime assembly splices the block onto the current
- *    user message and the user-prompt-submit hook persists the unwrapped inner
- *    text under `metadata.memoryV3InjectedBlock`; `conversation.ts` rehydrates
- *    it on load. The block is FROZEN thereafter: prior turns' card blocks stay
- *    byte-identical in history, so they ride the provider's cached prefix and
- *    survive restarts — mirroring v2's `memoryInjectedBlock` mechanism. An
- *    all-repeat turn returns an EMPTY-TEXT block: assembly attaches nothing,
- *    but the block's presence still keys v2 suppression (v3 ran and owns the
- *    `<memory>` layer this turn). A `null` return (failure / empty selection /
- *    every net-new card rendered empty) attaches no v3 block: in shadow mode
- *    (`memory-v3-live` off) v2 still ran this turn, so its block stays as the
- *    fallback; under `memory-v3-live` the user-prompt-submit hook skips v2
- *    retrieval entirely, so a null return leaves the turn with no NEW injected
- *    memory (prior turns' frozen cards still ride history).
- *
- *  - {@link memoryV3SpotlightInjector} (id `memory-v3-spotlight`,
- *    `after-memory-prefix`): the EPHEMERAL layer. Renders the top `spotlight.n`
- *    selected finder hits' matched sections, plus the previous
- *    `spotlight.windowTurns` turns' entries from an in-memory per-conversation
- *    ring (a daemon restart simply re-warms it), as a `<memory_spotlight>`
- *    block spliced immediately after the `<memory>` cards block (so the two
- *    memory layers sit adjacent in the prefix, ahead of the user's message
- *    text). Assembly strip-and-replaces this block every turn (scoped to this
- *    block id only); it is never persisted to metadata, so the frozen card
- *    prefix it follows stays byte-stable and cached regardless.
- *
- * Gating: `memory.v3.live` (config) attaches blocks; the `memory-v3-shadow`
- * flag (live off) logs what WOULD inject (net-new slugs + bytes + spotlight
- * refs) and attaches nothing; both off → no orchestration.
- *
- * Both injectors apply the same personal-memory trust gate as v2
- * ({@link isPersonalMemoryAllowed}): an untrusted remote actor's turn
- * produces nothing — no orchestration, no cards, no spotlight, and nothing
- * recorded or persisted. Memory pages, skill/CLI capability cards, and
- * matched-section spotlights all surface private user content — and because
- * v3 cards are persisted to message metadata and rehydrated forever, the gate
- * must also keep an untrusted turn from recording or persisting anything.
- *
- * Known mirror-of-v2 limitation: cards attached by mid-turn re-entry
- * assemblies (post-compaction re-injection) live only in memory — metadata is
- * persisted at the first-call site only — so a restart drops them while the
- * store still claims them, exactly as v2's `lastInjectedBlock` reinject does.
- * The next compaction clears the store and resets both layers.
- */
-
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
-import { getConfig } from "../../../config/loader.js";
-import { isMemoryV3Live } from "../../../config/memory-v3-gate.js";
-import {
-  type PendingConversationNotice,
-  queueConversationNotice,
-} from "../../../daemon/conversation-notices.js";
-import { isPersonalMemoryAllowed } from "../../../daemon/trust-context.js";
-import {
-  wrapMemoryBlock,
-  wrapMemorySpotlightBlock,
-} from "../../../memory/memory-marker.js";
-import { getLogger } from "../../../util/logger.js";
-import {
-  type InjectionBlock,
-  type Injector,
-  type TurnContext,
-} from "../../types.js";
-import { isCapabilitySlug } from "./capabilities.js";
-import { cardBytes } from "./card.js";
-import { getActiveSlugs, recordInjected } from "./ever-injected-store.js";
-import type { OrchestrateResult } from "./orchestrate.js";
-import { renderV3CardContent } from "./page-content.js";
-import { MemoryV3RetrievalUnavailableError } from "./pool-select.js";
-import { schedulePruneValve } from "./prune.js";
-import {
-  renderCardsBlockInner,
-  renderSpotlightInner,
-  type SpotlightEntry,
-} from "./render-injection.js";
-import { MEMORY_V3_SHADOW, observeTurn } from "./shadow-plugin.js";
-import {
-  MEMORY_V3_BLOCK_ID,
-  MEMORY_V3_COMMIT_META_KEY,
-  MEMORY_V3_SPOTLIGHT_BLOCK_ID,
-  type Slug,
-} from "./types.js";
-
-const log = getLogger("memory-v3-shadow");
-
-/**
- * Cap on the per-conversation maps below. Least-recently-touched entries are
- * evicted first; an evicted conversation simply re-warms (spotlight) or
- * re-runs orchestration (memo) on its next turn.
- */
-const MAX_TRACKED_CONVERSATIONS = 256;
-
-/**
- * LRU-set `key` on `map`: delete-then-set so a re-touched key moves to the
- * back of the Map's insertion order (a plain `set` on an existing key keeps
- * its original position, which would evict the most long-lived ACTIVE
- * conversation first). Eviction only fires when inserting a genuinely new
- * key at the cap.
- */
-function lruSet<V>(map: Map<string, V>, key: string, value: V): void {
-  if (map.has(key)) {
-    map.delete(key);
-  } else if (map.size >= MAX_TRACKED_CONVERSATIONS) {
-    const oldest = map.keys().next().value;
-    if (oldest !== undefined) map.delete(oldest);
-  }
-  map.set(key, value);
-}
-
-function queueMemoryV3ConversationNotice(
-  err: MemoryV3RetrievalUnavailableError,
-  ctx: TurnContext,
-  live: boolean,
-): void {
-  if (!live) return;
-  const notice: PendingConversationNotice = err.conversationNotice ?? {
-    source: "memory_v3",
-    code: "UNKNOWN",
-    userMessage:
-      "Memory is temporarily unavailable, so this response may not use your saved memories. You can retry in a moment.",
-    errorCategory: "memory_v3_degraded",
-  };
-  queueConversationNotice(
-    ctx.conversationId,
-    `memory_v3:${ctx.turnIndex}:${notice.errorCategory ?? notice.code}`,
-    notice,
-  );
-}
-
-// ─── shared per-turn orchestration memo ─────────────────────────────────────
-
-interface ObservedTurn {
-  turnIndex: number;
-  result: Promise<OrchestrateResult | null>;
-}
-
-/** Latest observed turn per conversation (both injectors + re-entry sites
- *  share one orchestration per turn). */
-const observedTurns = new Map<string, ObservedTurn>();
-
-/**
- * Run {@link observeTurn} once per (conversation, turn) and memoize the
- * promise. The cards and spotlight injectors both consume the result, and
- * re-entry assemblies within the same turn (overflow convergence,
- * post-compaction re-injection) reuse the turn's selections rather than
- * paying a second selector call. A new `turnIndex` replaces the entry, so the
- * memo never holds more than one turn per conversation.
- */
-function observeTurnOnce(
-  conversationId: string,
-  turnIndex: number,
-): Promise<OrchestrateResult | null> {
-  const cached = observedTurns.get(conversationId);
-  if (cached && cached.turnIndex === turnIndex) return cached.result;
-  const result = observeTurn(conversationId, turnIndex);
-  lruSet(observedTurns, conversationId, { turnIndex, result });
-  return result;
-}
-
-// ─── ephemeral spotlight ring ────────────────────────────────────────────────
-
-interface SpotlightTurn {
-  turnIndex: number;
-  entries: SpotlightEntry[];
-}
-
-/** Recent turns' spotlight entries per conversation, oldest → newest. */
-const spotlightRings = new Map<string, SpotlightTurn[]>();
-
-/**
- * Compute this turn's spotlight entries: the top `n` SELECTED finder hits'
- * matched sections, in finder surfacing order (needle → dense → edge
- * precedence). A finder hit on a stable-prefix page keeps its matched-section
- * ref in the orchestrate result, so core/hot pages with current relevance
- * spotlight too.
- */
-function computeSpotlightEntries(
-  result: OrchestrateResult,
-  n: number,
-): SpotlightEntry[] {
-  const selected = new Set<Slug>(result.selections.map((s) => s.slug));
-  const entries: SpotlightEntry[] = [];
-  for (const candidate of result.lanes.finder) {
-    if (entries.length >= n) break;
-    if (!selected.has(candidate.slug)) continue;
-    const section = result.matchedSections.get(candidate.slug);
-    if (!section) continue;
-    entries.push({
-      slug: candidate.slug,
-      title: section.title,
-      text: section.text,
-    });
-  }
-  return entries;
-}
-
-/**
- * Fold this turn's entries into the conversation's ring and return the
- * rendered window: current turn first, then previous turns newest-first,
- * deduped by slug § heading, bounded by `n × (windowTurns + 1)` entries by
- * construction. Re-observing the SAME turn (re-entry assembly) replaces that
- * turn's entry rather than accumulating.
- */
-function updateSpotlightWindow(
-  conversationId: string,
-  turnIndex: number,
-  entries: SpotlightEntry[],
-  windowTurns: number,
-): SpotlightEntry[] {
-  const prior = (spotlightRings.get(conversationId) ?? []).filter(
-    (t) => t.turnIndex < turnIndex && t.turnIndex >= turnIndex - windowTurns,
-  );
-  lruSet(spotlightRings, conversationId, [...prior, { turnIndex, entries }]);
-
-  const window: SpotlightEntry[] = [];
-  const seen = new Set<string>();
-  // Newest first: this turn's entries, then prior turns newest → oldest.
-  for (const turn of [{ turnIndex, entries }, ...prior.reverse()]) {
-    for (const entry of turn.entries) {
-      const key = `${entry.slug}§${entry.title}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      window.push(entry);
-    }
-  }
-  return window;
-}
-
-/** Test-only reset for the per-turn memo and the spotlight rings. */
-export function resetMemoryV3InjectorStateForTests(): void {
-  observedTurns.clear();
-  spotlightRings.clear();
-}
-
-// ─── injectors ───────────────────────────────────────────────────────────────
-
-export const memoryV3Injector: Injector = {
-  name: "memory-v3-shadow",
-  // High order so it sorts last; the live `<memory>` block uses the
-  // after-memory-prefix placement so it lands at the memory boundary regardless
-  // of this sort key, which only orders content-producing injectors.
-  order: 1000,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
-    const config = getConfig();
-    if (config.memory.enabled === false) return null;
-    const live = isMemoryV3Live(config);
-    const shadow = isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config);
-    if (!live && !shadow) return null;
-    if (!isPersonalMemoryAllowed(ctx.trust)) return null;
-
-    let observed: OrchestrateResult | null;
-    try {
-      observed = await observeTurnOnce(ctx.conversationId, ctx.turnIndex);
-    } catch (err) {
-      if (err instanceof MemoryV3RetrievalUnavailableError) {
-        queueMemoryV3ConversationNotice(err, ctx, live);
-        log.error(
-          {
-            err: err.message,
-            conversationId: ctx.conversationId,
-            mode: live ? "live" : "shadow",
-          },
-          "memory-v3 selection failed; skipping v3 memory for this turn",
-        );
-      }
-      return null;
-    }
-    // Empty selection → return null (attach nothing). Returning null (vs an
-    // empty block) preserves the shadow-mode v2 fallback: v2 suppression keys
-    // off BOTH the flag AND a produced block, so in shadow a turn with nothing
-    // selected ships v2's memory. Under `memory-v3-live` the hook skipped v2
-    // retrieval, so the turn simply gets no injected memory.
-    if (!observed || observed.selections.length === 0) return null;
-    // `const` so the non-null narrowing survives capture in the `commit`
-    // closure below (a `let` would re-widen to `OrchestrateResult | null`).
-    const result = observed;
-
-    try {
-      const active = getActiveSlugs(ctx.conversationId);
-      const netNew = result.selections
-        .map((s) => s.slug)
-        .filter((slug) => !active.has(slug));
-
-      // Render net-new cards, skipping slugs that resolve to no content
-      // (deleted pages, unresolvable capabilities) — nothing is attached for
-      // them, so nothing is recorded either.
-      const cards: Array<{ slug: Slug; card: string }> = [];
-      for (const slug of netNew) {
-        const card = await renderV3CardContent(slug);
-        if (card.trim().length > 0) cards.push({ slug, card });
-      }
-      // Every net-new card rendered empty: return null rather than an
-      // empty-text block. Returning null preserves the shadow-mode v2 fallback
-      // (an empty block would key v2 suppression yet show nothing); under
-      // `memory-v3-live` there is no v2 block, so the turn simply gets no new
-      // memory. Distinct from the all-repeat case (empty `netNew`), where the
-      // empty block correctly keeps v2 suppressed because the cards already
-      // ride history.
-      if (netNew.length > 0 && cards.length === 0) return null;
-      const entries = cards.map(({ slug, card }) => ({
-        slug,
-        // Capability cards (skills / CLI commands) render with their own
-        // `# Skill:` / `# CLI command:` headers, which the prune valve's
-        // `# memory/concepts/<slug>.md` section grammar can never locate to
-        // free. Record them at zero bytes so they never inflate the freeable
-        // resident accounting (the valve would otherwise loop-fire on bytes
-        // it cannot free).
-        bytes: isCapabilitySlug(slug) ? 0 : cardBytes(card),
-      }));
-
-      if (!live) {
-        // Shadow mode: log what WOULD inject, attach and record nothing.
-        const spotlightRefs = computeSpotlightEntries(
-          result,
-          config.memory.v3.spotlight.n,
-        ).map((e) => `${e.slug}§${e.title}`);
-        log.info(
-          {
-            conversationId: ctx.conversationId,
-            turnIndex: ctx.turnIndex,
-            netNew: entries,
-            netNewBytes: entries.reduce((sum, e) => sum + e.bytes, 0),
-            spotlightRefs,
-          },
-          "memory-v3 shadow: would inject net-new cards + spotlight",
-        );
-        return null;
-      }
-
-      // The everInjected store write and the prune-valve schedule are
-      // DEFERRED to this commit callback, invoked by runtime assembly at the
-      // point where attachment is guaranteed (the turn's tail is a user
-      // message — the same gate as metadata capture). Recording here in
-      // `produce()` would let a never-attached turn (non-user tail) claim
-      // cards in the store, suppressing them until compaction. The valve is
-      // scheduled after `recordInjected` so the resident accounting includes
-      // this turn's cards; stable-prefix lane members (core/hot/fresh) are
-      // exempt — the selector's stable prefix must never be pruned out from
-      // under it.
-      const commit = (): void => {
-        recordInjected(ctx.conversationId, entries);
-        schedulePruneValve(ctx.conversationId, {
-          exemptSlugs: new Set<Slug>([
-            ...result.lanes.core,
-            ...result.lanes.hot,
-            ...result.lanes.fresh,
-          ]),
-        });
-      };
-
-      // Empty net-new → empty-text block: assembly attaches no content
-      // (`applyInjectionBlock` no-ops empty text) but the block's presence
-      // still marks v3 as this turn's `<memory>` source for v2 suppression.
-      const inner = renderCardsBlockInner(cards.map((c) => c.card));
-      return {
-        id: MEMORY_V3_BLOCK_ID,
-        text: inner.length === 0 ? "" : wrapMemoryBlock(inner),
-        // Mirror v2's dynamic `<memory>` block placement.
-        placement: "after-memory-prefix",
-        meta: { [MEMORY_V3_COMMIT_META_KEY]: commit },
-      };
-    } catch (err) {
-      log.warn(
-        {
-          err: err instanceof Error ? err.message : String(err),
-          conversationId: ctx.conversationId,
-        },
-        "memory-v3 live render failed (non-fatal) — returning null (no v3 block this turn)",
-      );
-      return null;
-    }
-  },
-};
-
-export const memoryV3SpotlightInjector: Injector = {
-  name: "memory-v3-spotlight",
-  // After the cards injector so the shared memo is (usually) already primed.
-  order: 1001,
-  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
-    const config = getConfig();
-    if (config.memory.enabled === false) return null;
-    // Live-only: shadow mode logs spotlight refs from the cards injector and
-    // must keep the turn untouched (no ring state either, so a later
-    // live-flag flip starts from a clean window).
-    if (!isMemoryV3Live(config)) return null;
-    if (!isPersonalMemoryAllowed(ctx.trust)) return null;
-
-    try {
-      const result = await observeTurnOnce(ctx.conversationId, ctx.turnIndex);
-      if (!result || result.selections.length === 0) return null;
-
-      const { n, windowTurns } = config.memory.v3.spotlight;
-      const current = computeSpotlightEntries(result, n);
-      const window = updateSpotlightWindow(
-        ctx.conversationId,
-        ctx.turnIndex,
-        current,
-        windowTurns,
-      );
-      if (window.length === 0) return null;
-
-      return {
-        id: MEMORY_V3_SPOTLIGHT_BLOCK_ID,
-        text: wrapMemorySpotlightBlock(renderSpotlightInner(window)),
-        // Splices right after the `<memory>` cards block (this injector's
-        // order 1001 runs after the cards' 1000, and `countMemoryPrefixBlocks`
-        // counts the cards `<memory>` block but not `<memory_spotlight>`, so the
-        // spotlight lands immediately after the cards rather than at the user
-        // tail). Cache-neutral: the block is strip-and-replaced from prior
-        // messages by block id every turn regardless of placement, so the
-        // frozen card prefix stays byte-stable and cached.
-        placement: "after-memory-prefix",
-      };
-    } catch (err) {
-      if (err instanceof MemoryV3RetrievalUnavailableError) {
-        queueMemoryV3ConversationNotice(err, ctx, true);
-        log.error(
-          {
-            err: err.message,
-            conversationId: ctx.conversationId,
-          },
-          "memory-v3 spotlight selection failed; skipping spotlight",
-        );
-        return null;
-      }
-      log.warn(
-        {
-          err: err instanceof Error ? err.message : String(err),
-          conversationId: ctx.conversationId,
-        },
-        "memory-v3 spotlight render failed (non-fatal) — skipping spotlight",
-      );
-      return null;
-    }
-  },
-};