@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/injector-background-turn.test.ts

@@ -22,16 +22,12 @@ mock.module("../config/loader.js", () => ({
 
 import {
   DEFAULT_INJECTOR_ORDER,
-  defaultInjectorsPlugin,
-} from "../plugins/defaults/injectors/register.js";
-import {
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
+  defaultInjectors,
+} from "../plugins/defaults/memory-retrieval/injectors.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) {
@@ -57,8 +53,6 @@ const DEFAULT_INJECTION_TEXT =
 
 describe("background-turn injector", () => {
   beforeEach(() => {
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
     configBackgroundInjection = DEFAULT_INJECTION_TEXT;
   });
 

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,26 +40,29 @@ mock.module("../config/loader.js", () => ({
 
 const { applyRuntimeInjections, composeInjectorChain } =
   await import("../daemon/conversation-runtime-assembly.js");
-const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors/register.js");
+const { DEFAULT_INJECTOR_ORDER, defaultInjectors } =
+  await import("../plugins/defaults/memory-retrieval/injectors.js");
+const { getInjectorChain } =
+  await import("../plugins/defaults/memory-retrieval/injector-chain.js");
 import {
-  getInjectors,
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
-import type {
-  InjectionBlock,
-  Injector,
-  Plugin,
-  TurnContext,
-} from "../plugins/types.js";
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.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";
+
+// `makeTurnContext` and the workspace registry seed share this id so the
+// `workspace-context` injector resolves the seeded block for the turn.
+const TEST_CONVERSATION_ID = "conv-test-1";
 
 /** A fake TurnContext sufficient for driving `composeInjectorChain`. */
 function makeTurnContext(): TurnContext {
   return {
     requestId: "req-test-1",
-    conversationId: "conv-test-1",
+    conversationId: TEST_CONVERSATION_ID,
     turnIndex: 0,
     trust: {
       sourceChannel: "vellum",
@@ -72,26 +71,60 @@ 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 });
+}
+
+// The workspace-context injector sources its block off the live `Conversation`
+// looked up by `conversationId`. Seed a fake instance carrying a non-dirty
+// workspace cache under the id `makeTurnContext()` uses so the injector emits
+// the block; `clearConversations()` between tests keeps suites that assert the
+// workspace block is absent unaffected.
+function seedWorkspaceContext(text: string): void {
+  setConversation(TEST_CONVERSATION_ID, {
+    conversationId: TEST_CONVERSATION_ID,
+    workingDir: "/sandbox",
+    workspaceTopLevelContext: text,
+    workspaceTopLevelDirty: false,
+  } as never);
 }
 
 describe("injector chain", () => {
   beforeEach(() => {
-    resetPluginRegistryForTests();
+    clearPkbContent();
+    clearNowScratchpad();
+    clearConversations();
   });
 
-  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 +142,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 +174,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);
-
+    // 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 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.
-    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 +220,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 +249,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,18 +273,13 @@ 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>';
 
+    seedWorkspaceContext(workspaceText);
     const result = await applyRuntimeInjections(runMessages, {
       turnContext: makeTurnContext(),
-      workspaceTopLevelContext: workspaceText,
       unifiedTurnContext: unifiedTurn,
-      pkbContext: pkbContent,
-      pkbActive: false, // disable reminder-branch to keep the snapshot small
-      nowScratchpad: nowContent,
       subagentStatusBlock: subagentBlock,
     });
 
@@ -378,14 +294,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 +318,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 +325,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",
@@ -486,8 +350,11 @@ describe("injector chain", () => {
       },
     ];
 
-    const result = await applyRuntimeInjections(originalRun, {
-      turnContext: makeTurnContext(),
+    setConversation(TEST_CONVERSATION_ID, {
+      conversationId: TEST_CONVERSATION_ID,
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
       channelCapabilities: {
         channel: "slack",
         dashboardCapable: false,
@@ -495,6 +362,9 @@ describe("injector chain", () => {
         supportsVoiceInput: false,
         chatType: "channel",
       },
+    } as never);
+    const result = await applyRuntimeInjections(originalRun, {
+      turnContext: makeTurnContext(),
       slackChronologicalMessages: slackTranscript,
     });
 
@@ -522,8 +392,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(
       [
         {
@@ -534,11 +402,7 @@ describe("injector chain", () => {
       {
         turnContext: makeTurnContext(),
         mode: "minimal",
-        workspaceTopLevelContext: "<workspace>...</workspace>",
         unifiedTurnContext: "<turn_context>...</turn_context>",
-        pkbContext: "kbody",
-        pkbActive: true,
-        nowScratchpad: "nowbody",
         subagentStatusBlock: "<active_subagents>...</active_subagents>",
       },
     );