@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/app-conversation-ids.test.ts

@@ -7,8 +7,16 @@ import {
   addAppConversationId,
   createApp,
   getApp,
+  isDirectAppConversation,
+  linkAppToConversationLineage,
   listAppsByConversation,
 } from "../apps/app-store.js";
+import {
+  deleteConversation,
+  removeSubagentConversation,
+  setConversation,
+  setSubagentConversation,
+} from "../daemon/conversation-registry.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -16,6 +24,41 @@ import {
 
 let testDataDir: string;
 
+/**
+ * The registry stores live `Conversation` instances; lineage resolution only
+ * reads `parentConversationId`, so a minimal stand-in is enough.
+ */
+type RegistryConversation = Parameters<typeof setConversation>[1];
+
+const registeredTopLevel: string[] = [];
+const registeredSubagents: [string, RegistryConversation][] = [];
+
+function stubConversation(parentConversationId?: string): RegistryConversation {
+  return { parentConversationId } as unknown as RegistryConversation;
+}
+
+/** Register a resident top-level conversation, optionally forked from a parent. */
+function registerConversation(id: string, parentId?: string): void {
+  setConversation(id, stubConversation(parentId));
+  registeredTopLevel.push(id);
+}
+
+/** Register a live subagent conversation forked from `parentId`. */
+function registerSubagent(id: string, parentId: string): void {
+  const conversation = stubConversation(parentId);
+  setSubagentConversation(id, conversation);
+  registeredSubagents.push([id, conversation]);
+}
+
+function clearRegisteredConversations(): void {
+  for (const id of registeredTopLevel.splice(0)) {
+    deleteConversation(id);
+  }
+  for (const [id, conversation] of registeredSubagents.splice(0)) {
+    removeSubagentConversation(id, conversation);
+  }
+}
+
 function freshTempDir(): string {
   return join(
     tmpdir(),
@@ -41,6 +84,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  clearRegisteredConversations();
   if (existsSync(testDataDir)) {
     rmSync(testDataDir, { recursive: true, force: true });
   }
@@ -149,3 +193,163 @@ describe("listAppsByConversation", () => {
     expect(result).toEqual([]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// linkAppToConversationLineage
+// ---------------------------------------------------------------------------
+
+describe("linkAppToConversationLineage", () => {
+  test("an app created in a forked conversation carries the fork and its parent", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    expect(getApp(app.id)?.conversationIds).toEqual([
+      "conv-fork",
+      "conv-visible",
+    ]);
+  });
+
+  test("the user-visible ancestor lists an app created by a background subagent", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    const visible = listAppsByConversation("conv-visible");
+    expect(visible).toHaveLength(1);
+    expect(visible[0].id).toBe(app.id);
+  });
+
+  test("walks nested subagents up to the user-visible thread", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-outer", "conv-visible");
+    registerSubagent("conv-inner", "conv-outer");
+
+    const app = createApp(makeAppParams("Nested App"));
+    linkAppToConversationLineage(app.id, "conv-inner");
+
+    expect(getApp(app.id)?.conversationIds).toEqual([
+      "conv-inner",
+      "conv-outer",
+      "conv-visible",
+    ]);
+  });
+
+  test("re-linking the same lineage is idempotent", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Repeat App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    expect(getApp(app.id)?.conversationIds).toEqual([
+      "conv-fork",
+      "conv-visible",
+    ]);
+  });
+
+  test("a lineage of one behaves exactly like addAppConversationId", () => {
+    registerConversation("conv-plain");
+
+    const linked = createApp(makeAppParams("Linked App"));
+    const direct = createApp(makeAppParams("Direct App"));
+    linkAppToConversationLineage(linked.id, "conv-plain");
+    addAppConversationId(direct.id, "conv-plain");
+
+    expect(getApp(linked.id)?.conversationIds).toEqual(["conv-plain"]);
+    expect(getApp(direct.id)?.conversationIds).toEqual(
+      getApp(linked.id)?.conversationIds,
+    );
+    expect(listAppsByConversation("conv-plain")).toHaveLength(2);
+  });
+
+  test("an unregistered conversation links only itself", () => {
+    const app = createApp(makeAppParams("Orphan App"));
+    linkAppToConversationLineage(app.id, "conv-gone");
+
+    expect(getApp(app.id)?.conversationIds).toEqual(["conv-gone"]);
+  });
+
+  test("a non-existent app is a no-op", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    expect(() =>
+      linkAppToConversationLineage("nonexistent-id", "conv-fork"),
+    ).not.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Direct vs inherited associations
+// ---------------------------------------------------------------------------
+
+describe("isDirectAppConversation", () => {
+  test("the seed conversation is direct and its ancestors are inherited", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.inheritedConversationIds).toEqual(["conv-visible"]);
+    expect(isDirectAppConversation(loaded, "conv-fork")).toBe(true);
+    expect(isDirectAppConversation(loaded, "conv-visible")).toBe(false);
+  });
+
+  test("an inherited association still lists the app in the ancestor thread", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    expect(listAppsByConversation("conv-visible").map((a) => a.id)).toEqual([
+      app.id,
+    ]);
+  });
+
+  test("a record carrying no inherited list treats every association as direct", () => {
+    const app = createApp(makeAppParams("Plain App"));
+    addAppConversationId(app.id, "conv-plain");
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.inheritedConversationIds).toBeUndefined();
+    expect(isDirectAppConversation(loaded, "conv-plain")).toBe(true);
+  });
+
+  test("a direct association supersedes an earlier inherited one", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Adopted App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+    // The user later works on the same app in the thread they can see.
+    expect(addAppConversationId(app.id, "conv-visible")).toBe(false);
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.conversationIds).toEqual(["conv-fork", "conv-visible"]);
+    expect(loaded.inheritedConversationIds).toEqual([]);
+    expect(isDirectAppConversation(loaded, "conv-visible")).toBe(true);
+  });
+
+  test("an inherited link never demotes an existing direct association", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Foreground App"));
+    addAppConversationId(app.id, "conv-visible");
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.conversationIds).toEqual(["conv-visible", "conv-fork"]);
+    expect(loaded.inheritedConversationIds).toBeUndefined();
+    expect(isDirectAppConversation(loaded, "conv-visible")).toBe(true);
+  });
+});

package/src/__tests__/approval-cascade.test.ts

@@ -11,7 +11,7 @@ import { Minimatch } from "minimatch";
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentEvent } from "../agent/loop.js";
 import type { ConfirmationStateChangedEvent } from "../api/events/confirmation-state-changed.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import type { ConfirmationDetails } from "../runtime/pending-interactions.js";
 
@@ -188,7 +188,7 @@ function makeProvider() {
 }
 
 function makeConversation(
-  sendToClient?: (msg: ServerMessage) => void,
+  sendToClient?: (msg: AssistantEvent) => void,
   conversationId = CONV_ID,
 ): Conversation {
   return new Conversation(
@@ -257,7 +257,7 @@ beforeEach(() => {
 
 describe("approval cascading", () => {
   test("allow (one-time) does NOT cascade", () => {
-    const emitted: ServerMessage[] = [];
+    const emitted: AssistantEvent[] = [];
     const conversationObj = makeConversation(
       (msg) => emitted.push(msg),
       CONV_ID,
@@ -291,7 +291,7 @@ describe("approval cascading", () => {
   });
 
   test("deny (one-time) does NOT cascade", () => {
-    const emitted: ServerMessage[] = [];
+    const emitted: AssistantEvent[] = [];
     const conversationObj = makeConversation(
       (msg) => emitted.push(msg),
       CONV_ID,
@@ -325,7 +325,7 @@ describe("approval cascading", () => {
   });
 
   test("already-resolved request handled gracefully", () => {
-    const emitted: ServerMessage[] = [];
+    const emitted: AssistantEvent[] = [];
     const conversationObj = makeConversation(
       (msg) => emitted.push(msg),
       CONV_ID,

package/src/__tests__/approval-routes-http.test.ts

@@ -6,8 +6,8 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { SecretPromptResult } from "../permissions/secret-prompt-types.js";
 
 mock.module("../config/env.js", () => ({
@@ -123,7 +123,7 @@ function makeIdleSession(opts?: {
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      options?: { onEvent?: (msg: ServerMessage) => void },
+      options?: { onEvent?: (msg: AssistantEvent) => void },
     ) => {
       const onEvent = options?.onEvent ?? (() => {});
       onEvent({ type: "assistant_text_delta", text: "Hello!" });
@@ -186,7 +186,7 @@ function makeConfirmationEmittingSession(opts?: {
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      options?: { onEvent?: (msg: ServerMessage) => void },
+      options?: { onEvent?: (msg: AssistantEvent) => void },
     ) => {
       const onEvent = options?.onEvent ?? (() => {});
       // Simulate PermissionPrompter.prompt(): self-register in pendingInteractions

package/src/__tests__/ask-question-resolver.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Tests for the ask_question branch of the `pending_question` guardian-request
+ * resolver (`guardian-request-resolvers.ts`): a request without a
+ * `callSessionId` resolves the parked in-memory `question` interaction via the
+ * shared `resolvePendingQuestion` core, mapping the decision's answer-token /
+ * free text / deny action onto a batch submission.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type {
+  ActorContext,
+  ResolverContext,
+  ResolverDecision,
+} from "../approvals/guardian-request-resolvers.js";
+import { getResolver } from "../approvals/guardian-request-resolvers.js";
+import type { GuardianRequestWire } from "../channels/gateway-guardian-requests.js";
+import type { QuestionPromptResult } from "../permissions/question-prompter.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+
+const resolver = getResolver("pending_question");
+
+const actor: ActorContext = {
+  actorPrincipalId: "prin-guardian",
+  actorExternalUserId: "tg-guardian",
+  channel: "telegram",
+  guardianPrincipalId: "prin-guardian",
+};
+
+function makeRequest(
+  overrides: Partial<GuardianRequestWire> = {},
+): GuardianRequestWire {
+  return {
+    id: "req-q1",
+    kind: "pending_question",
+    sourceType: "channel",
+    sourceChannel: "telegram",
+    sourceConversationId: "conv-1",
+    requesterExternalUserId: "tg-guardian",
+    requesterChatId: "chat-1",
+    guardianExternalUserId: "tg-guardian",
+    guardianPrincipalId: "prin-guardian",
+    callSessionId: null,
+    pendingQuestionId: null,
+    questionText: "Which fruit?",
+    requestCode: "ABC123",
+    toolName: null,
+    inputDigest: null,
+    commandPreview: null,
+    riskLevel: null,
+    activityText: null,
+    executionTarget: null,
+    requesterSignals: null,
+    requestTrigger: null,
+    status: "approved",
+    answerText: null,
+    decidedByExternalUserId: null,
+    decidedByPrincipalId: null,
+    followupState: null,
+    expiresAt: null,
+    createdAt: 0,
+    updatedAt: 0,
+    ...overrides,
+  };
+}
+
+function makeContext(
+  decision: ResolverDecision,
+  requestOverrides: Partial<GuardianRequestWire> = {},
+): ResolverContext {
+  return { request: makeRequest(requestOverrides), decision, actor };
+}
+
+/** Register a parked single-question interaction like QuestionPrompter does. */
+function registerQuestion(
+  requestId: string,
+  options: string[],
+  rpcResolve: (value: unknown) => void = () => {},
+): void {
+  pendingInteractions.register(requestId, {
+    conversationId: "conv-1",
+    kind: "question",
+    rpcResolve,
+    metadata: { orderedIds: ["q1"], optionsById: { q1: options } },
+    questionDetails: {
+      entries: [
+        {
+          id: "q1",
+          question: "Which fruit?",
+          options: options.map((id) => ({ id, label: id })),
+        },
+      ],
+    },
+  });
+}
+
+beforeEach(() => pendingInteractions.clear());
+afterEach(() => pendingInteractions.clear());
+
+describe("pending_question resolver — ask_question branch", () => {
+  test("an answer-option token resolves the interaction with that option", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_1" }),
+    );
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "option", optionId: "banana" },
+    ]);
+    expect(pendingInteractions.get("req-q1")).toBeUndefined();
+  });
+
+  test("the skip token resolves the interaction as skipped", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "reject", userText: "answer_skip" }),
+    );
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "skipped" },
+    ]);
+  });
+
+  test("free text resolves as a free_text answer", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "a ripe mango" }),
+    );
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "free_text", text: "a ripe mango" },
+    ]);
+  });
+
+  test("a deny decision with no text skips the question", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(makeContext({ action: "reject" }));
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "skipped" },
+    ]);
+  });
+
+  test("an out-of-range option index fails without consuming the interaction", async () => {
+    registerQuestion("req-q1", ["apple", "banana"]);
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_9" }),
+    );
+
+    expect(result).toEqual({
+      ok: false,
+      reason: "question_option_index_out_of_range",
+    });
+    expect(pendingInteractions.get("req-q1")).toBeDefined();
+  });
+
+  test("a missing interaction reports no_pending_question_interaction", async () => {
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_0" }),
+    );
+
+    expect(result).toEqual({
+      ok: false,
+      reason: "no_pending_question_interaction",
+    });
+  });
+
+  test("a multi-question interaction is refused (cards are single-question)", async () => {
+    pendingInteractions.register("req-q1", {
+      conversationId: "conv-1",
+      kind: "question",
+      rpcResolve: () => {},
+      metadata: {
+        orderedIds: ["q1", "q2"],
+        optionsById: { q1: ["a"], q2: ["b"] },
+      },
+    });
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_0" }),
+    );
+
+    expect(result).toEqual({ ok: false, reason: "question_batch_not_single" });
+    expect(pendingInteractions.get("req-q1")).toBeDefined();
+  });
+});

package/src/__tests__/assistant-event-hub-self-exclusion.test.ts

@@ -14,14 +14,14 @@
  */
 import { describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   AssistantEventHub,
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
 
-function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
+function makeSyncChangedEvent(originClientId?: string): AssistantEventEnvelope {
   return {
     id: "evt_test_sync",
     conversationId: undefined,
@@ -37,9 +37,9 @@ function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
 describe("AssistantEventHub — self-echo suppression (excludeClientId)", () => {
   test("skips the named client and delivers to every other client", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
-    const receivedC: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
+    const receivedC: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -82,8 +82,8 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
   test("delivers to every subscriber when excludeClientId is omitted", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -112,7 +112,7 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
   test("excludeClientId does not match process-type subscribers", async () => {
     const hub = new AssistantEventHub();
-    const receivedProcess: AssistantEvent[] = [];
+    const receivedProcess: AssistantEventEnvelope[] = [];
 
     // A process subscriber sits in the same hub as a client whose id
     // matches `excludeClientId`. It must never be suppressed because
@@ -134,8 +134,8 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
   test("excludeClientId composes with conversation-scoped subscribers", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -159,7 +159,7 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
     });
 
     // Scoped event for sess_x; both clients filter to sess_x; exclude A.
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "evt_scoped",
       conversationId: "sess_x",
       emittedAt: "2026-05-03T00:00:00.000Z",
@@ -179,8 +179,8 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
 describe("broadcastMessage — derives excludeClientId from sync_changed.originClientId", () => {
   test("skips the originating client when originClientId is present", async () => {
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     const subA = assistantEventHub.subscribe({
       type: "client",
@@ -221,8 +221,8 @@ describe("broadcastMessage — derives excludeClientId from sync_changed.originC
   });
 
   test("fans out to every client when originClientId is absent", async () => {
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     const subA = assistantEventHub.subscribe({
       type: "client",
@@ -260,7 +260,7 @@ describe("broadcastMessage — derives excludeClientId from sync_changed.originC
   });
 
   test("ignores an empty-string originClientId (treats as absent)", async () => {
-    const receivedA: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
 
     const subA = assistantEventHub.subscribe({
       type: "client",

package/src/__tests__/assistant-event-hub-targeted.test.ts

@@ -13,10 +13,12 @@
  */
 import { describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 
-function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
+function makeEvent(
+  overrides: Partial<AssistantEventEnvelope> = {},
+): AssistantEventEnvelope {
   return {
     id: "evt_test",
     conversationId: "sess_web",
@@ -35,8 +37,8 @@ function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
 describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
   test("delivers only to the named client, bypassing conversation filter", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     // client-a is subscribed to "sess_macos" — different from the event's "sess_web"
     hub.subscribe({
@@ -75,8 +77,8 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("does not deliver to a client with a different clientId", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -106,7 +108,7 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("targeted delivery with wrong capability does not deliver", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
 
     // client-a only has host_file capability, NOT host_bash
     hub.subscribe({
@@ -130,7 +132,7 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("targeted delivery with matching capability delivers", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -152,7 +154,7 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("process-type subscriber is never matched by targetClientId", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -173,8 +175,8 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 describe("AssistantEventHub — untargeted capability targeting is unchanged", () => {
   test("targetCapability without targetClientId still applies conversation scoping", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",