@vellumai/assistant 0.10.12 → 0.11.0-staging.1

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

@@ -1881,3 +1881,179 @@ describe("schedule_delete tool", () => {
     expect(result.content).toContain("Schedule not found");
   });
 });
+
+// ── model-input schema validation (LUM-2853) ────────────────────────
+
+describe("schedule tools — model-input schema validation", () => {
+  beforeEach(() => {
+    getRawDb().run("DELETE FROM cron_runs");
+    getRawDb().run("DELETE FROM cron_jobs");
+  });
+
+  test("schedule_create rejects a mistyped field instead of persisting it", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad timezone",
+        expression: "0 9 * * *",
+        message: "hi",
+        timezone: 42,
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "schedule_create"',
+    );
+    expect(result.content).toContain("timezone");
+    const count = getRawDb()
+      .query("SELECT COUNT(*) as n FROM cron_jobs")
+      .get() as { n: number };
+    expect(count.n).toBe(0);
+  });
+
+  test("schedule_create rejects a non-integer retry policy", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad retries",
+        expression: "0 9 * * *",
+        message: "hi",
+        max_retries: "five",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("max_retries");
+  });
+
+  test("schedule_create rejects an unknown syntax value instead of persisting it", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad syntax",
+        expression: "0 9 * * *",
+        syntax: "daily",
+        message: "hi",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("syntax");
+  });
+
+  test("schedule_create treats explicit null as an omitted optional", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Null tolerance",
+        expression: "0 9 * * *",
+        message: "hi",
+        timezone: null,
+        enabled: null,
+        quiet: null,
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBeFalsy();
+    expect(result.content).toContain("Enabled: true");
+  });
+
+  test("schedule_create keeps the bespoke error for a non-string mode", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad mode",
+        expression: "0 9 * * *",
+        message: "hi",
+        mode: 42,
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("mode must be one of");
+  });
+
+  test("schedule_create passes unknown keys through (loose schema)", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Loose keys",
+        expression: "0 9 * * *",
+        message: "hi",
+        activity: "creating a schedule",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBeFalsy();
+  });
+
+  test("schedule_update rejects a mistyped field", async () => {
+    const create = await executeScheduleCreate(
+      { name: "To update", expression: "0 9 * * *", message: "hi" },
+      ctx,
+    );
+    expect(create.isError).toBeFalsy();
+    const jobId = (
+      getRawDb().query("SELECT id FROM cron_jobs").get() as { id: string }
+    ).id;
+
+    const result = await executeScheduleUpdate(
+      { job_id: jobId, max_retries: 2.5 },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "schedule_update"',
+    );
+    expect(result.content).toContain("max_retries");
+  });
+
+  test("schedule_update still clears timezone with an explicit null", async () => {
+    const create = await executeScheduleCreate(
+      {
+        name: "Tz clear",
+        expression: "0 9 * * *",
+        message: "hi",
+        timezone: "America/Los_Angeles",
+      },
+      ctx,
+    );
+    expect(create.isError).toBeFalsy();
+    const jobId = (
+      getRawDb().query("SELECT id FROM cron_jobs").get() as { id: string }
+    ).id;
+
+    const result = await executeScheduleUpdate(
+      { job_id: jobId, timezone: null },
+      ctx,
+    );
+
+    expect(result.isError).toBeFalsy();
+    const row = getRawDb()
+      .query("SELECT timezone FROM cron_jobs WHERE id = ?")
+      .get(jobId) as { timezone: string | null };
+    expect(row.timezone).toBeNull();
+  });
+
+  test("schedule_list rejects a mistyped enabled_only and tolerates null", async () => {
+    const bad = await executeScheduleList({ enabled_only: "yes" }, ctx);
+    expect(bad.isError).toBe(true);
+    expect(bad.content).toContain('Invalid input for tool "schedule_list"');
+
+    const ok = await executeScheduleList(
+      { enabled_only: null, job_id: null },
+      ctx,
+    );
+    expect(ok.isError).toBeFalsy();
+  });
+
+  test("schedule_delete rejects a mistyped job_id", async () => {
+    const result = await executeScheduleDelete({ job_id: 42 }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "schedule_delete"',
+    );
+  });
+});

package/src/__tests__/secret-prompt-log-hygiene.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SecretRequestEvent } from "../api/events/secret-request.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Capture all logger calls so we can verify secret values never appear
@@ -30,9 +30,9 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // Capture broadcastMessage calls
-const broadcastedMessages: ServerMessage[] = [];
+const broadcastedMessages: AssistantEvent[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: ServerMessage) => {
+  broadcastMessage: (msg: AssistantEvent) => {
     broadcastedMessages.push(msg);
   },
 }));

package/src/__tests__/secret-prompter-channel-fallback.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SecretRequestEvent } from "../api/events/secret-request.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Use a tiny timeout so the setTimeout branch fires quickly in tests
@@ -25,9 +25,9 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-let broadcastMessages: ServerMessage[] = [];
+let broadcastMessages: AssistantEvent[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: ServerMessage) => broadcastMessages.push(msg),
+  broadcastMessage: (msg: AssistantEvent) => broadcastMessages.push(msg),
 }));
 
 // Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.

package/src/__tests__/secret-response-routing.test.ts

@@ -1,12 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SecretRequestEvent } from "../api/events/secret-request.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { SecretPromptResult } from "../permissions/secret-prompt-types.js";
 
-let broadcastedMessages: ServerMessage[] = [];
+let broadcastedMessages: AssistantEvent[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
+  broadcastMessage: (msg: AssistantEvent) => broadcastedMessages.push(msg),
 }));
 
 // Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -90,13 +90,10 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 
 // `handleAddSecret` fires this detached when a managed-proxy credential lands —
 // a v2-memory side effect outside this suite's provider-registry scope. Stub it
-// to a no-op; its behavior is covered by memory-v2-startup.test.ts.
-mock.module(
-  "../plugins/defaults/memory/v3/substrate/memory-v2-startup.js",
-  () => ({
-    maybeReseedCapabilitiesAfterManagedCredential: async () => {},
-  }),
-);
+// to a no-op; its behavior is covered by boot-maintenance.test.ts.
+mock.module("../plugins/defaults/memory/substrate/boot-maintenance.js", () => ({
+  maybeReseedCapabilitiesAfterManagedCredential: async () => {},
+}));
 
 // secret-routes evicts conversations after a credential change so the next turn
 // rebuilds against the new providers; count the calls to assert that happens.

package/src/__tests__/secret-scanner.test.ts

@@ -8,6 +8,7 @@ import {
 import {
   _isPlaceholder,
   redactSecrets,
+  redactSecretsWith,
   scanText,
   type SecretMatch,
 } from "../security/secret-scanner.js";
@@ -433,6 +434,41 @@ describe("redaction", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// PEM private-key body redaction — the scanner replaces the matched span in
+// place, so the match must cover header→body→footer or the base64 body and
+// END footer survive redaction (the header-only-matcher leak this fixes).
+// Synthetic fake PEM material only — never a real key.
+// ---------------------------------------------------------------------------
+describe("private-key block redaction", () => {
+  const FAKE_PEM_BODY =
+    "MIIFAKEfakefakefakefakefakefakefakefakefake\n" +
+    "FAKEfakefakefakefakefakefakefakefakefake==";
+  const FULL_PEM_BLOCK = `-----BEGIN RSA PRIVATE KEY-----\n${FAKE_PEM_BODY}\n-----END RSA PRIVATE KEY-----`;
+
+  test("redactSecrets removes the whole block — body and footer, not just the header", () => {
+    const input = `here is the key:\n${FULL_PEM_BLOCK}\nuse it well`;
+    const result = redactSecrets(input);
+    expect(result).toContain('<redacted type="Private Key" />');
+    // The base64 body must not survive.
+    expect(result).not.toContain("MIIFAKE");
+    expect(result).not.toContain("FAKEfake");
+    // Header and footer must not survive either.
+    expect(result).not.toContain("-----BEGIN");
+    expect(result).not.toContain("-----END");
+    // Surrounding text is preserved.
+    expect(result).toContain("here is the key:");
+    expect(result).toContain("use it well");
+  });
+
+  test("redactSecretsWith removes the whole block", () => {
+    const result = redactSecretsWith(FULL_PEM_BLOCK, () => "[KEY]");
+    expect(result).toBe("[KEY]");
+    expect(result).not.toContain("MIIFAKE");
+    expect(result).not.toContain("-----END");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Plugin-declared patterns (runtime registry)
 // ---------------------------------------------------------------------------

package/src/__tests__/send-endpoint-busy.test.ts

@@ -10,8 +10,8 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
+import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import {
   getConversationByKey,
   getOrCreateConversation,
@@ -97,10 +97,10 @@ mock.module(
   () => gatewayGuardianRequestsStoreBridge,
 );
 
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { __resetGuardianDeliveryCacheForTest } from "../contacts/guardian-delivery-reader.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import type { ApprovalConversationGenerator } from "../runtime/http-types.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
@@ -143,7 +143,7 @@ function makeCompletingConversation(): Conversation {
     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!" });
@@ -162,7 +162,7 @@ function makeHangingConversation(): Conversation {
   const messages: unknown[] = [];
   const enqueuedMessages: Array<{
     content: string;
-    onEvent?: (msg: ServerMessage) => void;
+    onEvent?: (msg: AssistantEvent) => void;
     requestId?: string;
   }> = [];
   return {
@@ -191,7 +191,7 @@ function makeHangingConversation(): Conversation {
     getQueueDepth: () => enqueuedMessages.length,
     enqueueMessage: (options: {
       content: string;
-      onEvent?: (msg: ServerMessage) => void;
+      onEvent?: (msg: AssistantEvent) => void;
       requestId?: string;
     }) => {
       enqueuedMessages.push({
@@ -375,7 +375,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
   });
 
   test("publishes events to assistantEventHub when conversation is idle", async () => {
-    const publishedEvents: AssistantEvent[] = [];
+    const publishedEvents: AssistantEventEnvelope[] = [];
 
     await startServer(() => makeCompletingConversation());
 
@@ -384,7 +384,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       await import("../runtime/assistant-event-hub.js");
     routeEventHub.subscribe({
       type: "process",
-      callback: (event: AssistantEvent) => {
+      callback: (event: AssistantEventEnvelope) => {
         publishedEvents.push(event);
       },
     });

package/src/__tests__/slack-required-scopes-mirror.test.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * The required-scope list in `channel-readiness-service.ts` is a third copy of
+ * data owned by the Slack manifest — the web helper and the skill script hold
+ * the other two. Copies drift silently, and a stale list here would either miss
+ * a real gap or flag a scope the manifest stopped asking for, so pin it to the
+ * canonical source rather than trusting a comment to hold the line.
+ */
+const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+const MANIFEST_SOURCE = readFileSync(
+  join(REPO_ROOT, "skills/slack-app-setup/scripts/build-manifest.ts"),
+  "utf-8",
+);
+const READINESS_SOURCE = readFileSync(
+  join(import.meta.dir, "..", "runtime", "channel-readiness-service.ts"),
+  "utf-8",
+);
+const WEB_HELPER_SOURCE = readFileSync(
+  join(REPO_ROOT, "clients/web/src/utils/slack-manifest.ts"),
+  "utf-8",
+);
+
+/** Pull the quoted strings out of the array introduced by `opener`. */
+function scopeArrayAfter(source: string, opener: string): string[] {
+  const start = source.indexOf(opener);
+  if (start === -1) {
+    throw new Error(`Not found: ${opener}`);
+  }
+  const from = start + opener.length;
+  const end = source.indexOf("]", from);
+  if (end === -1) {
+    throw new Error(`Unterminated array after: ${opener}`);
+  }
+  return [...source.slice(from, end).matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+}
+
+const bot = scopeArrayAfter(MANIFEST_SOURCE, "bot: [");
+const botOptional = scopeArrayAfter(MANIFEST_SOURCE, "bot_optional: [");
+const required = scopeArrayAfter(
+  READINESS_SOURCE,
+  "const SLACK_REQUIRED_BOT_SCOPES = [",
+);
+const webBot = scopeArrayAfter(
+  WEB_HELPER_SOURCE,
+  "export const SLACK_MANIFEST_BOT_SCOPES = [",
+);
+const webBotOptional = scopeArrayAfter(
+  WEB_HELPER_SOURCE,
+  "const SLACK_MANIFEST_BOT_SCOPES_OPTIONAL = [",
+);
+
+describe("required Slack scopes stay in sync with the manifest", () => {
+  test("the manifest source parses into usable scope arrays", () => {
+    expect(bot.length).toBeGreaterThan(0);
+    expect(botOptional.length).toBeGreaterThan(0);
+    // Guards the extraction itself, and the manifest's own subset contract.
+    expect(botOptional.every((scope) => bot.includes(scope))).toBe(true);
+  });
+
+  test("readiness requires exactly the non-declinable bot scopes", () => {
+    const expected = bot.filter((scope) => !botOptional.includes(scope)).sort();
+
+    expect([...required].sort()).toEqual(expected);
+  });
+
+  test("readiness never demands a scope the workspace may decline", () => {
+    expect(required.filter((scope) => botOptional.includes(scope))).toEqual([]);
+  });
+
+  // The web helper is the third copy. Both mirrors are asserted to emit
+  // identical manifest JSON elsewhere, but that check lives in the web package
+  // and cannot see this one, so pin the scope arrays here too.
+  test("the web helper requests the same bot scopes as the skill script", () => {
+    expect([...webBot].sort()).toEqual([...bot].sort());
+    expect([...webBotOptional].sort()).toEqual([...botOptional].sort());
+  });
+});

package/src/__tests__/starter-task-flow.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage, SurfaceType } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
+import type {
+  SurfaceType,
+} from "../daemon/message-protocol.js";
 
 mock.module("../apps/app-store.js", () => ({
   getApp: (id: string) => {
-    if (id !== "test-app") return null;
+    if (id !== "test-app") {return null;}
     return {
       id,
       name: "Test App",
@@ -116,7 +119,7 @@ describe("starter task surface actions", () => {
   });
 
   test("app_open registers dynamic_page surface as action-capable", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext();
     ctx.sendToClient = (msg) => sent.push(msg);
 

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -17,7 +17,7 @@
  */
 import { afterAll, describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { getProvider as getProviderImport } from "../providers/registry.js";
 import { setConfig } from "./helpers/set-config.js";
 
@@ -42,7 +42,7 @@ class FakeConversation {
     provider: unknown,
     _systemPrompt: string,
     _maxTokens: number,
-    _sendToClient: (msg: ServerMessage) => void,
+    _sendToClient: (msg: AssistantEvent) => void,
   ) {
     capturedProvider = provider;
     this.capturedState = {

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: () => {},