@vellumai/assistant 0.10.3-dev.202606282033.2a8a8de → 0.10.3-dev.202606282228.b3d6565

package/openapi.yaml

@@ -8659,8 +8659,6 @@ paths:
                             type: number
                           live:
                             type: boolean
-                          shadow:
-                            type: boolean
                           selections:
                             type: array
                             items:
@@ -8690,7 +8688,6 @@ paths:
                         required:
                           - turn
                           - live
-                          - shadow
                           - selections
                           - injectedText
                         additionalProperties: false
@@ -18266,8 +18263,6 @@ paths:
                             type: number
                           live:
                             type: boolean
-                          shadow:
-                            type: boolean
                           selections:
                             type: array
                             items:
@@ -18297,7 +18292,6 @@ paths:
                         required:
                           - turn
                           - live
-                          - shadow
                           - selections
                           - injectedText
                         additionalProperties: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606282033.2a8a8de",
+  "version": "0.10.3-dev.202606282228.b3d6565",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/pointer-conversation-trust.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+
+import { elevatePointerConversationToGuardian } from "../daemon/pointer-conversation-trust.js";
+import {
+  INTERNAL_GUARDIAN_TRUST_CONTEXT,
+  type TrustContext,
+} from "../daemon/trust-context.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
+
+/**
+ * Fake conversation that mirrors `Conversation.loadFromDb`'s trust gate: a
+ * memory-capable (guardian) trust class sees the full guardian history; any
+ * other class sees an empty (filtered) history. `ensureActorScopedHistory`
+ * re-applies that gate against the current trust context, exactly like the real
+ * reload path.
+ */
+class FakeConversation {
+  trustContext: TrustContext | undefined;
+  visibleHistory: string[] = [];
+  setTrustContextCalls: Array<TrustContext | null> = [];
+  ensureCalls = 0;
+  private readonly guardianHistory: string[];
+  private readonly processing: boolean;
+
+  constructor(opts: {
+    trustContext?: TrustContext;
+    guardianHistory?: string[];
+    processing?: boolean;
+  }) {
+    this.trustContext = opts.trustContext;
+    this.guardianHistory = opts.guardianHistory ?? ["m1", "m2", "m3"];
+    this.processing = opts.processing ?? false;
+    this.applyHistoryForTrust();
+  }
+
+  private applyHistoryForTrust(): void {
+    this.visibleHistory = resolveCapabilities(this.trustContext?.trustClass)
+      .canAccessMemory
+      ? [...this.guardianHistory]
+      : [];
+  }
+
+  isProcessing(): boolean {
+    return this.processing;
+  }
+
+  setTrustContext(ctx: TrustContext | null): void {
+    this.setTrustContextCalls.push(ctx);
+    this.trustContext = ctx ?? undefined;
+  }
+
+  async ensureActorScopedHistory(): Promise<void> {
+    this.ensureCalls++;
+    this.applyHistoryForTrust();
+  }
+}
+
+const CONTACT_CONTEXT: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "unverified_contact",
+};
+
+const GUARDIAN_CONTEXT: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+describe("elevatePointerConversationToGuardian", () => {
+  test("elevates a cold trust-less conversation and rehydrates guardian history", async () => {
+    const conv = new FakeConversation({ trustContext: undefined });
+    // A cold (trust-less) load filters guardian history to empty.
+    expect(conv.visibleHistory).toEqual([]);
+
+    const restore = await elevatePointerConversationToGuardian(conv);
+
+    expect(conv.trustContext).toBe(INTERNAL_GUARDIAN_TRUST_CONTEXT);
+    expect(conv.ensureCalls).toBe(1);
+    // History is rehydrated rather than shipped empty.
+    expect(conv.visibleHistory).toEqual(["m1", "m2", "m3"]);
+
+    restore();
+    expect(conv.trustContext).toBeUndefined();
+  });
+
+  test("restores the prior non-memory trust context after the turn", async () => {
+    const conv = new FakeConversation({ trustContext: CONTACT_CONTEXT });
+    expect(conv.visibleHistory).toEqual([]);
+
+    const restore = await elevatePointerConversationToGuardian(conv);
+    expect(conv.trustContext).toBe(INTERNAL_GUARDIAN_TRUST_CONTEXT);
+    expect(conv.visibleHistory).toEqual(["m1", "m2", "m3"]);
+
+    restore();
+    expect(conv.trustContext).toBe(CONTACT_CONTEXT);
+  });
+
+  test("no-ops for a conversation that already has memory access", async () => {
+    const conv = new FakeConversation({ trustContext: GUARDIAN_CONTEXT });
+    expect(conv.visibleHistory).toEqual(["m1", "m2", "m3"]);
+
+    const restore = await elevatePointerConversationToGuardian(conv);
+
+    // No elevation, no redundant reload.
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.ensureCalls).toBe(0);
+    expect(conv.trustContext).toBe(GUARDIAN_CONTEXT);
+
+    restore();
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.trustContext).toBe(GUARDIAN_CONTEXT);
+  });
+
+  test("does not mutate trust while the conversation is processing", async () => {
+    const conv = new FakeConversation({
+      trustContext: undefined,
+      processing: true,
+    });
+
+    const restore = await elevatePointerConversationToGuardian(conv);
+
+    expect(conv.setTrustContextCalls).toEqual([]);
+    expect(conv.ensureCalls).toBe(0);
+    expect(conv.trustContext).toBeUndefined();
+
+    restore();
+    expect(conv.setTrustContextCalls).toEqual([]);
+  });
+
+  test("restore leaves trust alone when a later turn replaced it", async () => {
+    const conv = new FakeConversation({ trustContext: undefined });
+    const restore = await elevatePointerConversationToGuardian(conv);
+    expect(conv.trustContext).toBe(INTERNAL_GUARDIAN_TRUST_CONTEXT);
+
+    // Simulate a new turn legitimately replacing the trust context mid-flight.
+    conv.setTrustContext(GUARDIAN_CONTEXT);
+    restore();
+
+    // The restorer must not clobber the new turn's context.
+    expect(conv.trustContext).toBe(GUARDIAN_CONTEXT);
+  });
+});

package/src/api/responses/memory-v3-selection-log.ts

@@ -9,11 +9,10 @@
  *
  * Returned as part of `LlmContextResponse` — see `./llm-context-response.ts`.
  *
- * `live` / `shadow` reflect the CURRENT `memory-v3-live` / `memory-v3-shadow`
- * flag state, not the per-turn history (the selection rows don't record which
- * mode was active when they were written). When `live` is true the rendered
- * `injectedText` reflects the live selection; when only `shadow` is true it is
- * the block that WOULD have been injected.
+ * `live` reflects the CURRENT `memory.v3.live` config state, not the per-turn
+ * history (the selection rows don't record whether v3 was live when they were
+ * written). The rendered `injectedText` is the `<memory>` block for the logged
+ * selection.
  *
  * `injectedText` is inspector-only, not a verbatim record of the live cards +
  * spotlight. It re-renders each selection's matched section — resolved from the
@@ -58,7 +57,6 @@ export type MemoryV3SelectionRow = z.infer<typeof MemoryV3SelectionRowSchema>;
 export const MemoryV3SelectionLogSchema = z.object({
   turn: z.number(),
   live: z.boolean(),
-  shadow: z.boolean(),
   selections: z.array(MemoryV3SelectionRowSchema),
   injectedText: z.string(),
 });

package/src/config/feature-flag-registry.json

@@ -362,14 +362,6 @@
       "description": "Expose the developer-only Memory Router Playground tab in macOS Settings and the /assistant/memory-router-playground web page for dry-running v4 router config overrides against the live page index. Dev-only; default off.",
       "defaultEnabled": false
     },
-    {
-      "id": "memory-v3-shadow",
-      "scope": "assistant",
-      "key": "memory-v3-shadow",
-      "label": "Memory v3 Shadow",
-      "description": "When on, runs the new memory-v3 topic-tree retrieval alongside v2 in shadow mode: logs selections to memory_v3_selections, does not modify injected context. Off by default.",
-      "defaultEnabled": false
-    },
     {
       "id": "self-intro-greeting",
       "scope": "both",

package/src/daemon/lifecycle.ts

@@ -122,6 +122,7 @@ import {
   rebuildBm25CorpusStatsAndReseedSkills,
 } from "./memory-v2-startup.js";
 import { startOrphanReaper } from "./orphan-reaper.js";
+import { elevatePointerConversationToGuardian } from "./pointer-conversation-trust.js";
 import { processMessage } from "./process-message.js";
 import { runProfilerSweep } from "./profiler-run-store.js";
 import {
@@ -1117,6 +1118,14 @@ export async function runDaemon(): Promise<void> {
         const conversation =
           await server.getConversationForMessages(conversationId);
 
+        // Pointer turns are guardian-gated owner self-maintenance: elevate to
+        // the internal guardian context and rehydrate history so a cold
+        // (evicted) load doesn't filter guardian history to empty and ship a
+        // cache-missing turn. `restoreTrustContext` undoes the elevation after
+        // the turn. See pointer-conversation-trust.ts for the full rationale.
+        const restoreTrustContext =
+          await elevatePointerConversationToGuardian(conversation);
+
         // Constrain pointer generation to a tool-disabled path so call-
         // status events cannot trigger unintended side-effect tools.
         // Incrementing toolsDisabledDepth causes the resolveTools callback
@@ -1242,6 +1251,8 @@ export async function runDaemon(): Promise<void> {
         } finally {
           // Restore tool availability so subsequent turns aren't affected.
           conversation.toolsDisabledDepth--;
+          // Undo the temporary guardian elevation installed above.
+          restoreTrustContext();
         }
       },
     );

package/src/daemon/pointer-conversation-trust.ts

@@ -0,0 +1,66 @@
+/**
+ * Guardian-trust elevation for call-status pointer turns.
+ *
+ * Call-status pointer messages are generated as owner self-maintenance turns:
+ * only guardian-gated audiences route through the daemon processor (see
+ * `resolvePointerAudienceTrust` in `calls/call-pointer-messages.ts`), so the
+ * generation should run under the internal guardian context.
+ *
+ * The subtlety is history: `Conversation.loadFromDb` filters the persisted
+ * history to non-guardian provenance whenever the active trust context cannot
+ * access memory. On a cold (evicted) load — common on a memory-pressured daemon
+ * that evicts idle conversations — a freshly rebuilt conversation has no trust
+ * context, so a guardian-authored conversation's entire history is filtered to
+ * empty. The pointer turn would then ship with only its freshly persisted
+ * instruction, and because dropping the prior history (and tools) shifts the
+ * cacheable prefix, the request misses the prompt cache completely.
+ *
+ * Elevating to the guardian context and rehydrating before the turn restores
+ * the full history and makes the turn's shape deterministic regardless of
+ * eviction state.
+ */
+import { resolveCapabilities } from "../runtime/capabilities.js";
+import {
+  INTERNAL_GUARDIAN_TRUST_CONTEXT,
+  type TrustContext,
+} from "./trust-context.js";
+
+/** Minimal `Conversation` surface needed to elevate pointer trust. */
+export interface GuardianElevatableConversation {
+  readonly trustContext?: TrustContext | undefined;
+  isProcessing(): boolean;
+  setTrustContext(ctx: TrustContext | null): void;
+  ensureActorScopedHistory(): Promise<void>;
+}
+
+/**
+ * Elevate a pointer conversation to the internal guardian context and rehydrate
+ * its history so guardian-authored history is not filtered to empty on a cold
+ * load. Returns a function that restores the prior trust context.
+ *
+ * No-ops (returning a no-op restorer) when the conversation is already
+ * memory-capable, or when it is mid-turn — mutating `trustContext` during an
+ * active loop would elevate that turn's actor trust (mirrors the warm-path guard
+ * in `conversation-store.ts`).
+ */
+export async function elevatePointerConversationToGuardian(
+  conversation: GuardianElevatableConversation,
+): Promise<() => void> {
+  const priorTrustContext = conversation.trustContext;
+  const shouldElevate =
+    !conversation.isProcessing() &&
+    !resolveCapabilities(priorTrustContext?.trustClass).canAccessMemory;
+  if (!shouldElevate) return () => {};
+
+  conversation.setTrustContext(INTERNAL_GUARDIAN_TRUST_CONTEXT);
+  await conversation.ensureActorScopedHistory();
+
+  return () => {
+    // Undo only the elevation this call installed. If a new turn started at an
+    // await boundary and legitimately updated trustContext, the reference will
+    // differ and we leave it alone.
+    if (conversation.trustContext === INTERNAL_GUARDIAN_TRUST_CONTEXT) {
+      conversation.setTrustContext(priorTrustContext ?? null);
+    }
+  };
+}

package/src/memory/jobs-worker.ts

@@ -1,6 +1,5 @@
 import { join } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../config/types.js";
@@ -950,16 +949,13 @@ export function maybeEnqueueGraphMaintenanceJobs(
 
   // v3 self-maintenance backstop. Orthogonal to the v1/v2 mutual exclusion
   // above: it owns its own checkpoint and operates on the v3 topic tree, so it
-  // runs under either branch. Gated on the same flags that gate the v3 plugin
+  // runs under either branch. Gated on the same config that gates the v3 plugin
   // so it stays inert when v3 is off. The post-consolidation follow-up in
   // `consolidation-job.ts` remains the primary trigger; this interval only
   // self-heals when that follow-up is missed (failed enqueue). The job handler
   // itself no-ops when v3 is off, so
   // this guard is belt-and-suspenders that also avoids a wasted enqueue.
-  if (
-    isAssistantFeatureFlagEnabled("memory-v3-shadow", config) ||
-    isMemoryV3Live(config)
-  ) {
+  if (isMemoryV3Live(config)) {
     schedule.push({
       key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV3Maintain,
       intervalMs: GRAPH_V3_MAINTAIN_INTERVAL_MS,

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

@@ -105,22 +105,22 @@ mock.module("../../jobs-store.js", () => ({
   isMemoryEnabled: () => true,
 }));
 
-// ── v3 follow-up flag mock ──────────────────────────────────────────
+// ── v3 live gate mock ───────────────────────────────────────────────
 //
-// A v3 flag being on appends `memory_v3_maintain` to the post-consolidation
-// follow-up fan-out, and the LIVE flag (alone) selects the v3 article-shape
-// prompt. `v3FlagOn` toggles all flags at once for the existing tests;
-// `flagStates` overrides individual keys for the shadow-vs-live tests.
+// `memory.v3.live` being on appends `memory_v3_maintain` to the
+// post-consolidation follow-up fan-out, selects the v3 article-shape prompt,
+// and includes the core-pages curation section. `v3FlagOn` toggles the gate
+// for the existing on/off tests; `flagStates["memory-v3-live"]` overrides it
+// for the article-shape tests.
 let v3FlagOn = false;
 let flagStates: Record<string, boolean> = {};
 mock.module("../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) => flagStates[key] ?? v3FlagOn,
 }));
 
-// The v3-live gate moved to config (`config.memory.v3.live`), read via
-// `isMemoryV3Live`. Mirror the flag mock so the shadow-vs-live tests keep
-// driving live through `flagStates["memory-v3-live"]` (and `v3FlagOn` toggles
-// it alongside shadow for the existing on/off tests).
+// The v3-live gate lives in config (`config.memory.v3.live`), read via
+// `isMemoryV3Live`; drive it through `flagStates["memory-v3-live"]` (and
+// `v3FlagOn` for the existing on/off tests).
 mock.module("../../../config/memory-v3-gate.js", () => ({
   isMemoryV3Live: () => flagStates["memory-v3-live"] ?? v3FlagOn,
 }));
@@ -709,18 +709,15 @@ describe("CONSOLIDATION_PROMPT", () => {
   });
 });
 
-describe("article-shape selection — live flag only, never shadow", () => {
+describe("article-shape selection — keyed on the live gate", () => {
   // The v3 article shape drops the `summary:` field that v2 injection
-  // depends on. Under SHADOW, live prompts are still served by v2, so
-  // consolidation must keep producing v2-shaped pages — only the LIVE flag
-  // may select the v3 template. Collapsing this distinction (e.g. keying the
-  // shape on shadow||live) would corrupt the corpus of every shadow install
-  // before its flip.
+  // depends on, so only a live (`memory.v3.live`) install may select the v3
+  // template — a v2-only install must keep producing `summary:`-bearing pages.
   const V3_MARKER = "The lead IS the card";
 
-  test("shadow on, live off → v2 article shape", async () => {
+  test("v3 off → v2 article shape", async () => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");
-    flagStates = { "memory-v3-shadow": true, "memory-v3-live": false };
+    flagStates = { "memory-v3-live": false };
 
     await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
@@ -728,13 +725,13 @@ describe("article-shape selection — live flag only, never shadow", () => {
     const prompt = runnerLastArgs?.prompt as string;
     expect(prompt).not.toContain(V3_MARKER);
     expect(prompt).toContain("The `summary` field is required");
-    // §10 still rides the shadow flag.
-    expect(prompt).toContain("memory/core-pages.md");
+    // §10 (core-pages curation) is omitted on a v2-only install.
+    expect(prompt).not.toContain("memory/core-pages.md");
   });
 
   test("live on → v3 article shape", async () => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");
-    flagStates = { "memory-v3-shadow": false, "memory-v3-live": true };
+    flagStates = { "memory-v3-live": true };
 
     await memoryV2ConsolidateJob(makeJob(), CONFIG);
 

package/src/memory/v2/consolidation-job.ts

@@ -64,7 +64,6 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { isMemoryV3Live } from "../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { runBackgroundJob } from "../../runtime/background-job-runner.js";
@@ -85,12 +84,6 @@ const log = getLogger("memory-v2-consolidate");
 /** Stable identifier surfaced in `runBackgroundJob` logs and notifications. */
 const JOB_NAME = "memory.consolidate";
 
-/**
- * v3 plugin flags. Either being on enqueues `memory_v3_maintain` as a
- * post-consolidation follow-up. These gate the v3 plugin itself.
- */
-const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-
 /**
  * Hard timeout for the consolidation run. Consolidation reads the buffer,
  * rewrites several files, and re-encodes essentials/threads — generous
@@ -127,7 +120,7 @@ const STALE_LOCK_TTL_MS = 4 * CONSOLIDATION_TIMEOUT_MS;
  */
 const FOLLOW_UP_JOB_TYPES: readonly MemoryJobType[] = ["memory_v2_reembed"];
 
-/** Follow-up enqueued only when a v3 flag is on. */
+/** Follow-up enqueued only when v3 is live. */
 const V3_FOLLOW_UP_JOB_TYPE: MemoryJobType = "memory_v3_maintain";
 
 /**
@@ -262,21 +255,17 @@ export async function memoryV2ConsolidateJob(
     // the `memory.v2.consolidation_prompt_path` config override but bounds
     // it to a regular file under 1 MiB before substitution so a stray path
     // (or a `/dev/zero`-style pseudo-file) cannot exfiltrate megabytes of
-    // bytes through the wake hint. The core-pages curation section rides the
-    // same v3 gate as the maintenance follow-up: the file feeds the v3 core
-    // lane, so on a v2-only install the instruction would curate a file
-    // nothing reads.
-    // The article SHAPE is keyed on the live flag alone: under shadow, live
-    // prompts are still assembled by v2's injection model, so consolidation
-    // must keep producing `summary:`-bearing fragment pages until the flip.
+    // bytes through the wake hint. The core-pages curation section and the
+    // article SHAPE both ride the single `memory.v3.live` gate: the core-pages
+    // file feeds the v3 core lane (inert on a v2-only install), and the v3
+    // article shape drops the `summary:` field v2 injection depends on, so a
+    // v2-only install must keep producing `summary:`-bearing fragment pages.
     const memoryV3Live = isMemoryV3Live(config);
-    const memoryV3Active =
-      isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) || memoryV3Live;
     const prompt = resolveConsolidationPrompt(
       config.memory.v2.consolidation_prompt_path,
       cutoff,
       {
-        includeCorePagesSection: memoryV3Active,
+        includeCorePagesSection: memoryV3Live,
         articleShape: memoryV3Live ? "v3" : "v2",
       },
     );
@@ -309,11 +298,11 @@ export async function memoryV2ConsolidateJob(
 
     // Step 5: enqueue follow-up jobs. Enqueueing now keeps the dispatch
     // wiring exercised end-to-end so PR 21 only has to swap in the handler
-    // bodies. v3 maintenance is appended only while a v3 path (shadow or live)
-    // is active, so it never fans out on v2-only installs.
+    // bodies. v3 maintenance is appended only while v3 is live, so it never
+    // fans out on v2-only installs.
     const followUpJobIds: string[] = [];
     const jobTypes: MemoryJobType[] = [...FOLLOW_UP_JOB_TYPES];
-    if (memoryV3Active) {
+    if (memoryV3Live) {
       jobTypes.push(V3_FOLLOW_UP_JOB_TYPE);
     }
     for (const jobType of jobTypes) {

package/src/plugins/defaults/memory-v3-shadow/__tests__/injection.test.ts

@@ -12,8 +12,6 @@
  *   - fork dedup: a conversation whose everInjected record was seeded from
  *     inherited blocks does not re-render those slugs;
  *   - prune round-trip: a pruned slug that is re-selected re-injects;
- *   - shadow mode: attaches nothing and records nothing, but logs the
- *     would-inject set;
  *   - spotlight: current-window entries only, re-rendered (never accumulated),
  *     bounded by `n × (windowTurns + 1)`, live-only, absent from the
  *     persistent card layer.
@@ -58,7 +56,6 @@ let injectionMockActive = false;
 // ─── mutable test state ──────────────────────────────────────────────────────
 
 let liveEnabled = false;
-let shadowEnabled = false;
 let memoryEnabled = true;
 let spotlightConfig = { n: 6, windowTurns: 2 };
 /** `null` disables the prune valve (the default for tests not exercising it —
@@ -163,11 +160,7 @@ mock.module("../../../../config/assistant-feature-flags.js", () => ({
         config,
       );
     }
-    return key === "memory-v3-live"
-      ? liveEnabled
-      : key === "memory-v3-shadow"
-        ? shadowEnabled
-        : false;
+    return key === "memory-v3-live" ? liveEnabled : false;
   },
 }));
 
@@ -311,7 +304,6 @@ beforeEach(async () => {
   await flushPruneValveForTests();
   injectionMockActive = true;
   liveEnabled = false;
-  shadowEnabled = false;
   memoryEnabled = true;
   spotlightConfig = { n: 6, windowTurns: 2 };
   pruneConfig = null;
@@ -552,31 +544,6 @@ describe("memoryV3Injector — frozen net-new cards", () => {
     expect(getActiveSlugs("conv-1")).toEqual(new Set());
   });
 
-  test("shadow mode (live off) attaches nothing, records nothing, logs the would-inject set", async () => {
-    shadowEnabled = true;
-    turnResults.set(
-      0,
-      result(
-        ["page-a"],
-        [["page-a", section("page-a", "Heading", "section text")]],
-      ),
-    );
-
-    expect(await produceCards("conv-1", 0)).toBeNull();
-    expect(await produceSpotlight("conv-1", 0)).toBeNull();
-    expect(getActiveSlugs("conv-1")).toEqual(new Set());
-    const shadowLog = logCalls.find((c) =>
-      c.msg.includes("memory-v3 shadow: would inject"),
-    );
-    expect(shadowLog).toBeDefined();
-    const data = shadowLog!.data as {
-      netNew: Array<{ slug: string; bytes: number }>;
-      spotlightRefs: string[];
-    };
-    expect(data.netNew.map((e) => e.slug)).toEqual(["page-a"]);
-    expect(data.spotlightRefs).toEqual(["page-a§Heading"]);
-  });
-
   test("the persistent card block never contains the spotlight wrapper", async () => {
     liveEnabled = true;
     turnResults.set(
@@ -709,8 +676,7 @@ describe("memoryV3SpotlightInjector — ephemeral section spotlight", () => {
     expect(await produceSpotlight("conv-1", 0)).toBeNull();
   });
 
-  test("live off → null even when shadow is on", async () => {
-    shadowEnabled = true;
+  test("live off → null", async () => {
     turnResults.set(0, result(["page-a"], [["page-a", sectionA]]));
     expect(await produceSpotlight("conv-1", 0)).toBeNull();
   });