@vellumai/assistant 0.6.5 → 0.7.0

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
@@ -16,7 +16,6 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
   },
 }));
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ChannelCapabilities,
   SlackTranscriptInputRow,
@@ -31,8 +30,6 @@ import {
   findLastInjectedNowContent,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
-  injectNowScratchpad,
-  injectSubagentStatus,
   isGroupChatType,
   isSlackChannelConversation,
   loadSlackActiveThreadFocusBlock,
@@ -49,9 +46,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 +809,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
@@ -1186,90 +1124,48 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).not.toContain("trust_class:");
   });
 
-  test("non-guardian trusted_contact: all actor fields + behavioral guidance", () => {
-    _setOverridesForTesting({ "permission-controls-v2": false });
-    try {
-      const options: UnifiedTurnContextOptions = {
-        timestamp: "2026-04-02T12:00:00Z",
-        interfaceName: "telegram",
-        channelName: "telegram",
-        actorContext: {
-          sourceChannel: "telegram",
-          canonicalActorIdentity: "trusted-user-1",
-          actorIdentifier: "@jeff_handle",
-          actorDisplayName: "Jeff",
-          actorSenderDisplayName: "Jeffrey",
-          actorMemberDisplayName: "Jeff",
-          trustClass: "trusted_contact",
-          guardianIdentity: "guardian-user-1",
-          memberStatus: "active",
-          memberPolicy: "allow",
-        },
-      };
-
-      const text = buildUnifiedTurnContextBlock(options);
-      expect(text).toContain("<turn_context>");
-      expect(text).toContain("current_time: 2026-04-02T12:00:00Z");
-      expect(text).toContain("interface: telegram");
-      expect(text).toContain("source_channel: telegram");
-      expect(text).toContain("canonical_actor_identity: trusted-user-1");
-      expect(text).toContain("actor_identifier: @jeff_handle");
-      expect(text).toContain("actor_display_name: Jeff");
-      expect(text).toContain("actor_sender_display_name: Jeffrey");
-      expect(text).toContain("actor_member_display_name: Jeff");
-      expect(text).toContain("trust_class: trusted_contact");
-      expect(text).toContain("guardian_identity: guardian-user-1");
-      expect(text).toContain("member_status: active");
-      expect(text).toContain("member_policy: allow");
-      // Behavioral guidance
-      expect(text).toContain("trusted contact (non-guardian)");
-      expect(text).toContain("attempt to fulfill it normally");
-      expect(text).toContain(
-        "tool execution layer will automatically deny it and escalate",
-      );
-      expect(text).toContain('their name is "Jeff"');
-      expect(text).toContain("</turn_context>");
-    } finally {
-      _setOverridesForTesting({});
-    }
-  });
-
-  test("non-guardian trusted_contact under v2: guidance shifts to conversational guardian confirmation", () => {
-    _setOverridesForTesting({ "permission-controls-v2": true });
-
-    try {
-      const options: UnifiedTurnContextOptions = {
-        timestamp: "2026-04-02T12:00:00Z",
-        interfaceName: "telegram",
-        channelName: "telegram",
-        actorContext: {
-          sourceChannel: "telegram",
-          canonicalActorIdentity: "trusted-user-1",
-          actorIdentifier: "@jeff_handle",
-          actorDisplayName: "Jeff",
-          actorSenderDisplayName: "Jeffrey",
-          actorMemberDisplayName: "Jeff",
-          trustClass: "trusted_contact",
-          guardianIdentity: "guardian-user-1",
-          memberStatus: "active",
-          memberPolicy: "allow",
-        },
-      };
+  test("non-guardian trusted_contact: all actor fields + conversational guidance", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "telegram",
+      channelName: "telegram",
+      actorContext: {
+        sourceChannel: "telegram",
+        canonicalActorIdentity: "trusted-user-1",
+        actorIdentifier: "@jeff_handle",
+        actorDisplayName: "Jeff",
+        actorSenderDisplayName: "Jeffrey",
+        actorMemberDisplayName: "Jeff",
+        trustClass: "trusted_contact",
+        guardianIdentity: "guardian-user-1",
+        memberStatus: "active",
+        memberPolicy: "allow",
+      },
+    };
 
-      const text = buildUnifiedTurnContextBlock(options);
-      expect(text).toContain("trusted contact (non-guardian)");
-      expect(text).toContain(
-        "confirming the guardian's intent conversationally",
-      );
-      expect(text).toContain(
-        "ask the guardian to enable computer access for this conversation",
-      );
-      expect(text).not.toContain(
-        "tool execution layer will automatically deny it and escalate",
-      );
-    } finally {
-      _setOverridesForTesting({});
-    }
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).toContain("<turn_context>");
+    expect(text).toContain("current_time: 2026-04-02T12:00:00Z");
+    expect(text).toContain("interface: telegram");
+    expect(text).toContain("source_channel: telegram");
+    expect(text).toContain("canonical_actor_identity: trusted-user-1");
+    expect(text).toContain("actor_identifier: @jeff_handle");
+    expect(text).toContain("actor_display_name: Jeff");
+    expect(text).toContain("actor_sender_display_name: Jeffrey");
+    expect(text).toContain("actor_member_display_name: Jeff");
+    expect(text).toContain("trust_class: trusted_contact");
+    expect(text).toContain("guardian_identity: guardian-user-1");
+    expect(text).toContain("member_status: active");
+    expect(text).toContain("member_policy: allow");
+    // Behavioral guidance: conversational confirmation (one-time decision pattern)
+    expect(text).toContain("trusted contact (non-guardian)");
+    expect(text).toContain(
+      "confirming the guardian's intent conversationally",
+    );
+    expect(text).not.toContain(
+      "tool execution layer will automatically deny it and escalate",
+    );
+    expect(text).toContain("</turn_context>");
   });
 
   test("non-guardian unknown: all actor fields + unknown guidance", () => {
@@ -1837,22 +1733,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 +2585,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 +3549,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 +3828,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 +3879,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 +4037,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 +4359,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 +4379,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 +4399,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', () => {