@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/subagent-disposal.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
 
@@ -13,7 +13,7 @@ interface FakeManagedSubagent {
       role: string;
       content: Array<{ type: string; text: string }>;
     }>;
-    sendToClient: (msg: ServerMessage) => void;
+    sendToClient: (msg: AssistantEvent) => void;
     persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
     enqueueMessage?: () => { rejected: boolean; queued: boolean };
@@ -25,7 +25,7 @@ interface FakeManagedSubagent {
     subagentDeniedToolNames: Set<string>;
   } | null;
   state: SubagentState;
-  parentSendToClient: (msg: ServerMessage) => void;
+  parentSendToClient: (msg: AssistantEvent) => void;
   retainedUntil?: number;
   hadEnqueuedMessages?: boolean;
 }
@@ -34,6 +34,7 @@ interface FakeManagedSubagent {
 interface ManagerInternals {
   subagents: Map<string, FakeManagedSubagent>;
   parentToChildren: Map<string, Set<string>>;
+  labelIndex: Map<string, string>;
   runSubagent: (subagentId: string, objective: string) => Promise<void>;
   sweepTerminal: () => void;
   stopSweep: () => void;
@@ -60,7 +61,7 @@ function injectFakeSubagent(
   manager: SubagentManager,
   subagentId: string,
   state: SubagentState,
-  parentSendToClient?: (msg: ServerMessage) => void,
+  parentSendToClient?: (msg: AssistantEvent) => void,
   conversation?: FakeManagedSubagent["conversation"],
 ): void {
   const internals = asInternals(manager);
@@ -77,6 +78,10 @@ function injectFakeSubagent(
     internals.parentToChildren.set(parentId, new Set());
   }
   internals.parentToChildren.get(parentId)!.add(subagentId);
+  internals.labelIndex.set(
+    `${parentId}:${state.config.label.toLowerCase().trim()}`,
+    subagentId,
+  );
 }
 
 function makeState(
@@ -210,12 +215,36 @@ describe("SubagentManager terminal disposal", () => {
     expect(manager.getState("sub-1")).toBeDefined();
 
     // Parent disposal should remove it.
-    manager.abortAllForParent("parent-sess-1");
+    manager.disposeAllForParent("parent-sess-1");
 
     expect(manager.getState("sub-1")).toBeUndefined();
     expect(manager.getChildrenOf("parent-sess-1")).toHaveLength(0);
   });
 
+  test("parent cancel keeps a completed child readable within its retention window", () => {
+    const manager = new SubagentManager();
+    injectFakeSubagent(
+      manager,
+      "sub-done",
+      makeState("sub-done", { status: "completed" }),
+      undefined,
+      null, // conversation released, metadata retained
+    );
+    asInternals(manager).subagents.get("sub-done")!.retainedUntil =
+      Date.now() + 60_000;
+
+    // A user stop / idle eviction aborts in-flight children only.
+    manager.abortAllForParent("parent-sess-1");
+
+    // The completed child's result must remain resolvable by id and by label
+    // so the parent can still subagent_read it after the cancel.
+    expect(manager.getState("sub-done")?.status).toBe("completed");
+    expect(
+      manager.getByLabel("Test subagent", "parent-sess-1")?.config.id,
+    ).toBe("sub-done");
+    expect(manager.getChildrenOf("parent-sess-1")).toHaveLength(1);
+  });
+
   test("TTL sweep removes expired terminal entries but not active subagents", () => {
     const manager = new SubagentManager();
 
@@ -332,8 +361,8 @@ describe("SubagentManager terminal disposal", () => {
 describe("SubagentManager.abort usage", () => {
   test("emits the conversation's latest usage on abort, not zeros", () => {
     const manager = new SubagentManager();
-    const sent: ServerMessage[] = [];
-    const sender = (msg: ServerMessage) => sent.push(msg);
+    const sent: AssistantEvent[] = [];
+    const sender = (msg: AssistantEvent) => sent.push(msg);
 
     const subagentId = "sa-abort-usage";
     // state.usage starts at {0,0,0}; the live (fake) conversation has accrued
@@ -347,7 +376,7 @@ describe("SubagentManager.abort usage", () => {
     expect(aborted).toBe(true);
 
     const statusMsg = sent.find(
-      (m): m is Extract<ServerMessage, { type: "subagent_status_changed" }> =>
+      (m): m is Extract<AssistantEvent, { type: "subagent_status_changed" }> =>
         m.type === "subagent_status_changed",
     );
     expect(statusMsg).toBeDefined();
@@ -365,8 +394,8 @@ describe("SubagentManager.abort usage", () => {
 
   test("keeps the last-known state.usage when the conversation was already released", () => {
     const manager = new SubagentManager();
-    const sent: ServerMessage[] = [];
-    const sender = (msg: ServerMessage) => sent.push(msg);
+    const sent: AssistantEvent[] = [];
+    const sender = (msg: AssistantEvent) => sent.push(msg);
 
     const subagentId = "sa-abort-no-conv";
     // No live conversation (released), but state carries a last-known usage —
@@ -381,7 +410,7 @@ describe("SubagentManager.abort usage", () => {
     });
 
     const statusMsg = sent.find(
-      (m): m is Extract<ServerMessage, { type: "subagent_status_changed" }> =>
+      (m): m is Extract<AssistantEvent, { type: "subagent_status_changed" }> =>
         m.type === "subagent_status_changed",
     );
     expect(statusMsg!.usage).toEqual({

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -29,7 +29,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
 
@@ -42,7 +42,7 @@ interface FakeManagedSubagent {
       role: string;
       content: Array<{ type: string; text: string }>;
     }>;
-    sendToClient: (msg: ServerMessage) => void;
+    sendToClient: (msg: AssistantEvent) => void;
     loadFromDb?: () => Promise<void>;
     persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
@@ -54,7 +54,7 @@ interface FakeManagedSubagent {
     subagentDeniedToolNames: Set<string>;
   } | null;
   state: SubagentState;
-  parentSendToClient: (msg: ServerMessage) => void;
+  parentSendToClient: (msg: AssistantEvent) => void;
 }
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
@@ -73,7 +73,7 @@ function injectFakeSubagent(
   manager: SubagentManager,
   subagentId: string,
   state: SubagentState,
-  parentSendToClient?: (msg: ServerMessage) => void,
+  parentSendToClient?: (msg: AssistantEvent) => void,
 ): void {
   const fakeSession: FakeManagedSubagent["conversation"] = {
     abort: () => {},

package/src/__tests__/subagent-fork-prompt-role.test.ts

@@ -15,7 +15,7 @@
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 
 // ── Captured constructor state ──────────────────────────────────────────────
 
@@ -36,7 +36,7 @@ class FakeConversation {
     _id: string,
     _provider: unknown,
     systemPrompt: string,
-    _sendToClient: (msg: ServerMessage) => void,
+    _sendToClient: (msg: AssistantEvent) => void,
     _workingDir: string,
     _options?: unknown,
   ) {
@@ -148,7 +148,7 @@ describe("SubagentManager fork — prompt source and role decoupling", () => {
   ): Promise<CapturedConversationState> {
     await manager.spawn(makeForkSpawnConfig(overrides), () => {});
     const created = capturedConversations[0];
-    if (!created) throw new Error("Expected a subagent conversation");
+    if (!created) {throw new Error("Expected a subagent conversation");}
     return created;
   }
 

package/src/__tests__/subagent-fork-spawn.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEvent } from "../api/index.js";
 import {
   clearConversations,
   findConversation,
   setConversation,
 } from "../daemon/conversation-registry.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message } from "../providers/types.js";
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentConfig, SubagentState } from "../subagent/types.js";
@@ -16,7 +16,7 @@ interface FakeManagedSubagent {
     abort: () => void;
     dispose: () => void;
     messages: Message[];
-    sendToClient: (msg: ServerMessage) => void;
+    sendToClient: (msg: AssistantEvent) => void;
     persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
     enqueueMessage?: () => { rejected: boolean; queued: boolean };
@@ -31,7 +31,7 @@ interface FakeManagedSubagent {
     subagentDeniedToolNames: Set<string>;
   } | null;
   state: SubagentState;
-  parentSendToClient: (msg: ServerMessage) => void;
+  parentSendToClient: (msg: AssistantEvent) => void;
   retainedUntil?: number;
   hadEnqueuedMessages?: boolean;
 }
@@ -66,7 +66,7 @@ function injectFakeSubagent(
   manager: SubagentManager,
   subagentId: string,
   state: SubagentState,
-  parentSendToClient?: (msg: ServerMessage) => void,
+  parentSendToClient?: (msg: AssistantEvent) => void,
   conversation?: FakeManagedSubagent["conversation"],
 ): void {
   const internals = asInternals(manager);

package/src/__tests__/subagent-manager-notify.test.ts

@@ -29,7 +29,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
 
@@ -42,7 +42,7 @@ interface FakeManagedSubagent {
       role: string;
       content: Array<{ type: string; text: string }>;
     }>;
-    sendToClient: (msg: ServerMessage) => void;
+    sendToClient: (msg: AssistantEvent) => void;
     loadFromDb?: () => Promise<void>;
     persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
@@ -54,7 +54,7 @@ interface FakeManagedSubagent {
     subagentDeniedToolNames: Set<string>;
   } | null;
   state: SubagentState;
-  parentSendToClient: (msg: ServerMessage) => void;
+  parentSendToClient: (msg: AssistantEvent) => void;
 }
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
@@ -77,7 +77,7 @@ function injectFakeSubagent(
   manager: SubagentManager,
   subagentId: string,
   state: SubagentState,
-  parentSendToClient?: (msg: ServerMessage) => void,
+  parentSendToClient?: (msg: AssistantEvent) => void,
 ): void {
   const fakeSession: FakeManagedSubagent["conversation"] = {
     abort: () => {},
@@ -137,8 +137,8 @@ describe("SubagentManager abort notification", () => {
     const state = makeState(subagentId);
     injectFakeSubagent(manager, subagentId, state);
 
-    const clientMessages: ServerMessage[] = [];
-    const sendToClient = (msg: ServerMessage) => clientMessages.push(msg);
+    const clientMessages: AssistantEvent[] = [];
+    const sendToClient = (msg: AssistantEvent) => clientMessages.push(msg);
 
     const result = manager.abort(subagentId, sendToClient);
 
@@ -160,8 +160,8 @@ describe("SubagentManager abort notification", () => {
     injectFakeSubagent(manager, subagentId, state, parentSender);
 
     // A different sender (simulating abort from a different thread's socket).
-    const abortingSender = ((_msg: ServerMessage) => {}) as (
-      msg: ServerMessage,
+    const abortingSender = ((_msg: AssistantEvent) => {}) as (
+      msg: AssistantEvent,
     ) => void;
 
     manager.abort(subagentId, abortingSender);
@@ -175,8 +175,8 @@ describe("SubagentManager abort notification", () => {
     const manager = new SubagentManager();
     const subagentId = "sub-1";
 
-    const clientMessages: ServerMessage[] = [];
-    const sendToClient = (msg: ServerMessage) => clientMessages.push(msg);
+    const clientMessages: AssistantEvent[] = [];
+    const sendToClient = (msg: AssistantEvent) => clientMessages.push(msg);
 
     // Pass the sender as parentSendToClient so the stored sender receives the status update.
     injectFakeSubagent(
@@ -386,7 +386,7 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
 });
 
 describe("SubagentManager abortAllForParent", () => {
-  test("aborts all active children of a parent", () => {
+  test("aborts active children but keeps every child's state readable", () => {
     clearCaptured();
     const manager = new SubagentManager();
     injectFakeSubagent(manager, "sub-1", makeState("sub-1"));
@@ -402,20 +402,79 @@ describe("SubagentManager abortAllForParent", () => {
     expect(count).toBe(2); // sub-1 and sub-2, not sub-3 (already completed)
     expect(capturedNotifications).toHaveLength(2);
 
-    // All children should be disposed — parent is going away.
+    // The parent conversation lives on (stop/eviction/rebuild), so every
+    // child stays tracked: aborted ones as terminal metadata, and the
+    // completed one still readable via subagent_read.
+    expect(manager.getState("sub-1")?.status).toBe("aborted");
+    expect(manager.getState("sub-2")?.status).toBe("aborted");
+    expect(manager.getState("sub-3")?.status).toBe("completed");
+    expect(manager.getChildrenOf("parent-sess-1")).toHaveLength(3);
+  });
+
+  test("returns 0 for unknown parent", () => {
+    const manager = new SubagentManager();
+    const count = manager.abortAllForParent("nonexistent");
+    expect(count).toBe(0);
+  });
+});
+
+describe("SubagentManager disposeAllForParent", () => {
+  test("aborts and removes all children — parent data is going away", () => {
+    clearCaptured();
+    const manager = new SubagentManager();
+    injectFakeSubagent(manager, "sub-1", makeState("sub-1"));
+    injectFakeSubagent(
+      manager,
+      "sub-2",
+      makeState("sub-2", { status: "completed" }),
+    );
+
+    const count = manager.disposeAllForParent("parent-sess-1", () => {});
+
+    expect(count).toBe(1); // only sub-1 was still in flight
     expect(manager.getState("sub-1")).toBeUndefined();
     expect(manager.getState("sub-2")).toBeUndefined();
-    expect(manager.getState("sub-3")).toBeUndefined();
     expect(manager.getChildrenOf("parent-sess-1")).toHaveLength(0);
   });
 
   test("returns 0 for unknown parent", () => {
     const manager = new SubagentManager();
-    const count = manager.abortAllForParent("nonexistent");
+    const count = manager.disposeAllForParent("nonexistent");
     expect(count).toBe(0);
   });
 });
 
+describe("SubagentManager disposeAllForAllParents", () => {
+  test("removes retained children across every parent — clear-all semantics", () => {
+    clearCaptured();
+    const manager = new SubagentManager();
+    // Two parents; only one would appear in the in-memory conversation store
+    // during a clear-all — the other models an evicted parent whose terminal
+    // children are still retained.
+    injectFakeSubagent(manager, "sub-a", makeState("sub-a"));
+    injectFakeSubagent(
+      manager,
+      "sub-b",
+      makeState("sub-b", {
+        config: {
+          id: "sub-b",
+          parentConversationId: "parent-evicted",
+          label: "Evicted parent child",
+          objective: "Do something",
+        },
+        status: "completed",
+      }),
+    );
+
+    manager.disposeAllForAllParents();
+
+    expect(manager.getState("sub-a")).toBeUndefined();
+    expect(manager.getState("sub-b")).toBeUndefined();
+    expect(manager.getChildrenOf("parent-sess-1")).toHaveLength(0);
+    expect(manager.getChildrenOf("parent-evicted")).toHaveLength(0);
+  });
+});
+
 describe("SubagentManager sharedRequestTimestamps", () => {
   test("defaults to an empty array", () => {
     const manager = new SubagentManager();

package/src/__tests__/subagent-notify-parent.test.ts

@@ -44,7 +44,13 @@ const capturedParentIds: string[] = [];
 // Live subagent conversations, keyed by conversationId. notifyParentFromChild
 // routes to the parent recorded here (the non-writable in-process source), so
 // tests register a child before expecting a notification to route.
-const liveSubagents = new Map<string, { parentConversationId: string }>();
+const liveSubagents = new Map<
+  string,
+  {
+    parentConversationId: string;
+    subagentSuppressParentNotifications?: boolean;
+  }
+>();
 
 mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => {
@@ -60,9 +66,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
   },
   findConversationOrSubagent: (id: string) => {
     const live = liveSubagents.get(id);
-    return live
-      ? { parentConversationId: live.parentConversationId }
-      : undefined;
+    return live ? { ...live } : undefined;
   },
 }));
 
@@ -321,6 +325,23 @@ describe("notifyParentFromChild", () => {
     expect(lastCapturedMessage()).toContain("Test message");
   });
 
+  test("returns false for a synchronous child that suppresses parent notifications", () => {
+    clearCaptured();
+    const conversationId = "conv-suppressed-1";
+    seedSubagent(conversationId);
+    // spawnAndAwait children carry this flag: the awaiting caller is their
+    // only parent channel, so a mid-run injection must not reach the parent.
+    const live = liveSubagents.get(conversationId);
+    if (live) {
+      live.subagentSuppressParentNotifications = true;
+    }
+
+    expect(
+      notifyParentFromChild(conversationId, "Should not arrive", "info"),
+    ).toBe(false);
+    expect(capturedMessages).toHaveLength(0);
+  });
+
   test("labels forks as Fork", () => {
     clearCaptured();
     const conversationId = "conv-fork-1";
@@ -349,3 +370,26 @@ describe("notifyParentFromChild", () => {
     expect(capturedParentIds).not.toContain("victim-conversation");
   });
 });
+
+describe("notify_parent — model-input schema validation (LUM-2857)", () => {
+  test("rejects a non-string message", async () => {
+    const result = await executeSubagentNotifyParent(
+      { message: 42 },
+      makeContext("conv-notify-schema-1"),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "notify_parent"');
+  });
+
+  test("degrades a malformed urgency to info instead of forwarding it", async () => {
+    const conversationId = "conv-notify-schema-2";
+    seedSubagent(conversationId);
+    const result = await executeSubagentNotifyParent(
+      { message: "found something", urgency: 42 },
+      makeContext(conversationId),
+    );
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content) as { urgency: string };
+    expect(parsed.urgency).toBe("info");
+  });
+});

package/src/__tests__/subagent-spawn-and-await.test.ts

@@ -13,7 +13,7 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { Message } from "../providers/types.js";
 
 // ── Fake Conversation ───────────────────────────────────────────────────────
@@ -36,7 +36,7 @@ interface FakeConversationConfig {
    */
   resolveOnAbort?: boolean;
   /** Deltas to emit through sendToClient before runAgentLoop resolves. */
-  emitDeltas?: ServerMessage[];
+  emitDeltas?: AssistantEvent[];
   /**
    * Invoked synchronously at the very start of runAgentLoop (after the loop has
    * begun, so the run is past the early-terminal guard and marked "running").
@@ -54,6 +54,13 @@ let runLoopInvoked = false;
 let lastPersistedUserMessage: string | undefined;
 /** Records `setSubagentDenySideEffects` on the most recent FakeConversation. */
 let lastDenySideEffects: boolean | undefined;
+/**
+ * Records `setSubagentSuppressParentNotifications` on the most recent
+ * FakeConversation.
+ */
+let lastSuppressParentNotifications: boolean | undefined;
+/** Records `setTrustContext` on the most recent FakeConversation. */
+let lastTrustContext: unknown;
 /** Options the most recent `bootstrapConversation` call received. */
 let lastBootstrapOptions: Record<string, unknown> | undefined;
 
@@ -64,7 +71,7 @@ class FakeConversation {
   conversationType = "background";
   hasSystemPromptOverride = false;
 
-  private sendToClient: (msg: ServerMessage) => void;
+  private sendToClient: (msg: AssistantEvent) => void;
   private readonly cfg: FakeConversationConfig;
   private aborted = false;
   private resolveAbort?: () => void;
@@ -73,7 +80,7 @@ class FakeConversation {
     _id: string,
     _provider: unknown,
     _systemPrompt: string,
-    sendToClient: (msg: ServerMessage) => void,
+    sendToClient: (msg: AssistantEvent) => void,
     _workingDir: string,
     _options?: unknown,
   ) {
@@ -82,13 +89,15 @@ class FakeConversation {
     this.messages = this.cfg.messages ?? [];
   }
 
-  updateClient(sendToClient: (msg: ServerMessage) => void) {
+  updateClient(sendToClient: (msg: AssistantEvent) => void) {
     // The manager re-points sendToClient via updateClient; honor it so the
     // wrappedSendToClient tap is the one the deltas flow through.
     this.sendToClient = sendToClient;
   }
 
-  setTrustContext() {}
+  setTrustContext(ctx: unknown) {
+    lastTrustContext = ctx;
+  }
   setAuthContext() {}
   getAuthContext() {
     return undefined;
@@ -99,6 +108,9 @@ class FakeConversation {
   setSubagentDenySideEffects(deny: boolean) {
     lastDenySideEffects = deny;
   }
+  setSubagentSuppressParentNotifications(suppress: boolean) {
+    lastSuppressParentNotifications = suppress;
+  }
   setPreactivatedSkillIds() {}
   getCurrentSystemPrompt() {
     return "system";
@@ -125,7 +137,9 @@ class FakeConversation {
           this.resolveAbort = resolve;
         });
       }
-      if (this.cfg.resolveOnAbort) return;
+      if (this.cfg.resolveOnAbort) {
+        return;
+      }
       throw new Error("aborted");
     }
     if (this.cfg.runError) {
@@ -199,7 +213,7 @@ function makeConfig(overrides: Record<string, unknown> = {}) {
 }
 
 /** Statuses broadcast to the parent via `subagent_status_changed` events. */
-function broadcastStatuses(events: ServerMessage[]): string[] {
+function broadcastStatuses(events: AssistantEvent[]): string[] {
   return events
     .filter((m) => m.type === "subagent_status_changed")
     .map((m) => (m as { status: string }).status);
@@ -228,6 +242,8 @@ describe("SubagentManager.spawnAndAwait", () => {
   // `undefined` across the opaque spawnAndAwait call.
   beforeEach(() => {
     lastDenySideEffects = undefined;
+    lastSuppressParentNotifications = undefined;
+    lastTrustContext = undefined;
   });
 
   test("wires denySideEffectTools onto the subagent conversation (read-only)", async () => {
@@ -251,6 +267,38 @@ describe("SubagentManager.spawnAndAwait", () => {
     expect(lastDenySideEffects).toBeUndefined();
   });
 
+  test("an explicit config trustContext lands on the subagent conversation", async () => {
+    nextConversationConfig = {};
+
+    const manager = new SubagentManager();
+    // No parent conversation is registered here, so inheritance would leave
+    // trust unset — the explicit config value must be applied regardless (the
+    // live-voice continuation path, where the parent's per-turn trust has
+    // already been cleared at spawn time).
+    await manager.spawnAndAwait(
+      makeConfig({
+        trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+      }),
+      () => {},
+    );
+
+    expect(lastTrustContext).toMatchObject({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    });
+  });
+
+  test("suppresses mid-run parent notifications on the synchronous path", async () => {
+    nextConversationConfig = {};
+
+    const manager = new SubagentManager();
+    await manager.spawnAndAwait(makeConfig(), () => {});
+
+    // The awaiting caller is the child's only parent channel: notify_parent
+    // must not inject a user-role turn into the live parent mid-await.
+    expect(lastSuppressParentNotifications).toBe(true);
+  });
+
   test("stamps the parent conversation id on the subagent's conversation", async () => {
     nextConversationConfig = {};
 
@@ -326,14 +374,14 @@ describe("SubagentManager.spawnAndAwait", () => {
         { role: "assistant", content: [{ type: "text", text: "done" }] },
       ],
       emitDeltas: [
-        { type: "assistant_text_delta", text: "Hello " } as ServerMessage,
+        { type: "assistant_text_delta", text: "Hello " } as AssistantEvent,
         {
           type: "assistant_thinking_delta",
           thinking: "(pondering) ",
-        } as ServerMessage,
-        { type: "assistant_text_delta", text: "world" } as ServerMessage,
+        } as AssistantEvent,
+        { type: "assistant_text_delta", text: "world" } as AssistantEvent,
         // Non-delta events must not be forwarded to onText.
-        { type: "subagent_status_changed" } as ServerMessage,
+        { type: "subagent_status_changed" } as AssistantEvent,
       ],
     };
 
@@ -382,7 +430,7 @@ describe("SubagentManager.spawnAndAwait", () => {
     // terminal first so this is recorded and broadcast as "aborted".
     nextConversationConfig = { resolveOnAbort: true };
 
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const controller = new AbortController();
     const manager = new SubagentManager();
     const promise = manager.spawnAndAwait(
@@ -441,7 +489,7 @@ describe("SubagentManager.spawnAndAwait", () => {
     const controller = new AbortController();
     controller.abort();
 
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const manager = new SubagentManager();
     await expect(
       manager.spawnAndAwait(makeConfig(), (msg) => events.push(msg), {