@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/conversation-queue.test.ts

@@ -55,7 +55,7 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
+
     llm: {
       default: {
         provider: "mock-provider",
@@ -330,7 +330,9 @@ interface PendingRun {
   reject: (err: Error) => void;
   messages: Message[];
   onEvent: (event: AgentEvent) => void;
-  onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision;
+  onCheckpoint?: (
+    checkpoint: CheckpointInfo,
+  ) => CheckpointDecision | Promise<CheckpointDecision>;
 }
 
 let pendingRuns: PendingRun[] = [];
@@ -341,6 +343,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     getActiveModel() {
       return undefined;
     }
@@ -349,7 +354,9 @@ mock.module("../agent/loop.js", () => ({
       onEvent: (event: AgentEvent) => void,
       _signal?: AbortSignal,
       _requestId?: string,
-      onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+      onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return new Promise<Message[]>((resolve, reject) => {
         pendingRuns.push({ resolve, reject, messages, onEvent, onCheckpoint });
@@ -1728,7 +1735,7 @@ describe("Conversation checkpoint handoff", () => {
     // Simulate the agent loop calling it at a turn boundary.
     const run = pendingRuns[0];
     expect(run.onCheckpoint).toBeDefined();
-    const decision = run.onCheckpoint!({
+    const decision = await run.onCheckpoint!({
       turnIndex: 0,
       toolCount: 1,
       hasToolUse: true,
@@ -1771,7 +1778,7 @@ describe("Conversation checkpoint handoff", () => {
     // The pending run should have an onCheckpoint callback
     const run = pendingRuns[0];
     expect(run.onCheckpoint).toBeDefined();
-    const decision = run.onCheckpoint!({
+    const decision = await run.onCheckpoint!({
       turnIndex: 0,
       toolCount: 1,
       hasToolUse: true,
@@ -1813,7 +1820,7 @@ describe("Conversation checkpoint handoff", () => {
     // Simulate the agent loop yielding at the checkpoint (first run is mid-tool-use)
     const run0 = pendingRuns[0];
     expect(run0.onCheckpoint).toBeDefined();
-    const decision = run0.onCheckpoint!({
+    const decision = await run0.onCheckpoint!({
       turnIndex: 0,
       toolCount: 1,
       hasToolUse: true,
@@ -1871,7 +1878,7 @@ describe("Conversation checkpoint handoff", () => {
 
     // Simulate multiple tool-use turns before the checkpoint fires
     // Turn 0 — checkpoint yields because msg-2 is waiting
-    const decision = run.onCheckpoint!({
+    const decision = await run.onCheckpoint!({
       turnIndex: 0,
       toolCount: 1,
       hasToolUse: true,
@@ -1966,7 +1973,7 @@ describe("Conversation checkpoint handoff", () => {
     const runA = pendingRuns[0];
     expect(runA.onCheckpoint).toBeDefined();
     expect(
-      runA.onCheckpoint!({
+      await runA.onCheckpoint!({
         turnIndex: 0,
         toolCount: 1,
         hasToolUse: true,
@@ -1983,7 +1990,7 @@ describe("Conversation checkpoint handoff", () => {
     const runB = pendingRuns[1];
     expect(runB.onCheckpoint).toBeDefined();
     expect(
-      runB.onCheckpoint!({
+      await runB.onCheckpoint!({
         turnIndex: 0,
         toolCount: 1,
         hasToolUse: true,
@@ -1998,7 +2005,7 @@ describe("Conversation checkpoint handoff", () => {
     expect(runC.onCheckpoint).toBeDefined();
     // Only D remains, still should yield
     expect(
-      runC.onCheckpoint!({
+      await runC.onCheckpoint!({
         turnIndex: 0,
         toolCount: 1,
         hasToolUse: true,
@@ -2012,7 +2019,7 @@ describe("Conversation checkpoint handoff", () => {
     const runD = pendingRuns[3];
     expect(runD.onCheckpoint).toBeDefined();
     expect(
-      runD.onCheckpoint!({
+      await runD.onCheckpoint!({
         turnIndex: 0,
         toolCount: 1,
         hasToolUse: true,
@@ -2411,7 +2418,12 @@ describe("Conversation attachment event payloads", () => {
       model: "mock",
       providerDurationMs: 100,
     });
-    run.onEvent({ type: "message_complete", message: assistantMsg });
+    // Await the message_complete dispatch so the async persistence pipeline
+    // (which sets `state.lastAssistantMessageId`) finishes before the mock
+    // resolves `agentLoop.run()` and downstream post-processing runs. The
+    // real agent loop in `agent/loop.ts` awaits onEvent before returning,
+    // so awaiting here keeps the mock faithful to production semantics.
+    await run.onEvent({ type: "message_complete", message: assistantMsg });
     run.resolve([...run.messages, assistantMsg]);
 
     await p1;
@@ -2450,7 +2462,7 @@ describe("Conversation attachment event payloads", () => {
     const run = pendingRuns[0];
     expect(run.onCheckpoint).toBeDefined();
     expect(
-      run.onCheckpoint!({
+      await run.onCheckpoint!({
         turnIndex: 0,
         toolCount: 1,
         hasToolUse: true,
@@ -2585,7 +2597,10 @@ describe("Regression: cancel semantics and error channel split", () => {
       model: "mock",
       providerDurationMs: 100,
     });
-    run.onEvent({ type: "message_complete", message: assistantMsg });
+    // Await the message_complete dispatch so the async persistence pipeline
+    // finishes before the mock resolves `agentLoop.run()`. See the matching
+    // comment in "message_complete includes assistant attachments".
+    await run.onEvent({ type: "message_complete", message: assistantMsg });
     run.resolve([...run.messages, assistantMsg]);
     await p1;
 

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -432,15 +432,16 @@ describe("macOS browser backend fallback (no extension, no cdp-inspect)", () =>
     expect(interfaceCtx!.userMessageInterface).toBe("macos");
     expect(interfaceCtx!.assistantMessageInterface).toBe("macos");
 
-    // With no extension in the ChromeExtensionRegistry, the conversation's
-    // hostBrowserProxy should NOT be provisioned through the registry.
-    // The absence of a hostBrowserProxy means the CDP factory will skip
-    // the extension candidate entirely and fall through:
-    // cdp-inspect (desktop-auto) → local.
+    // macOS now natively supports host_browser, so the conversation gets a
+    // hostBrowserProxy provisioned via the SSE sender path even without an
+    // extension connection. The proxy routes host_browser_request frames to
+    // the macOS desktop client over SSE. The hostBrowserSenderOverride
+    // remains undefined because no registry-routed extension connection is
+    // present — the proxy uses the default SSE sender.
     expect(
       (capturedConversation as unknown as Record<string, unknown>)
         .hostBrowserProxy,
-    ).toBeUndefined();
+    ).toBeDefined();
     expect(
       (capturedConversation as unknown as Record<string, unknown>)
         .hostBrowserSenderOverride,

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

@@ -1,4 +1,4 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // PKB search is mocked so the reminder-hints tests can assert behavior
 // without standing up Qdrant. The mock returns whatever is staged in
@@ -31,8 +31,6 @@ import {
   findLastInjectedNowContent,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
-  injectNowScratchpad,
-  injectSubagentStatus,
   isGroupChatType,
   isSlackChannelConversation,
   loadSlackActiveThreadFocusBlock,
@@ -49,9 +47,24 @@ import {
   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 type { SubagentState } from "../subagent/types.js";
 
+// `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);
+});
+
 // ---------------------------------------------------------------------------
 // resolveChannelCapabilities
 // ---------------------------------------------------------------------------
@@ -797,86 +810,12 @@ describe("applyRuntimeInjections — injection mode", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// injectNowScratchpad
-// ---------------------------------------------------------------------------
-
-describe("injectNowScratchpad", () => {
-  const baseUserMessage: Message = {
-    role: "user",
-    content: [{ type: "text", text: "What should I work on?" }],
-  };
-
-  test("inserts NOW.md before user content", () => {
-    const result = injectNowScratchpad(
-      baseUserMessage,
-      "Current focus: shipping PR 3",
-    );
-    expect(result.content.length).toBe(2);
-    // Scratchpad comes first (before user content)
-    const injected = result.content[0];
-    expect(injected.type).toBe("text");
-    const text = (injected as { type: "text"; text: string }).text;
-    expect(text).toBe(
-      "<NOW.md Always keep this up to date; keep under 10 lines>\nCurrent focus: shipping PR 3\n</NOW.md>",
-    );
-    // Original content comes last
-    expect((result.content[1] as { type: "text"; text: string }).text).toBe(
-      "What should I work on?",
-    );
-  });
-
-  test("inserts after memory_context but before user content", () => {
-    const messageWithMemory: Message = {
-      role: "user",
-      content: [
-        {
-          type: "text",
-          text: "<memory_context __injected>\nrecalled notes\n</memory_context>",
-        },
-        { type: "text", text: "What should I work on?" },
-      ],
-    };
-
-    const result = injectNowScratchpad(messageWithMemory, "scratchpad notes");
-    expect(result.content.length).toBe(3);
-    // Memory context stays first
-    expect(
-      (result.content[0] as { type: "text"; text: string }).text,
-    ).toContain("<memory_context");
-    // Scratchpad inserted after memory
-    expect(
-      (result.content[1] as { type: "text"; text: string }).text,
-    ).toContain("<NOW.md");
-    // User content is last
-    expect((result.content[2] as { type: "text"; text: string }).text).toBe(
-      "What should I work on?",
-    );
-  });
-
-  test("preserves existing multi-block content with scratchpad before it", () => {
-    const multiBlockMessage: Message = {
-      role: "user",
-      content: [
-        { type: "text", text: "First block" },
-        { type: "text", text: "Second block" },
-      ],
-    };
-
-    const result = injectNowScratchpad(multiBlockMessage, "scratchpad notes");
-    expect(result.content.length).toBe(3);
-    // Scratchpad is first (no memory_context to skip)
-    expect(
-      (result.content[0] as { type: "text"; text: string }).text,
-    ).toContain("<NOW.md");
-    expect((result.content[1] as { type: "text"; text: string }).text).toBe(
-      "First block",
-    );
-    expect((result.content[2] as { type: "text"; text: string }).text).toBe(
-      "Second block",
-    );
-  });
-});
+// 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.
 
 // ---------------------------------------------------------------------------
 // stripNowScratchpad
@@ -1837,22 +1776,9 @@ describe("buildSubagentStatusBlock", () => {
   });
 });
 
-describe("injectSubagentStatus", () => {
-  test("appends status block to user message", () => {
-    const msg: Message = {
-      role: "user",
-      content: [{ type: "text", text: "hello" }],
-    };
-    const result = injectSubagentStatus(
-      msg,
-      "<active_subagents>\ntest\n</active_subagents>",
-    );
-    expect(result.content).toHaveLength(2);
-    expect(
-      (result.content[1] as { type: string; text: string }).text,
-    ).toContain("<active_subagents>");
-  });
-});
+// `injectSubagentStatus` was removed in G2.1 — coverage of the append
+// placement lives in the `applyRuntimeInjections — subagent status` suite
+// below, which exercises the subagent-status default injector end-to-end.
 
 describe("applyRuntimeInjections — subagent status", () => {
   const userMsg: Message = {
@@ -2702,7 +2628,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
           },
           {
             role: "assistant",
-            content: [{ type: "text", text: "[11/14/23 14:26]: prior reply" }],
+            content: [{ type: "text", text: "prior reply" }],
           },
         ],
       },
@@ -3666,6 +3592,125 @@ describe("assembleSlackActiveThreadFocusBlock", () => {
     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.
+    const rows: SlackTranscriptInputRow[] = [
+      buildRow(
+        "user",
+        "Parent",
+        1_000,
+        buildMeta({ channelTs: PARENT_TS, displayName: "@alice" }),
+      ),
+      // Assistant reply in the thread — gets an `@assistant:` prefix.
+      buildRow(
+        "assistant",
+        "Assistant reply",
+        2_000,
+        buildMeta({
+          channelTs: "1700000005.000001",
+          threadTs: PARENT_TS,
+        }),
+      ),
+      // Assistant reaction on the parent — must NOT get a second prefix.
+      buildRow(
+        "assistant",
+        "[reaction]",
+        3_000,
+        buildMeta({
+          channelTs: "1700000008.000002",
+          eventKind: "reaction",
+          reaction: {
+            emoji: "👍",
+            targetChannelTs: PARENT_TS,
+            op: "added",
+          },
+        }),
+      ),
+      // Latest user row in the thread — required for `detectActiveThreadTs`
+      // to lock onto PARENT_TS (the latest user turn is the anchor).
+      buildRow(
+        "user",
+        "User follow-up",
+        4_000,
+        buildMeta({
+          channelTs: REPLY_TS,
+          threadTs: PARENT_TS,
+          displayName: "@alice",
+        }),
+      ),
+    ];
+    const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
+    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.
+    expect(result!).toContain("@assistant reacted 👍");
+    expect(result!).toContain("@assistant: Assistant reply");
+  });
+
+  test("assistant reaction overflow trailer is not double-attributed", () => {
+    // When assistant reactions overflow the per-target cap, `renderSlackTranscript`
+    // emits a trailer line (`[…and N more reactions to Mxxxxxx]`) whose role
+    // is inherited from the first overflowing reaction — i.e. `assistant`. The
+    // trailer embeds no actor attribution but ends with the parent alias and
+    // shares the same `M<hex>]` signature as a real reaction line, so it must
+    // be detected by `isReactionTagLine` and skipped by the prefix step.
+    const PARENT_ALIAS_TS = PARENT_TS;
+    const buildAssistantReaction = (ts: string, emoji: string) =>
+      buildRow(
+        "assistant",
+        "[reaction]",
+        Number.parseFloat(ts) * 1000,
+        buildMeta({
+          channelTs: ts,
+          eventKind: "reaction",
+          reaction: {
+            emoji,
+            targetChannelTs: PARENT_ALIAS_TS,
+            op: "added",
+          },
+        }),
+      );
+    const rows: SlackTranscriptInputRow[] = [
+      buildRow(
+        "user",
+        "Parent",
+        1_000,
+        buildMeta({ channelTs: PARENT_TS, displayName: "@alice" }),
+      ),
+      // Overflow the default per-target cap (5) with 7 reactions so the
+      // trailer line is emitted with 2 excess.
+      buildAssistantReaction("1700000100.000001", "👍"),
+      buildAssistantReaction("1700000100.000002", "🎉"),
+      buildAssistantReaction("1700000100.000003", "🔥"),
+      buildAssistantReaction("1700000100.000004", "💯"),
+      buildAssistantReaction("1700000100.000005", "👏"),
+      buildAssistantReaction("1700000100.000006", "👀"),
+      buildAssistantReaction("1700000100.000007", "🚀"),
+      // Latest user row in the thread — required for `detectActiveThreadTs`.
+      buildRow(
+        "user",
+        "Follow-up",
+        2_000_000,
+        buildMeta({
+          channelTs: REPLY_TS,
+          threadTs: PARENT_TS,
+          displayName: "@alice",
+        }),
+      ),
+    ];
+    const result = assembleSlackActiveThreadFocusBlock(rows, SLACK_CAPS);
+    expect(result).not.toBeNull();
+    expect(result!).toContain("more reactions");
+    // The trailer line must not be double-attributed.
+    expect(result!).not.toMatch(/@assistant: \[…and \d+ more reaction/);
+  });
+
   test("emits a block even when the parent has not been backfilled yet", () => {
     // The inbound reply detects an `activeThreadTs` from its own
     // `threadTs`, but the parent (`channelTs === activeThreadTs`) has not
@@ -3826,7 +3871,7 @@ describe("assembleSlackChronologicalMessages", () => {
       },
       {
         role: "assistant",
-        content: [{ type: "text", text: "[11/14/23 14:26]: hi back!" }],
+        content: [{ type: "text", text: "hi back!" }],
       },
       {
         role: "user",
@@ -3877,9 +3922,9 @@ describe("assembleSlackChronologicalMessages", () => {
     expect(result!.map((m) => (m.content[0] as { text: string }).text)).toEqual(
       [
         "[11/14/23 14:25]: old hi",
-        "[11/14/23 14:26]: old reply",
+        "old reply",
         "[11/14/23 14:28 @alice]: fresh hi",
-        "[11/14/23 14:30]: fresh reply",
+        "fresh reply",
       ],
     );
     expect(result!.map((m) => m.role)).toEqual([
@@ -4035,7 +4080,7 @@ describe("assembleSlackChronologicalMessages", () => {
     expect(rendered[1]!).toEqual({
       role: "assistant",
       content: [
-        { type: "text", text: "[11/14/23 14:26]: looking it up" },
+        { type: "text", text: "looking it up" },
         {
           type: "tool_use",
           id: "tu_1",
@@ -4357,11 +4402,11 @@ describe("assembleSlackChronologicalMessages", () => {
       role: "user",
       content: [{ type: "text", text: "[11/14/23 23:03 @alice]: hi" }],
     });
-    // Row 2: assistant tag line + tool_use(abc).
+    // Row 2: assistant content + tool_use(abc) — no tag line.
     expect(result![1]).toEqual({
       role: "assistant",
       content: [
-        { type: "text", text: "[11/14/23 23:03]: checking..." },
+        { type: "text", text: "checking..." },
         {
           type: "tool_use",
           id: "tu_abc",
@@ -4377,11 +4422,11 @@ describe("assembleSlackChronologicalMessages", () => {
         { type: "tool_result", tool_use_id: "tu_abc", content: "result 1" },
       ],
     });
-    // Row 4: assistant tag line + tool_use(def).
+    // Row 4: assistant content + tool_use(def) — no tag line.
     expect(result![3]).toEqual({
       role: "assistant",
       content: [
-        { type: "text", text: "[11/14/23 23:03]: one more lookup..." },
+        { type: "text", text: "one more lookup..." },
         {
           type: "tool_use",
           id: "tu_def",
@@ -4397,10 +4442,10 @@ describe("assembleSlackChronologicalMessages", () => {
         { type: "tool_result", tool_use_id: "tu_def", content: "result 2" },
       ],
     });
-    // Row 6: assistant final text-only answer, rendered as tag line only.
+    // Row 6: assistant final text-only answer, content-only (no tag line).
     expect(result![5]).toEqual({
       role: "assistant",
-      content: [{ type: "text", text: "[11/14/23 23:03]: all done" }],
+      content: [{ type: "text", text: "all done" }],
     });
     // Row 7: user follow-up tag line.
     expect(result![6]).toEqual({

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

@@ -1,9 +1,11 @@
-import { describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
+import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.js";
+import { defaultInjectorsPlugin } from "../plugins/defaults/injectors.js";
 import {
-  applyRuntimeInjections,
-  injectWorkspaceTopLevelContext,
-} from "../daemon/conversation-runtime-assembly.js";
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
 import type { Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -21,43 +23,21 @@ function userMsg(text: string): Message {
 const sampleContext =
   "<workspace>\nRoot: /sandbox\nDirectories: src, lib, tests\n</workspace>";
 
-describe("Workspace top-level context — injection", () => {
-  test("prepends workspace block to user message content", () => {
-    const original = userMsg("Hello");
-    const injected = injectWorkspaceTopLevelContext(original, sampleContext);
+// The standalone `injectWorkspaceTopLevelContext` helper was removed in
+// G2.1. The workspace-context default injector (registered by
+// `defaultInjectorsPlugin`) now emits the workspace block as a
+// `prepend-user-tail` placement during `applyRuntimeInjections`. The suite
+// below exercises that end-to-end path instead.
 
-    expect(injected.content).toHaveLength(2);
-    expect(injected.content[0]).toEqual({ type: "text", text: sampleContext });
-    expect(injected.content[1]).toEqual({ type: "text", text: "Hello" });
-  });
-
-  test("preserves multi-block user content after prepend", () => {
-    const original: Message = {
-      role: "user",
-      content: [
-        { type: "text", text: "First" },
-        { type: "text", text: "Second" },
-      ],
-    };
-    const injected = injectWorkspaceTopLevelContext(original, sampleContext);
-
-    expect(injected.content).toHaveLength(3);
-    expect(injected.content[0].type).toBe("text");
-    expect((injected.content[0] as { text: string }).text).toBe(sampleContext);
-    expect((injected.content[1] as { text: string }).text).toBe("First");
-    expect((injected.content[2] as { text: string }).text).toBe("Second");
-  });
-
-  test("does not mutate original message", () => {
-    const original = userMsg("Hello");
-    const originalContentLength = original.content.length;
-    injectWorkspaceTopLevelContext(original, sampleContext);
-
-    expect(original.content).toHaveLength(originalContentLength);
+describe("applyRuntimeInjections — workspace top-level context", () => {
+  beforeEach(() => {
+    // Post-G2.1: workspace injection is driven by the `workspace-context`
+    // default injector, so the plugin must be registered for the chain to
+    // produce a block. Each test gets a clean registry.
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
   });
-});
 
-describe("applyRuntimeInjections — workspace top-level context", () => {
   test("injects workspace context when provided", async () => {
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {
@@ -100,6 +80,11 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
 });
 
 describe("applyRuntimeInjections — minimal mode skips workspace blocks", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
+  });
+
   test("minimal mode skips workspace top-level context", async () => {
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {

package/src/__tests__/conversation-seed-composer.test.ts

@@ -411,14 +411,14 @@ describe("composeConversationSeed", () => {
     });
 
     test('falls back to event name when title is "Notification" and body is empty', () => {
-      const signal = makeSignal({ sourceEventName: "schedule.complete" });
+      const signal = makeSignal({ sourceEventName: "watcher.notification" });
       const copy = makeCopy({ title: "Notification", body: "" });
       const seed = composeConversationSeed(
         signal,
         "vellum" as NotificationChannel,
         copy,
       );
-      expect(seed).toBe("Schedule complete");
+      expect(seed).toBe("Watcher notification");
     });
 
     test('uses context payload "message" field in fallback when available', () => {

package/src/__tests__/conversation-slash-queue.test.ts

@@ -30,7 +30,7 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
+
     llm: {
       default: {
         provider: "mock-provider",
@@ -207,6 +207,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
     getActiveModel() {
       return undefined;
     }
@@ -215,7 +218,9 @@ mock.module("../agent/loop.js", () => ({
       onEvent: (event: AgentEvent) => void,
       _signal?: AbortSignal,
       _requestId?: string,
-      _onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+      _onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return new Promise<Message[]>((resolve) => {
         pendingRuns.push({ resolve, messages, onEvent });