@vellumai/assistant 0.4.44 → 0.4.45

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -31,7 +31,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -130,6 +129,7 @@ function registerPendingToolApprovalInteraction(
   const handleConfirmationResponse = mock(() => {});
   const mockSession = {
     handleConfirmationResponse,
+    ensureActorScopedHistory: async () => {},
   } as unknown as import("../daemon/session.js").Session;
 
   pendingInteractions.register(requestId, {

package/src/__tests__/guardian-routing-state.test.ts

@@ -18,7 +18,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -17,7 +17,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/guardian-verify-setup-skill-regression.test.ts

@@ -13,12 +13,10 @@ import { describe, expect, test } from "bun:test";
 // Locate the skill SKILL.md
 // ---------------------------------------------------------------------------
 
-const ASSISTANT_DIR = resolve(import.meta.dirname ?? __dirname, "..", "..");
+const REPO_ROOT = resolve(import.meta.dirname ?? __dirname, "..", "..", "..");
 const SKILL_PATH = resolve(
-  ASSISTANT_DIR,
-  "src",
-  "config",
-  "bundled-skills",
+  REPO_ROOT,
+  "skills",
   "guardian-verify-setup",
   "SKILL.md",
 );

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -1,50 +1,25 @@
+/**
+ * Tests for confirmation response handling (handleConfirmationResponse).
+ *
+ * The legacy handleUserMessage tests that previously lived here were removed
+ * when session-user-message.ts was deleted. The approval-reply behavior they
+ * tested now lives on the HTTP path and is covered by
+ * conversation-routes-guardian-reply.test.ts, send-endpoint-busy.test.ts,
+ * and http-user-message-parity.test.ts.
+ */
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 import type { HandlerContext } from "../daemon/handlers/shared.js";
-import type {
-  ConfirmationResponse,
-  UserMessage,
-} from "../daemon/message-protocol.js";
+import type { ConfirmationResponse } from "../daemon/message-protocol.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { DebouncerMap } from "../util/debounce.js";
 
-const routeGuardianReplyMock = mock(async () => ({
-  consumed: false,
-  decisionApplied: false,
-  type: "not_consumed" as const,
-})) as any;
-const createCanonicalGuardianRequestMock = mock(() => ({
-  id: "canonical-id",
-}));
-const generateCanonicalRequestCodeMock = mock(() => "ABC123");
-const listPendingByDestinationMock = mock(
-  () => [] as Array<{ id: string; kind?: string }>,
-);
-const listCanonicalMock = mock(() => [] as Array<{ id: string }>);
 const resolveCanonicalGuardianRequestMock = mock(
   () => null as { id: string } | null,
 );
-const getByConversationMock = mock(
-  () =>
-    [] as Array<{
-      requestId: string;
-      kind: "confirmation" | "secret";
-      session?: unknown;
-    }>,
-);
-const registerMock = mock(() => {});
 const resolveMock = mock(() => undefined as unknown);
-const addMessageMock = mock(async () => ({ id: "persisted-message-id" }));
-const getConfigMock = mock(() => ({
-  daemon: { standaloneRecording: false },
-  secretDetection: { customPatterns: [], entropyThreshold: 3.5 },
-}));
-
-mock.module("../runtime/guardian-reply-router.js", () => ({
-  routeGuardianReply: routeGuardianReplyMock,
-}));
 
 // Bun's module mocks are global within the worker, so keep this mock
 // transparent when this file is not actively exercising it.
@@ -62,15 +37,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
   ) =>
     (globalThis as Record<string, unknown>)
       .__approvalConsumptionUseMockCanonicalStore
-      ? (
-          createCanonicalGuardianRequestMock as unknown as (
-            ...mockArgs: Parameters<
-              typeof realCanonicalGuardianStore.createCanonicalGuardianRequest
-            >
-          ) => ReturnType<
-            typeof realCanonicalGuardianStore.createCanonicalGuardianRequest
-          >
-        )(...args)
+      ? resolveCanonicalGuardianRequestMock()
       : realCanonicalGuardianStore.createCanonicalGuardianRequest(...args),
   generateCanonicalRequestCode: (
     ...args: Parameters<
@@ -79,15 +46,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
   ) =>
     (globalThis as Record<string, unknown>)
       .__approvalConsumptionUseMockCanonicalStore
-      ? (
-          generateCanonicalRequestCodeMock as unknown as (
-            ...mockArgs: Parameters<
-              typeof realCanonicalGuardianStore.generateCanonicalRequestCode
-            >
-          ) => ReturnType<
-            typeof realCanonicalGuardianStore.generateCanonicalRequestCode
-          >
-        )(...args)
+      ? "ABC123"
       : realCanonicalGuardianStore.generateCanonicalRequestCode(...args),
   listPendingCanonicalGuardianRequestsByDestinationConversation: (
     ...args: Parameters<
@@ -96,15 +55,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
   ) =>
     (globalThis as Record<string, unknown>)
       .__approvalConsumptionUseMockCanonicalStore
-      ? (
-          listPendingByDestinationMock as unknown as (
-            ...mockArgs: Parameters<
-              typeof realCanonicalGuardianStore.listPendingCanonicalGuardianRequestsByDestinationConversation
-            >
-          ) => ReturnType<
-            typeof realCanonicalGuardianStore.listPendingCanonicalGuardianRequestsByDestinationConversation
-          >
-        )(...args)
+      ? []
       : realCanonicalGuardianStore.listPendingCanonicalGuardianRequestsByDestinationConversation(
           ...args,
         ),
@@ -115,15 +66,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
   ) =>
     (globalThis as Record<string, unknown>)
       .__approvalConsumptionUseMockCanonicalStore
-      ? (
-          listCanonicalMock as unknown as (
-            ...mockArgs: Parameters<
-              typeof realCanonicalGuardianStore.listCanonicalGuardianRequests
-            >
-          ) => ReturnType<
-            typeof realCanonicalGuardianStore.listCanonicalGuardianRequests
-          >
-        )(...args)
+      ? []
       : realCanonicalGuardianStore.listCanonicalGuardianRequests(...args),
   resolveCanonicalGuardianRequest: (
     ...args: Parameters<
@@ -145,18 +88,21 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: registerMock,
-  getByConversation: getByConversationMock,
+  register: mock(() => {}),
+  getByConversation: mock(() => []),
   resolve: resolveMock,
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  addMessage: addMessageMock,
+  addMessage: mock(async () => ({ id: "persisted-message-id" })),
 }));
 
 mock.module("../config/loader.js", () => ({
-  getConfig: getConfigMock,
-  loadConfig: getConfigMock,
+  getConfig: () => ({
+    daemon: { standaloneRecording: false },
+    secretDetection: { customPatterns: [], entropyThreshold: 3.5 },
+  }),
+  loadConfig: () => ({}),
   loadRawConfig: () => ({}),
   saveConfig: () => {},
   saveRawConfig: () => {},
@@ -167,21 +113,14 @@ mock.module("../config/loader.js", () => ({
   API_KEY_PROVIDERS: [],
 }));
 
-mock.module("../daemon/approval-generators.js", () => ({
-  createApprovalConversationGenerator: () => async () => ({
-    disposition: "keep_pending",
-    replyText: "pending",
-  }),
-}));
-
 mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalIpcTrustContext: () => ({
+  resolveLocalTrustContext: () => ({
     trustClass: "guardian",
     sourceChannel: "vellum",
     guardianPrincipalId: "local-principal",
   }),
-  resolveLocalIpcAuthContext: () => ({
-    scope: "ipc_v1",
+  resolveLocalAuthContext: () => ({
+    scope: "local_v1",
     actorPrincipalId: "local-principal",
   }),
 }));
@@ -204,7 +143,6 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-import { handleUserMessage } from "../daemon/handlers/session-user-message.js";
 import { handleConfirmationResponse } from "../daemon/handlers/sessions.js";
 
 interface TestSession {
@@ -218,7 +156,6 @@ interface TestSession {
   denyAllPendingConfirmations: () => void;
   enqueueMessage: (...args: unknown[]) => {
     queued: boolean;
-    rejected?: boolean;
     requestId: string;
   };
   traceEmitter: { emit: (...args: unknown[]) => void };
@@ -262,16 +199,6 @@ function createContext(session: TestSession): {
   return { ctx, sent };
 }
 
-function makeMessage(content: string): UserMessage {
-  return {
-    type: "user_message",
-    sessionId: "conv-1",
-    content,
-    channel: "vellum",
-    interface: "macos",
-  };
-}
-
 function makeSession(overrides: Partial<TestSession> = {}): TestSession {
   return {
     messages: [],
@@ -298,22 +225,13 @@ function makeSession(overrides: Partial<TestSession> = {}): TestSession {
   };
 }
 
-describe("handleUserMessage pending-confirmation reply interception", () => {
+describe("handleConfirmationResponse canonical status sync", () => {
   beforeEach(() => {
     (
       globalThis as Record<string, unknown>
     ).__approvalConsumptionUseMockCanonicalStore = true;
-    routeGuardianReplyMock.mockClear();
-    createCanonicalGuardianRequestMock.mockClear();
-    generateCanonicalRequestCodeMock.mockClear();
-    listPendingByDestinationMock.mockClear();
-    listCanonicalMock.mockClear();
     resolveCanonicalGuardianRequestMock.mockClear();
-    registerMock.mockClear();
-    getByConversationMock.mockClear();
     resolveMock.mockClear();
-    addMessageMock.mockClear();
-    getConfigMock.mockClear();
   });
 
   afterAll(() => {
@@ -322,323 +240,7 @@ describe("handleUserMessage pending-confirmation reply interception", () => {
     ).__approvalConsumptionUseMockCanonicalStore = false;
   });
 
-  test("consumes decision replies before auto-deny", async () => {
-    listPendingByDestinationMock.mockReturnValue([
-      { id: "req-1", kind: "tool_approval" },
-    ]);
-    listCanonicalMock.mockReturnValue([{ id: "req-1" }]);
-    routeGuardianReplyMock.mockResolvedValue({
-      consumed: true,
-      decisionApplied: true,
-      type: "canonical_decision_applied",
-      requestId: "req-1",
-    });
-
-    const session = makeSession();
-    const { ctx, sent } = createContext(session);
-
-    await handleUserMessage(makeMessage("go for it"), ctx);
-
-    expect(routeGuardianReplyMock).toHaveBeenCalledTimes(1);
-    const routeCall = (routeGuardianReplyMock as any).mock
-      .calls[0][0] as Record<string, unknown>;
-    expect(routeCall.messageText).toBe("go for it");
-    expect(typeof routeCall.approvalConversationGenerator).toBe("function");
-    expect((session.denyAllPendingConfirmations as any).mock.calls.length).toBe(
-      0,
-    );
-    expect((session.enqueueMessage as any).mock.calls.length).toBe(0);
-    expect(session.messages).toHaveLength(2);
-    expect(session.messages[0]?.role).toBe("user");
-    expect(session.messages[1]?.role).toBe("assistant");
-    expect(addMessageMock).toHaveBeenCalledTimes(2);
-    expect(addMessageMock).toHaveBeenCalledWith(
-      "conv-1",
-      "user",
-      expect.any(String),
-      expect.objectContaining({
-        userMessageChannel: "vellum",
-        assistantMessageChannel: "vellum",
-        userMessageInterface: "macos",
-        assistantMessageInterface: "macos",
-        provenanceTrustClass: "guardian",
-      }),
-    );
-    expect(addMessageMock).toHaveBeenCalledWith(
-      "conv-1",
-      "assistant",
-      expect.stringContaining("Decision applied."),
-      expect.objectContaining({
-        userMessageChannel: "vellum",
-        assistantMessageChannel: "vellum",
-        userMessageInterface: "macos",
-        assistantMessageInterface: "macos",
-        provenanceTrustClass: "guardian",
-      }),
-    );
-    expect(sent.map((msg) => msg.type)).toEqual([
-      "message_queued",
-      "message_dequeued",
-      "assistant_text_delta",
-      "message_request_complete",
-    ]);
-    const assistantDelta = sent.find(
-      (msg): msg is Extract<ServerMessage, { type: "assistant_text_delta" }> =>
-        msg.type === "assistant_text_delta",
-    );
-    expect(assistantDelta?.text).toBe("Decision applied.");
-    const requestComplete = sent.find(
-      (
-        msg,
-      ): msg is Extract<ServerMessage, { type: "message_request_complete" }> =>
-        msg.type === "message_request_complete",
-    );
-    expect(requestComplete?.runStillActive).toBe(false);
-  });
-
-  test("consumes decision replies even when queue depth is non-zero", async () => {
-    listPendingByDestinationMock.mockReturnValue([
-      { id: "req-1", kind: "tool_approval" },
-    ]);
-    listCanonicalMock.mockReturnValue([{ id: "req-1" }]);
-    routeGuardianReplyMock.mockResolvedValue({
-      consumed: true,
-      decisionApplied: true,
-      type: "canonical_decision_applied",
-      requestId: "req-1",
-    });
-
-    const session = makeSession({
-      getQueueDepth: () => 2,
-    });
-    const { ctx } = createContext(session);
-
-    await handleUserMessage(makeMessage("approve"), ctx);
-
-    expect(routeGuardianReplyMock).toHaveBeenCalledTimes(1);
-    expect((session.denyAllPendingConfirmations as any).mock.calls.length).toBe(
-      0,
-    );
-    expect((session.enqueueMessage as any).mock.calls.length).toBe(0);
-  });
-
-  test("does not mutate in-memory history while processing", async () => {
-    listPendingByDestinationMock.mockReturnValue([
-      { id: "req-1", kind: "tool_approval" },
-    ]);
-    listCanonicalMock.mockReturnValue([{ id: "req-1" }]);
-    routeGuardianReplyMock.mockResolvedValue({
-      consumed: true,
-      decisionApplied: true,
-      type: "canonical_decision_applied",
-      requestId: "req-1",
-    });
-
-    const session = makeSession({ isProcessing: () => true });
-    const { ctx, sent } = createContext(session);
-
-    await handleUserMessage(makeMessage("approve"), ctx);
-
-    expect(addMessageMock).toHaveBeenCalledTimes(2);
-    expect(session.messages).toHaveLength(0);
-    // assistant_text_delta must NOT be sent when the session is processing —
-    // it would contaminate the agent's in-flight streaming message on the client.
-    expect(sent.some((msg) => msg.type === "assistant_text_delta")).toBe(false);
-    expect(sent.map((msg) => msg.type)).toEqual([
-      "message_queued",
-      "message_dequeued",
-      "message_request_complete",
-    ]);
-    const requestComplete = sent.find(
-      (
-        msg,
-      ): msg is Extract<ServerMessage, { type: "message_request_complete" }> =>
-        msg.type === "message_request_complete",
-    );
-    expect(requestComplete?.runStillActive).toBe(true);
-  });
-
-  test("nl keep_pending falls back to existing auto-deny + queue behavior", async () => {
-    listPendingByDestinationMock.mockReturnValue([
-      { id: "req-1", kind: "tool_approval" },
-    ]);
-    listCanonicalMock.mockReturnValue([{ id: "req-1" }]);
-    routeGuardianReplyMock.mockResolvedValue({
-      consumed: true,
-      decisionApplied: false,
-      type: "nl_keep_pending",
-      requestId: "req-1",
-      replyText: "Need clarification",
-    });
-
-    const session = makeSession();
-    const { ctx, sent } = createContext(session);
-
-    await handleUserMessage(makeMessage("what does that do?"), ctx);
-
-    expect(routeGuardianReplyMock).toHaveBeenCalledTimes(1);
-    expect((session.denyAllPendingConfirmations as any).mock.calls.length).toBe(
-      1,
-    );
-    expect((session.enqueueMessage as any).mock.calls.length).toBe(1);
-    expect(session.messages).toHaveLength(0);
-    expect(addMessageMock).toHaveBeenCalledTimes(0);
-    expect(sent.some((msg) => msg.type === "message_queued")).toBe(true);
-    expect(sent.some((msg) => msg.type === "message_dequeued")).toBe(false);
-  });
-
-  test("routes only live pending confirmation request ids", async () => {
-    const session = makeSession({
-      hasPendingConfirmation: (requestId: string) => requestId === "req-live",
-    });
-
-    getByConversationMock.mockReturnValue([
-      { requestId: "req-stale", kind: "confirmation", session: {} },
-      {
-        requestId: "req-live",
-        kind: "confirmation",
-        session: session as unknown,
-      },
-    ]);
-    listPendingByDestinationMock.mockReturnValue([
-      { id: "req-stale", kind: "tool_approval" },
-      { id: "req-live", kind: "tool_approval" },
-    ]);
-    listCanonicalMock.mockReturnValue([
-      { id: "req-stale" },
-      { id: "req-live" },
-    ]);
-    routeGuardianReplyMock.mockResolvedValue({
-      consumed: false,
-      decisionApplied: false,
-      type: "not_consumed",
-    });
-
-    const { ctx } = createContext(session);
-    await handleUserMessage(makeMessage("allow"), ctx);
-
-    expect(routeGuardianReplyMock).toHaveBeenCalledTimes(1);
-    const routeCall = (routeGuardianReplyMock as any).mock
-      .calls[0][0] as Record<string, unknown>;
-    expect(routeCall.pendingRequestIds).toEqual(["req-live"]);
-    // Auto-deny clears matching confirmation entries from pending-interactions
-    // so stale IDs are not reused as routing candidates. Only the live
-    // session-scoped interaction should be resolved.
-    expect(resolveMock).toHaveBeenCalledTimes(1);
-    expect(resolveMock).toHaveBeenCalledWith("req-live");
-    expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledTimes(1);
-    expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledWith(
-      "req-live",
-      "pending",
-      { status: "denied" },
-    );
-  });
-
-  test("registers IPC confirmation events for NL approval routing", async () => {
-    const session = makeSession({
-      hasAnyPendingConfirmation: () => false,
-      enqueueMessage: mock(() => ({ queued: false, requestId: "direct-id" })),
-      processMessage: async (_content, _attachments, onEvent) => {
-        (onEvent as (msg: ServerMessage) => void)({
-          type: "confirmation_request",
-          requestId: "req-confirm-1",
-          toolName: "call_start",
-          input: { phone_number: "+18084436762" },
-          riskLevel: "high",
-          executionTarget: "host",
-          allowlistOptions: [],
-          scopeOptions: [],
-          persistentDecisionsAllowed: false,
-        } as ServerMessage);
-        return "msg-id";
-      },
-    });
-    const { ctx, sent } = createContext(session);
-
-    await handleUserMessage(makeMessage("please call now"), ctx);
-
-    expect(registerMock).toHaveBeenCalledTimes(1);
-    expect(registerMock).toHaveBeenCalledWith(
-      "req-confirm-1",
-      expect.objectContaining({
-        conversationId: "conv-1",
-        kind: "confirmation",
-        session,
-        confirmationDetails: expect.objectContaining({
-          toolName: "call_start",
-          riskLevel: "high",
-          executionTarget: "host",
-        }),
-      }),
-    );
-    expect(createCanonicalGuardianRequestMock).toHaveBeenCalledTimes(1);
-    expect(createCanonicalGuardianRequestMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: "req-confirm-1",
-        kind: "tool_approval",
-        sourceType: "desktop",
-        sourceChannel: "vellum",
-        conversationId: "conv-1",
-        toolName: "call_start",
-        status: "pending",
-        requestCode: "ABC123",
-      }),
-    );
-    expect(sent.some((event) => event.type === "confirmation_request")).toBe(
-      true,
-    );
-  });
-
-  test("registers IPC confirmation events emitted via session sender (prompter path)", async () => {
-    let currentSender: (msg: ServerMessage) => void = () => {};
-    const session = makeSession({
-      hasAnyPendingConfirmation: () => false,
-      enqueueMessage: mock(() => ({ queued: false, requestId: "direct-id" })),
-      updateClient: (sendToClient: (msg: ServerMessage) => void) => {
-        currentSender = sendToClient;
-      },
-      processMessage: async () => {
-        currentSender({
-          type: "confirmation_request",
-          requestId: "req-prompter-1",
-          toolName: "call_start",
-          input: { phone_number: "+18084436762" },
-          riskLevel: "high",
-          executionTarget: "host",
-          allowlistOptions: [],
-          scopeOptions: [],
-          persistentDecisionsAllowed: false,
-        } as ServerMessage);
-        return "msg-id";
-      },
-    });
-    const { ctx, sent } = createContext(session);
-
-    await handleUserMessage(makeMessage("please call now"), ctx);
-
-    expect(registerMock).toHaveBeenCalledWith(
-      "req-prompter-1",
-      expect.objectContaining({
-        conversationId: "conv-1",
-        kind: "confirmation",
-        session,
-      }),
-    );
-    expect(createCanonicalGuardianRequestMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: "req-prompter-1",
-        kind: "tool_approval",
-        sourceType: "desktop",
-        sourceChannel: "vellum",
-        conversationId: "conv-1",
-      }),
-    );
-    expect(sent.some((event) => event.type === "confirmation_request")).toBe(
-      true,
-    );
-  });
-
-  test("syncs canonical status to approved for IPC allow decisions", () => {
+  test("syncs canonical status to approved for allow decisions", () => {
     const session = {
       hasPendingConfirmation: (requestId: string) =>
         requestId === "req-confirm-allow",
@@ -676,7 +278,7 @@ describe("handleUserMessage pending-confirmation reply interception", () => {
     expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
   });
 
-  test("syncs canonical status to denied for IPC deny decisions in CU sessions", () => {
+  test("syncs canonical status to denied for deny decisions in CU sessions", () => {
     const cuSession = {
       hasPendingConfirmation: (requestId: string) =>
         requestId === "req-confirm-deny",