@vellumai/assistant 0.10.12 → 0.11.0-staging.1

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), {

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

@@ -1986,3 +1986,67 @@ describe("Advisor role is tool-less", () => {
     ).toBe(0);
   });
 });
+
+// ── model-input schema validation (LUM-2855) ────────────────────────
+
+describe("subagent tools — model-input schema validation", () => {
+  test("spawn rejects a non-string label instead of spawning with it", async () => {
+    const result = await executeSubagentSpawn(
+      { label: 42, objective: "do something" },
+      makeContext("sess-schema", { sendToClient: () => {} }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "subagent_spawn"');
+    expect(result.content).toContain("label");
+  });
+
+  test("spawn treats explicit null label as missing (bespoke required error)", async () => {
+    const result = await executeSubagentSpawn(
+      { label: null, objective: "do something" },
+      makeContext("sess-schema", { sendToClient: () => {} }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("required");
+  });
+
+  test("status rejects a non-string subagent_id", async () => {
+    const result = await executeSubagentStatus(
+      { subagent_id: 42 },
+      makeContext("sess-schema"),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "subagent_status"',
+    );
+  });
+
+  test("message rejects a non-string content", async () => {
+    const result = await executeSubagentMessage(
+      { subagent_id: "some-id", content: 42 },
+      makeContext("sess-schema"),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "subagent_message"',
+    );
+    expect(result.content).toContain("content");
+  });
+
+  test("read rejects a non-string label but passes malformed last_n through", async () => {
+    const bad = await executeSubagentRead(
+      { label: 42 },
+      makeContext("sess-schema"),
+    );
+    expect(bad.isError).toBe(true);
+    expect(bad.content).toContain('Invalid input for tool "subagent_read"');
+
+    // last_n is loose passthrough — a malformed value is ignored, so the call
+    // reaches the bespoke "required" check instead of failing validation.
+    const passthrough = await executeSubagentRead(
+      { last_n: "five" },
+      makeContext("sess-schema"),
+    );
+    expect(passthrough.isError).toBe(true);
+    expect(passthrough.content).toContain("required");
+  });
+});

package/src/__tests__/sync-message-contract.test.ts

@@ -1,16 +1,16 @@
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEvent } from "../api/index.js";
 import {
   buildSyncChangedMessage,
   conversationMessagesSyncTag,
-  type ServerMessage,
   SYNC_TAGS,
   SyncChangedEventSchema,
 } from "../daemon/message-protocol.js";
 
 describe("sync message contract", () => {
-  test("sync_changed is assignable to ServerMessage", () => {
-    const message: ServerMessage = {
+  test("sync_changed is assignable to AssistantEvent", () => {
+    const message: AssistantEvent = {
       type: "sync_changed",
       tags: [SYNC_TAGS.assistantAvatar],
     };

package/src/__tests__/terminal-tools.test.ts

@@ -219,7 +219,10 @@ describe("Shell tool input validation", () => {
       baseContext,
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("command is required");
+    expect(result.content).toContain('Invalid input for tool "bash"');
+    expect(result.content).toContain(
+      "command: Too small: expected string to have >=1 characters",
+    );
   });
 
   test("rejects non-string command", async () => {
@@ -228,7 +231,10 @@ describe("Shell tool input validation", () => {
       baseContext,
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("command is required");
+    expect(result.content).toContain('Invalid input for tool "bash"');
+    expect(result.content).toContain(
+      "command: Invalid input: expected string, received number",
+    );
   });
 
   test("rejects command with null bytes", async () => {
@@ -243,7 +249,10 @@ describe("Shell tool input validation", () => {
   test("rejects missing command", async () => {
     const result = await shellTool.execute({ reason: "test" }, baseContext);
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("command is required");
+    expect(result.content).toContain('Invalid input for tool "bash"');
+    expect(result.content).toContain(
+      "command: Invalid input: expected string, received undefined",
+    );
   });
 
   test("executes simple command successfully", async () => {

package/src/__tests__/test-preload.ts

@@ -55,6 +55,15 @@ const savedCesCredentialUrl = process.env.CES_CREDENTIAL_URL;
 delete process.env.IS_CONTAINERIZED;
 delete process.env.CES_CREDENTIAL_URL;
 
+// A test runs daemon code in-process, so it acts as the main daemon for the
+// event hub's publish routing (a non-daemon forwards publishes over IPC to a
+// daemon that isn't there). Default the shared process-role slot to true; a
+// test simulating a worker overrides it. Written directly (not via
+// `runtime/process-role.ts`) to keep the preload free of source-module imports;
+// the slot is typed by the ambient `VellumAssistantNamespace` global (declared
+// in `src/vellum-assistant-namespace.d.ts`), so no import is needed to touch it.
+(globalThis.vellumAssistant ??= {}).mainDaemonProcess = true;
+
 // --- Phase 2: install the IPC mock (no source-module imports) ---
 
 // Mock gateway IPC so no test accidentally connects to a real gateway socket.