@vellumai/assistant 0.8.2 → 0.8.3

package/src/__tests__/config-get-vision-flag.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Verifies that `GET /v1/config` enriches each profile in `llm.profiles`
+ * with `supportsVision` resolved from the model catalog.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+// ---------------------------------------------------------------------------
+// Mocks for handleGetConfig's transitive deps
+// ---------------------------------------------------------------------------
+
+let rawConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => structuredClone(rawConfig),
+  saveRawConfig: () => {},
+  deepMergeOverwrite: () => {},
+  getConfig: () => rawConfig,
+  getDeploymentContextDefaults: () => ({}),
+  fillContextDefaultsForMissingKeys: () => {},
+  invalidateConfigCache: () => {},
+  setNestedValue: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  initializeProviders: async () => {},
+}));
+
+mock.module("../memory/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  validateAllowlistFile: () => null,
+}));
+
+import { ROUTES } from "../runtime/routes/conversation-query-routes.js";
+
+const configGetRoute = ROUTES.find((r) => r.operationId === "config_get")!;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("GET /v1/config profile vision enrichment", () => {
+  test("profile with a non-vision model gets supportsVision: false", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-no-vision": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/kimi-k2p5",
+          },
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(result?.llm?.profiles?.["test-no-vision"]?.supportsVision).toBe(
+      false,
+    );
+  });
+
+  test("profile with a vision-capable model gets supportsVision: true", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-vision": {
+            provider: "anthropic",
+            model: "claude-opus-4-6",
+          },
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(result?.llm?.profiles?.["test-vision"]?.supportsVision).toBe(true);
+  });
+
+  test("profile with an unknown model defaults supportsVision to true (fail-open)", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-unknown": {
+            provider: "anthropic",
+            model: "some-unknown-model-xyz",
+          },
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(result?.llm?.profiles?.["test-unknown"]?.supportsVision).toBe(true);
+  });
+
+  test("profile without provider/model is left without supportsVision", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-empty": {},
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(
+      result?.llm?.profiles?.["test-empty"]?.supportsVision,
+    ).toBeUndefined();
+  });
+});

package/src/__tests__/config-loader-backfill.test.ts

@@ -7,6 +7,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
+import { Database } from "bun:sqlite";
 import {
   afterAll,
   afterEach,
@@ -17,6 +18,8 @@ import {
   test,
 } from "bun:test";
 
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
 // ---------------------------------------------------------------------------
 // Mocks — declared before imports that depend on platform/logger
 // ---------------------------------------------------------------------------
@@ -73,6 +76,12 @@ import {
   mergeDefaultWorkspaceConfig,
 } from "../config/loader.js";
 import { seedInferenceProfiles } from "../config/seed-inference-profiles.js";
+import type { DrizzleDb } from "../memory/db-connection.js";
+import { migrateCreateProviderConnections } from "../memory/migrations/243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../memory/migrations/244-provider-connection-status-label.js";
+import { migrateProviderConnectionBaseUrlAndModels } from "../memory/migrations/250-provider-connection-base-url-and-models.js";
+import * as schema from "../memory/schema.js";
+import { getConnection } from "../providers/inference/connections.js";
 import { _setStorePath } from "../security/encrypted-store.js";
 
 // ---------------------------------------------------------------------------
@@ -83,15 +92,26 @@ function writeConfig(obj: unknown): void {
   writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
 }
 
-function mergeDefaultConfigAndSeedInferenceProfiles(): void {
+function mergeDefaultConfigAndSeedInferenceProfiles(db?: DrizzleDb): void {
   const defaultConfigMerge = mergeDefaultWorkspaceConfig();
   seedInferenceProfiles({
     preserveProfileNames: defaultConfigMerge.providedLlmProfileNames,
     preserveActiveProfile: defaultConfigMerge.providedLlmActiveProfile,
     isHatch: defaultConfigMerge.hadOverlay,
+    db,
   });
 }
 
+function createProviderConnectionsDb(): DrizzleDb {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  const db = drizzle(sqlite, { schema });
+  migrateCreateProviderConnections(db);
+  migrateProviderConnectionStatusLabel(db);
+  migrateProviderConnectionBaseUrlAndModels(db);
+  return db;
+}
+
 // ---------------------------------------------------------------------------
 // Tests: deepMergeOverwrite (unit) — JSON-null-as-deletion semantics
 //
@@ -523,7 +543,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles["custom-balanced"].provider_connection).toBe(
       "anthropic-personal",
     );
-    // Managed profiles are also seeded for anthropic-managed.
+    // Managed balanced profile is seeded for anthropic-managed.
     expect(raw.llm.profiles.balanced.provider).toBe("anthropic");
     expect(raw.llm.profiles.balanced.provider_connection).toBe(
       "anthropic-managed",
@@ -589,11 +609,8 @@ describe("loadConfig startup behavior", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
       overlayPath,
-      JSON.stringify(
-        { llm: { default: { provider: "openai" } } },
-        null,
-        2,
-      ) + "\n",
+      JSON.stringify({ llm: { default: { provider: "openai" } } }, null, 2) +
+        "\n",
     );
     process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
 
@@ -617,7 +634,7 @@ describe("loadConfig startup behavior", () => {
       "gpt-5.4-nano",
     );
 
-    // Managed anthropic profiles are also seeded.
+    // Managed profiles are also seeded (balanced uses Anthropic).
     expect(raw.llm.profiles.balanced.provider).toBe("anthropic");
     expect(raw.llm.profiles.balanced.provider_connection).toBe(
       "anthropic-managed",
@@ -981,11 +998,8 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
       overlayPath,
-      JSON.stringify(
-        { llm: { default: { provider: "anthropic" } } },
-        null,
-        2,
-      ) + "\n",
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
     );
     process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
 
@@ -997,6 +1011,92 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     expect(config.llm.profiles["cost-optimized"]?.status).toBe("disabled");
   });
 
+  test("off-platform managed-inference hatch keeps selected managed connection active", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify(
+        {
+          llm: {
+            default: { provider: "anthropic" },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+    const db = createProviderConnectionsDb();
+
+    mergeDefaultConfigAndSeedInferenceProfiles(db);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.activeProfile).toBe("balanced");
+    expect(raw.llm.profiles.balanced.provider_connection).toBe(
+      "anthropic-managed",
+    );
+    expect("status" in raw.llm.profiles.balanced).toBe(false);
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
+  test("off-platform managed-inference hatch respects explicit non-managed active connection", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify(
+        {
+          llm: {
+            default: { provider: "anthropic" },
+            profiles: {
+              balanced: {
+                source: "managed",
+                provider: "anthropic",
+                provider_connection: "anthropic-personal",
+                model: "claude-sonnet-4-6",
+              },
+            },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+    const db = createProviderConnectionsDb();
+
+    mergeDefaultConfigAndSeedInferenceProfiles(db);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.activeProfile).toBe("balanced");
+    expect(raw.llm.profiles.balanced.provider_connection).toBe(
+      "anthropic-personal",
+    );
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
+  test("off-platform BYOK hatch still disables managed connections", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+    const db = createProviderConnectionsDb();
+
+    mergeDefaultConfigAndSeedInferenceProfiles(db);
+
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
   test("non-hatch off-platform boot does NOT auto-disable freshly-materialized managed profiles", () => {
     // Existing installs that upgrade to a version where the managed
     // profile didn't previously exist (e.g. a new template added later)
@@ -1029,11 +1129,8 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
       overlayPath,
-      JSON.stringify(
-        { llm: { default: { provider: "anthropic" } } },
-        null,
-        2,
-      ) + "\n",
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
     );
     process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
 

package/src/__tests__/context-token-estimator.test.ts

@@ -219,36 +219,7 @@ describe("token estimator", () => {
     expect(largeFileTokens).toBe(smallFileTokens);
   });
 
-  // Non-Anthropic providers use base64 payload size for image estimation
-  test("scales image token estimate with base64 payload size (non-Anthropic)", () => {
-    const smallImageTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: "a".repeat(64),
-        },
-      },
-      { providerName: "openai" },
-    );
-    const largeImageTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: "a".repeat(60_000),
-        },
-      },
-      { providerName: "openai" },
-    );
-
-    expect(largeImageTokens).toBeGreaterThan(smallImageTokens);
-    expect(largeImageTokens - smallImageTokens).toBeGreaterThan(1000);
-  });
-
-  test("estimates Anthropic image tokens from dimensions, not base64 size", () => {
+  test("estimates image tokens from dimensions, not base64 size", () => {
     // Build a minimal valid PNG header encoding 1920x1080 dimensions.
     // PNG header: 8-byte signature + 4-byte IHDR length + 4-byte "IHDR" + 4-byte width + 4-byte height = 24 bytes minimum
     const pngHeader = Buffer.alloc(24);
@@ -278,55 +249,49 @@ describe("token estimator", () => {
     const fullPayload = Buffer.concat([pngHeader, padding]);
     const base64Data = fullPayload.toString("base64");
 
-    const anthropicTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: base64Data },
-      },
-      { providerName: "anthropic" },
-    );
-
     // 1920x1080 scaled to fit 1568px bounding box: dimScale = 1568/1920 = 0.8167
     // scaledWidth = round(1920 * 0.8167) = 1568, scaledHeight = round(1080 * 0.8167) = 882
     // pixels = 1568 * 882 = 1,382,976 > 1,200,000 → mpScale = sqrt(1200000/1382976) = 0.9315
     // scaledWidth = round(1568 * 0.9315) = 1461, scaledHeight = round(882 * 0.9315) = 822
     // tokens = ceil(1461 * 822 / 750) = ceil(1601.26) = ~1,602
-    // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000
-    expect(anthropicTokens).toBeLessThan(5_000);
-
-    // Verify it's NOT using base64 size (which would be ~50,000+ tokens)
-    const nonAnthropicTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: base64Data },
-      },
-      { providerName: "openai" },
-    );
-    expect(nonAnthropicTokens).toBeGreaterThan(50_000);
+    // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000.
+    // Same result for every provider — dimension-based estimate is universal.
+    for (const providerName of ["anthropic", "openai", "openrouter"]) {
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: { type: "base64", media_type: "image/png", data: base64Data },
+        },
+        { providerName },
+      );
+      expect(tokens).toBeLessThan(5_000);
+    }
   });
 
-  test("falls back to max tokens when Anthropic image dimensions can't be parsed", () => {
+  test("falls back to max tokens when image dimensions can't be parsed", () => {
     // Corrupted base64 that won't parse as a valid image header
     const corruptedData = Buffer.from(
       "not-a-valid-image-header-at-all",
     ).toString("base64");
 
-    const tokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: corruptedData,
+    for (const providerName of ["anthropic", "openai", "openrouter"]) {
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: corruptedData,
+          },
         },
-      },
-      { providerName: "anthropic" },
-    );
+        { providerName },
+      );
 
-    // Should fall back to ANTHROPIC_IMAGE_MAX_TOKENS (1,600)
-    // Total = 16 (block overhead) + ceil(9/4) (media_type) + 1600 = 1619
-    expect(tokens).toBeGreaterThanOrEqual(1_600);
-    expect(tokens).toBeLessThan(2_000);
+      // Falls back to the per-image cap (1,600 tokens). Total = 16 (block
+      // overhead) + ceil(9/4) (media_type) + 1600 = 1619.
+      expect(tokens).toBeGreaterThanOrEqual(1_600);
+      expect(tokens).toBeLessThan(2_000);
+    }
   });
 
   test("Anthropic image tokens are the same for same-dimension images regardless of payload size", () => {

package/src/__tests__/conversation-agent-loop.test.ts

@@ -386,6 +386,7 @@ mock.module("../daemon/history-repair.js", () => ({
 
 const recordUsageMock = mock(() => {});
 const recordRequestLogMock = mock(() => {});
+const backfillMessageIdOnLogsMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -482,7 +483,7 @@ mock.module("../memory/archive-store.js", () => ({
 
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: recordRequestLogMock,
-  backfillMessageIdOnLogs: () => {},
+  backfillMessageIdOnLogs: backfillMessageIdOnLogsMock,
 }));
 
 let mockHasProactiveArtifactCompleted = true;
@@ -658,6 +659,7 @@ beforeEach(() => {
   mockInjectionBlocks = {};
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
+  backfillMessageIdOnLogsMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
   updateMessageMetadataMock.mockClear();
@@ -2855,6 +2857,60 @@ describe("session-agent-loop", () => {
       );
       expect(conversationErrors.length).toBeGreaterThanOrEqual(1);
     });
+
+    test("pipes synthetic assistant message id into provider-error log rows via backfill", async () => {
+      // Codex P1 regression test: the provider-failure turn must not leave
+      // its `llm_request_logs` row orphaned. Without the backfill call in
+      // the synthetic-message branch, a later turn's `handleMessageComplete`
+      // sweep would wrong-attach this row to the wrong assistant message.
+      const events: ServerMessage[] = [];
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // 1) handleProviderError -> writes an `llm_request_logs` row with
+        //    messageId=null (the orphan we are trying to link).
+        onEvent({
+          type: "provider_error",
+          error: new Error("upstream 500"),
+          rawRequest: { model: "gpt-4.1", messages: [] },
+          actualProvider: "openai",
+        });
+        // 2) handleError -> sets `state.providerErrorUserMessage`, which
+        //    activates the synthetic-message branch below the loop.
+        onEvent({
+          type: "error",
+          error: new Error("upstream 500"),
+        });
+        // Provider returned no assistant content — same messages back.
+        return messages;
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      // The orphan was written with messageId=undefined.
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const recordCall = recordRequestLogMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        string | undefined,
+        string | undefined,
+      ];
+      expect(recordCall[0]).toBe("test-conv");
+      expect(recordCall[3]).toBeUndefined();
+
+      // The synthetic-message branch then piped the assigned message id
+      // (from the mocked `addMessage` -> `{ id: "mock-msg-id" }`) into the
+      // backfill primitive, scoped to this conversation.
+      expect(backfillMessageIdOnLogsMock).toHaveBeenCalledTimes(1);
+      const backfillCall =
+        backfillMessageIdOnLogsMock.mock.calls[0] as unknown as [
+          string,
+          string,
+        ];
+      expect(backfillCall[0]).toBe("test-conv");
+      expect(backfillCall[1]).toBe("mock-msg-id");
+    });
   });
 
   describe("pkbSystemReminderBlock metadata persistence", () => {

package/src/__tests__/conversation-media-retry.test.ts

@@ -23,7 +23,11 @@ function makeImageBlockWithSize(
 ): Extract<ContentBlock, { type: "image" }> {
   return {
     type: "image",
-    source: { type: "base64", media_type: "image/png", data: "A".repeat(dataLength) },
+    source: {
+      type: "base64",
+      media_type: "image/png",
+      data: "A".repeat(dataLength),
+    },
   };
 }
 
@@ -103,16 +107,19 @@ describe("stripMediaPayloadsForRetry", () => {
   // ---------------------------------------------------------------------------
 
   test("budget-aware: keeps images that fit within token budget", () => {
-    // Non-Anthropic estimation: estimateTextTokens(base64Data) + overhead (~19 tokens).
-    // Data length 4000 → 1000 data tokens + 19 overhead ≈ 1019 tokens/image.
-    // Budget of 3500 allows 3 images (3 * 1019 = 3057 <= 3500) but not 4.
-    const images = Array.from({ length: 5 }, () => makeImageBlockWithSize(4000));
+    // Dimension-based estimation: when the base64 data has no parseable image
+    // header, fall back to IMAGE_MAX_TOKENS (1600) + overhead (~19 tokens) ≈
+    // 1619 tokens/image. Budget of 5000 allows 3 images (3 * 1619 = 4857
+    // <= 5000) but not 4 (4 * 1619 = 6476 > 5000).
+    const images = Array.from({ length: 5 }, () =>
+      makeImageBlockWithSize(4000),
+    );
     const messages: Message[] = [
       makeUserMessage({ type: "text", text: "describe these" }, ...images),
     ];
 
     const result = stripMediaPayloadsForRetry(messages, {
-      mediaTokenBudget: 3500,
+      mediaTokenBudget: 5000,
       providerName: "mock",
     });
     expect(result.modified).toBe(true);
@@ -120,7 +127,9 @@ describe("stripMediaPayloadsForRetry", () => {
     const content = result.messages[0].content;
     const keptImages = content.filter((b) => b.type === "image");
     const stubs = content.filter(
-      (b) => b.type === "text" && (b as { text: string }).text.includes("Image omitted"),
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("Image omitted"),
     );
     expect(keptImages.length).toBe(3);
     expect(stubs.length).toBe(2);
@@ -174,7 +183,9 @@ describe("stripMediaPayloadsForRetry", () => {
     const content = result.messages[0].content;
     const keptImages = content.filter((b) => b.type === "image");
     const stubs = content.filter(
-      (b) => b.type === "text" && (b as { text: string }).text.includes("Image omitted"),
+      (b) =>
+        b.type === "text" &&
+        (b as { text: string }).text.includes("Image omitted"),
     );
     expect(keptImages.length).toBe(3);
     expect(stubs.length).toBe(2);

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

@@ -930,6 +930,28 @@ describe("stripInjectionsForCompaction with NOW.md", () => {
       "Hello",
     );
   });
+
+  test("strips <background_turn> blocks", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<background_turn>\nGuardian isn't watching — notify on anything noteworthy.\n</background_turn>",
+          },
+          { 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",
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1880,7 +1902,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     },
   ];
 
-  const FLAT_REMINDER = buildPkbReminder([], false);
+  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
@@ -2136,7 +2158,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
       role: "user",
       content: [
         { type: "text", text: "hello" },
-        { type: "text", text: buildPkbReminder([], false) },
+        { type: "text", text: buildPkbReminder([]) },
       ],
     };
     const hintedMessage: Message = {
@@ -2145,7 +2167,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
         { type: "text", text: "hello" },
         {
           type: "text",
-          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"], false),
+          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"]),
         },
       ],
     };
@@ -4827,7 +4849,7 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
       mode: "full",
     });
 
-    const expected = buildPkbReminder([], false);
+    const expected = buildPkbReminder([]);
     expect(blocks.pkbSystemReminder).toBe(expected);
   });