@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1,4 +1,6 @@
-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";
 
 // This test exercises v1 PKB injection. `config.memory.v2.enabled` (default
 // `true`) makes the PKB injector go silent — force it off here so the v1
@@ -33,6 +35,10 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
   },
 }));
 
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
 import type {
   ChannelCapabilities,
   SlackTranscriptInputRow,
@@ -44,7 +50,6 @@ import {
   assembleSlackChronologicalMessages,
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
-  findLastInjectedNowContent,
   getSlackCompactionWatermarkForPrefix,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
@@ -58,31 +63,102 @@ import {
   stripInjectionsForCompaction,
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
+import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
 import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
 import type { MessageRow } from "../memory/conversation-crud.js";
+import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import { getPkbRoot } from "../memory/pkb/types.js";
 import {
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
 import { parentAlias } from "../messaging/providers/slack/render-transcript.js";
-import { defaultInjectorsPlugin } from "../plugins/defaults/injectors.js";
-import {
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
 import type { Message } from "../providers/types.js";
 import { wrapUntrustedContent } from "../security/untrusted-content.js";
 import type { SubagentState } from "../subagent/types.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
+
+// The pkb-reminder injector derives PKB-active state from the workspace itself
+// — `readPkbContext()` returning content behind the personal-memory trust gate
+// — rather than from a threaded flag. Tests that need the reminder to fire seed
+// a default auto-injected PKB file under the workspace pkb root; tests that
+// need it suppressed leave the pkb dir empty.
+function seedPkbContent(): void {
+  const root = getPkbRoot();
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, "INDEX.md"), "workspace knowledge index", "utf-8");
+}
 
-// `applyRuntimeInjections` is now driven by the default injector chain
-// (PR G2.1). The default-injectors plugin must be registered for the chain
-// to emit workspace, PKB, NOW.md, subagent, Slack, and thread-focus blocks.
-// Each test gets a clean registry so a test that registers its own plugin
-// doesn't leak into the next one.
-beforeEach(() => {
-  resetPluginRegistryForTests();
-  registerPlugin(defaultInjectorsPlugin);
-});
+function clearPkbContent(): void {
+  rmSync(getPkbRoot(), { recursive: true, force: true });
+}
+
+// The now-md injector derives NOW.md state from the workspace itself —
+// `readNowScratchpad()` returning content 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 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`. Register a fake instance carrying both a
+// non-dirty workspace context (non-null content, not dirty) so
+// `resolveWorkspaceTopLevelContext` returns it verbatim without rescanning the
+// filesystem, and an active dynamic-page surface, so `applyRuntimeInjections`
+// resolves the `<workspace>` and `<active_workspace>` blocks from it;
+// `clearConversations()` between tests keeps suites that assert the blocks are
+// absent unaffected.
+function seedActiveSurfaceConversation(
+  conversationId: string,
+  workspaceText: string,
+  surfaceId: string,
+  data: SurfaceData,
+  channelCapabilities?: ChannelCapabilities,
+): void {
+  setConversation(conversationId, {
+    conversationId,
+    workingDir: "/sandbox",
+    workspaceTopLevelContext: workspaceText,
+    workspaceTopLevelDirty: false,
+    currentActiveSurfaceId: surfaceId,
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData }
+    >([[surfaceId, { surfaceType: "dynamic_page", data }]]),
+    channelCapabilities: channelCapabilities ?? undefined,
+  } as never);
+}
+
+function clearWorkspaceContext(): void {
+  clearConversations();
+}
+
+// The `<channel_capabilities>` branch and the Slack gates source the channel
+// capabilities off the live `Conversation` looked up by `conversationId`.
+// Register a fake fallback instance carrying the given capabilities (and a
+// non-dirty empty workspace + empty surface so the other live-sourced branches
+// stay inert) so `applyRuntimeInjections` resolves them; `clearConversations()`
+// between tests keeps suites asserting absence unaffected.
+function seedChannelCapabilitiesConversation(
+  caps: ChannelCapabilities | null,
+): void {
+  setConversation("runtime-assembly-fallback", {
+    conversationId: "runtime-assembly-fallback",
+    workingDir: "/sandbox",
+    workspaceTopLevelContext: "",
+    workspaceTopLevelDirty: false,
+    surfaceState: new Map(),
+    channelCapabilities: caps ?? undefined,
+  } as never);
+}
 
 // ---------------------------------------------------------------------------
 // resolveChannelCapabilities
@@ -556,6 +632,8 @@ describe("stripChannelCapabilityContext", () => {
 // ---------------------------------------------------------------------------
 
 describe("applyRuntimeInjections with channelCapabilities", () => {
+  afterEach(clearConversations);
+
   const baseMessages: Message[] = [
     {
       role: "user",
@@ -571,9 +649,8 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      channelCapabilities: caps,
-    });
+    seedChannelCapabilitiesConversation(caps);
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(2);
@@ -584,9 +661,8 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
   });
 
   test("does not inject when channelCapabilities is null", async () => {
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      channelCapabilities: null,
-    });
+    seedChannelCapabilitiesConversation(null);
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(1);
@@ -607,9 +683,8 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      channelCapabilities: caps,
-    });
+    seedChannelCapabilitiesConversation(caps);
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
     // channelCapabilities prepends
@@ -736,24 +811,52 @@ describe("applyRuntimeInjections — injection mode", () => {
     },
   ];
 
+  const channelCapabilities: ChannelCapabilities = {
+    channel: "telegram",
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+  };
+
   const fullOptions = {
-    workspaceTopLevelContext: "<workspace>\nRoot: /sandbox\n</workspace>",
     channelCommandContext: { type: "start" } as const,
-    activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
-    channelCapabilities: {
-      channel: "telegram",
-      dashboardCapable: false,
-      supportsDynamicUi: false,
-      supportsVoiceInput: false,
-    } as ChannelCapabilities,
     unifiedTurnContext:
       "<turn_context>\ncurrent_time: 2026-03-04 (Tuesday) 12:00:00 +00:00 (UTC)\ninterface: telegram\n</turn_context>",
-    nowScratchpad: "Current focus: shipping PR 3",
-    pkbContext: "essentials content here",
-    pkbActive: true,
     isNonInteractive: true,
+    // Guardian trust so the personal-memory gate admits the actor regardless
+    // of the telegram channel capabilities under test, letting the reminder
+    // gate hinge purely on PKB content presence.
+    turnContext: {
+      requestId: "injection-mode-req",
+      conversationId: "injection-mode-conv",
+      turnIndex: 0,
+      trust: {
+        sourceChannel: "vellum" as const,
+        trustClass: "guardian" as const,
+      },
+    },
   };
 
+  // The reminder fires only when the workspace has PKB content, and the now-md
+  // injector only when NOW.md has content; seed both so the full-mode cases
+  // exercise the active branch.
+  beforeEach(() => {
+    seedPkbContent();
+    seedNowScratchpad("Current focus: shipping PR 3");
+    seedActiveSurfaceConversation(
+      "injection-mode-conv",
+      "<workspace>\nRoot: /sandbox\n</workspace>",
+      "sf_1",
+      { html: "<div>test</div>" },
+      channelCapabilities,
+    );
+  });
+  afterEach(() => {
+    clearPkbContent();
+    clearNowScratchpad();
+    clearWorkspaceContext();
+  });
+
   test("full mode (default) includes all injections", async () => {
     const { messages: result } = await applyRuntimeInjections(
       baseMessages,
@@ -860,12 +963,10 @@ describe("applyRuntimeInjections — injection mode", () => {
   });
 });
 
-// The standalone `injectNowScratchpad` helper was removed in G2.1. The
-// now-md default injector (registered by `defaultInjectorsPlugin`) emits
-// the `<NOW.md>` block as an `after-memory-prefix` placement during
-// `applyRuntimeInjections`. The suites below (`applyRuntimeInjections with
-// nowScratchpad` and the injection-mode tests) cover that behaviour
-// end-to-end.
+// The now-md default injector emits the `<NOW.md>` block as an
+// `after-memory-prefix` placement during `applyRuntimeInjections`. The suites
+// below (`applyRuntimeInjections with nowScratchpad` and the injection-mode
+// tests) cover that behaviour end-to-end.
 
 // ---------------------------------------------------------------------------
 // stripNowScratchpad
@@ -1013,7 +1114,7 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
     ).toContain("<turn_context>");
   });
 
-  test("<workspace> blocks are NOT stripped", () => {
+  test("<workspace> blocks ARE stripped so the injector re-sources them post-compaction", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1029,10 +1130,10 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
 
     const result = stripInjectionsForCompaction(messages);
     expect(result.length).toBe(1);
-    expect(result[0].content.length).toBe(2);
-    expect(
-      (result[0].content[0] as { type: "text"; text: string }).text,
-    ).toContain("<workspace>");
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      "Hello",
+    );
   });
 
   test("legacy <workspace_top_level> blocks ARE stripped for backward compat", () => {
@@ -1102,6 +1203,84 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// stripInjectionsForCompaction — memory/info wrapper shape
+// ---------------------------------------------------------------------------
+
+describe("stripInjectionsForCompaction memory/info wrapper matching", () => {
+  test("injected <info>…</info> static-memory block IS stripped", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\nessentials and threads\n</info>" },
+          { type: "text", text: "Hello" },
+        ],
+      },
+    ];
+
+    const result = stripInjectionsForCompaction(messages);
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      "Hello",
+    );
+  });
+
+  test("injected <memory>…</memory> activation block IS stripped", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<memory>\nactivated slugs\n</memory>" },
+          { type: "text", text: "Hello" },
+        ],
+      },
+    ];
+
+    const result = stripInjectionsForCompaction(messages);
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      "Hello",
+    );
+  });
+
+  test("user text merely starting with <info>\\n (no closing tag) is NOT stripped", () => {
+    const userText = "<info>\nHere is what I want to discuss about the markup";
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: userText }],
+      },
+    ];
+
+    const result = stripInjectionsForCompaction(messages);
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      userText,
+    );
+  });
+
+  test("user text merely starting with <memory>\\n (no closing tag) is NOT stripped", () => {
+    const userText = "<memory>\nplease remember to buy milk";
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: userText }],
+      },
+    ];
+
+    const result = stripInjectionsForCompaction(messages);
+    expect(result.length).toBe(1);
+    expect(result[0].content.length).toBe(1);
+    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
+      userText,
+    );
+  });
+});
+
 // ---------------------------------------------------------------------------
 // applyRuntimeInjections with nowScratchpad
 // ---------------------------------------------------------------------------
@@ -1114,10 +1293,14 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     },
   ];
 
-  test("injects NOW.md block when provided", async () => {
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      nowScratchpad: "Current focus: fix the bug",
-    });
+  // The now-md injector sources NOW.md from the workspace itself rather than
+  // from a threaded option, so seed the file to drive injection and clear it so
+  // the absent-content cases see no block.
+  afterEach(clearNowScratchpad);
+
+  test("injects NOW.md block when the file has content", async () => {
+    seedNowScratchpad("Current focus: fix the bug");
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(2);
@@ -1128,9 +1311,8 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
   });
 
   test("scratchpad appears before user's original text content", async () => {
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      nowScratchpad: "scratchpad notes",
-    });
+    seedNowScratchpad("scratchpad notes");
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     // Scratchpad comes first (before user content)
     expect(
@@ -1142,16 +1324,7 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     );
   });
 
-  test("does not inject when nowScratchpad is null", async () => {
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      nowScratchpad: null,
-    });
-
-    expect(result.length).toBe(1);
-    expect(result[0].content.length).toBe(1);
-  });
-
-  test("does not inject when nowScratchpad is omitted", async () => {
+  test("does not inject when the NOW.md file is absent", async () => {
     const { messages: result } = await applyRuntimeInjections(baseMessages, {});
 
     expect(result.length).toBe(1);
@@ -1159,8 +1332,8 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
   });
 
   test("skipped in minimal mode", async () => {
+    seedNowScratchpad("Current focus: fix the bug");
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
-      nowScratchpad: "Current focus: fix the bug",
       mode: "minimal",
     });
 
@@ -1704,85 +1877,6 @@ describe("applyRuntimeInjections blocks.unifiedTurnContext", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// findLastInjectedNowContent
-// ---------------------------------------------------------------------------
-
-describe("findLastInjectedNowContent", () => {
-  test("extracts NOW.md content from the last user message", () => {
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<NOW.md Always keep this up to date>\nCurrent focus: fix the bug\n</NOW.md>",
-          },
-          { type: "text", text: "Hello" },
-        ],
-      },
-    ];
-
-    expect(findLastInjectedNowContent(messages)).toBe(
-      "Current focus: fix the bug",
-    );
-  });
-
-  test("returns null when no NOW.md injection exists", () => {
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [{ type: "text", text: "Hello" }],
-      },
-    ];
-
-    expect(findLastInjectedNowContent(messages)).toBeNull();
-  });
-
-  test("returns the most recent injection when multiple exist", () => {
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<NOW.md Always keep this up to date>\nOld focus\n</NOW.md>",
-          },
-        ],
-      },
-      { role: "assistant", content: [{ type: "text", text: "OK" }] },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<NOW.md Always keep this up to date>\nNew focus\n</NOW.md>",
-          },
-        ],
-      },
-    ];
-
-    expect(findLastInjectedNowContent(messages)).toBe("New focus");
-  });
-
-  test("skips assistant messages", () => {
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<NOW.md Always keep this up to date>\nUser focus\n</NOW.md>",
-          },
-        ],
-      },
-      { role: "assistant", content: [{ type: "text", text: "response" }] },
-    ];
-
-    expect(findLastInjectedNowContent(messages)).toBe("User focus");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Subagent status injection
 // ---------------------------------------------------------------------------
@@ -1954,21 +2048,33 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 
   const FLAT_REMINDER = buildPkbReminder([]);
 
-  // Use a platform-agnostic absolute workspace root so the tests work on
-  // macOS and Linux runners alike. `pkbRoot` sits under `pkbWorkingDir` to
-  // mirror production, where `pkbRoot = join(workingDir, "pkb")`.
-  const pkbWorkingDir = "/tmp/fake-workspace";
-  const pkbRoot = `${pkbWorkingDir}/pkb`;
+  // The pkb-reminder injector sources the PKB root itself via `getPkbRoot()`,
+  // so the in-context file paths these tests build must resolve against the
+  // same per-test workspace the injector sees.
+  const pkbRoot = getPkbRoot();
+
+  // The pkb-reminder injector reads the dense/sparse PKB query pair off the
+  // conversation's live graph handle (the memory-retrieval hook records it
+  // there during retrieval), not from the injection options. Register a handle
+  // for the fallback conversation id `applyRuntimeInjections` synthesizes and
+  // seed it with a query vector so the hint-search branch runs.
+  let graphHandle: ConversationGraphMemory;
+  beforeEach(() => {
+    graphHandle = new ConversationGraphMemory("runtime-assembly-fallback");
+    graphHandle.recordPkbQueryVectors([0.1, 0.2, 0.3], undefined);
+  });
+  afterEach(() => {
+    graphHandle.dispose();
+  });
+
+  // PKB content makes `readPkbContext()` non-null so the (vellum/guardian-
+  // equivalent) fallback trust gate admits the reminder; cleared after each
+  // test to avoid leaking into suites that assert the reminder is absent.
+  beforeEach(seedPkbContent);
+  afterEach(clearPkbContent);
 
   function makePkbOptions(overrides: Record<string, unknown> = {}) {
     return {
-      pkbActive: true,
-      pkbQueryVector: [0.1, 0.2, 0.3],
-      pkbScopeId: "scope-1",
-      pkbConversation: { messages: baseMessages },
-      pkbRoot,
-      pkbWorkingDir,
-      pkbAutoInjectList: [],
       ...overrides,
     };
   }
@@ -2004,10 +2110,11 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
   test("default auto-injected files (from PKB_DEFAULT_FILES) are filtered out of hints", async () => {
     // Regression test: when `_autoinject.md` is missing, `readPkbContext`
     // falls back to PKB_DEFAULT_FILES — so those files ARE in the prompt.
-    // The tracker must know about them too, otherwise the reminder would
-    // redundantly recommend e.g. `essentials.md` even though its contents
-    // are already injected. The agent-loop passes the effective auto-inject
-    // list (via `getPkbAutoInjectList`) to `applyRuntimeInjections`.
+    // The injector sources the same fallback via `getPkbAutoInjectList`, so
+    // it must know about them too, otherwise the reminder would redundantly
+    // recommend e.g. `essentials.md` even though its contents are already
+    // injected. The per-test workspace has no `_autoinject.md`, so the
+    // injector resolves PKB_DEFAULT_FILES here.
     pkbSearchResults = [
       { path: "essentials.md", denseScore: 0.95 },
       { path: "topics/alpha.md", denseScore: 0.9 },
@@ -2016,16 +2123,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 
     const { messages: result } = await applyRuntimeInjections(
       baseMessages,
-      makePkbOptions({
-        // Simulate the fallback the agent-loop now threads through:
-        // `_autoinject.md` is missing, so defaults are injected.
-        pkbAutoInjectList: [
-          "INDEX.md",
-          "essentials.md",
-          "threads.md",
-          "buffer.md",
-        ],
-      }),
+      makePkbOptions(),
     );
     const texts = extractTexts(result);
     const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
@@ -2065,27 +2163,26 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     ];
     pkbSearchThrows = null;
 
-    // Build a conversation that has already read topics/beta.md via file_read.
-    const conversationWithRead: { messages: Message[] } = {
-      messages: [
-        ...baseMessages,
-        {
-          role: "assistant",
-          content: [
-            {
-              type: "tool_use",
-              id: "tu_1",
-              name: "file_read",
-              input: { path: `${pkbRoot}/topics/beta.md` },
-            },
-          ],
-        },
-      ],
-    };
+    // Working messages where topics/beta.md was already read via file_read on
+    // an earlier turn, followed by the current user prompt as the tail.
+    const conversationWithRead: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "file_read",
+            input: { path: `${pkbRoot}/topics/beta.md` },
+          },
+        ],
+      },
+      ...baseMessages,
+    ];
 
     const { messages: result } = await applyRuntimeInjections(
-      baseMessages,
-      makePkbOptions({ pkbConversation: conversationWithRead }),
+      conversationWithRead,
+      makePkbOptions(),
     );
     const texts = extractTexts(result);
     const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
@@ -2123,10 +2220,13 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 
   test("missing query vector → flat fallback, search is not attempted", async () => {
     pkbSearchThrows = new Error("should not be called");
+    // No dense vector was recorded on the graph handle this turn, so the
+    // injector must skip the hint search entirely.
+    graphHandle.recordPkbQueryVectors(undefined, undefined);
 
     const { messages: result } = await applyRuntimeInjections(
       baseMessages,
-      makePkbOptions({ pkbQueryVector: undefined }),
+      makePkbOptions(),
     );
     const texts = extractTexts(result);
     const reminder = texts.find((t) => t.startsWith("<system_reminder>"));
@@ -2240,37 +2340,28 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     ];
     pkbSearchThrows = null;
 
-    // Pre-compaction conversation: beta was already read.
-    const preCompactionConversation: { messages: Message[] } = {
-      messages: [
-        ...baseMessages,
-        {
-          role: "assistant",
-          content: [
-            {
-              type: "tool_use",
-              id: "tu_pre",
-              name: "file_read",
-              input: { path: `${pkbRoot}/topics/beta.md` },
-            },
-          ],
-        },
-      ],
-    };
+    // Pre-compaction working messages: beta was already read on an earlier
+    // turn, followed by the current user prompt as the tail.
+    const preCompactionMessages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tu_pre",
+            name: "file_read",
+            input: { path: `${pkbRoot}/topics/beta.md` },
+          },
+        ],
+      },
+      ...baseMessages,
+    ];
 
     // 1. Initial injection sees the pre-compaction state — beta should be
     // filtered out.
     const { messages: initialResult } = await applyRuntimeInjections(
-      baseMessages,
-      {
-        pkbActive: true,
-        pkbQueryVector: [0.1, 0.2],
-        pkbScopeId: "scope-1",
-        pkbConversation: preCompactionConversation,
-        pkbRoot,
-        pkbWorkingDir,
-        pkbAutoInjectList: [],
-      },
+      preCompactionMessages,
+      {},
     );
     // Unwrap the injected reminder from the last user message.
     const initialTexts = extractTexts(initialResult);
@@ -2282,41 +2373,29 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     expect(initialReminder).toBeDefined();
     expect(initialReminder).not.toContain("- topics/beta.md");
 
-    // 2. Simulate compaction: strip all runtime injections, rebuild
-    // conversation to reflect the post-compaction state (tool_use blocks
-    // are serialized into summary text, so the only live file_read is the
-    // newly-read gamma).
-    const postCompactionConversation: { messages: Message[] } = {
-      messages: [
-        ...baseMessages,
-        {
-          role: "assistant",
-          content: [
-            {
-              type: "tool_use",
-              id: "tu_post",
-              name: "file_read",
-              input: { path: `${pkbRoot}/topics/gamma.md` },
-            },
-          ],
-        },
-      ],
-    };
-    const postCompactionMessages = stripInjectionsForCompaction(initialResult);
+    // 2. After compaction the working messages reflect the post-compaction
+    // state: beta's tool_use was serialized into summary text and dropped,
+    // so the only live file_read is the newly-read gamma.
+    const postCompactionMessages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tu_post",
+            name: "file_read",
+            input: { path: `${pkbRoot}/topics/gamma.md` },
+          },
+        ],
+      },
+      ...baseMessages,
+    ];
 
-    // 3. Re-inject with the new conversation — gamma (now in context)
+    // 3. Re-inject over the post-compaction messages — gamma (now in context)
     // should be filtered, and beta (no longer "in context") should appear.
     const { messages: rebuiltResult } = await applyRuntimeInjections(
       postCompactionMessages,
-      {
-        pkbActive: true,
-        pkbQueryVector: [0.1, 0.2],
-        pkbScopeId: "scope-1",
-        pkbConversation: postCompactionConversation,
-        pkbRoot,
-        pkbWorkingDir,
-        pkbAutoInjectList: [],
-      },
+      {},
     );
     const rebuiltTexts = extractTexts(rebuiltResult);
     const rebuiltReminder = rebuiltTexts.find(
@@ -2336,6 +2415,8 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 // ---------------------------------------------------------------------------
 
 describe("Slack channel chronological rendering — multi-thread", () => {
+  afterEach(clearConversations);
+
   // Slack ts values are seconds-since-epoch with microsecond precision.
   // Pick a few stable anchors so thread aliases (sha-derived) stay
   // predictable across the scenarios.
@@ -2421,8 +2502,8 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "current turn" }],
     };
+    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages } = await applyRuntimeInjections([lastUserMessage], {
-      channelCapabilities: slackChannelCaps,
       slackChronologicalMessages,
     });
     return messages;
@@ -2710,15 +2791,15 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "vellum question" }],
     };
+    seedChannelCapabilitiesConversation({
+      channel: "vellum",
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+    });
     const { messages: result } = await applyRuntimeInjections(
       [lastUserMessage],
       {
-        channelCapabilities: {
-          channel: "vellum",
-          dashboardCapable: true,
-          supportsDynamicUi: true,
-          supportsVoiceInput: true,
-        },
         // Even if we accidentally pass a chronological transcript, the
         // branch must be a no-op for non-slack channels.
         slackChronologicalMessages: [
@@ -2748,16 +2829,16 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "DM question" }],
     };
+    seedChannelCapabilitiesConversation({
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    });
     const { messages: result } = await applyRuntimeInjections(
       [lastUserMessage],
       {
-        channelCapabilities: {
-          channel: "slack",
-          dashboardCapable: false,
-          supportsDynamicUi: false,
-          supportsVoiceInput: false,
-          chatType: "im",
-        },
         slackChronologicalMessages: [
           {
             role: "user",
@@ -2816,10 +2897,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         ],
       },
     ];
+    seedChannelCapabilitiesConversation(slackCaps);
     const { messages: result } = await applyRuntimeInjections(
       runMessagesWithMemory,
       {
-        channelCapabilities: slackCaps,
         slackChronologicalMessages: [
           {
             role: "user",
@@ -2880,10 +2961,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         ],
       },
     ];
+    seedChannelCapabilitiesConversation(slackCaps);
     const { messages: result } = await applyRuntimeInjections(
       runMessagesWithMemory,
       {
-        channelCapabilities: slackCaps,
         slackChronologicalMessages: [
           {
             role: "user",
@@ -2919,10 +3000,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       supportsVoiceInput: false,
       chatType: "im",
     };
+    seedChannelCapabilitiesConversation(slackCaps);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "inbound" }] }],
       {
-        channelCapabilities: slackCaps,
         slackChronologicalMessages: [
           {
             role: "user",
@@ -2963,10 +3044,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       { loader: () => rows, trustClass: "guardian" },
     );
 
+    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
       {
-        channelCapabilities: slackChannelCaps,
         slackChronologicalMessages,
         transportHints: ["thread context: ..."],
       },
@@ -2993,10 +3074,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       chatType: "im",
     };
 
+    seedChannelCapabilitiesConversation(slackDmCaps);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "hi DM" }] }],
       {
-        channelCapabilities: slackDmCaps,
         transportHints: ["dm context: ..."],
       },
     );
@@ -3012,16 +3093,16 @@ describe("Slack channel chronological rendering — multi-thread", () => {
 
   // ── transport_hints kept for non-slack channels ───────────────────────
   test("non-slack conversations still receive <transport_hints>", async () => {
+    seedChannelCapabilitiesConversation({
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "private",
+    });
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "hi" }] }],
       {
-        channelCapabilities: {
-          channel: "telegram",
-          dashboardCapable: false,
-          supportsDynamicUi: false,
-          supportsVoiceInput: false,
-          chatType: "private",
-        },
         transportHints: ["please answer concisely"],
       },
     );
@@ -3348,8 +3429,8 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "current turn" }],
     };
+    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages } = await applyRuntimeInjections([lastUserMessage], {
-      channelCapabilities: slackChannelCaps,
       slackChronologicalMessages,
       slackActiveThreadFocusBlock: focusBlock,
     });
@@ -3618,8 +3699,8 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       chatType: "channel",
     };
     const newFocus = "<active_thread>\nnewly built\n</active_thread>";
+    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages: reInjected } = await applyRuntimeInjections(stripped, {
-      channelCapabilities: slackChannelCaps,
       slackActiveThreadFocusBlock: newFocus,
     });
     const reInjectedTexts = reInjected
@@ -3639,15 +3720,15 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     // Defensive: the focus injection is gated on `slackChannel` (i.e.
     // `isSlackChannelConversation`). Even if a caller mistakenly forwards
     // a focus block on a non-Slack channel, it must NOT be appended.
+    seedChannelCapabilitiesConversation({
+      channel: "vellum",
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+    });
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "vellum question" }] }],
       {
-        channelCapabilities: {
-          channel: "vellum",
-          dashboardCapable: true,
-          supportsDynamicUi: true,
-          supportsVoiceInput: true,
-        },
         slackActiveThreadFocusBlock: "<active_thread>\nbogus\n</active_thread>",
       },
     );
@@ -3664,16 +3745,16 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     // Same as above but for Slack DMs (chatType === "im"). The focus
     // injection is keyed on `isSlackChannelConversation` which excludes
     // DMs, so the block must not appear.
+    seedChannelCapabilitiesConversation({
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "im",
+    });
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "DM question" }] }],
       {
-        channelCapabilities: {
-          channel: "slack",
-          dashboardCapable: false,
-          supportsDynamicUi: false,
-          supportsVoiceInput: false,
-          chatType: "im",
-        },
         slackActiveThreadFocusBlock: "<active_thread>\nbogus\n</active_thread>",
       },
     );
@@ -3912,11 +3993,11 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
     expect(result!).not.toContain("Sibling top-level");
   });
 
-  test("preserves speaker attribution when flattening to plain text", () => {
+  test("preserves user attribution while leaving assistant text unchanged", () => {
     // The `<active_thread>` block is rendered as newline-joined plain text,
-    // discarding `Message.role`. Assistant rows and unnamed user rows must
-    // therefore carry an explicit `@assistant` / `@user` label so the model
-    // can still tell turns apart inside the flattened block.
+    // discarding `Message.role`. User rows keep explicit Slack attribution,
+    // while assistant rows remain raw to avoid teaching the model a synthetic
+    // reply prefix.
     const rows: SlackTranscriptInputRow[] = [
       buildRow(
         "user",
@@ -3943,17 +4024,16 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
     const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
     expect(result).not.toBeNull();
     expect(result!).toContain("@alice");
-    expect(result!).toContain("@assistant");
+    expect(result!).toContain("Assistant reply");
+    expect(result!).not.toContain("@assistant: Assistant reply");
     expect(result!).toContain("@user");
   });
 
   test("assistant reactions are not double-attributed (`@assistant: [... @assistant reacted ...]`)", () => {
     // `renderReaction` bakes `@assistant` into the reaction tag line
     // (`[11/14/23 14:28 @assistant reacted 👍 to Mxxxxxx]`). The
-    // post-render step that prepends `@assistant: ` to assistant content
-    // lines must skip reaction lines, otherwise the flattened block
-    // produces `@assistant: [... @assistant reacted ...]` — two
-    // attributions for one event.
+    // flattened block should preserve that renderer-owned attribution without
+    // adding any extra assistant-message prefix.
     const rows: SlackTranscriptInputRow[] = [
       buildRow(
         "user",
@@ -3961,7 +4041,7 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
         1_000,
         buildMeta({ channelTs: PARENT_TS, displayName: "@alice" }),
       ),
-      // Assistant reply in the thread — gets an `@assistant:` prefix.
+      // Assistant reply in the thread — stays unchanged.
       buildRow(
         "assistant",
         "Assistant reply",
@@ -4003,12 +4083,13 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
     expect(result).not.toBeNull();
     // Double-attribution anti-pattern must NOT appear anywhere.
     expect(result!).not.toContain("@assistant: [");
-    // Both the reaction attribution and the reply prefix are still present.
+    // Reaction attribution remains, and the assistant reply stays raw.
     expect(result!).toContain("@assistant reacted 👍");
-    expect(result!).toContain("@assistant: Assistant reply");
+    expect(result!).toContain("Assistant reply");
+    expect(result!).not.toContain("@assistant: Assistant reply");
   });
 
-  test("timezone-aware assistant rows keep renderer attribution in active-thread focus block", () => {
+  test("timezone-aware assistant rows stay unchanged in active-thread focus block", () => {
     const rows: SlackTranscriptInputRow[] = [
       buildRow(
         "user",
@@ -4049,15 +4130,12 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
 
     const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
     expect(result).not.toBeNull();
-    expect(result!).toContain(
-      "[nov 14 2023 3:13 PM MT assistant] Assistant reply",
-    );
-    expect(result!).not.toContain(
-      "@assistant: [nov 14 2023 3:13 PM MT assistant]",
-    );
+    expect(result!).toContain("\nAssistant reply\n");
+    expect(result!).not.toContain("[nov 14 2023 3:13 PM MT assistant]");
+    expect(result!).not.toContain("@assistant: Assistant reply");
   });
 
-  test("assistant content that only looks like a compact tag still gets active-thread attribution", () => {
+  test("assistant content that only looks like a compact tag stays unchanged", () => {
     const compactLookingContent =
       "[nov 14 2023 3:13 PM MT assistant] Assistant reply";
     const rows: SlackTranscriptInputRow[] = [
@@ -4090,7 +4168,8 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
 
     const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
     expect(result).not.toBeNull();
-    expect(result!).toContain(`@assistant: ${compactLookingContent}`);
+    expect(result!).toContain(`\n${compactLookingContent}\n`);
+    expect(result!).not.toContain(`@assistant: ${compactLookingContent}`);
   });
 
   test("assistant reaction overflow trailer is not double-attributed", () => {
@@ -5024,11 +5103,15 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
     },
   ];
 
+  // The reminder gate hinges on PKB content presence; clear it after each test
+  // so the "PKB inactive" case starts from an empty workspace pkb dir.
+  afterEach(clearPkbContent);
+
   test("captures exact reminder bytes when full mode and PKB active", async () => {
+    seedPkbContent();
     pkbSearchResults = [];
     pkbSearchThrows = null;
     const { blocks } = await applyRuntimeInjections(baseMessages, {
-      pkbActive: true,
       mode: "full",
     });
 
@@ -5037,8 +5120,8 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
   });
 
   test("not captured in minimal mode", async () => {
+    seedPkbContent();
     const { blocks } = await applyRuntimeInjections(baseMessages, {
-      pkbActive: true,
       mode: "minimal",
     });
 
@@ -5047,7 +5130,6 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
 
   test("not captured when PKB inactive", async () => {
     const { blocks } = await applyRuntimeInjections(baseMessages, {
-      pkbActive: false,
       mode: "full",
     });