@vellumai/assistant 0.7.0 → 0.7.1

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

@@ -55,11 +55,11 @@ mock.module("../runtime/gateway-client.js", () => ({
   },
 }));
 
-import { createGuardianBinding } from "../contacts/contacts-write.js";
 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();
 
@@ -257,65 +257,4 @@ describe("Slack inbound trusted contact verification", () => {
     // No Slack DM was sent
   });
 
-  test("user can verify by replying with the code in the DM", async () => {
-    // Step 1: Unknown user sends a message, gets verification challenge
-    const req = buildSlackInboundRequest();
-    await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
-
-    const session = findActiveSession("slack");
-    expect(session).not.toBeNull();
-
-    // The challenge hash is stored in the session — extract the secret
-    // from the DM text sent to the user. The code is embedded in the
-    // template text. Since we're using a 6-digit code for identity-bound
-    // sessions, extract it from the session's challengeHash by consuming
-    // the challenge directly.
-    // The session was created with createOutboundSession which generates
-    // a 6-digit code. We can validate by calling validateAndConsumeVerification
-    // with the correct secret. Since the mock captures the DM text, we
-    // can extract the code indirectly. But for testing, we just verify
-    // the session properties and that validateAndConsumeVerification works
-    // with the correct identity.
-
-    // The actual secret was sent in the DM. For this test, let's use the
-    // session directly via the channel-verification-service to verify the
-    // consume path works.
-    // The DM text contains the verification code implicitly (it's in the
-    // template message). Since we need to test the full round-trip, let's
-    // verify via the inbound handler by sending the code as a message.
-
-    // Extract the session's challenge hash and verify that submitting the
-    // correct code works. We create a fresh session with a known secret for
-    // this part of the test.
-    resetState();
-
-    // Create a verification session manually to test the consume path
-    const { createOutboundSession } =
-      await import("../runtime/channel-verification-service.js");
-
-    const outboundSession = createOutboundSession({
-      channel: "slack",
-      expectedExternalUserId: "U0123UNKNOWN",
-      expectedChatId: "U0123UNKNOWN",
-      identityBindingStatus: "bound",
-      destinationAddress: "U0123UNKNOWN",
-      verificationPurpose: "trusted_contact",
-    });
-
-    // User replies with the code in the DM
-    const verifyReq = buildSlackInboundRequest({
-      conversationExternalId: "U0123UNKNOWN",
-      content: outboundSession.secret,
-      externalMessageId: `msg-verify-${Date.now()}`,
-    });
-    const verifyResp = await handleChannelInbound(
-      verifyReq,
-      undefined,
-      TEST_BEARER_TOKEN,
-    );
-    const verifyJson = (await verifyResp.json()) as Record<string, unknown>;
-
-    expect(verifyJson.accepted).toBe(true);
-    expect(verifyJson.verificationOutcome).toBe("verified");
-  });
 });

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

@@ -1,4 +1,35 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// ── Module mocks ──────────────────────────────────────────────────
+
+/**
+ * Captured messages from injectMessageIntoParent → findConversation → enqueueMessage.
+ * Each test clears this before use.
+ */
+const capturedNotifications: {
+  parentConversationId: string;
+  message: string;
+}[] = [];
+
+mock.module("../daemon/conversation-store.js", () => ({
+  findConversation: (id: string) => ({
+    enqueueMessage: (content: string) => {
+      capturedNotifications.push({
+        parentConversationId: id,
+        message: content,
+      });
+      return { queued: true };
+    },
+    persistUserMessage: async () => "mock-msg",
+    runAgentLoop: async () => {},
+  }),
+  addConversation: () => {},
+  removeConversation: () => {},
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: () => {},
+}));
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { SubagentManager } from "../subagent/manager.js";
@@ -108,8 +139,13 @@ function makeForkState(
   });
 }
 
+function clearCaptured(): void {
+  capturedNotifications.length = 0;
+}
+
 describe("Fork completion notifications", () => {
   test("fork completion notification includes last_n: 1 guidance", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "fork-1";
     const state = makeForkState(subagentId);
@@ -119,21 +155,16 @@ describe("Fork completion notifications", () => {
     managed.conversation!.persistUserMessage = () => "msg-1";
     managed.conversation!.runAgentLoop = async () => {};
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Analyze data");
 
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain("last_n: 1");
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain("last_n: 1");
 
     asInternals(manager).stopSweep();
   });
 
   test("fork completion notification includes internal-processing instruction", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "fork-1";
     const state = makeForkState(subagentId);
@@ -143,19 +174,13 @@ describe("Fork completion notifications", () => {
     managed.conversation!.persistUserMessage = () => "msg-1";
     managed.conversation!.runAgentLoop = async () => {};
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Analyze data");
 
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain(
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain(
       "do NOT share raw fork output with the user",
     );
-    expect(notifications[0].message).toContain(
+    expect(capturedNotifications[0].message).toContain(
       '[Fork "Analysis fork" completed]',
     );
 
@@ -163,6 +188,7 @@ describe("Fork completion notifications", () => {
   });
 
   test("fork failure notification uses [Fork prefix", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "fork-1";
     const state = makeForkState(subagentId);
@@ -174,20 +200,14 @@ describe("Fork completion notifications", () => {
       throw new Error("Context too large");
     };
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Analyze data");
 
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain(
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain(
       '[Fork "Analysis fork" failed]',
     );
-    expect(notifications[0].message).toContain("Context too large");
-    expect(notifications[0].message).not.toContain("[Subagent");
+    expect(capturedNotifications[0].message).toContain("Context too large");
+    expect(capturedNotifications[0].message).not.toContain("[Subagent");
 
     asInternals(manager).stopSweep();
   });
@@ -233,6 +253,7 @@ describe("Status response includes isFork", () => {
 
 describe("Regular sub-agent notifications are unchanged", () => {
   test("regular completed subagent uses [Subagent prefix", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
@@ -242,25 +263,20 @@ describe("Regular sub-agent notifications are unchanged", () => {
     managed.conversation!.persistUserMessage = () => "msg-1";
     managed.conversation!.runAgentLoop = async () => {};
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain(
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain(
       '[Subagent "Test subagent" completed]',
     );
-    expect(notifications[0].message).not.toContain("[Fork");
-    expect(notifications[0].message).not.toContain("last_n: 1");
+    expect(capturedNotifications[0].message).not.toContain("[Fork");
+    expect(capturedNotifications[0].message).not.toContain("last_n: 1");
 
     asInternals(manager).stopSweep();
   });
 
   test("regular failed subagent uses [Subagent prefix", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
@@ -272,19 +288,13 @@ describe("Regular sub-agent notifications are unchanged", () => {
       throw new Error("Something went wrong");
     };
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain(
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain(
       '[Subagent "Test subagent" failed]',
     );
-    expect(notifications[0].message).not.toContain("[Fork");
+    expect(capturedNotifications[0].message).not.toContain("[Fork");
 
     asInternals(manager).stopSweep();
   });

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

@@ -1,4 +1,35 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// ── Module mocks ──────────────────────────────────────────────────
+
+/**
+ * Captured messages from injectMessageIntoParent → findConversation → enqueueMessage.
+ * Each test clears this before use.
+ */
+const capturedNotifications: {
+  parentConversationId: string;
+  message: string;
+}[] = [];
+
+mock.module("../daemon/conversation-store.js", () => ({
+  findConversation: (id: string) => ({
+    enqueueMessage: (content: string) => {
+      capturedNotifications.push({
+        parentConversationId: id,
+        message: content,
+      });
+      return { queued: true };
+    },
+    persistUserMessage: async () => "mock-msg",
+    runAgentLoop: async () => {},
+  }),
+  addConversation: () => {},
+  removeConversation: () => {},
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: () => {},
+}));
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { SubagentManager } from "../subagent/manager.js";
@@ -94,19 +125,18 @@ function makeState(
   };
 }
 
+function clearCaptured(): void {
+  capturedNotifications.length = 0;
+}
+
 describe("SubagentManager abort notification", () => {
   test("abort notifies parent with do-not-respawn message", () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
     injectFakeSubagent(manager, subagentId, state);
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     const clientMessages: ServerMessage[] = [];
     const sendToClient = (msg: ServerMessage) => clientMessages.push(msg);
 
@@ -114,21 +144,16 @@ describe("SubagentManager abort notification", () => {
 
     expect(result).toBe(true);
     expect(state.status).toBe("aborted");
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain("explicitly aborted");
-    expect(notifications[0].message).toContain("Do NOT re-spawn");
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain("explicitly aborted");
+    expect(capturedNotifications[0].message).toContain("Do NOT re-spawn");
   });
 
-  test("abort notification routes to parent sender, not aborting sender", () => {
+  test("abort notification goes to parent conversation via findConversation", () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
-    const state = makeState(subagentId);
-
-    // Track which sender onSubagentFinished receives.
-    let notificationSender: unknown = null;
-    manager.onSubagentFinished = (_pid, _message, sender) => {
-      notificationSender = sender;
-    };
+    const state = makeState(subagentId); // parentConversationId = 'parent-sess-1'
 
     // The parent's stored sender (set at spawn time).
     const parentSender = () => {};
@@ -141,9 +166,9 @@ describe("SubagentManager abort notification", () => {
 
     manager.abort(subagentId, abortingSender);
 
-    // onSubagentFinished should receive the parent's sender, not the aborting one.
-    expect(notificationSender).toBe(parentSender);
-    expect(notificationSender).not.toBe(abortingSender);
+    // Notification should be routed to the parent conversation via findConversation.
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].parentConversationId).toBe("parent-sess-1");
   });
 
   test("abort sends subagent_status_changed to client", () => {
@@ -195,21 +220,18 @@ describe("SubagentManager abort notification", () => {
   });
 
   test("abort without sendToClient sets status but does not notify", () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
     injectFakeSubagent(manager, subagentId, state);
 
-    let notified = false;
-    manager.onSubagentFinished = () => {
-      notified = true;
-    };
-
     const result = manager.abort(subagentId);
 
     expect(result).toBe(true);
     expect(state.status).toBe("aborted");
-    expect(notified).toBe(false);
+    // Without parentSendToClient, abort skips both the status update and notification.
+    expect(capturedNotifications).toHaveLength(0);
   });
 
   test("abort rejects when callerConversationId does not match parent", () => {
@@ -249,27 +271,26 @@ describe("SubagentManager abort notification", () => {
     expect(state.status).toBe("aborted");
   });
 
-  test("abort with suppressNotification skips onSubagentFinished", () => {
+  test("abort with suppressNotification skips parent notification", () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
     injectFakeSubagent(manager, subagentId, state);
 
-    const notifications: string[] = [];
-    manager.onSubagentFinished = (_pid, message) => notifications.push(message);
-
     const result = manager.abort(subagentId, () => {}, undefined, {
       suppressNotification: true,
     });
 
     expect(result).toBe(true);
     expect(state.status).toBe("aborted");
-    expect(notifications).toHaveLength(0);
+    expect(capturedNotifications).toHaveLength(0);
   });
 });
 
 describe("SubagentManager notifyParent (via runSubagent)", () => {
   test("completed subagent notifies parent to use subagent_read", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
@@ -280,12 +301,6 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
     managed.conversation!.persistUserMessage = () => "msg-1";
     managed.conversation!.runAgentLoop = async () => {};
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
     expect(state.status).toBe("completed");
@@ -294,17 +309,18 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
       outputTokens: 50,
       estimatedCost: 0.005,
     });
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].parentConversationId).toBe("parent-sess-1");
-    expect(notifications[0].message).toContain(
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].parentConversationId).toBe("parent-sess-1");
+    expect(capturedNotifications[0].message).toContain(
       '[Subagent "Test subagent" completed]',
     );
-    expect(notifications[0].message).toContain("subagent_read");
+    expect(capturedNotifications[0].message).toContain("subagent_read");
 
     asInternals(manager).stopSweep();
   });
 
   test("failed subagent notifies parent with error and asks user before retry", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId);
@@ -318,12 +334,6 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
       throw new Error("API rate limit exceeded");
     };
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
     expect(state.status).toBe("failed");
@@ -333,15 +343,18 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
       outputTokens: 50,
       estimatedCost: 0.005,
     });
-    expect(notifications).toHaveLength(1);
-    expect(notifications[0].message).toContain("failed");
-    expect(notifications[0].message).toContain("API rate limit exceeded");
-    expect(notifications[0].message).toContain("Do NOT re-spawn");
+    expect(capturedNotifications).toHaveLength(1);
+    expect(capturedNotifications[0].message).toContain("failed");
+    expect(capturedNotifications[0].message).toContain(
+      "API rate limit exceeded",
+    );
+    expect(capturedNotifications[0].message).toContain("Do NOT re-spawn");
 
     asInternals(manager).stopSweep();
   });
 
   test("failed subagent does not notify if already aborted", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId, { status: "aborted" });
@@ -354,16 +367,10 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
       throw new Error("Conversation aborted");
     };
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
     // Should NOT notify — status was already terminal (aborted).
-    expect(notifications).toHaveLength(0);
+    expect(capturedNotifications).toHaveLength(0);
 
     asInternals(manager).stopSweep();
   });
@@ -371,6 +378,7 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
 
 describe("SubagentManager abortAllForParent", () => {
   test("aborts all active children of a parent", () => {
+    clearCaptured();
     const manager = new SubagentManager();
     injectFakeSubagent(manager, "sub-1", makeState("sub-1"));
     injectFakeSubagent(manager, "sub-2", makeState("sub-2"));
@@ -380,13 +388,10 @@ describe("SubagentManager abortAllForParent", () => {
       makeState("sub-3", { status: "completed" }),
     );
 
-    const notifications: string[] = [];
-    manager.onSubagentFinished = (_pid, message) => notifications.push(message);
-
     const count = manager.abortAllForParent("parent-sess-1", () => {});
 
     expect(count).toBe(2); // sub-1 and sub-2, not sub-3 (already completed)
-    expect(notifications).toHaveLength(2);
+    expect(capturedNotifications).toHaveLength(2);
 
     // All children should be disposed — parent is going away.
     expect(manager.getState("sub-1")).toBeUndefined();
@@ -422,6 +427,7 @@ describe("SubagentManager sharedRequestTimestamps", () => {
 
 describe("SubagentManager abort race guard", () => {
   test("completed subagent does not notify if already aborted", async () => {
+    clearCaptured();
     const manager = new SubagentManager();
     const subagentId = "sub-1";
     const state = makeState(subagentId, { status: "aborted" });
@@ -436,16 +442,10 @@ describe("SubagentManager abort race guard", () => {
       { role: "assistant", content: [{ type: "text", text: "Done!" }] },
     ];
 
-    const notifications: { parentConversationId: string; message: string }[] =
-      [];
-    manager.onSubagentFinished = (parentConversationId, message) => {
-      notifications.push({ parentConversationId, message });
-    };
-
     await asInternals(manager).runSubagent(subagentId, "Do something");
 
     // Should NOT notify — status was already terminal (aborted) when loop finished.
-    expect(notifications).toHaveLength(0);
+    expect(capturedNotifications).toHaveLength(0);
     // Status should remain aborted, not overwritten to completed.
     expect(state.status).toBe("aborted");