@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -272,7 +272,6 @@ describe("WhatsApp channel ingress attachment resolution", () => {
     const trustVerdict = resolveLocalTrustVerdict({
       channelType: "whatsapp",
       actorExternalId: WHATSAPP_USER_ID,
-      externalChatId: "whatsapp-chat-1",
     });
     return {
       sourceChannel: "whatsapp",

package/src/__tests__/secret-ingress-http.test.ts

@@ -96,6 +96,8 @@ const addMessageMock = mock(
 );
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: (
     conversationId: string,
     role: string,
@@ -127,6 +129,18 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
   }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-contact",
+      principalId: "test-user",
+      address: "test-user",
+      status: "active",
+    },
+  ],
+}));
+
 mock.module("../runtime/guardian-reply-router.js", () => ({
   routeGuardianReply: async () => ({
     consumed: false,

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

@@ -109,17 +109,38 @@ mock.module("../daemon/approval-generators.js", () => ({
   createApprovalConversationGenerator: () => _approvalGenerator,
 }));
 
-// Mock local-actor-identity to return a stable guardian context that uses
-// the same principal as the canonical requests created in tests.
+// Dev-bypass resolves the real guardian principal, then runs the real
+// local-principal trust mapper against the gateway delivery read.
 mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalTrustContext: () => ({
-    sourceChannel: "vellum",
-    trustClass: "guardian",
-    guardianPrincipalId: "test-principal-id",
-    guardianExternalUserId: "test-principal-id",
-  }),
+  findLocalGuardianPrincipalId: async () => "test-principal-id",
+}));
+
+// Mock the IPC transport rather than local-principal-trust.js so the sibling
+// resolver unit test (which mocks guardian-delivery-reader, not ipcCall) isn't
+// shadowed when both files run in one Bun process. resolve_guardian_delivery
+// returns a single active vellum guardian whose principal matches the
+// dev-bypass-resolved id; any other method throws so unexpected IPC surfaces.
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async (method: string) => {
+    if (method === "resolve_guardian_delivery") {
+      return {
+        guardians: [
+          {
+            channelType: "vellum",
+            contactId: "test-contact-id",
+            principalId: "test-principal-id",
+            address: "test-principal-id",
+            externalChatId: "test-principal-id",
+            status: "active",
+          },
+        ],
+      };
+    }
+    throw new Error(`Unexpected ipcCall in test: ${method}`);
+  },
 }));
 
+import { __resetGuardianDeliveryCacheForTest } from "../contacts/guardian-delivery-reader.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
@@ -343,6 +364,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     db.run("DELETE FROM contact_channels");
     db.run("DELETE FROM contacts");
     pendingInteractions.clear();
+    __resetGuardianDeliveryCacheForTest();
 
     createGuardianBinding({
       channel: "vellum",

package/src/__tests__/skills.test.ts

@@ -351,6 +351,50 @@ describe("plugin-resident skills", () => {
     expect(skill).toBeUndefined();
   });
 
+  test("warns when a plugin directory is missing package.json", () => {
+    const warnings: unknown[][] = [];
+    const originalWarn = noopLogger.warn;
+    noopLogger.warn = (...args: unknown[]) => {
+      warnings.push(args);
+    };
+    try {
+      writePluginSkill(
+        "the-force",
+        "software-engineering",
+        "Software Engineering",
+        "Engineering workflow",
+        "body",
+        { withPackageJson: false },
+      );
+
+      const skill = loadSkillCatalog().find(
+        (s) => s.id === "software-engineering",
+      );
+      expect(skill).toBeUndefined();
+
+      const warnedForDir = warnings.some(
+        (args) =>
+          typeof args[0] === "object" &&
+          args[0] !== null &&
+          "pluginDir" in args[0] &&
+          (args[0] as { pluginDir: string }).pluginDir.endsWith("the-force") &&
+          typeof args[1] === "string" &&
+          args[1].includes("missing package.json"),
+      );
+      expect(warnedForDir).toBe(true);
+    } finally {
+      noopLogger.warn = originalWarn;
+    }
+  });
+
+  test("does not load resident skills from a plugin disabled via .disabled", () => {
+    writePluginSkill("caveman", "caveman", "Caveman", "Terse mode");
+    writeFileSync(join(pluginsDir, "caveman", ".disabled"), "");
+
+    const skill = loadSkillCatalog().find((s) => s.id === "caveman");
+    expect(skill).toBeUndefined();
+  });
+
   test("workspace skill overrides a plugin-resident skill with the same id", () => {
     const WORKSPACE_DIR = join(
       tmpdir(),

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

@@ -55,6 +55,35 @@ 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";
@@ -80,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",
@@ -162,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",

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" }]),