@vellumai/assistant 0.10.3-dev.202606282129.2e2ccad → 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.202606282129.2e2ccad",
+  "version": "0.10.3-dev.202606282228.b3d6565",
   "license": "MIT",
   "type": "module",
   "exports": {

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/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();
   });

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

@@ -1,6 +1,5 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
-import { setOverridesForTesting } from "../../../../__tests__/feature-flag-test-helpers.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { EmbeddingBackendUnavailableError } from "../../../../memory/embedding-backend.js";
 import { EmbeddingBillingBlockError } from "../../../../memory/embedding-billing-breaker.js";
@@ -17,12 +16,8 @@ import {
 import { buildSectionIndex } from "../sections.js";
 import type { Section, SectionIndex, Slug } from "../types.js";
 
-const FLAG_SHADOW = "memory-v3-shadow";
-
-// The shadow flag resolver ignores the passed config and reads the override
-// cache; the config arg only satisfies the signature. Shadow is driven via
-// `setOverridesForTesting`; v3-live (now config-gated) is driven through the
-// `isMemoryV3Live` mock slot below.
+// v3-live (config-gated) is driven through the `isMemoryV3Live` mock slot
+// below; the config arg only satisfies the signature.
 const CONFIG = {} as AssistantConfig;
 
 let memoryV3LiveSlot = false;
@@ -50,7 +45,6 @@ const JOB = { id: "job-1", type: "memory_v3_maintain" } as unknown as MemoryJob;
 
 describe("maintainJob", () => {
   afterEach(() => {
-    setOverridesForTesting({});
     memoryV3LiveSlot = false;
   });
 
@@ -103,8 +97,7 @@ describe("maintainJob", () => {
     return { deps: { ...base, ...overrides }, calls };
   }
 
-  test("no-op when both v3 flags are off", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: false });
+  test("no-op when v3 is disabled", async () => {
     const { deps: d, calls } = deps({
       selectChangedPages: async () => ["page-a"],
     });
@@ -114,8 +107,8 @@ describe("maintainJob", () => {
     expect(calls.invalidate).toBe(0);
   });
 
-  test("re-chunks + re-embeds changed pages and invalidates lanes (shadow on)", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+  test("re-chunks + re-embeds changed pages and invalidates lanes (live on)", async () => {
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       selectChangedPages: async () => ["page-a", "page-b"],
     });
@@ -148,7 +141,7 @@ describe("maintainJob", () => {
   });
 
   test("skips the dense store entirely when no pages changed", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({ selectChangedPages: async () => [] });
     const outcome = await maintainJob(JOB, CONFIG, d);
     expect(outcome.reembedded).toBe(0);
@@ -161,7 +154,7 @@ describe("maintainJob", () => {
   });
 
   test("a single failing page is contained; other pages still re-embed", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       selectChangedPages: async () => ["page-ok", "page-bad", "page-ok-2"],
       upsertSections: async (_config, sections) => {
@@ -190,7 +183,7 @@ describe("maintainJob", () => {
   });
 
   test("a thrown re-embed stage does not abort lane invalidation", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       selectChangedPages: async () => {
         throw new Error("select boom");
@@ -204,7 +197,7 @@ describe("maintainJob", () => {
   });
 
   test("advances the high-water mark after a successful re-embed pass", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       selectChangedPages: async () => ["page-a"],
     });
@@ -213,7 +206,7 @@ describe("maintainJob", () => {
   });
 
   test("does not advance the high-water mark when selection throws", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       selectChangedPages: async () => {
         throw new Error("select boom");
@@ -225,7 +218,7 @@ describe("maintainJob", () => {
   });
 
   test("prunes sections for an article absent from the page index", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     // The dense store holds points for a live page, a deleted page, and a
     // synthetic capability row; the page index holds only the live + synthetic
     // slugs. Only the deleted page's sections are pruned. `selectChangedPages`
@@ -250,7 +243,7 @@ describe("maintainJob", () => {
   });
 
   test("prunes nothing when every stored article is still in the index", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       listSectionArticles: async () => ["page-a", "page-b"],
       listIndexedSlugs: async () => ["page-a", "page-b", "page-c"],
@@ -262,7 +255,7 @@ describe("maintainJob", () => {
   });
 
   test("a single failing prune delete is contained; other deletions proceed", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       listSectionArticles: async () => ["gone-1", "gone-bad", "gone-2"],
       listIndexedSlugs: async () => [],
@@ -284,7 +277,7 @@ describe("maintainJob", () => {
   });
 
   test("reports dangling core entries without mutating anything", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     // The core file lists a live page, a renamed/deleted page, and a synthetic
     // capability slug; only the missing page is reported. The stage is
     // report-only: no deletes, no upserts, and the maintainer-owned file is
@@ -308,7 +301,7 @@ describe("maintainJob", () => {
   });
 
   test("reports nothing when every core entry is still in the index", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d } = deps({
       loadCoreSet: () => ["page-a", "page-b"],
       listIndexedSlugs: async () => ["page-a", "page-b", "page-c"],
@@ -318,7 +311,7 @@ describe("maintainJob", () => {
   });
 
   test("an empty core set skips validation entirely", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     let indexReads = 0;
     const { deps: d } = deps({
       loadCoreSet: () => [],
@@ -335,7 +328,7 @@ describe("maintainJob", () => {
   });
 
   test("a thrown core-validation stage is contained and does not abort lane invalidation", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       loadCoreSet: () => {
         throw new Error("core boom");
@@ -350,7 +343,7 @@ describe("maintainJob", () => {
   });
 
   test("a thrown prune stage is contained and does not abort lane invalidation", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       listSectionArticles: async () => {
         throw new Error("scroll boom");
@@ -366,7 +359,7 @@ describe("maintainJob", () => {
   });
 
   test("reconciles capability rows missing from the section store", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     // The index lists a real page and three capability rows; the store already
     // holds one of the caps. The change-delta excludes capability rows, so
     // without this stage a skill enabled after the one-time backfill never
@@ -397,7 +390,7 @@ describe("maintainJob", () => {
   });
 
   test("skips a cold capability row (empty body) without deleting its points", async () => {
-    setOverridesForTesting({ [FLAG_SHADOW]: true });
+    memoryV3LiveSlot = true;
     const { deps: d, calls } = deps({
       listIndexedSlugs: async () => ["skills/cold"],
       listSectionArticles: async () => [],
@@ -459,7 +452,6 @@ describe("computeChangedPages", () => {
 
 describe("backfillAllSections", () => {
   afterEach(() => {
-    setOverridesForTesting({});
     memoryV3LiveSlot = false;
   });
 

package/src/plugins/defaults/memory-v3-shadow/__tests__/selection-log-store.test.ts

@@ -11,7 +11,7 @@
  *   - the fork fallback: a turn inherited from a fork resolves to the parent's
  *     rows via the message's `forkSourceMessageId` back-pointer;
  *   - source/pinned/section mapping and the rendered `<memory>` block;
- *   - `live` / `shadow` reflect the flag resolver.
+ *   - `live` reflects the config gate.
  *
  * `mock.module` is process-global and leaks into sibling files in a
  * `bun test <dir>` run, so every stub DELEGATES to the real implementation
@@ -37,7 +37,6 @@ const realPageContent = { ...(await import("../page-content.js")) };
 
 let storeMockActive = false;
 let liveEnabled = false;
-let shadowEnabled = false;
 
 let testSqlite: Database;
 let testDb = makeDb();
@@ -101,9 +100,7 @@ mock.module("../../../../config/assistant-feature-flags.js", () => ({
     storeMockActive
       ? key === "memory-v3-live"
         ? liveEnabled
-        : key === "memory-v3-shadow"
-          ? shadowEnabled
-          : false
+        : false
       : realFlags.isAssistantFeatureFlagEnabled(
           key as Parameters<typeof realFlags.isAssistantFeatureFlagEnabled>[0],
           config as Parameters<
@@ -152,7 +149,6 @@ const {
 beforeEach(() => {
   storeMockActive = true;
   liveEnabled = false;
-  shadowEnabled = false;
   testDb = makeDb();
 });
 
@@ -222,18 +218,15 @@ describe("getMemoryV3SelectionForInspector", () => {
     expect(log?.injectedText).toContain("body for domain-b/page-2");
   });
 
-  test("live/shadow reflect the flag resolver", async () => {
+  test("live reflects the config gate", async () => {
     seed("conv-5", 1, [{ slug: "domain-a/page-1", source: "needle" }]);
 
     const off = await getMemoryV3SelectionForInspector("conv-5", 1);
     expect(off?.live).toBe(false);
-    expect(off?.shadow).toBe(false);
 
     liveEnabled = true;
-    shadowEnabled = true;
     const on = await getMemoryV3SelectionForInspector("conv-5", 1);
     expect(on?.live).toBe(true);
-    expect(on?.shadow).toBe(true);
   });
 });
 

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

@@ -1,28 +1,27 @@
 /**
- * Shadow-mode end-to-end integration test for the memory-v3 section-lane
- * pipeline.
+ * End-to-end integration test for the memory-v3 section-lane pipeline.
  *
- * SCOPE / ALTITUDE. A full daemon-assembly run (plugin registry → flag read →
+ * SCOPE / ALTITUDE. A full daemon-assembly run (plugin registry → config read →
  * runtime assembly → provider call → DB write) is too heavy and too
- * mock-fragile for a unit test. Instead this composes the REAL shadow units
+ * mock-fragile for a unit test. Instead this composes the REAL engine units
  * with a mocked select provider, a stubbed dense lane, an in-memory selections
  * DB, and synthetic fixtures, driving them over a MULTI-TURN sequence:
  *
  *   orchestrate (cache-ordered pool: core + hot stable prefix, then
  *     needle ∪ dense ∪ edge finder candidates → ONE selectPool call)
- *       → attribute selections to lane sources (the shadow plugin's REAL
+ *       → attribute selections to lane sources (the plugin's REAL
  *         `attributeSelections`, reading `result.lanes`)
- *       → write to `memory_v3_selections` (the shadow plugin's REAL
+ *       → write to `memory_v3_selections` (the plugin's REAL
  *         `writeSelections`)
  *       → summarizeSelections (the offline A/B readout)
  *
- * This is exactly the side-effect contract shadow mode observes each turn: the
+ * This is exactly the selection contract the engine records each turn: the
  * candidate pool is the cache-ordered union of the lanes — synthetic capability
  * pages are indexed like any other page, so they enter through the needle lane
  * rather than being always-added — a SINGLE select runs per turn, the result is
- * this turn's selections only, and each selection is
- * logged tagged with its lane source. None of this changes live injection —
- * shadow mode is observation-only; cutover is the `memory-v3-live` flag flip.
+ * this turn's selections only, and each selection is logged tagged with its
+ * lane source. Selection logging runs on the live path
+ * (`memory.v3.live`); injection is exercised in the injector tests.
  *
  * Slugs are generic placeholders (`page-a`, `topic-x`, `page-b`, …) — this is a
  * public repo.
@@ -342,7 +341,7 @@ afterAll(() => {
 // their content — not by always being appended.
 // ---------------------------------------------------------------------------
 
-describe("memory-v3 shadow integration — candidate pool", () => {
+describe("memory-v3 integration — candidate pool", () => {
   test("pool unions needle ∪ dense ∪ edge; one select per turn", async () => {
     const lanes = await buildLanes();
     // "apple" hits page-a (needle). Dense returns page-b. page-a links to
@@ -372,7 +371,7 @@ describe("memory-v3 shadow integration — candidate pool", () => {
 // source tags. Selections are current-turn only — nothing carries.
 // ---------------------------------------------------------------------------
 
-describe("memory-v3 shadow integration — core + hot stable prefix", () => {
+describe("memory-v3 integration — core + hot stable prefix", () => {
   test("core and hot head the pool every turn and log lane-correct sources", async () => {
     const lanes = await buildLanes();
     const prefix = { core: ["topic-x"], hot: ["page-b"] };
@@ -422,7 +421,7 @@ describe("memory-v3 shadow integration — core + hot stable prefix", () => {
 // matched section and is attributed `needle` — exactly like a concept page.
 // ---------------------------------------------------------------------------
 
-describe("memory-v3 shadow integration — lane-source attribution", () => {
+describe("memory-v3 integration — lane-source attribution", () => {
   test("a needle-ranked capability selection is logged with the needle source", async () => {
     const lanes = await buildLanes();
     // "durian" matches the capability page's content section, so selecting it
@@ -437,11 +436,11 @@ describe("memory-v3 shadow integration — lane-source attribution", () => {
 });
 
 // ---------------------------------------------------------------------------
-// A/B readout: summarizeSelections aggregates the logged shadow run by lane
+// A/B readout: summarizeSelections aggregates the logged run by lane
 // source, and reports turn count + distinct-slug selection footprint.
 // ---------------------------------------------------------------------------
 
-describe("memory-v3 shadow integration — selection-log readout", () => {
+describe("memory-v3 integration — selection-log readout", () => {
   test("summarizeSelections aggregates a multi-turn run by source", async () => {
     const lanes = await buildLanes();
     const prefix = { hot: ["topic-x"] };

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

@@ -1,12 +1,10 @@
 /**
  * Tests for `shadow-plugin.ts` (section-lane pipeline).
  *
- * The v3 plugin is flag-gated. These tests assert:
- *   - both flags OFF → orchestrate is never called and no DB rows are written;
- *   - either flag ON → orchestrate runs and selection rows land in
+ * These tests assert the v3 orchestration engine and the live injector:
+ *   - {@link observeTurn} runs orchestration and selection rows land in
  *     `memory_v3_selections` with the new lane source tags;
- *   - shadow-only (live off) → the injector returns `null` (never mutates the
- *     turn) but still logs;
+ *   - {@link observeTurn} is skipped when global memory is disabled;
  *   - live on → the injector returns the rendered `<memory>` block;
  *   - an empty selection under live → `null`;
  *   - lazy-init runs the lane builders only once across multiple turns, and
@@ -79,7 +77,6 @@ let shadowMockActive = false;
 // ─── mutable test state, read by the mocks below ────────────────────────────
 
 let liveEnabled = false;
-let shadowEnabled = false;
 let memoryEnabled = true;
 let messages: Array<{ role: string; content: string }> = [];
 
@@ -177,11 +174,7 @@ const FAKE_SECTION_INDEX: SectionIndex = {
 
 mock.module("../../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "memory-v3-live"
-      ? liveEnabled
-      : key === "memory-v3-shadow"
-        ? shadowEnabled
-        : false,
+    key === "memory-v3-live" ? liveEnabled : false,
 }));
 
 mock.module("../../../../config/loader.js", () => ({
@@ -383,7 +376,7 @@ mock.module("../orchestrate.js", () => ({
 
 // Import AFTER mocks so the plugin binds to them.
 const {
-  runShadowObservation,
+  observeTurn,
   resetShadowLanesForTests,
   invalidateLanes,
   attributeSelections,
@@ -407,7 +400,6 @@ function readRows() {
 beforeEach(() => {
   shadowMockActive = true;
   liveEnabled = false;
-  shadowEnabled = false;
   memoryEnabled = true;
   messages = [
     {
@@ -448,30 +440,19 @@ async function produce(conversationId: string, turnIndex: number) {
   return block;
 }
 
-describe("memory-v3 shadow plugin", () => {
-  test("global memory disabled → observation is skipped even when v3 flags are on", async () => {
-    shadowEnabled = true;
-    liveEnabled = true;
+describe("memory-v3 engine", () => {
+  test("global memory disabled → observation is skipped", async () => {
     memoryEnabled = false;
 
-    await runShadowObservation("conv-1", 0);
-
-    expect(orchestrateSpy).not.toHaveBeenCalled();
-    expect(sectionBuilds).toBe(0);
-    expect(readRows()).toHaveLength(0);
-  });
+    await observeTurn("conv-1", 0);
 
-  test("shadow flag OFF → orchestrate not called, no DB writes", async () => {
-    shadowEnabled = false;
-    await runShadowObservation("conv-1", 0);
     expect(orchestrateSpy).not.toHaveBeenCalled();
     expect(sectionBuilds).toBe(0);
     expect(readRows()).toHaveLength(0);
   });
 
-  test("shadow flag ON → orchestrate runs and rows are written with per-lane sources", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 2);
+  test("observeTurn runs orchestration and writes rows with per-lane sources", async () => {
+    await observeTurn("conv-1", 2);
 
     expect(orchestrateSpy).toHaveBeenCalledTimes(1);
     const rows = readRows();
@@ -499,7 +480,6 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("the turn carries the tail of the previous assistant reply for the reply-query pass", async () => {
-    shadowEnabled = true;
     messages = [
       {
         role: "user",
@@ -516,7 +496,7 @@ describe("memory-v3 shadow plugin", () => {
         content: JSON.stringify([{ type: "text", text: "and now this" }]),
       },
     ];
-    await runShadowObservation("conv-1", 1);
+    await observeTurn("conv-1", 1);
 
     const turn = (
       orchestrateSpy.mock.calls as unknown as unknown[][]
@@ -528,8 +508,7 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("a conversation-opening turn has no previous assistant message", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
 
     const turn = (
       orchestrateSpy.mock.calls as unknown as unknown[][]
@@ -562,8 +541,7 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("the turn passed to orchestrate carries the latest user message", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
     const turn = (
       orchestrateSpy.mock.calls as unknown as unknown[][]
     )[0]![0] as {
@@ -577,8 +555,7 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("orchestrate receives the lane deps", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
     const deps = (
       orchestrateSpy.mock.calls as unknown as unknown[][]
     )[0]![1] as {
@@ -596,7 +573,6 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("initLanes filters core to existing pages and excludes core from the hot set", async () => {
-    shadowEnabled = true;
     // The core file lists a live page and a dangling slug; the hot set returns
     // a live page and a deleted one (selection rows can outlive their pages).
     coreSetSlugs = ["page-1", "missing-page"];
@@ -604,7 +580,7 @@ describe("memory-v3 shadow plugin", () => {
       { slug: "page-2", score: 2 },
       { slug: "gone-page", score: 1 },
     ];
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
 
     const deps = (
       orchestrateSpy.mock.calls as unknown as unknown[][]
@@ -619,27 +595,16 @@ describe("memory-v3 shadow plugin", () => {
     expect(hotSetOpts?.halfLifeMs).toBe(14 * 24 * 60 * 60 * 1000);
   });
 
-  test("both flags OFF → produce returns null, no orchestrate, no writes", async () => {
+  test("live off → produce returns null, no orchestrate, no writes", async () => {
     liveEnabled = false;
-    shadowEnabled = false;
     const block = await produce("conv-1", 0);
     expect(block).toBeNull();
     expect(orchestrateSpy).not.toHaveBeenCalled();
     expect(readRows()).toHaveLength(0);
   });
 
-  test("shadow-only (live off) → produce returns null but still logs", async () => {
-    liveEnabled = false;
-    shadowEnabled = true;
-    const block = await produce("conv-1", 0);
-    expect(block).toBeNull();
-    expect(orchestrateSpy).toHaveBeenCalledTimes(1);
-    expect(readRows().length).toBeGreaterThan(0);
-  });
-
   test("live on → produce returns the net-new CARD block and logs", async () => {
     liveEnabled = true;
-    shadowEnabled = false;
     const block = await produce("conv-1", 0);
     expect(block).not.toBeNull();
     expect(block!.placement).toBe("after-memory-prefix");
@@ -659,7 +624,6 @@ describe("memory-v3 shadow plugin", () => {
 
   test("live on → a later turn re-selecting the same pages renders an EMPTY block (net-new dedup)", async () => {
     liveEnabled = true;
-    shadowEnabled = false;
     const first = await produce("conv-1", 0);
     expect(first!.text.length).toBeGreaterThan(0);
     // Same orchestrate fixture on the next turn → zero net-new cards. The
@@ -671,7 +635,6 @@ describe("memory-v3 shadow plugin", () => {
 
   test("live on but empty selection → produce returns null", async () => {
     liveEnabled = true;
-    shadowEnabled = false;
     orchestrateSpy.mockImplementationOnce(async () => ({
       selections: [],
       matchedSections: new Map(),
@@ -684,10 +647,9 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("lazy-init runs the lane builders only once across turns", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
-    await runShadowObservation("conv-1", 1);
-    await runShadowObservation("conv-1", 2);
+    await observeTurn("conv-1", 0);
+    await observeTurn("conv-1", 1);
+    await observeTurn("conv-1", 2);
     expect(sectionBuilds).toBe(1);
     expect(needleBuilds).toBe(1);
     expect(edgeBuilds).toBe(1);
@@ -696,12 +658,11 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("a Qdrant section-collection failure does not disable the in-memory lanes", async () => {
-    shadowEnabled = true;
     ensureCollectionThrows = true;
     // initLanes still builds the needle + edge lanes and orchestrate runs — a
     // Qdrant outage degrades only the dense lane, it does not take down all of v3
     // (and does not poison the memoized lanes by rejecting init).
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
     expect(needleBuilds).toBe(1);
     expect(edgeBuilds).toBe(1);
     expect(ensureCollectionCalls).toBe(1);
@@ -709,69 +670,64 @@ describe("memory-v3 shadow plugin", () => {
   });
 
   test("invalidateLanes forces a one-time rebuild on the next turn", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
-    await runShadowObservation("conv-1", 1);
+    await observeTurn("conv-1", 0);
+    await observeTurn("conv-1", 1);
     expect(sectionBuilds).toBe(1);
     expect(needleBuilds).toBe(1);
 
     invalidateLanes();
 
-    await runShadowObservation("conv-1", 2);
+    await observeTurn("conv-1", 2);
     expect(sectionBuilds).toBe(2);
     expect(needleBuilds).toBe(2);
     expect(edgeBuilds).toBe(2);
 
     // ...and the rebuild is memoized again — no further builds until the next
     // invalidation.
-    await runShadowObservation("conv-1", 3);
+    await observeTurn("conv-1", 3);
     expect(sectionBuilds).toBe(2);
     expect(needleBuilds).toBe(2);
   });
 
   test("resetShadowLanesForTests invalidates like invalidateLanes", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
     expect(sectionBuilds).toBe(1);
 
     resetShadowLanesForTests();
 
-    await runShadowObservation("conv-1", 1);
+    await observeTurn("conv-1", 1);
     expect(sectionBuilds).toBe(2);
   });
 
   test("concurrent first turns after invalidation share a single build", async () => {
-    shadowEnabled = true;
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
     expect(sectionBuilds).toBe(1);
 
     invalidateLanes();
 
     await Promise.all([
-      runShadowObservation("conv-1", 1),
-      runShadowObservation("conv-1", 2),
+      observeTurn("conv-1", 1),
+      observeTurn("conv-1", 2),
     ]);
     expect(sectionBuilds).toBe(2);
     expect(needleBuilds).toBe(2);
   });
 
   test("no user message → no orchestrate, no writes", async () => {
-    shadowEnabled = true;
     messages = [
       {
         role: "assistant",
         content: JSON.stringify([{ type: "text", text: "hi" }]),
       },
     ];
-    await runShadowObservation("conv-1", 0);
+    await observeTurn("conv-1", 0);
     expect(orchestrateSpy).not.toHaveBeenCalled();
     expect(readRows()).toHaveLength(0);
   });
 
   describe("initLanes feeds synthetic capability pages into the section index", () => {
     test("the pageBody resolver returns capability content for a synthetic slug and disk body otherwise", async () => {
-      shadowEnabled = true;
-      await runShadowObservation("conv-1", 0);
+      await observeTurn("conv-1", 0);
 
       // `initLanes` ran the real pageBody-building closure and handed it to
       // `buildSectionIndex`; the stub captured it.
@@ -787,8 +743,7 @@ describe("memory-v3 shadow plugin", () => {
     });
 
     test("a synthetic slug's capability content yields a section the needle ranks", async () => {
-      shadowEnabled = true;
-      await runShadowObservation("conv-1", 0);
+      await observeTurn("conv-1", 0);
       const pageBody = capturedPageBody!;
 
       // Feed the captured resolver through the REAL section builder + needle:
@@ -819,35 +774,21 @@ describe("memory-v3 infrastructure-failure handling", () => {
 
   test("LIVE injector logs and degrades to no v3 block on an infra failure", async () => {
     liveEnabled = true;
-    shadowEnabled = false;
     throwInfra();
 
     expect(await produce("conv-infra-live", 0)).toBeNull();
   });
 
-  test("SHADOW injector swallows an infra failure (v2 fallback) — no throw, no block", async () => {
-    liveEnabled = false;
-    shadowEnabled = true;
-    throwInfra();
-
-    // Shadow mode: v2 retrieval still ran this turn, so the v3 injector returns
-    // null.
-    expect(await produce("conv-infra-shadow", 0)).toBeNull();
-  });
-
-  test("runShadowObservation never throws on an infra failure (fire-and-forget)", async () => {
-    liveEnabled = false;
-    shadowEnabled = true;
+  test("observeTurn rethrows an infra failure so the injector can degrade distinctly", async () => {
     throwInfra();
 
-    await expect(
-      runShadowObservation("conv-infra-obs", 0),
-    ).resolves.toBeUndefined();
+    await expect(observeTurn("conv-infra-obs", 0)).rejects.toBeInstanceOf(
+      MemoryV3RetrievalUnavailableError,
+    );
   });
 
   test("LIVE injector stays NON-fatal on a non-infra error (degrades to no v3 block)", async () => {
     liveEnabled = true;
-    shadowEnabled = false;
     orchestrateSpy.mockImplementationOnce(async () => {
       throw new Error("some unexpected non-infra bug");
     });

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

@@ -24,11 +24,10 @@
  *    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).
+ *    every net-new card rendered empty) attaches no v3 block: 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`
@@ -41,9 +40,8 @@
  *    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.
+ * Gating: `memory.v3.live` (config) runs orchestration and attaches blocks;
+ * with it off, no orchestration runs and nothing is attached.
  *
  * Both injectors apply the same personal-memory trust gate as v2
  * ({@link isPersonalMemoryAllowed}): an untrusted remote actor's turn
@@ -60,7 +58,6 @@
  * 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 {
@@ -90,7 +87,7 @@ import {
   renderSpotlightInner,
   type SpotlightEntry,
 } from "./render-injection.js";
-import { MEMORY_V3_SHADOW, observeTurn } from "./shadow-plugin.js";
+import { observeTurn } from "./shadow-plugin.js";
 import {
   MEMORY_V3_BLOCK_ID,
   MEMORY_V3_COMMIT_META_KEY,
@@ -261,8 +258,7 @@ export const memoryV3Injector: Injector = {
     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 (!live) return null;
     if (!isPersonalMemoryAllowed(ctx.trust)) return null;
 
     let observed: OrchestrateResult | null;
@@ -275,18 +271,17 @@ export const memoryV3Injector: Injector = {
           {
             err: err.message,
             conversationId: ctx.conversationId,
-            mode: live ? "live" : "shadow",
+            mode: "live",
           },
           "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.
+    // Empty selection → return null (attach nothing). The user-prompt-submit
+    // hook skipped v2 retrieval under live, so a turn with nothing selected
+    // simply gets no v3 `<memory>` block (prior turns' frozen cards still ride
+    // history).
     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`).
@@ -307,12 +302,10 @@ export const memoryV3Injector: Injector = {
         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.
+      // empty-text block. Under 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,
@@ -325,25 +318,6 @@ export const memoryV3Injector: Injector = {
         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
@@ -396,9 +370,8 @@ export const memoryV3SpotlightInjector: Injector = {
   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).
+    // The spotlight rides the live `<memory>` layer; with `memory.v3.live` off
+    // it produces nothing and keeps no ring state.
     if (!isMemoryV3Live(config)) return null;
     if (!isPersonalMemoryAllowed(ctx.trust)) return null;
 

package/src/plugins/defaults/memory-v3-shadow/maintain-job.ts

@@ -51,7 +51,6 @@
  * and `invalidateLanes` without process-global module mocks.
  */
 
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { isMemoryV3Live } from "../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../config/types.js";
 import {
@@ -80,8 +79,6 @@ import { buildSectionIndex as realBuildSectionIndex } from "./sections.js";
 import { invalidateLanes as realInvalidateLanes } from "./shadow-plugin.js";
 import type { Slug } from "./types.js";
 
-const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-
 /**
  * Durable checkpoint holding the epoch-ms high-water mark of the last successful
  * re-embed pass. Pages whose mtime is past this mark are re-chunked + re-embedded
@@ -656,9 +653,7 @@ export async function maintainJob(
     failures: [],
   };
 
-  const enabled =
-    isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
-    isMemoryV3Live(config);
+  const enabled = isMemoryV3Live(config);
   if (!enabled) {
     outcome.disabled = true;
     return outcome;

package/src/plugins/defaults/memory-v3-shadow/selection-log-store.ts

@@ -17,7 +17,6 @@
  */
 
 import type { MemoryV3SelectionLog } from "../../../api/responses/memory-v3-selection-log.js";
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../config/loader.js";
 import { isMemoryV3Live } from "../../../config/memory-v3-gate.js";
 import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
@@ -35,8 +34,6 @@ import {
   type Slug,
 } from "./types.js";
 
-const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-
 interface SelectionRow {
   turn: number;
   slug: string;
@@ -180,7 +177,6 @@ async function buildSelectionLog(
   return {
     turn: rows[0]!.turn,
     live: isMemoryV3Live(config),
-    shadow: isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config),
     selections,
     injectedText,
   };

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

@@ -1,20 +1,12 @@
 /**
- * Memory v3 — flag-gated shadow/live orchestration engine.
+ * Memory v3 — config-gated live orchestration engine.
  *
- * Runs the v3 orchestrator each turn and records its selection set to
- * `memory_v3_selections`. Two flags gate behavior:
+ * When `memory.v3.live` is set, runs the v3 orchestrator each turn and records
+ * its selection set to `memory_v3_selections`. The injector (`memoryV3Injector`
+ * in `./injector.ts`) renders this turn's selections into a `<memory>` block
+ * and returns it at v2's dynamic-memory placement (`after-memory-prefix`).
  *
- *   - `memory-v3-shadow` (live OFF): observation-only. {@link observeTurn}
- *     orchestrates and logs the selection set; no injection is produced, so v2
- *     injection is bit-for-bit identical — the only difference is the
- *     side-effect telemetry write.
- *   - `memory-v3-live`: live injection. The injector (`memoryV3Injector` in
- *     `./injector.ts`) additionally renders this turn's selections into a
- *     `<memory>` block and returns it at v2's dynamic-memory placement
- *     (`after-memory-prefix`). Selections are still logged.
- *   - both OFF: orchestration is skipped entirely.
- *
- * On each turn (either flag on):
+ * On each live turn:
  *   1. Lazy-init the v3 lanes ONCE across the whole process (section index,
  *      section-grain BM25 needle, dense lane config, link-graph edge graph,
  *      curated core set, frecency hot set), memoizing the init promise so
@@ -23,15 +15,13 @@
  *   3. Run {@link orchestrate} and record its selection set to
  *      `memory_v3_selections` with a best-effort lane attribution.
  *
- * {@link observeTurn} wraps everything after the flag read in try/catch — any
- * failure is logged and swallowed so it can never affect the live turn. The
- * injector treats a `null`/empty result as "no v3 injection", so v2 memory
- * remains the fallback rather than dropping all memory.
+ * {@link observeTurn} wraps everything in try/catch — any failure is logged and
+ * swallowed so it can never affect the live turn. The injector treats a
+ * `null`/empty result as "no v3 injection".
  */
 
 import { existsSync, readFileSync } from "node:fs";
 
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../config/loader.js";
 import type { AssistantConfig } from "../../../config/schema.js";
 import { loadSkillCatalog } from "../../../config/skills.js";
@@ -71,8 +61,6 @@ import {
   type Slug,
 } from "./types.js";
 
-export const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-
 const log = getLogger("memory-v3-shadow");
 
 /** How many recent messages to fold into the shadow `recentContext` string. */
@@ -619,25 +607,3 @@ export async function observeTurn(
     return null;
   }
 }
-
-/**
- * Test-facing shadow wrapper: gate on the shadow flag, then run v3
- * orchestration for one turn and log the selection set. Production injection
- * goes through `produce()` → {@link observeTurn} directly (which checks both
- * flags); this wrapper exists so tests can drive shadow observation in
- * isolation. Never throws — all failures are logged and swallowed so the live
- * turn is unaffected.
- */
-export async function runShadowObservation(
-  conversationId: string,
-  turnIndex: number,
-): Promise<void> {
-  const config = getConfig();
-  if (config.memory.enabled === false) return;
-  if (!isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config)) return;
-  try {
-    await observeTurn(conversationId, turnIndex);
-  } catch {
-    // Shadow observation is fire-and-forget and must never fail a turn.
-  }
-}