@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/injector-chain.test.ts

@@ -1,29 +1,25 @@
 /**
- * Tests for the plugin-driven runtime-injection chain (PR 21 of the
- * `agent-plugin-system` plan).
+ * Tests for the static runtime-injection chain.
  *
  * Covers:
  *
- * 1. The ten default injectors registered by `defaultInjectorsPlugin` come
- *    back from `getInjectors()` in the documented order
- *    (disk-pressure-warning → workspace-context → unified-turn-context →
- *    pkb-context → pkb-reminder → memory-v2-static → now-md →
+ * 1. The default injectors ({@link defaultInjectors}) are listed in the
+ *    documented order (disk-pressure-warning → workspace-context →
+ *    background-turn → unified-turn-context → pkb-context → pkb-reminder →
+ *    memory-v2-static → now-md → active-documents → document-comments →
  *    subagent-status → slack-messages → thread-focus).
- * 2. A third-party-registered injector at `order: 25` slots between
- *    `unified-turn-context` (order 20) and `pkb` (order 30), proving the
- *    extensibility contract.
- * 3. `composeInjectorChain` concatenates non-null blocks with a blank-line
- *    separator and yields an empty string when every injector opts out — the
- *    latter matches pre-PR behavior for the golden-path conversation state
- *    (all defaults return `null` in this PR).
- * 4. `applyRuntimeInjections` with an empty `turnContext` chain leaves
- *    `blocks.injectorChainBlock` undefined, preserving the existing snapshot
- *    for conversations that don't opt into the chain.
- * 5. `applyRuntimeInjections` surfaces the composed chain output on
- *    `blocks.injectorChainBlock` when a third-party injector contributes
- *    content.
+ * 2. The assembled {@link injectorChain} sorts the defaults together with the
+ *    memory-v3 injector by ascending `order`, so memory-v3 (order 1000) lands
+ *    last.
+ * 3. `composeInjectorChain` yields an empty string when every injector opts out
+ *    — the golden-path conversation state where all defaults return `null`.
+ * 4. `applyRuntimeInjections` splices each default injector's block into the
+ *    correct position in the per-turn message array, and gates blocks by
+ *    injection mode.
  */
 
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // This test exercises v1 PKB injection. `config.memory.v2.enabled`
@@ -44,20 +40,15 @@ mock.module("../config/loader.js", () => ({
 
 const { applyRuntimeInjections, composeInjectorChain } =
   await import("../daemon/conversation-runtime-assembly.js");
-const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
+const { DEFAULT_INJECTOR_ORDER, defaultInjectors } =
   await import("../plugins/defaults/injectors/register.js");
-import {
-  getInjectors,
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
-import type {
-  InjectionBlock,
-  Injector,
-  Plugin,
-  TurnContext,
-} from "../plugins/types.js";
+const { getInjectorChain } =
+  await import("../plugins/defaults/memory-retrieval/injector-chain.js");
+import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
+import { getPkbRoot } from "../memory/pkb/types.js";
+import type { TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 
 /** A fake TurnContext sufficient for driving `composeInjectorChain`. */
 function makeTurnContext(): TurnContext {
@@ -72,26 +63,45 @@ function makeTurnContext(): TurnContext {
   };
 }
 
-/** Build a tiny valid plugin wrapping an array of injectors. */
-function wrapInPlugin(name: string, injectors: Injector[]): Plugin {
-  return {
-    manifest: {
-      name,
-      version: "0.0.1",
-    },
-    injectors,
-  };
+// The pkb-context and pkb-reminder injectors both derive PKB-active state from
+// the workspace itself — `readPkbContext()` returning content behind the
+// personal-memory trust gate — rather than from a threaded flag. Seed the file
+// with exactly the content the test expects so the `<knowledge_base>` block
+// renders deterministically; clear it between tests so suites that assert the
+// PKB injectors are absent stay unaffected.
+function seedPkbContent(content: string): void {
+  const root = getPkbRoot();
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, "INDEX.md"), content, "utf-8");
+}
+
+function clearPkbContent(): void {
+  rmSync(getPkbRoot(), { recursive: true, force: true });
+}
+
+// The now-md injector sources NOW.md from the workspace itself — behind the
+// personal-memory trust gate and the `scratchpadInjection` config toggle —
+// rather than from a threaded option. Seed the file so the injector fires;
+// clear it between tests so suites that assert NOW.md is absent stay
+// unaffected.
+function seedNowScratchpad(content: string): void {
+  const nowPath = getWorkspacePromptPath("NOW.md");
+  mkdirSync(dirname(nowPath), { recursive: true });
+  writeFileSync(nowPath, content, "utf-8");
+}
+
+function clearNowScratchpad(): void {
+  rmSync(getWorkspacePromptPath("NOW.md"), { force: true });
 }
 
 describe("injector chain", () => {
   beforeEach(() => {
-    resetPluginRegistryForTests();
+    clearPkbContent();
+    clearNowScratchpad();
   });
 
-  test("defaultInjectorsPlugin registers the defaults in the documented order", () => {
-    registerPlugin(defaultInjectorsPlugin);
-
-    const names = getInjectors().map((i) => i.name);
+  test("defaultInjectors lists the defaults in the documented order", () => {
+    const names = defaultInjectors.map((i) => i.name);
     expect(names).toEqual([
       "disk-pressure-warning",
       "workspace-context",
@@ -109,10 +119,8 @@ describe("injector chain", () => {
     ]);
   });
 
-  test("default injector order constants match the registered order values", () => {
-    registerPlugin(defaultInjectorsPlugin);
-
-    const byName = new Map(getInjectors().map((i) => [i.name, i.order]));
+  test("default injector order constants match the listed order values", () => {
+    const byName = new Map(defaultInjectors.map((i) => [i.name, i.order]));
     expect(byName.get("disk-pressure-warning")).toBe(
       DEFAULT_INJECTOR_ORDER.diskPressureWarning,
     );
@@ -143,114 +151,38 @@ describe("injector chain", () => {
     expect(byName.get("thread-focus")).toBe(DEFAULT_INJECTOR_ORDER.threadFocus);
   });
 
-  test("a third-party injector at order 25 slots between unified-turn-context (20) and pkb-context (30)", () => {
-    registerPlugin(defaultInjectorsPlugin);
-
-    const middleInjector: Injector = {
-      name: "plugin-25",
-      order: 25,
-      async produce() {
-        return null;
-      },
-    };
-    registerPlugin(wrapInPlugin("third-party", [middleInjector]));
-
-    const names = getInjectors().map((i) => i.name);
-    expect(names).toEqual([
-      "disk-pressure-warning", // 5
-      "workspace-context", // 10
-      "background-turn", // 15
-      "unified-turn-context", // 20
-      "plugin-25", // 25 — slots in
-      "pkb-context", // 30
-      "pkb-reminder", // 35
-      "memory-v2-static", // 38
-      "now-md", // 40
-      "active-documents", // 45
-      "document-comments", // 46
-      "subagent-status", // 50
-      "slack-messages", // 60
-      "thread-focus", // 70
+  test("the injector chain sorts the defaults plus memory-v3 by ascending order", () => {
+    // The assembled chain merges the defaults with the memory-v3 injector and
+    // sorts by `order`, so memory-v3 (order 1000) sits last.
+    const chain = getInjectorChain();
+    const orders = chain.map((i) => i.order);
+    expect(orders).toEqual([...orders].sort((a, b) => a - b));
+    expect(chain[chain.length - 1]?.name).toBe("memory-v3-shadow");
+    expect(chain.map((i) => i.name)).toEqual([
+      ...defaultInjectors.map((i) => i.name),
+      "memory-v3-shadow",
     ]);
   });
 
   test("composeInjectorChain returns empty string when every injector opts out", async () => {
-    // The default chain is the golden-path: all ten defaults return `null`
-    // on an empty turn context, so the composed block is an empty string.
-    registerPlugin(defaultInjectorsPlugin);
-
-    const composed = await composeInjectorChain(makeTurnContext());
-    expect(composed).toBe("");
-  });
-
-  test("composeInjectorChain returns empty string when registry is empty", async () => {
-    // No plugins registered — the chain is a no-op and must return an empty
-    // string (not throw, not undefined). Callers rely on this to treat the
-    // chain as purely additive.
+    // The default chain is the golden-path: every default returns `null` on an
+    // empty turn context, so the composed block is an empty string.
     const composed = await composeInjectorChain(makeTurnContext());
     expect(composed).toBe("");
   });
 
-  test("composeInjectorChain concatenates non-null blocks in order with blank-line separators", async () => {
-    const first: Injector = {
-      name: "a",
-      order: 5,
-      async produce(): Promise<InjectionBlock> {
-        return { id: "a", text: "BLOCK_A" };
-      },
-    };
-    const second: Injector = {
-      name: "b",
-      order: 15,
-      async produce(): Promise<InjectionBlock> {
-        return { id: "b", text: "BLOCK_B" };
-      },
-    };
-    const skipped: Injector = {
-      name: "c",
-      order: 25,
-      async produce() {
-        return null;
-      },
-    };
-    // Register the higher-order one first to prove the chain sorts by `order`
-    // rather than registration order.
-    registerPlugin(wrapInPlugin("higher", [second]));
-    registerPlugin(wrapInPlugin("lower", [first]));
-    registerPlugin(wrapInPlugin("opts-out", [skipped]));
-
-    const composed = await composeInjectorChain(makeTurnContext());
-    expect(composed).toBe("BLOCK_A\n\nBLOCK_B");
-  });
-
-  test("composeInjectorChain skips blocks with empty text", async () => {
-    const emitEmpty: Injector = {
-      name: "empty",
-      order: 10,
-      async produce(): Promise<InjectionBlock> {
-        return { id: "empty", text: "" };
-      },
-    };
-    const emitReal: Injector = {
-      name: "real",
-      order: 20,
-      async produce(): Promise<InjectionBlock> {
-        return { id: "real", text: "CONTENT" };
-      },
-    };
-    registerPlugin(wrapInPlugin("plugin", [emitEmpty, emitReal]));
-
-    const composed = await composeInjectorChain(makeTurnContext());
-    expect(composed).toBe("CONTENT");
-  });
+  // ── Integration tests ───────────────────────────────────────────────
+  //
+  // These assertions exercise the real per-turn injection pipeline with
+  // the static chain active, verifying that each default injector emits
+  // the expected content in the correct position in the final user-tail
+  // content.
 
   test("applyRuntimeInjections leaves injectorChainBlock undefined when defaults opt out", async () => {
-    // Golden-path snapshot: with only default injectors (all returning
+    // Golden-path snapshot: with the static chain (all defaults returning
     // `null`), `applyRuntimeInjections` reports no chain output, so the
     // historical `blocks` shape is preserved byte-for-byte for any
-    // conversation that doesn't involve third-party injectors.
-    registerPlugin(defaultInjectorsPlugin);
-
+    // conversation that doesn't drive a known injector.
     const runMessages: Message[] = [
       { role: "user", content: [{ type: "text", text: "hello" }] },
     ];
@@ -265,68 +197,27 @@ describe("injector chain", () => {
     expect(result.messages).toEqual(runMessages);
   });
 
-  test("applyRuntimeInjections surfaces third-party injector output on blocks.injectorChainBlock", async () => {
-    registerPlugin(defaultInjectorsPlugin);
-    registerPlugin(
-      wrapInPlugin("third-party-25", [
-        {
-          name: "plugin-25",
-          order: 25,
-          async produce(): Promise<InjectionBlock> {
-            return { id: "plugin-25", text: "THIRD_PARTY_BLOCK" };
-          },
-        },
-      ]),
-    );
-
+  test("applyRuntimeInjections without turnContext still runs the chain under a synthesized context", async () => {
+    // The static chain is the canonical injection path, so
+    // `applyRuntimeInjections` must drive it even when the caller doesn't
+    // pass a `turnContext`. Call sites that rely on option fields to opt
+    // into injections continue to work because the synthesized fallback
+    // exposes `injectionInputs` built from `options`.
     const runMessages: Message[] = [
       { role: "user", content: [{ type: "text", text: "hi" }] },
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      unifiedTurnContext: "<turn_context>\nsynthesized\n</turn_context>",
     });
 
-    expect(result.blocks.injectorChainBlock).toBe("THIRD_PARTY_BLOCK");
-  });
-
-  test("applyRuntimeInjections without turnContext still runs the chain under a synthesized context", async () => {
-    // Post-G2.1 semantics: the default chain is the canonical injection
-    // path, so `applyRuntimeInjections` must drive it even when the caller
-    // doesn't pass a `turnContext`. Test/legacy call sites that rely on
-    // option fields to opt into injections continue to work because the
-    // synthesized fallback exposes `injectionInputs` built from `options`.
-    registerPlugin(defaultInjectorsPlugin);
-    registerPlugin(
-      wrapInPlugin("third-party-25", [
-        {
-          name: "plugin-25",
-          order: 25,
-          async produce(): Promise<InjectionBlock> {
-            return { id: "plugin-25", text: "THIRD_PARTY_BLOCK" };
-          },
-        },
-      ]),
+    // The unified-turn-context injector fires even without a caller-supplied
+    // turnContext, proving the chain runs under the synthesized context.
+    expect(result.blocks.unifiedTurnContext).toBe(
+      "<turn_context>\nsynthesized\n</turn_context>",
     );
-
-    const runMessages: Message[] = [
-      { role: "user", content: [{ type: "text", text: "hi" }] },
-    ];
-
-    const result = await applyRuntimeInjections(runMessages, {});
-
-    // Third-party injector runs even without a caller-supplied turnContext.
-    expect(result.blocks.injectorChainBlock).toBe("THIRD_PARTY_BLOCK");
   });
 
-  // ── Integration tests ───────────────────────────────────────────────
-  //
-  // These assertions exercise the real per-turn injection pipeline with
-  // the default chain active, verifying that each default injector emits
-  // the expected content and that a third-party injector registered at a
-  // fractional `order` slots into the correct position in the final
-  // user-tail content.
-
   test("golden-path: default chain injects workspace + unified-turn + PKB + NOW + subagent in the correct positions", async () => {
     // Canonical golden-path conversation state: full mode, non-Slack
     // channel, workspace context + unified-turn + PKB + NOW + subagent
@@ -335,14 +226,21 @@ describe("injector chain", () => {
     //   [workspace]            ← prepend order 10 (topmost)
     //   [unified-turn]         ← prepend order 20
     //   [now-md]               ← after-memory-prefix order 40 (highest order, closest to memory)
-    //   [pkb-reminder]         ← after-memory-prefix order 35 (skipped when pkbActive=false)
+    //   [pkb-reminder]         ← after-memory-prefix order 35
     //   [pkb-context]          ← after-memory-prefix order 30
     //   [user text]
     //   [subagent]             ← append order 50
     //
     // No memory prefix blocks in this scenario, so after-memory-prefix
-    // lands right at the head of the user-text cluster.
-    registerPlugin(defaultInjectorsPlugin);
+    // lands right at the head of the user-text cluster. The pkb-context and
+    // pkb-reminder injectors both fire off the seeded PKB content under the
+    // guardian trust on `makeTurnContext()` — pkb-context renders the seeded
+    // `<knowledge_base>` body, pkb-reminder the flat `<system_reminder>`
+    // (no graph handle is registered, so it has no search hints).
+    const pkbContent = "essentials of the project";
+    seedPkbContent(pkbContent);
+    const nowContent = "Current focus: shipping G2.1";
+    seedNowScratchpad(nowContent);
 
     const runMessages: Message[] = [
       { role: "user", content: [{ type: "text", text: "What next?" }] },
@@ -352,8 +250,6 @@ describe("injector chain", () => {
       "<workspace>\nRoot: /sandbox\nDirectories: src, lib\n</workspace>";
     const unifiedTurn =
       "<turn_context>\ncurrent_time: 2026-04-22\ninterface: macos\n</turn_context>";
-    const pkbContent = "essentials of the project";
-    const nowContent = "Current focus: shipping G2.1";
     const subagentBlock =
       '<active_subagents>\n- [running] "worker" (sub-1) | elapsed: 5s\n</active_subagents>';
 
@@ -361,9 +257,6 @@ describe("injector chain", () => {
       turnContext: makeTurnContext(),
       workspaceTopLevelContext: workspaceText,
       unifiedTurnContext: unifiedTurn,
-      pkbContext: pkbContent,
-      pkbActive: false, // disable reminder-branch to keep the snapshot small
-      nowScratchpad: nowContent,
       subagentStatusBlock: subagentBlock,
     });
 
@@ -378,14 +271,17 @@ describe("injector chain", () => {
     // placement says it does.
     expect(texts[0]).toBe(workspaceText); // prepend order 10
     expect(texts[1]).toBe(unifiedTurn); // prepend order 20
-    // NOW and PKB are both after-memory-prefix; NOW runs later so sits above PKB.
+    // NOW, pkb-reminder and pkb-context are all after-memory-prefix; higher
+    // order splices closer to the memory prefix, so NOW sits above the
+    // reminder, which sits above the knowledge_base.
     expect(texts[2]).toBe(
       `<NOW.md Always keep this up to date; keep under 10 lines>\n${nowContent}\n</NOW.md>`,
     );
-    expect(texts[3]).toBe(`<knowledge_base>\n${pkbContent}\n</knowledge_base>`);
-    expect(texts[4]).toBe("What next?"); // user's typed text
-    expect(texts[5]).toBe(subagentBlock); // append order 50
-    expect(texts).toHaveLength(6);
+    expect(texts[3]).toBe(buildPkbReminder([])); // pkb-reminder order 35
+    expect(texts[4]).toBe(`<knowledge_base>\n${pkbContent}\n</knowledge_base>`);
+    expect(texts[5]).toBe("What next?"); // user's typed text
+    expect(texts[6]).toBe(subagentBlock); // append order 50
+    expect(texts).toHaveLength(7);
 
     // Block metadata captures for DB persistence — one field per default
     // injector whose output the loader rehydrates from message metadata.
@@ -399,59 +295,6 @@ describe("injector chain", () => {
     );
   });
 
-  test("third-party prepend injector at order 15 lands between workspace (10) and unified-turn-context (20) in the final message", async () => {
-    // Proves the extensibility contract end-to-end: a plugin-registered
-    // injector at `order: 15` with `placement: "prepend-user-tail"` slots
-    // between the workspace prepend (order 10) and the unified-turn
-    // prepend (order 20). Because descending-order application for
-    // prepends puts the lowest-`order` injector topmost, workspace ends
-    // up on top, then plugin@15, then unified-turn.
-    registerPlugin(defaultInjectorsPlugin);
-    registerPlugin(
-      wrapInPlugin("third-party-15-prepend", [
-        {
-          name: "plugin-15",
-          order: 15, // between workspace (10) and unified-turn (20)
-          async produce(): Promise<InjectionBlock> {
-            return {
-              id: "plugin-15",
-              text: "<plugin_block_15/>",
-              placement: "prepend-user-tail",
-            };
-          },
-        },
-      ]),
-    );
-
-    const runMessages: Message[] = [
-      { role: "user", content: [{ type: "text", text: "hi" }] },
-    ];
-
-    const workspaceText = "<workspace>\nRoot: /sandbox\n</workspace>";
-    const unifiedTurn =
-      "<turn_context>\ncurrent_time: 2026-04-22\n</turn_context>";
-
-    const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
-      workspaceTopLevelContext: workspaceText,
-      unifiedTurnContext: unifiedTurn,
-    });
-
-    const tail = result.messages[result.messages.length - 1];
-    expect(tail.role).toBe("user");
-    const texts = tail.content
-      .filter((b): b is { type: "text"; text: string } => b.type === "text")
-      .map((b) => b.text);
-
-    // Descending-order application for prepends puts the lowest-`order`
-    // injector topmost, so order 10 (workspace) ends up on top, then
-    // plugin@15 below it, then unified-turn (order 20) below that.
-    expect(texts[0]).toBe(workspaceText);
-    expect(texts[1]).toBe("<plugin_block_15/>");
-    expect(texts[2]).toBe(unifiedTurn);
-    expect(texts[3]).toBe("hi");
-  });
-
   test("slack-messages injector replaces runMessages when a chronological transcript is provided", async () => {
     // End-to-end verification for the `replace-run-messages` placement:
     // a Slack channel turn with a pre-rendered chronological transcript
@@ -459,8 +302,6 @@ describe("injector chain", () => {
     // after-memory/append placements run. Memory-prefix blocks from the
     // original tail are re-prepended onto the new tail so PKB / NOW
     // splices still find them.
-    registerPlugin(defaultInjectorsPlugin);
-
     const originalRun: Message[] = [
       {
         role: "user",
@@ -522,8 +363,6 @@ describe("injector chain", () => {
     // opts out in minimal mode, so the tail should carry only the turn
     // context prepend plus any non-injector hardcoded content (none
     // here).
-    registerPlugin(defaultInjectorsPlugin);
-
     const result = await applyRuntimeInjections(
       [
         {
@@ -536,9 +375,6 @@ describe("injector chain", () => {
         mode: "minimal",
         workspaceTopLevelContext: "<workspace>...</workspace>",
         unifiedTurnContext: "<turn_context>...</turn_context>",
-        pkbContext: "kbody",
-        pkbActive: true,
-        nowScratchpad: "nowbody",
         subagentStatusBlock: "<active_subagents>...</active_subagents>",
       },
     );

package/src/__tests__/injector-disk-pressure.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
 import {
   applyRuntimeInjections,
@@ -6,18 +6,14 @@ import {
 } from "../daemon/conversation-runtime-assembly.js";
 import {
   DEFAULT_INJECTOR_ORDER,
-  defaultInjectorsPlugin,
+  defaultInjectors,
   DISK_PRESSURE_WARNING_PROMPT,
 } from "../plugins/defaults/injectors/register.js";
-import {
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 
 function findInjector(name: string): Injector {
-  const injector = defaultInjectorsPlugin.injectors?.find(
+  const injector = defaultInjectors.find(
     (candidate) => candidate.name === name,
   );
   if (!injector) {
@@ -50,11 +46,6 @@ const diskPressureInjector = findInjector("disk-pressure-warning");
 const cleanupContext = { cleanupModeActive: true };
 
 describe("disk-pressure-warning injector", () => {
-  beforeEach(() => {
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
-  });
-
   test("emits the exact cleanup prompt during disk pressure cleanup mode", async () => {
     const block = await diskPressureInjector.produce(
       makeContext({

package/src/__tests__/injector-document-comments.test.ts

@@ -8,12 +8,12 @@ mock.module("../documents/document-comments-store.js", () => ({
   listComments: (...args: unknown[]) => listCommentsMock(...args),
 }));
 
-const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
+const { DEFAULT_INJECTOR_ORDER, defaultInjectors } =
   await import("../plugins/defaults/injectors/register.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
 
 function findInjector(name: string): Injector {
-  const injector = defaultInjectorsPlugin.injectors?.find(
+  const injector = defaultInjectors.find(
     (candidate) => candidate.name === name,
   );
   if (!injector) {

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -12,7 +12,9 @@
  * search so the reminder-with-hints branch can resolve deterministically
  * when called.
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 let v2Active = false;
 
@@ -20,7 +22,12 @@ const realLoader = await import("../config/loader.js");
 
 mock.module("../config/loader.js", () => ({
   ...realLoader,
-  getConfig: () => ({ memory: { v2: { enabled: v2Active } } }),
+  getConfig: () => ({
+    memory: {
+      v2: { enabled: v2Active },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
+  }),
 }));
 
 mock.module("../memory/pkb/pkb-search.js", () => ({
@@ -29,12 +36,10 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
 
 const { applyRuntimeInjections } =
   await import("../daemon/conversation-runtime-assembly.js");
-const { defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors/register.js");
-const { registerPlugin, resetPluginRegistryForTests } =
-  await import("../plugins/registry.js");
+import { getPkbRoot } from "../memory/pkb/types.js";
 import type { TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 
 function makeTurnContext(): TurnContext {
   return {
@@ -55,28 +60,37 @@ function tailTexts(messages: Message[]): string[] {
     .map((b) => b.text);
 }
 
-const PKB_CONTEXT = "essentials of the project";
-const NOW_CONTENT = "Current focus: shipping G2.1";
 const RUN_MESSAGES: Message[] = [
   { role: "user", content: [{ type: "text", text: "What next?" }] },
 ];
 
 describe("PKB injector v2 cutover behavior", () => {
+  // The pkb-reminder gate derives PKB-active state from the workspace
+  // (`readPkbContext()` returning content) behind the guardian trust on
+  // `makeTurnContext()`, so seed a default auto-injected PKB file rather than
+  // passing a flag.
   beforeEach(() => {
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
     v2Active = false;
+    mkdirSync(getPkbRoot(), { recursive: true });
+    writeFileSync(
+      join(getPkbRoot(), "INDEX.md"),
+      "workspace knowledge index",
+      "utf-8",
+    );
+    // now-md sources NOW.md from the workspace behind the same guardian trust,
+    // so seed the file rather than passing a flag.
+    const nowPath = getWorkspacePromptPath("NOW.md");
+    mkdirSync(dirname(nowPath), { recursive: true });
+    writeFileSync(nowPath, "Current focus: shipping G2.1", "utf-8");
+  });
+  afterEach(() => {
+    rmSync(getPkbRoot(), { recursive: true, force: true });
+    rmSync(getWorkspacePromptPath("NOW.md"), { force: true });
   });
 
   test("v2 inactive → pkb-context, pkb-reminder, and now-md all produce blocks", async () => {
     const result = await applyRuntimeInjections(RUN_MESSAGES, {
       turnContext: makeTurnContext(),
-      pkbContext: PKB_CONTEXT,
-      pkbActive: true,
-      pkbScopeId: "scope-default",
-      pkbRoot: "/tmp/pkb",
-      pkbConversation: { messages: [] },
-      nowScratchpad: NOW_CONTENT,
     });
 
     const texts = tailTexts(result.messages);
@@ -89,12 +103,6 @@ describe("PKB injector v2 cutover behavior", () => {
     v2Active = true;
     const result = await applyRuntimeInjections(RUN_MESSAGES, {
       turnContext: makeTurnContext(),
-      pkbContext: PKB_CONTEXT,
-      pkbActive: true,
-      pkbScopeId: "scope-default",
-      pkbRoot: "/tmp/pkb",
-      pkbConversation: { messages: [] },
-      nowScratchpad: NOW_CONTENT,
     });
 
     const texts = tailTexts(result.messages);