@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/slack-inbound-verification.test.ts

@@ -55,13 +55,42 @@ mock.module("../runtime/gateway-client.js", () => ({
   },
 }));
 
+// Guardian identity resolves via the gateway delivery reader, not the local
+// contacts DB. Seed it to mirror the createGuardianBinding calls below.
+interface GatewayGuardian {
+  channelType: string;
+  contactId: string;
+  principalId?: string | null;
+  displayName?: string | null;
+  address: string;
+  externalChatId?: string | null;
+  status: string;
+  verifiedAt?: number | null;
+}
+let gatewayGuardians: GatewayGuardian[] = [];
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => gatewayGuardians,
+  guardianForChannel: (list: GatewayGuardian[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+function seedGatewayGuardian(
+  g: Partial<GatewayGuardian> & { channelType: string; address: string },
+): void {
+  gatewayGuardians.push({
+    contactId: `c-${g.channelType}`,
+    status: "active",
+    ...g,
+  });
+}
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -71,7 +100,6 @@ const TEST_BEARER_TOKEN = "test-token";
 
 function resetState(): void {
   const db = getDb();
-  db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM channel_verification_sessions");
   db.run("DELETE FROM channel_guardian_rate_limits");
   db.run("DELETE FROM channel_inbound_events");
@@ -81,7 +109,16 @@ function resetState(): void {
   db.run("DELETE FROM canonical_guardian_deliveries");
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");
-  // Seed the vellum guardian binding (gateway does this at startup in production)
+  gatewayGuardians = [];
+  // Seed the vellum guardian binding (gateway does this at startup in
+  // production). The gateway list is the source of truth for guardian
+  // resolution; the DB write mirrors it for any local INFO reads.
+  seedGatewayGuardian({
+    channelType: "vellum",
+    address: "guardian-principal",
+    principalId: "guardian-principal",
+    displayName: "guardian-principal",
+  });
   createGuardianBinding({
     channel: "vellum",
     guardianExternalUserId: "guardian-principal",
@@ -163,7 +200,14 @@ describe("Slack inbound trusted contact verification", () => {
   });
 
   test("guardian is notified of the access attempt alongside verification", async () => {
-    // Set up a guardian binding so the notification can target it
+    // Set up a guardian binding so the notification can target it. The gateway
+    // list resolves guardian identity; the DB write mirrors it.
+    seedGatewayGuardian({
+      channelType: "slack",
+      address: "U_GUARDIAN",
+      externalChatId: "D_GUARDIAN_DM",
+      principalId: "guardian-principal",
+    });
     createGuardianBinding({
       channel: "slack",
       guardianExternalUserId: "U_GUARDIAN",
@@ -256,5 +300,4 @@ describe("Slack inbound trusted contact verification", () => {
 
     // No Slack DM was sent
   });
-
 });

package/src/__tests__/slack-messaging-token-resolution.test.ts

@@ -50,8 +50,11 @@ mock.module("../runtime/auth/token-service.js", () => ({}));
 // Slack client stubs (not exercised in these tests, but required on import)
 mock.module("../messaging/providers/slack/client.js", () => ({}));
 
-// Gmail client stubs
-mock.module("../messaging/providers/gmail/client.js", () => ({}));
+// Gmail client stubs. Re-export GMAIL_REQUIRED_SCOPES so the adapter's
+// `requiredScopes` is populated (and the forwarding assertion below is real).
+mock.module("../messaging/providers/gmail/client.js", () => ({
+  GMAIL_REQUIRED_SCOPES: ["https://www.googleapis.com/auth/gmail.readonly"],
+}));
 mock.module("../messaging/providers/gmail/people-client.js", () => ({}));
 
 // Telegram client stubs
@@ -244,8 +247,16 @@ describe("Slack messaging token resolution", () => {
 
       const result = await getProviderConnection(gmailMessagingProvider);
       expect(result).toBe(oauthConn);
+      // Gmail forwards its requiredScopes so a narrowly-scoped (e.g.
+      // Calendar-only) Google connection is rejected at resolution time
+      // instead of 403-ing on the first Gmail API call. Asserted as a concrete
+      // value (not the provider property) so removing the forwarding fails.
+      expect(gmailMessagingProvider.requiredScopes).toEqual([
+        "https://www.googleapis.com/auth/gmail.readonly",
+      ]);
       expect(resolveOAuthConnectionMock).toHaveBeenCalledWith("google", {
         account: undefined,
+        requiredScopes: ["https://www.googleapis.com/auth/gmail.readonly"],
       });
     });
   });

package/src/__tests__/slack-reaction-canonical-approval.test.ts

@@ -37,7 +37,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Constants & helpers

package/src/__tests__/sse-actor-principal-guardian-source.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Regression: the SSE subscribe path must resolve the actor principal from the
+ * SAME guardian source as the send/result routes.
+ *
+ * The send/result routes resolve the actor principal via the async,
+ * gateway-first `findLocalGuardianPrincipalId`. The SSE eager-subscribe path
+ * cannot await and uses the sync `findLocalGuardianPrincipalIdFromStore`. When
+ * the gateway binding is canonical but the local contact row is stale/missing
+ * (after a guardian reset or gateway-owned binding update), the sync path must
+ * still land on the gateway principal — otherwise the event hub registers the
+ * SSE client under a DIFFERENT principal than the turn/result paths use, and
+ * targeted result submissions 403.
+ *
+ * These tests pin the invariant by priming the gateway-delivery cache with a
+ * principal that differs from the stale local store and asserting both
+ * resolvers agree; and that a cold cache falls back to the local store.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+// ── Controllable IPC mock (drives the gateway-delivery cache) ────────────────
+
+let ipcGuardians: GuardianDelivery[] = [];
+
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async () => ({ guardians: ipcGuardians }),
+  ipcCallPersistent: async () => undefined,
+  resetPersistentClient: () => {},
+}));
+
+// ── Local store mock (the stale fallback source) ─────────────────────────────
+
+let storePrincipalId: string | undefined;
+
+mock.module("../contacts/contact-store.js", () => ({
+  findGuardianForChannel: (channelType: string) =>
+    storePrincipalId && channelType === "vellum"
+      ? { contact: { principalId: storePrincipalId }, channel: {} }
+      : null,
+}));
+
+import {
+  __resetGuardianDeliveryCacheForTest,
+  getGuardianDelivery,
+} from "../contacts/guardian-delivery-reader.js";
+import {
+  findLocalGuardianPrincipalId,
+  findLocalGuardianPrincipalIdFromStore,
+} from "../runtime/local-actor-identity.js";
+
+const gatewayVellumGuardian: GuardianDelivery = {
+  channelType: "vellum",
+  contactId: "contact-gw",
+  principalId: "guardian-from-gateway",
+  address: "vellum:self",
+  status: "active",
+};
+
+describe("SSE actor principal resolves from the same guardian source as send/result routes", () => {
+  beforeEach(() => {
+    __resetGuardianDeliveryCacheForTest();
+    ipcGuardians = [];
+    storePrincipalId = undefined;
+  });
+
+  test("warm gateway cache: sync (SSE) and async (send/result) resolve the SAME principal despite a stale local store", async () => {
+    // Gateway binding is canonical; local store row is stale (different id).
+    ipcGuardians = [gatewayVellumGuardian];
+    storePrincipalId = "guardian-stale-local";
+
+    // Prime the cache the way the async hot paths do.
+    const asyncPrincipalId = await findLocalGuardianPrincipalId();
+    expect(asyncPrincipalId).toBe("guardian-from-gateway");
+
+    // SSE's sync resolver reads the same cached gateway snapshot, NOT the
+    // stale store — so the principals match and host-proxy targeting works.
+    expect(findLocalGuardianPrincipalIdFromStore()).toBe(asyncPrincipalId);
+  });
+
+  test("cold cache: sync resolver falls back to the local store as before", () => {
+    // Nothing primed the cache; only the local store has a binding.
+    storePrincipalId = "guardian-stale-local";
+
+    expect(findLocalGuardianPrincipalIdFromStore()).toBe("guardian-stale-local");
+  });
+
+  test("cold cache with no store binding: sync resolver returns undefined", () => {
+    expect(findLocalGuardianPrincipalIdFromStore()).toBeUndefined();
+  });
+
+  test("warm gateway cache primes via the vellum-filtered read the async path uses", async () => {
+    ipcGuardians = [gatewayVellumGuardian];
+
+    // The async path filters by channelType vellum; the sync peek must read
+    // the same cache key, not the unfiltered "ALL" entry.
+    await getGuardianDelivery({ channelTypes: ["vellum"] });
+
+    expect(findLocalGuardianPrincipalIdFromStore()).toBe("guardian-from-gateway");
+  });
+});

package/src/__tests__/steer-on-enqueue-question.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Enqueue-steer contract: when a chat message is enqueued while an
+ * `ask_question` prompt is open for the same conversation, the user has chosen
+ * to move on rather than answer it. `steerOnEnqueuedMessageIfQuestionParked`
+ * steers to that message — aborting the parked turn (which settles the open
+ * question via its turn-abort signal) and draining the message — instead of
+ * stranding it behind a prompt no one will answer.
+ *
+ * Only `kind: "question"` interactions trigger the steer; pending confirmations
+ * are handled separately by the enqueue path's auto-deny.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import {
+  steerOnEnqueuedMessageIfQuestionParked,
+  supersedePendingInteractionsOnEnqueue,
+} from "../daemon/handlers/conversations.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+
+interface ParkedTurn {
+  abortCount: () => number;
+  fake: { pendingSteerRepair: boolean };
+}
+
+/**
+ * Register a fake conversation whose in-flight turn is parked. The fake exposes
+ * just the surface `steerToMessage` touches: a processing flag, a queue whose
+ * head can be promoted, an abort controller that records aborts, and the
+ * confirmation-deny hook.
+ */
+function registerParkedTurn(id: string): ParkedTurn {
+  let abortCount = 0;
+  const fake = {
+    isProcessing: () => true,
+    queue: {
+      promoteToHead: (requestId: string) => ({ requestId }),
+    },
+    pendingSteerRepair: false,
+    abortController: {
+      abort: () => {
+        abortCount += 1;
+      },
+    },
+    hasAnyPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+  };
+  setConversation(id, fake as unknown as Conversation);
+  return { abortCount: () => abortCount, fake };
+}
+
+const registeredRequestIds: string[] = [];
+function registerInteraction(
+  conversationId: string,
+  kind: "question" | "confirmation",
+): void {
+  const requestId = `pending-${kind}-${conversationId}`;
+  pendingInteractions.register(requestId, { conversationId, kind });
+  registeredRequestIds.push(requestId);
+}
+
+const QUESTION_CONV = "steer-enqueue-question";
+const CONFIRMATION_CONV = "steer-enqueue-confirmation";
+const NONE_CONV = "steer-enqueue-none";
+
+describe("steerOnEnqueuedMessageIfQuestionParked", () => {
+  afterEach(() => {
+    for (const id of registeredRequestIds) {
+      pendingInteractions.resolve(id, "cancelled");
+    }
+    registeredRequestIds.length = 0;
+    deleteConversation(QUESTION_CONV);
+    deleteConversation(CONFIRMATION_CONV);
+    deleteConversation(NONE_CONV);
+  });
+
+  test("steers to the enqueued message when an ask_question is parked", () => {
+    const conv = registerParkedTurn(QUESTION_CONV);
+    registerInteraction(QUESTION_CONV, "question");
+
+    const steered = steerOnEnqueuedMessageIfQuestionParked(
+      QUESTION_CONV,
+      "msg-1",
+    );
+
+    // The parked turn is aborted (which settles the open question) and marked
+    // for tool-result repair so the drain path can pick up the new message.
+    expect(steered).toBe(true);
+    expect(conv.abortCount()).toBe(1);
+    expect(conv.fake.pendingSteerRepair).toBe(true);
+  });
+
+  test("steers for a parked question even when a confirmation is also pending", () => {
+    // A single model response can open an ask_question and a confirmation
+    // concurrently (tools run via Promise.all), so both interactions can be
+    // registered at once. The steer must still fire for the question — the
+    // enqueue path runs it before the confirmation auto-deny clears entries.
+    const conv = registerParkedTurn(QUESTION_CONV);
+    registerInteraction(QUESTION_CONV, "confirmation");
+    registerInteraction(QUESTION_CONV, "question");
+
+    const steered = steerOnEnqueuedMessageIfQuestionParked(
+      QUESTION_CONV,
+      "msg-1",
+    );
+
+    expect(steered).toBe(true);
+    expect(conv.abortCount()).toBe(1);
+  });
+
+  test("does not steer for a pending confirmation (not a question)", () => {
+    const conv = registerParkedTurn(CONFIRMATION_CONV);
+    registerInteraction(CONFIRMATION_CONV, "confirmation");
+
+    const steered = steerOnEnqueuedMessageIfQuestionParked(
+      CONFIRMATION_CONV,
+      "msg-1",
+    );
+
+    expect(steered).toBe(false);
+    expect(conv.abortCount()).toBe(0);
+  });
+
+  test("does not steer when no prompt is parked", () => {
+    const conv = registerParkedTurn(NONE_CONV);
+
+    const steered = steerOnEnqueuedMessageIfQuestionParked(NONE_CONV, "msg-1");
+
+    expect(steered).toBe(false);
+    expect(conv.abortCount()).toBe(0);
+  });
+
+  test("supersedePendingInteractionsOnEnqueue steers a parked question", () => {
+    // The centralized routine is invoked by both the HTTP send handler and the
+    // CLI signal path. With no pending confirmation it steers a parked question
+    // — the behavior the CLI signal path previously lacked.
+    const conv = registerParkedTurn(QUESTION_CONV);
+    registerInteraction(QUESTION_CONV, "question");
+
+    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
+
+    expect(conv.abortCount()).toBe(1);
+    expect(conv.fake.pendingSteerRepair).toBe(true);
+  });
+});
+
+describe("removeByConversation preserves question interactions", () => {
+  // The enqueue path's confirmation auto-deny calls removeByConversation before
+  // the steer runs. Questions must survive it — they are settled instead by the
+  // steer's turn abort — or, when an ask_question and a confirmation are pending
+  // concurrently, the queued message would strand behind a question whose entry
+  // was cleared (and whose Promise was never settled) before the steer fired.
+  const CONV = "remove-by-conv-preserve-question";
+  const ids: string[] = [];
+  function register(kind: "question" | "confirmation"): void {
+    const requestId = `rbc-${kind}`;
+    pendingInteractions.register(requestId, { conversationId: CONV, kind });
+    ids.push(requestId);
+  }
+
+  afterEach(() => {
+    for (const id of ids) pendingInteractions.resolve(id, "cancelled");
+    ids.length = 0;
+  });
+
+  test("removes confirmations but leaves questions registered", () => {
+    register("confirmation");
+    register("question");
+
+    pendingInteractions.removeByConversation(CONV);
+
+    const remaining = pendingInteractions
+      .getByConversation(CONV)
+      .map((interaction) => interaction.kind);
+    expect(remaining).toEqual(["question"]);
+  });
+});

package/src/__tests__/stt-hints.test.ts

@@ -13,6 +13,15 @@ let mockRecentContacts: ContactWithChannels[] = [];
 let mockFindContactByAddressThrows = false;
 let mockListContactsThrows = false;
 
+// Guardian deliveries returned by the mocked gateway reader. resolveGuardianName
+// is mocked to echo mockGuardianName, so the displayName here is captured below.
+let mockGuardianDelivery: Array<{
+  channelType: string;
+  status: string;
+  displayName: string | null;
+}> | null = null;
+let lastGuardianDisplayNameSeen: string | null | undefined;
+
 const logWarnFn = mock(() => {});
 
 // ---------------------------------------------------------------------------
@@ -25,7 +34,10 @@ mock.module("../daemon/identity-helpers.js", () => ({
 
 mock.module("../prompts/user-reference.js", () => ({
   DEFAULT_USER_REFERENCE: "my human",
-  resolveGuardianName: () => mockGuardianName,
+  resolveGuardianName: (displayName?: string | null) => {
+    lastGuardianDisplayNameSeen = displayName;
+    return mockGuardianName;
+  },
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
@@ -35,8 +47,6 @@ mock.module("../contacts/contact-store.js", () => ({
     }
     return mockTargetContact;
   },
-  findGuardianForChannel: () => null,
-  listGuardianChannels: () => null,
   listContacts: (_limit?: number) => {
     if (mockListContactsThrows) {
       throw new Error("DB error: listContacts");
@@ -45,6 +55,15 @@ mock.module("../contacts/contact-store.js", () => ({
   },
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => mockGuardianDelivery,
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: unknown[]) => list[0],
+}));
+
 // Bun's mock.module for "../util/logger.js" doesn't intercept the transitive
 // import in stt-hints.ts due to a Bun limitation. Mocking pino at the package
 // level works because getLogger uses a Proxy that lazily creates a pino child
@@ -319,10 +338,22 @@ describe("resolveCallHints", () => {
     mockRecentContacts = [];
     mockFindContactByAddressThrows = false;
     mockListContactsThrows = false;
+    mockGuardianDelivery = null;
+    lastGuardianDisplayNameSeen = undefined;
     logWarnFn.mockClear();
   });
 
-  test("happy path wires all sources correctly", () => {
+  test("guardian displayName for hints comes from the gateway binding", async () => {
+    mockGuardianDelivery = [
+      { channelType: "phone", status: "active", displayName: "GatewayGuardian" },
+    ];
+
+    await resolveCallHints(null, []);
+
+    expect(lastGuardianDisplayNameSeen).toBe("GatewayGuardian");
+  });
+
+  test("happy path wires all sources correctly", async () => {
     mockTargetContact = makeContact("Alice");
     mockRecentContacts = [makeContact("Bob"), makeContact("Charlie")];
 
@@ -335,7 +366,7 @@ describe("resolveCallHints", () => {
       inviteGuardianName: "Eve",
     };
 
-    const result = resolveCallHints(session, ["StaticHint"]);
+    const result = await resolveCallHints(session, ["StaticHint"]);
     const parts = result.split(",");
 
     expect(parts).toContain("StaticHint");
@@ -351,7 +382,7 @@ describe("resolveCallHints", () => {
     expect(logWarnFn).not.toHaveBeenCalled();
   });
 
-  test("findContactByAddress failure is caught and logged without throwing", () => {
+  test("findContactByAddress failure is caught and logged without throwing", async () => {
     mockFindContactByAddressThrows = true;
     mockRecentContacts = [makeContact("Bob")];
 
@@ -365,7 +396,7 @@ describe("resolveCallHints", () => {
     };
 
     // Should not throw
-    const result = resolveCallHints(session, []);
+    const result = await resolveCallHints(session, []);
     const parts = result.split(",");
 
     // Target contact should be absent (lookup failed)
@@ -376,7 +407,7 @@ describe("resolveCallHints", () => {
     expect(logWarnFn).toHaveBeenCalled();
   });
 
-  test("listContacts failure is caught and logged without throwing", () => {
+  test("listContacts failure is caught and logged without throwing", async () => {
     mockListContactsThrows = true;
     mockTargetContact = makeContact("Alice");
 
@@ -390,7 +421,7 @@ describe("resolveCallHints", () => {
     };
 
     // Should not throw
-    const result = resolveCallHints(session, []);
+    const result = await resolveCallHints(session, []);
     const parts = result.split(",");
 
     // Recent contacts should be absent (listing failed)
@@ -401,7 +432,7 @@ describe("resolveCallHints", () => {
     expect(logWarnFn).toHaveBeenCalled();
   });
 
-  test("inbound call resolves caller contact from fromNumber", () => {
+  test("inbound call resolves caller contact from fromNumber", async () => {
     mockTargetContact = makeContact("Alice");
     mockRecentContacts = [makeContact("Bob")];
 
@@ -414,7 +445,7 @@ describe("resolveCallHints", () => {
       inviteGuardianName: null,
     };
 
-    const result = resolveCallHints(session, []);
+    const result = await resolveCallHints(session, []);
     const parts = result.split(",");
 
     // For inbound, the contact found via fromNumber should appear as caller, not target
@@ -425,10 +456,10 @@ describe("resolveCallHints", () => {
     expect(logWarnFn).not.toHaveBeenCalled();
   });
 
-  test("null session produces hints from assistant name, guardian name, and recent contacts", () => {
+  test("null session produces hints from assistant name, guardian name, and recent contacts", async () => {
     mockRecentContacts = [makeContact("RecentOne"), makeContact("RecentTwo")];
 
-    const result = resolveCallHints(null, ["Static"]);
+    const result = await resolveCallHints(null, ["Static"]);
     const parts = result.split(",");
 
     expect(parts).toContain("Static");

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

@@ -130,6 +130,33 @@ describe("parseSubagentMessages", () => {
     expect(result.objective).toBe("Research vampire lore");
   });
 
+  test("emits toolUseId and raw input on tool_use, toolUseId on tool_result", () => {
+    const messages = [
+      msg("user", [{ type: "text", text: "Do something" }]),
+      msg("assistant", [
+        {
+          type: "tool_use",
+          id: "t-abc",
+          name: "bash",
+          input: { command: "ls -la" },
+        },
+      ]),
+      msg("user", [
+        { type: "tool_result", tool_use_id: "t-abc", content: "total 0" },
+      ]),
+    ];
+
+    const result = parseSubagentMessages("sub-1", messages);
+    const toolUse = result.events.find((e) => e.type === "tool_use");
+    expect(toolUse).toBeDefined();
+    expect(toolUse!.toolUseId).toBe("t-abc");
+    expect(toolUse!.input).toEqual({ command: "ls -la" });
+
+    const toolResult = result.events.find((e) => e.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    expect(toolResult!.toolUseId).toBe("t-abc");
+  });
+
   test("includes messageId on text events from assistant messages", () => {
     const messages = [
       msg("user", [{ type: "text", text: "Do something" }]),

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

@@ -326,3 +326,68 @@ describe("SubagentManager terminal disposal", () => {
     asInternals(manager).stopSweep();
   });
 });
+
+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 subagentId = "sa-abort-usage";
+    // state.usage starts at {0,0,0}; the live (fake) conversation has accrued
+    // usage (makeFakeConversation → {100, 50, 0.005}). Wire `sender` as the
+    // stored parent sender so `setStatus` routes the terminal event through it.
+    injectFakeSubagent(manager, subagentId, makeState(subagentId), sender);
+
+    const aborted = manager.abort(subagentId, sender, undefined, {
+      suppressNotification: true,
+    });
+    expect(aborted).toBe(true);
+
+    const statusMsg = sent.find(
+      (m): m is Extract<ServerMessage, { type: "subagent_status_changed" }> =>
+        m.type === "subagent_status_changed",
+    );
+    expect(statusMsg).toBeDefined();
+    expect(statusMsg!.status).toBe("aborted");
+    // The emitted usage is the conversation's accrued total — NOT the {0,0,0}
+    // init — so the client doesn't flush the token panel to zero on stop.
+    expect(statusMsg!.usage).toEqual({
+      inputTokens: 100,
+      outputTokens: 50,
+      estimatedCost: 0.005,
+    });
+
+    asInternals(manager).stopSweep();
+  });
+
+  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 subagentId = "sa-abort-no-conv";
+    // No live conversation (released), but state carries a last-known usage —
+    // the abort must surface that, not overwrite it.
+    const state = makeState(subagentId, {
+      usage: { inputTokens: 320, outputTokens: 80, estimatedCost: 0.004 },
+    });
+    injectFakeSubagent(manager, subagentId, state, sender, null);
+
+    manager.abort(subagentId, sender, undefined, {
+      suppressNotification: true,
+    });
+
+    const statusMsg = sent.find(
+      (m): m is Extract<ServerMessage, { type: "subagent_status_changed" }> =>
+        m.type === "subagent_status_changed",
+    );
+    expect(statusMsg!.usage).toEqual({
+      inputTokens: 320,
+      outputTokens: 80,
+      estimatedCost: 0.004,
+    });
+
+    asInternals(manager).stopSweep();
+  });
+});