@vellumai/assistant 0.4.56 → 0.5.0

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

@@ -69,11 +69,10 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 1 },
     skills: { entries: {}, allowBundled: true },
     permissions: { mode: "workspace" },
-    sandbox: { enabled: false },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,
@@ -90,9 +89,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
   loadRawConfig: () => ({}),
@@ -178,7 +177,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../context/window-manager.js", () => ({
@@ -1735,12 +1734,23 @@ describe("Regression: cancel semantics and error channel split", () => {
   });
 
   test("commitTurnChanges never resolving within budget -> turn still completes and drains queue", async () => {
-    const conversation = makeConversation();
-    await conversation.loadFromDb();
-
-    turnCommitHangForever = true;
+    // Replace setTimeout with a zero-delay version so the 4000ms
+    // raceWithTimeout fires instantly instead of waiting real time.
+    const origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 0, ...args);
+    }) as typeof setTimeout;
 
     try {
+      const conversation = makeConversation();
+      await conversation.loadFromDb();
+
+      turnCommitHangForever = true;
+
       const events1: ServerMessage[] = [];
       const events2: ServerMessage[] = [];
 
@@ -1761,10 +1771,8 @@ describe("Regression: cancel semantics and error channel split", () => {
 
       // The turn should still complete (timeout fires) and drain the queue
       // even though commitTurnChanges never resolves.
-      // The default turnCommitMaxWaitMs is 4000ms in the config mock,
-      // but the mock config doesn't set it, so it defaults to 4000ms.
-      // We wait for the second run to be registered, which proves the
-      // turn completed and the queue drained despite the hanging commit.
+      // With the zero-delay setTimeout wrapper the 4000ms budget fires
+      // instantly, so we only need a short wait for the second run.
       await waitForPendingRun(2, 10_000);
 
       // First message should have completed
@@ -1781,9 +1789,10 @@ describe("Regression: cancel semantics and error channel split", () => {
       // Complete the second run so the test can clean up
       turnCommitHangForever = false;
       resolveRun(1);
-      await new Promise((r) => setTimeout(r, 10));
+      await new Promise((r) => origSetTimeout(r, 10));
     } finally {
       turnCommitHangForever = false;
+      globalThis.setTimeout = origSetTimeout;
     }
   }, 15_000);
 });

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -29,7 +29,7 @@ mock.module("../config/loader.js", () => ({
     model: "claude-opus-4-6",
     provider: "anthropic",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     contextWindow: { maxInputTokens: 200000 },
     services: {
@@ -41,9 +41,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
 }));

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

@@ -7,20 +7,19 @@ import type {
 } from "../daemon/conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
-  buildChannelTurnContextBlock,
+  buildTurnContextBlock,
   injectChannelCapabilityContext,
-  injectChannelTurnContext,
+  injectChannelCommandContext,
   injectInboundActorContext,
   injectTemporalContext,
+  injectTurnContext,
   isGroupChatType,
   resolveChannelCapabilities,
-  sanitizePttActivationKey,
   stripChannelCapabilityContext,
   stripChannelTurnContext,
   stripInboundActorContext,
   stripTemporalContext,
 } from "../daemon/conversation-runtime-assembly.js";
-import { buildChannelAwarenessSection } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -135,7 +134,7 @@ describe("resolveChannelCapabilities", () => {
   });
 
   test("propagates chatType when provided", () => {
-    const caps = resolveChannelCapabilities("telegram", null, null, "group");
+    const caps = resolveChannelCapabilities("telegram", null, "group");
     expect(caps.chatType).toBe("group");
   });
 
@@ -155,7 +154,7 @@ describe("injectChannelCapabilityContext", () => {
     content: [{ type: "text", text: "Hello" }],
   };
 
-  test("injects channel capabilities block for dashboard channel", () => {
+  test("skips injection entirely for desktop happy path (all capabilities true)", () => {
     const caps: ChannelCapabilities = {
       channel: "vellum",
       dashboardCapable: true,
@@ -165,26 +164,9 @@ describe("injectChannelCapabilityContext", () => {
 
     const result = injectChannelCapabilityContext(baseUserMessage, caps);
 
-    // Should prepend a text block with channel_capabilities
-    expect(result.content.length).toBe(2);
-    const injected = result.content[0];
-    expect(injected.type).toBe("text");
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "<channel_capabilities>",
-    );
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "dashboard_capable: true",
-    );
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "supports_dynamic_ui: true",
-    );
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "</channel_capabilities>",
-    );
-    // Should NOT contain constraint rules for dashboard
-    expect((injected as { type: "text"; text: string }).text).not.toContain(
-      "CHANNEL CONSTRAINTS",
-    );
+    // Message returned unchanged — no injection at all
+    expect(result).toBe(baseUserMessage);
+    expect(result.content.length).toBe(1);
   });
 
   test("injects constraint rules for non-dashboard channel", () => {
@@ -293,6 +275,50 @@ describe("injectChannelCapabilityContext", () => {
     expect(text).toContain("GROUP CHAT ETIQUETTE");
     expect(text).toContain("emoji reactions");
   });
+
+  test("still injects for group chats even when all capabilities are true", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+      chatType: "channel",
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    // Not the happy path because chatType is a group type
+    expect(result).not.toBe(baseUserMessage);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("GROUP CHAT ETIQUETTE");
+  });
+
+  test("injects WhatsApp formatting constraint for whatsapp channel", () => {
+    const caps: ChannelCapabilities = {
+      channel: "whatsapp",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("Do NOT use markdown tables");
+    expect(text).toContain("bullet lists");
+    expect(text).toContain("CAPS for emphasis");
+  });
+
+  test("does NOT inject WhatsApp formatting for non-whatsapp channels", () => {
+    const caps: ChannelCapabilities = {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).not.toContain("Do NOT use markdown tables");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -449,60 +475,12 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// buildChannelAwarenessSection
-// ---------------------------------------------------------------------------
-
-describe("buildChannelAwarenessSection", () => {
-  test("includes channel awareness heading", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("## Channel Awareness & Trust Gating");
-  });
-
-  test("includes channel-specific rules", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("dashboard_capable");
-    expect(section).toContain("supports_dynamic_ui");
-    expect(section).toContain("supports_voice_input");
-  });
-
-  test("includes trust gating rules for permission asks", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("firstConversationComplete");
-    expect(section).toContain("Permission ask trust gating");
-    expect(section).toContain(
-      "Do NOT proactively ask for elevated permissions",
-    );
-  });
-
-  test("gates microphone permissions on voice capability", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("Do not ask for microphone permissions");
-  });
-
-  test("gates computer-control on dashboard channel", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("computer-control permissions on non-dashboard");
-  });
-
-  test("does NOT include group chat etiquette (gated per-turn instead)", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).not.toContain("Group chat etiquette");
-    expect(section).not.toContain("Stay silent when");
-  });
-
-  test("does NOT include Discord references (not a supported channel)", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).not.toContain("Discord");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Trust-gating behavior: channel constraints for permission asks
 // ---------------------------------------------------------------------------
 
 describe("trust-gating via channel capabilities", () => {
-  test("vellum channel with macos interface does not add constraint rules", () => {
+  test("vellum channel with macos interface skips injection (happy path)", () => {
     const caps = resolveChannelCapabilities("vellum", "macos");
     const message: Message = {
       role: "user",
@@ -510,10 +488,9 @@ describe("trust-gating via channel capabilities", () => {
     };
 
     const result = injectChannelCapabilityContext(message, caps);
-    const injected = (result.content[0] as { type: "text"; text: string }).text;
 
-    expect(injected).not.toContain("CHANNEL CONSTRAINTS");
-    expect(injected).toContain("dashboard_capable: true");
+    // Happy path: message returned unchanged
+    expect(result).toBe(message);
   });
 
   test("non-dashboard channel adds constraint rules preventing UI references", () => {
@@ -554,6 +531,50 @@ describe("trust-gating via channel capabilities", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// injectChannelCommandContext
+// ---------------------------------------------------------------------------
+
+describe("injectChannelCommandContext", () => {
+  const baseUserMessage: Message = {
+    role: "user",
+    content: [{ type: "text", text: "Hello" }],
+  };
+
+  test("injects start command instructions when type is start", () => {
+    const result = injectChannelCommandContext(baseUserMessage, {
+      type: "start",
+    });
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("command_type: start");
+    expect(text).toContain("warm, brief greeting");
+    expect(text).toContain("Treat /start as a hello");
+    expect(text).toContain("Do NOT reset conversation");
+  });
+
+  test("includes language code and payload when provided", () => {
+    const result = injectChannelCommandContext(baseUserMessage, {
+      type: "start",
+      payload: "ref123",
+      languageCode: "es",
+    });
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("payload: ref123");
+    expect(text).toContain("language_code: es");
+    expect(text).toContain("warm, brief greeting");
+  });
+
+  test("does NOT inject start instructions for non-start commands", () => {
+    const result = injectChannelCommandContext(baseUserMessage, {
+      type: "help",
+    });
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("command_type: help");
+    expect(text).not.toContain("warm, brief greeting");
+    expect(text).not.toContain("Treat /start as a hello");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // injectTemporalContext
 // ---------------------------------------------------------------------------
@@ -768,9 +789,13 @@ describe("injectInboundActorContext", () => {
     expect(text).toContain("trust_class: guardian");
     expect(text).toContain("source_channel: phone");
     expect(text).toContain("canonical_actor_identity: guardian-user-1");
+    // Display names differ from canonical, so they should appear
+    expect(text).toContain("actor_identifier: +15550001111");
     expect(text).toContain("actor_display_name: Guardian Name");
     expect(text).toContain("actor_sender_display_name: Guardian Name");
     expect(text).toContain("actor_member_display_name: Guardian Name");
+    // guardian_identity matches canonical, so it should be omitted
+    expect(text).not.toContain("guardian_identity:");
     expect(text).toContain("</inbound_actor_context>");
   });
 
@@ -798,6 +823,30 @@ describe("injectInboundActorContext", () => {
     );
   });
 
+  test("omits name_preference_note when member name matches canonical and is suppressed", () => {
+    const ctx: InboundActorContext = {
+      sourceChannel: "telegram",
+      canonicalActorIdentity: "Jeff",
+      actorIdentifier: "@jeff_handle",
+      actorDisplayName: "Jeff",
+      actorSenderDisplayName: "Jeffrey",
+      actorMemberDisplayName: "Jeff",
+      trustClass: "trusted_contact",
+      guardianIdentity: "guardian-user-1",
+      memberStatus: "active",
+      memberPolicy: "allow",
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    // actor_member_display_name matches canonical → omitted by differs() guard
+    expect(text).not.toContain("actor_member_display_name:");
+    // actor_sender_display_name differs from canonical → emitted
+    expect(text).toContain("actor_sender_display_name: Jeffrey");
+    // name_preference_note must NOT appear since actor_member_display_name was omitted
+    expect(text).not.toContain("name_preference_note:");
+  });
+
   test("sanitizes inline actor context values to prevent line injection", () => {
     const ctx: InboundActorContext = {
       sourceChannel: "telegram",
@@ -903,6 +952,38 @@ describe("injectInboundActorContext", () => {
     expect(text).not.toContain("non-guardian account");
   });
 
+  test("omits redundant fields when they match canonical_actor_identity", () => {
+    const uuid = "vellum-principal-b77e94f5-67c0-4599-8baa-871b925b3da8";
+    const ctx: InboundActorContext = {
+      sourceChannel: "vellum",
+      canonicalActorIdentity: uuid,
+      actorIdentifier: uuid,
+      actorDisplayName: uuid,
+      actorSenderDisplayName: undefined,
+      actorMemberDisplayName: uuid,
+      trustClass: "guardian",
+      guardianIdentity: uuid,
+      memberStatus: "active",
+      memberPolicy: "allow",
+      contactNotes: "guardian",
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    // Only essential fields should remain
+    expect(text).toContain("source_channel: vellum");
+    expect(text).toContain(`canonical_actor_identity: ${uuid}`);
+    expect(text).toContain("trust_class: guardian");
+    // Redundant fields should be omitted
+    expect(text).not.toContain("actor_identifier:");
+    expect(text).not.toContain("actor_display_name:");
+    expect(text).not.toContain("actor_sender_display_name:");
+    expect(text).not.toContain("actor_member_display_name:");
+    expect(text).not.toContain("guardian_identity:");
+    // contact_notes: "guardian" matches trust_class, should be omitted
+    expect(text).not.toContain("contact_notes:");
+  });
+
   test("omits member_status and member_policy when not provided", () => {
     const ctx: InboundActorContext = {
       sourceChannel: "phone",
@@ -969,46 +1050,51 @@ describe("applyRuntimeInjections with inboundActorContext", () => {
 });
 
 // ---------------------------------------------------------------------------
-// buildChannelTurnContextBlock
+// buildTurnContextBlock (channel-only)
 // ---------------------------------------------------------------------------
 
-describe("buildChannelTurnContextBlock", () => {
-  test("formats block with all three channel fields", () => {
-    const block = buildChannelTurnContextBlock({
-      turnContext: {
-        userMessageChannel: "telegram",
-        assistantMessageChannel: "telegram",
+describe("buildTurnContextBlock (channel-only)", () => {
+  test("collapses to single field when all channels match", () => {
+    const block = buildTurnContextBlock(
+      {
+        turnContext: {
+          userMessageChannel: "telegram",
+          assistantMessageChannel: "telegram",
+        },
+        conversationOriginChannel: "telegram",
       },
-      conversationOriginChannel: "telegram",
-    });
+      undefined,
+    );
     expect(block).toBe(
-      "<channel_turn_context>\n" +
-        "user_message_channel: telegram\n" +
-        "assistant_message_channel: telegram\n" +
-        "conversation_origin_channel: telegram\n" +
-        "</channel_turn_context>",
+      "<turn_context>\n" + "channel: telegram\n" + "</turn_context>",
     );
   });
 
   test('uses "unknown" when conversationOriginChannel is null', () => {
-    const block = buildChannelTurnContextBlock({
-      turnContext: {
-        userMessageChannel: "vellum",
-        assistantMessageChannel: "vellum",
+    const block = buildTurnContextBlock(
+      {
+        turnContext: {
+          userMessageChannel: "vellum",
+          assistantMessageChannel: "vellum",
+        },
+        conversationOriginChannel: null,
       },
-      conversationOriginChannel: null,
-    });
+      undefined,
+    );
     expect(block).toContain("conversation_origin_channel: unknown");
   });
 
   test("handles mixed channels", () => {
-    const block = buildChannelTurnContextBlock({
-      turnContext: {
-        userMessageChannel: "telegram",
-        assistantMessageChannel: "vellum",
+    const block = buildTurnContextBlock(
+      {
+        turnContext: {
+          userMessageChannel: "telegram",
+          assistantMessageChannel: "vellum",
+        },
+        conversationOriginChannel: "vellum",
       },
-      conversationOriginChannel: "vellum",
-    });
+      undefined,
+    );
     expect(block).toContain("user_message_channel: telegram");
     expect(block).toContain("assistant_message_channel: vellum");
     expect(block).toContain("conversation_origin_channel: vellum");
@@ -1016,10 +1102,10 @@ describe("buildChannelTurnContextBlock", () => {
 });
 
 // ---------------------------------------------------------------------------
-// injectChannelTurnContext
+// injectTurnContext (channel-only)
 // ---------------------------------------------------------------------------
 
-describe("injectChannelTurnContext", () => {
+describe("injectTurnContext (channel-only)", () => {
   const baseUserMessage: Message = {
     role: "user",
     content: [{ type: "text", text: "Hello from telegram" }],
@@ -1033,14 +1119,14 @@ describe("injectChannelTurnContext", () => {
       },
       conversationOriginChannel: "telegram",
     };
-    const result = injectChannelTurnContext(baseUserMessage, params);
+    const result = injectTurnContext(baseUserMessage, params, undefined);
     expect(result.content.length).toBe(2);
     const injected = result.content[0];
     expect(injected.type).toBe("text");
     const text = (injected as { type: "text"; text: string }).text;
-    expect(text).toContain("<channel_turn_context>");
-    expect(text).toContain("user_message_channel: telegram");
-    expect(text).toContain("</channel_turn_context>");
+    expect(text).toContain("<turn_context>");
+    expect(text).toContain("channel: telegram");
+    expect(text).toContain("</turn_context>");
   });
 
   test("preserves original message content", () => {
@@ -1051,7 +1137,7 @@ describe("injectChannelTurnContext", () => {
       },
       conversationOriginChannel: "vellum",
     };
-    const result = injectChannelTurnContext(baseUserMessage, params);
+    const result = injectTurnContext(baseUserMessage, params, undefined);
     const lastBlock = result.content[result.content.length - 1];
     expect((lastBlock as { type: "text"; text: string }).text).toBe(
       "Hello from telegram",
@@ -1071,7 +1157,7 @@ describe("stripChannelTurnContext", () => {
         content: [
           {
             type: "text",
-            text: "<channel_turn_context>\nuser_message_channel: telegram\n</channel_turn_context>",
+            text: "<turn_context>\nuser_message_channel: telegram\n</turn_context>",
           },
           { type: "text", text: "Hello" },
         ],
@@ -1099,7 +1185,7 @@ describe("stripChannelTurnContext", () => {
         content: [
           {
             type: "text",
-            text: "<channel_turn_context>\nuser_message_channel: macos\n</channel_turn_context>",
+            text: "<turn_context>\nuser_message_channel: macos\n</turn_context>",
           },
         ],
       },
@@ -1152,7 +1238,7 @@ describe("applyRuntimeInjections with channelTurnContext", () => {
     expect(result[0].content.length).toBe(2);
     const injected = result[0].content[0];
     expect((injected as { type: "text"; text: string }).text).toContain(
-      "<channel_turn_context>",
+      "<turn_context>",
     );
   });
 
@@ -1173,73 +1259,6 @@ describe("applyRuntimeInjections with channelTurnContext", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// sanitizePttActivationKey
-// ---------------------------------------------------------------------------
-
-describe("sanitizePttActivationKey", () => {
-  test("returns undefined for null/undefined input", () => {
-    expect(sanitizePttActivationKey(null)).toBeUndefined();
-    expect(sanitizePttActivationKey(undefined)).toBeUndefined();
-  });
-
-  test("passes through valid JSON PTTActivator payloads", () => {
-    const modifierOnly = JSON.stringify({
-      kind: "modifierOnly",
-      modifierFlags: 8388608,
-    });
-    expect(sanitizePttActivationKey(modifierOnly)).toBe(modifierOnly);
-    const keyPayload = JSON.stringify({ kind: "key", keyCode: 49 });
-    expect(sanitizePttActivationKey(keyPayload)).toBe(keyPayload);
-    const nonePayload = JSON.stringify({ kind: "none" });
-    expect(sanitizePttActivationKey(nonePayload)).toBe(nonePayload);
-  });
-
-  test("returns undefined for invalid keys", () => {
-    expect(
-      sanitizePttActivationKey("malicious\nprompt injection"),
-    ).toBeUndefined();
-    expect(sanitizePttActivationKey("arbitrary_value")).toBeUndefined();
-    expect(sanitizePttActivationKey("")).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveChannelCapabilities sanitizes pttActivationKey
-// ---------------------------------------------------------------------------
-
-describe("resolveChannelCapabilities with PTT metadata", () => {
-  test("sanitizes valid JSON PTTActivator pttActivationKey", () => {
-    const key = JSON.stringify({
-      kind: "modifierOnly",
-      modifierFlags: 8388608,
-    });
-    const caps = resolveChannelCapabilities("macos", "macos", {
-      pttActivationKey: key,
-    });
-    expect(caps.pttActivationKey).toBe(key);
-  });
-
-  test("sanitizes invalid pttActivationKey to undefined", () => {
-    const caps = resolveChannelCapabilities("macos", "macos", {
-      pttActivationKey: "evil\nprompt",
-    });
-    expect(caps.pttActivationKey).toBeUndefined();
-  });
-
-  test("passes through microphonePermissionGranted", () => {
-    const key = JSON.stringify({
-      kind: "modifierOnly",
-      modifierFlags: 8388608,
-    });
-    const caps = resolveChannelCapabilities("macos", "macos", {
-      pttActivationKey: key,
-      microphonePermissionGranted: true,
-    });
-    expect(caps.microphonePermissionGranted).toBe(true);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // applyRuntimeInjections — injection mode
 // ---------------------------------------------------------------------------
@@ -1299,8 +1318,8 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<channel_command_context>");
     expect(allText).toContain("<active_workspace>");
     expect(allText).toContain("<channel_capabilities>");
-    expect(allText).toContain("<channel_turn_context>");
-    expect(allText).toContain("<interface_turn_context>");
+    expect(allText).toContain("<turn_context>");
+    expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<inbound_actor_context>");
     expect(allText).toContain("<non_interactive_context>");
   });
@@ -1349,8 +1368,8 @@ describe("applyRuntimeInjections — injection mode", () => {
       .join("\n");
 
     // Kept in minimal mode
-    expect(allText).toContain("<channel_turn_context>");
-    expect(allText).toContain("<interface_turn_context>");
+    expect(allText).toContain("<turn_context>");
+    expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<inbound_actor_context>");
     expect(allText).toContain("<non_interactive_context>");
     expect(allText).toContain("<channel_capabilities>");