@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/compaction-events.test.ts

@@ -0,0 +1,501 @@
+/**
+ * Tests for compaction event emission.
+ *
+ * Verifies that forceCompact() emits a `context_compacted` event (carrying
+ * the fresh `estimatedInputTokens` / `maxInputTokens`) after a successful
+ * compaction, so the UI indicator refreshes without waiting for the next full
+ * turn. The `context_compacted` event is the single source of truth for the
+ * indicator — the paired `usage_update` intentionally omits
+ * `contextWindowTokens` to avoid a redundant SwiftUI invalidation.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type {
+  AgentEvent,
+  AgentLoopConfig,
+  CheckpointDecision,
+  CheckpointInfo,
+} from "../agent/loop.js";
+import type { ContextWindowResult } from "../context/window-manager.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede Conversation import
+// ---------------------------------------------------------------------------
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/guardian-action-store.js", () => ({
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "high" as const,
+        speed: "standard",
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    timeouts: { permissionTimeoutSec: 1 },
+    skills: { entries: {}, allowBundled: true },
+    permissions: { mode: "workspace" },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: `msg-${Date.now()}` }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: `att-${Date.now()}` }),
+  linkAttachmentToMessage: () => {},
+}));
+
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => ({
+    enabled: false,
+    degraded: false,
+    injectedText: "",
+    semanticHits: 0,
+    injectedTokens: 0,
+    latencyMs: 0,
+  }),
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+
+// Per-test compaction result — set before calling forceCompact().
+let mockCompactResult: ContextWindowResult = {
+  messages: [],
+  compacted: false,
+  previousEstimatedInputTokens: 0,
+  estimatedInputTokens: 0,
+  maxInputTokens: 0,
+  thresholdTokens: 0,
+  compactedMessages: 0,
+  compactedPersistedMessages: 0,
+  summaryCalls: 0,
+  summaryInputTokens: 0,
+  summaryOutputTokens: 0,
+  summaryModel: "",
+  summaryText: "",
+};
+
+mock.module("../context/window-manager.js", () => ({
+  ContextWindowManager: class {
+    nonPersistedPrefixCount = 0;
+    summaryIsInjected = false;
+    constructor() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact(): Promise<ContextWindowResult> {
+      return mockCompactResult;
+    }
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../memory/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "mock-id", createdAt: Date.now() }),
+  listUsageEvents: () => [],
+}));
+
+mock.module("../memory/auto-analysis-enqueue.js", () => ({
+  enqueueAutoAnalysisOnCompaction: () => {},
+}));
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    constructor(
+      _provider: unknown,
+      _systemPrompt: string,
+      _config?: Partial<AgentLoopConfig>,
+    ) {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
+    async run(
+      _messages: Message[],
+      _onEvent: (event: AgentEvent) => void,
+      _signal?: AbortSignal,
+      _requestId?: string,
+      _onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>,
+    ): Promise<Message[]> {
+      return [];
+    }
+  },
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+  createCanonicalGuardianRequest: () => ({
+    id: "mock-cg-id",
+    code: "MOCK",
+    status: "pending",
+  }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: "mock-cgd-id" }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => "MOCK-CODE",
+}));
+
+// ---------------------------------------------------------------------------
+// Import Conversation AFTER mocks
+// ---------------------------------------------------------------------------
+
+import { Conversation } from "../daemon/conversation.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeProvider() {
+  return {
+    name: "mock-provider",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+function makeConversation(
+  collected: ServerMessage[],
+  id = "conv-compact-events",
+): Conversation {
+  return new Conversation(
+    id,
+    makeProvider(),
+    "system prompt",
+    4096,
+    (msg) => {
+      collected.push(msg);
+    },
+    "/tmp",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("forceCompact event emission", () => {
+  test("emits context_compacted and a usage_update without contextWindow when compacted", async () => {
+    const collected: ServerMessage[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      previousEstimatedInputTokens: 150_000,
+      estimatedInputTokens: 80_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(collected);
+    await conversation.forceCompact();
+
+    const compactedEvents = collected.filter(
+      (m) => m.type === "context_compacted",
+    );
+    expect(compactedEvents.length).toBe(1);
+    const compactedEvent = compactedEvents[0] as Extract<
+      ServerMessage,
+      { type: "context_compacted" }
+    >;
+    expect(compactedEvent.conversationId).toBe("conv-compact-events");
+    expect(compactedEvent.estimatedInputTokens).toBe(80_000);
+    expect(compactedEvent.maxInputTokens).toBe(200_000);
+    expect(compactedEvent.previousEstimatedInputTokens).toBe(150_000);
+    expect(compactedEvent.summaryCalls).toBe(1);
+    expect(compactedEvent.summaryInputTokens).toBe(500);
+    expect(compactedEvent.summaryOutputTokens).toBe(200);
+    expect(compactedEvent.summaryModel).toBe("test-model");
+    // Quality signals derived from the summary text itself.
+    expect(compactedEvent.summaryCharCount).toBe("summary text".length);
+    expect(compactedEvent.summaryHeaderCount).toBe(0);
+    expect(compactedEvent.summaryHadMemoryEcho).toBe(false);
+
+    const usageEvents = collected.filter((m) => m.type === "usage_update");
+    expect(usageEvents.length).toBe(1);
+    const usageEvent = usageEvents[0] as Extract<
+      ServerMessage,
+      { type: "usage_update" }
+    >;
+    // `context_compacted` is now the single source of truth for the UI
+    // indicator after compaction; the paired `usage_update` intentionally
+    // omits contextWindow to avoid a redundant SwiftUI invalidation.
+    expect(usageEvent.contextWindowTokens).toBeUndefined();
+    expect(usageEvent.contextWindowMaxTokens).toBeUndefined();
+    expect(usageEvent.inputTokens).toBe(500);
+    expect(usageEvent.outputTokens).toBe(200);
+    expect(usageEvent.model).toBe("test-model");
+  });
+
+  test("emits context_compacted even when summary LLM was skipped (truncation-only path)", async () => {
+    const collected: ServerMessage[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      previousEstimatedInputTokens: 150_000,
+      estimatedInputTokens: 80_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 0,
+      summaryInputTokens: 0,
+      summaryOutputTokens: 0,
+      summaryModel: "",
+      summaryText: "",
+    };
+
+    const conversation = makeConversation(collected, "conv-compact-trunc");
+    await conversation.forceCompact();
+
+    // The truncation-only path does not call the summary LLM, so
+    // `recordUsage` early-returns on 0/0 tokens and no `usage_update` is
+    // emitted. The client instead picks up the fresh context-window tokens
+    // from the `context_compacted` event, which carries the post-compaction
+    // `estimatedInputTokens` and `maxInputTokens` alongside `conversationId`.
+    const compactedEvents = collected.filter(
+      (m) => m.type === "context_compacted",
+    );
+    expect(compactedEvents.length).toBe(1);
+    const compactedEvent = compactedEvents[0] as Extract<
+      ServerMessage,
+      { type: "context_compacted" }
+    >;
+    expect(compactedEvent.conversationId).toBe("conv-compact-trunc");
+    expect(compactedEvent.estimatedInputTokens).toBe(80_000);
+    expect(compactedEvent.maxInputTokens).toBe(200_000);
+
+    // No usage_update synthesis in the truncation-only path (the previous
+    // synthetic fallback was removed now that context_compacted carries
+    // conversationId and refreshes the indicator on the client).
+    expect(collected.filter((m) => m.type === "usage_update").length).toBe(0);
+  });
+
+  test("skips emission when compacted is false", async () => {
+    const collected: ServerMessage[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: false,
+      previousEstimatedInputTokens: 0,
+      estimatedInputTokens: 0,
+      maxInputTokens: 0,
+      thresholdTokens: 0,
+      compactedMessages: 0,
+      compactedPersistedMessages: 0,
+      summaryCalls: 0,
+      summaryInputTokens: 0,
+      summaryOutputTokens: 0,
+      summaryModel: "",
+      summaryText: "",
+    };
+
+    const conversation = makeConversation(collected, "conv-compact-noop");
+    await conversation.forceCompact();
+
+    expect(collected.filter((m) => m.type === "context_compacted").length).toBe(
+      0,
+    );
+    expect(collected.filter((m) => m.type === "usage_update").length).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// computeSummaryQualitySignals — imported lazily after mocks are installed so
+// the logger stub and other module replacements take effect first.
+// ---------------------------------------------------------------------------
+
+import { computeSummaryQualitySignals } from "../daemon/conversation-agent-loop.js";
+
+describe("computeSummaryQualitySignals", () => {
+  test("counts `## ` headers at the start of lines", () => {
+    const summary =
+      "Narrative opener.\n\n## What We're Working On\n- x\n\n## Open Threads\n- y";
+    const signals = computeSummaryQualitySignals(summary);
+    expect(signals.headerCount).toBe(2);
+    expect(signals.charCount).toBe(summary.length);
+    expect(signals.hadMemoryEcho).toBe(false);
+  });
+
+  test("reports empty signals for an empty summary", () => {
+    const signals = computeSummaryQualitySignals("");
+    expect(signals.charCount).toBe(0);
+    expect(signals.headerCount).toBe(0);
+    expect(signals.hadMemoryEcho).toBe(false);
+  });
+
+  test("flags summaries that leaked injection tags", () => {
+    const leaked =
+      "## Facts\nThe user had a `<memory __injected>` block in their history";
+    expect(computeSummaryQualitySignals(leaked).hadMemoryEcho).toBe(true);
+
+    const turnCtxLeak = "A <turn_context> fragment snuck through";
+    expect(computeSummaryQualitySignals(turnCtxLeak).hadMemoryEcho).toBe(true);
+
+    const nowLeak = "<NOW.md> scratchpad echo";
+    expect(computeSummaryQualitySignals(nowLeak).hadMemoryEcho).toBe(true);
+  });
+
+  test("flags tags that sit next to an underscore (word-boundary gap)", () => {
+    // These four tags contain underscores, so `\b` only asserts between the
+    // full tag name and `>` (not between two word characters like the `e_` in
+    // `workspace_top_level`). Each tag must be detected as a memory echo when
+    // leaked into a summary.
+    const cases = [
+      "<workspace_top_level>\nlisting",
+      "<active_subagents>\nstuff",
+      "<active_workspace>\nstuff",
+      "<active_dynamic_page>\nstuff",
+    ];
+    for (const leaked of cases) {
+      expect(computeSummaryQualitySignals(leaked).hadMemoryEcho).toBe(true);
+    }
+  });
+
+  test("does not flag ordinary mentions of the word 'memory'", () => {
+    const clean =
+      "## Facts\nThe user asked about their memory and remembered their dad's recipe.";
+    expect(computeSummaryQualitySignals(clean).hadMemoryEcho).toBe(false);
+  });
+});

package/src/__tests__/compaction-pipeline.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Tests for the `compaction` plugin pipeline (PR 25).
+ *
+ * Covers:
+ * - Default plugin delegates to the manager's `maybeCompact` and returns the
+ *   same `ContextWindowResult` object the manager produced.
+ * - A custom plugin layered on top can short-circuit before the terminal is
+ *   reached and return a different summary, demonstrating that the pipeline
+ *   slot is observable and replaceable without patching the manager.
+ *
+ * The tests drive `runPipeline` directly rather than going through the full
+ * orchestrator — the integration path (conversation-agent-loop) is exercised
+ * by `conversation-agent-loop-overflow.test.ts`, which must continue to pass
+ * as the acceptance criterion for this PR.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import {
+  DEFAULT_COMPACTION_PLUGIN_NAME,
+  defaultCompactionTerminal,
+} from "../plugins/defaults/compaction.js";
+import { runPipeline } from "../plugins/pipeline.js";
+import {
+  type CompactionArgs,
+  type CompactionResult,
+  type Middleware,
+  PluginExecutionError,
+  type TurnContext,
+} from "../plugins/types.js";
+
+type ContextWindowResultShape = {
+  compacted: boolean;
+  summaryText: string;
+  messages: unknown[];
+  previousEstimatedInputTokens: number;
+  estimatedInputTokens: number;
+  maxInputTokens: number;
+  thresholdTokens: number;
+  compactedMessages: number;
+  compactedPersistedMessages: number;
+  summaryCalls: number;
+  summaryInputTokens: number;
+  summaryOutputTokens: number;
+  summaryModel: string;
+  reason?: string;
+};
+
+const trust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+function makeTurnCtx(manager: {
+  maybeCompact: (...args: unknown[]) => Promise<unknown>;
+}): TurnContext {
+  return {
+    requestId: "req-compaction-test",
+    conversationId: "conv-compaction-test",
+    turnIndex: 0,
+    trust,
+    // `TurnContext.contextWindowManager` is a typed optional field; the
+    // default compaction plugin reads it directly without a cast.
+    contextWindowManager:
+      manager as unknown as TurnContext["contextWindowManager"],
+  };
+}
+
+function makeResult(
+  overrides: Partial<ContextWindowResultShape> = {},
+): ContextWindowResultShape {
+  return {
+    compacted: true,
+    summaryText: "default-summary",
+    messages: [],
+    previousEstimatedInputTokens: 1000,
+    estimatedInputTokens: 100,
+    maxInputTokens: 100000,
+    thresholdTokens: 80000,
+    compactedMessages: 3,
+    compactedPersistedMessages: 3,
+    summaryCalls: 1,
+    summaryInputTokens: 500,
+    summaryOutputTokens: 120,
+    summaryModel: "default-model",
+    ...overrides,
+  };
+}
+
+describe("compaction pipeline", () => {
+  test("default plugin delegates to the manager and returns its result unchanged", async () => {
+    const observed: {
+      messages: unknown;
+      signal: unknown;
+      options: unknown;
+    }[] = [];
+    const expected = makeResult({
+      summaryText: "manager-summary",
+      compactedMessages: 7,
+    });
+    const manager = {
+      maybeCompact: async (
+        messages: unknown,
+        signal: unknown,
+        options: unknown,
+      ) => {
+        observed.push({ messages, signal, options });
+        return expected;
+      },
+    };
+    const turnCtx = makeTurnCtx(manager);
+    const args: CompactionArgs = {
+      messages: [{ role: "user", content: "hi" }],
+      signal: new AbortController().signal,
+      options: { lastCompactedAt: 42, precomputedEstimate: 1234 },
+    };
+
+    // No middleware registered — the runner invokes the terminal directly.
+    const result = (await runPipeline<CompactionArgs, CompactionResult>(
+      "compaction",
+      [],
+      (innerArgs) => defaultCompactionTerminal(innerArgs, turnCtx),
+      args,
+      turnCtx,
+      30000,
+    )) as ContextWindowResultShape;
+
+    // Terminal forwarded args verbatim to the manager — except for
+    // `signal`, which the pipeline runner replaces with a signal linked
+    // to its internal timeout controller. The linked signal must forward
+    // caller-originated aborts, which is verified in the dedicated
+    // pipeline-runner abort-propagation tests.
+    expect(observed).toHaveLength(1);
+    expect(observed[0]!.messages).toBe(args.messages);
+    expect(observed[0]!.signal).toBeInstanceOf(AbortSignal);
+    expect(observed[0]!.options).toBe(args.options);
+
+    // Returned result is the manager's object, unmodified — no wrapping
+    // or shape transformation is allowed in the default path.
+    expect(result).toBe(expected);
+    expect(result.summaryText).toBe("manager-summary");
+    expect(result.compactedMessages).toBe(7);
+  });
+
+  test("custom plugin short-circuits to a different summary without touching the manager", async () => {
+    let managerCallCount = 0;
+    const manager = {
+      maybeCompact: async () => {
+        managerCallCount++;
+        return makeResult({ summaryText: "should-not-run" });
+      },
+    };
+    const turnCtx = makeTurnCtx(manager);
+
+    const custom: Middleware<CompactionArgs, CompactionResult> =
+      async function customCompaction(_args, _next, _ctx) {
+        // Short-circuit — omit the `next` call so the terminal never fires.
+        return makeResult({
+          summaryText: "custom-plugin-summary",
+          compactedMessages: 0,
+          summaryCalls: 0,
+          reason: "short-circuited by custom plugin",
+        });
+      };
+
+    const args: CompactionArgs = {
+      messages: [],
+      signal: undefined,
+      options: undefined,
+    };
+
+    const result = (await runPipeline<CompactionArgs, CompactionResult>(
+      "compaction",
+      [custom],
+      (innerArgs) => defaultCompactionTerminal(innerArgs, turnCtx),
+      args,
+      turnCtx,
+      30000,
+    )) as ContextWindowResultShape;
+
+    expect(managerCallCount).toBe(0);
+    expect(result.summaryText).toBe("custom-plugin-summary");
+    expect(result.reason).toBe("short-circuited by custom plugin");
+  });
+
+  test("default terminal surfaces a PluginExecutionError when the manager is missing", async () => {
+    // Build a turn context without the extension field so the default
+    // terminal's lenient read fails — this guards against a future refactor
+    // that removes the handle-attach helper in the orchestrator.
+    const turnCtxWithoutManager: TurnContext = {
+      requestId: "req-missing",
+      conversationId: "conv-missing",
+      turnIndex: 0,
+      trust,
+    };
+    const args: CompactionArgs = {
+      messages: [],
+      signal: undefined,
+      options: undefined,
+    };
+
+    await expect(
+      defaultCompactionTerminal(args, turnCtxWithoutManager),
+    ).rejects.toThrow(PluginExecutionError);
+    await expect(
+      defaultCompactionTerminal(args, turnCtxWithoutManager),
+    ).rejects.toThrow(DEFAULT_COMPACTION_PLUGIN_NAME);
+  });
+});