@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/channel-approval-routes.test.ts

@@ -325,7 +325,9 @@ describe("inbound callback metadata triggers decision handling", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cb-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-cb-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -362,7 +364,9 @@ describe("inbound callback metadata triggers decision handling", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cb-2", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-cb-2", "deny", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -410,7 +414,9 @@ describe("inbound text matching approval phrases triggers decision handling", ()
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-txt-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-txt-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -554,7 +560,9 @@ describe("empty content with callbackData bypasses validation", () => {
     const body = (await res.json()) as Record<string, unknown>;
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-empty-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-empty-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -696,7 +704,9 @@ describe("callback requestId validation", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-match", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-match", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -730,7 +740,9 @@ describe("callback requestId validation", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-plaintext", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-plaintext", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -933,7 +945,9 @@ describe("plain-text channel approval decisions", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-pt-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-pt-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -966,7 +980,9 @@ describe("plain-text channel approval decisions", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-pt-2", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-pt-2", "deny", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1098,7 +1114,9 @@ describe("guardian decision scoping — multiple pending approvals", () => {
     expect(body.approval).toBe("guardian_decision_applied");
 
     // The older request's session should have been called
-    expect(olderSession).toHaveBeenCalledWith("req-older", "allow");
+    expect(olderSession).toHaveBeenCalledWith("req-older", "allow", {
+      decisionContext: undefined,
+    });
 
     // The newer request's session should NOT have been called
     expect(newerSession).not.toHaveBeenCalled();
@@ -1244,7 +1262,9 @@ describe("expired guardian approval auto-denies via sweep", () => {
     await new Promise((resolve) => setTimeout(resolve, 10));
 
     // The session should have been denied
-    expect(sessionMock).toHaveBeenCalledWith("req-exp-1", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-exp-1", "deny", {
+      decisionContext: undefined,
+    });
 
     // Both requester and guardian should have been notified
     const requesterNotify = deliverSpy.mock.calls.filter(
@@ -1457,7 +1477,9 @@ describe("conversational approval engine — standard path", () => {
     expect(body.approval).toBe("decision_applied");
 
     // The session should have received an allow decision
-    expect(sessionMock).toHaveBeenCalledWith("req-conv-2", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-conv-2", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1504,7 +1526,9 @@ describe("conversational approval engine — standard path", () => {
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
 
-    expect(sessionMock).toHaveBeenCalledWith("req-conv-3", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-conv-3", "deny", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1556,7 +1580,9 @@ describe("conversational approval engine — standard path", () => {
 
     // The callback button should have been used directly, not the engine
     expect(mockConversationGenerator).not.toHaveBeenCalled();
-    expect(sessionMock).toHaveBeenCalledWith("req-conv-4", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-conv-4", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1705,7 +1731,9 @@ describe("guardian conversational approval via conversation engine", () => {
     expect(body.approval).toBe("guardian_decision_applied");
 
     // The session should have received an 'allow' decision
-    expect(sessionMock).toHaveBeenCalledWith("req-gnlp-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-gnlp-1", "allow", {
+      decisionContext: undefined,
+    });
 
     // The approval record should have been updated (no longer pending)
     const pending = getAllPendingApprovalsByGuardianChat(
@@ -2097,7 +2125,9 @@ describe("requester cancel of guardian-gated pending request", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cancel-1", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-cancel-1", "deny", {
+      decisionContext: undefined,
+    });
 
     // Requester should have been notified
     const requesterReply = deliverSpy.mock.calls.find(
@@ -2178,7 +2208,9 @@ describe("requester cancel of guardian-gated pending request", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cancel-2", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-cancel-2", "deny", {
+      decisionContext: undefined,
+    });
 
     // Engine should have been called with reject-only allowed actions
     expect(mockConversationGenerator).toHaveBeenCalledTimes(1);
@@ -2605,7 +2637,6 @@ describe("background channel processing approval prompts", () => {
       async (
         conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });
@@ -2666,7 +2697,6 @@ describe("background channel processing approval prompts", () => {
       async (
         conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });
@@ -2724,7 +2754,6 @@ describe("background channel processing approval prompts", () => {
       async (
         _conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });
@@ -2765,7 +2794,6 @@ describe("background channel processing approval prompts", () => {
       async (
         conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });

package/src/__tests__/channel-approvals.test.ts

@@ -240,6 +240,7 @@ describe("handleChannelDecision", () => {
     expect(mockConv.handleConfirmationResponse).toHaveBeenCalledWith(
       "req-1",
       "allow",
+      { decisionContext: undefined },
     );
   });
 
@@ -257,6 +258,7 @@ describe("handleChannelDecision", () => {
     expect(mockConv.handleConfirmationResponse).toHaveBeenCalledWith(
       "req-1",
       "deny",
+      { decisionContext: undefined },
     );
   });
 
@@ -277,6 +279,7 @@ describe("handleChannelDecision", () => {
     expect(newerMock.handleConfirmationResponse).toHaveBeenCalledWith(
       "req-newer",
       "allow",
+      { decisionContext: undefined },
     );
     expect(olderMock.handleConfirmationResponse).not.toHaveBeenCalled();
   });
@@ -293,7 +296,6 @@ describe("handleChannelDecision", () => {
     expect(result.applied).toBe(false);
     expect(result.requestId).toBeUndefined();
   });
-
 });
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/__tests__/channel-invite-transport.test.ts

@@ -7,11 +7,7 @@
  * canonical registry APIs (`createInviteAdapterRegistry`,
  * `getInviteAdapterRegistry`) that replaced the deprecated shims.
  */
-import { describe, expect, mock, test } from "bun:test";
-
-mock.module("../email/feature-gate.js", () => ({
-  isEmailEnabled: () => true,
-}));
+import { describe, expect, test } from "bun:test";
 
 import {
   type ChannelInviteAdapter,

package/src/__tests__/channel-readiness-routes.test.ts

@@ -58,10 +58,6 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? null,
 }));
 
-mock.module("../email/feature-gate.js", () => ({
-  isEmailEnabled: () => true,
-}));
-
 // ---------------------------------------------------------------------------
 // Import under test
 // ---------------------------------------------------------------------------

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -47,10 +47,6 @@ mock.module("../calls/twilio-config.js", () => ({
   resolveTwilioPhoneNumber: () => undefined,
 }));
 
-mock.module("../email/feature-gate.js", () => ({
-  isEmailEnabled: () => false,
-}));
-
 mock.module("./channel-invite-transports/whatsapp.js", () => ({
   resolveWhatsAppDisplayNumber: () => undefined,
 }));
@@ -83,9 +79,8 @@ afterEach(() => {
 });
 
 async function runSlackRemoteProbe() {
-  const { createReadinessService } = await import(
-    "../runtime/channel-readiness-service.js"
-  );
+  const { createReadinessService } =
+    await import("../runtime/channel-readiness-service.js");
   const service = createReadinessService();
   return service.getReadiness("slack", true);
 }

package/src/__tests__/channel-retry-sweep.test.ts

@@ -213,29 +213,27 @@ describe("channel-retry-sweep", () => {
           }
         | undefined;
 
-      await sweepFailedEvents(
-        async (conversationId, _content, _attachmentIds, options) => {
-          capturedOptions = options as {
-            trustContext?: {
-              trustClass?: string;
-              guardianPrincipalId?: string;
-            };
-            isInteractive?: boolean;
+      await sweepFailedEvents(async (conversationId, _content, options) => {
+        capturedOptions = options as {
+          trustContext?: {
+            trustClass?: string;
+            guardianPrincipalId?: string;
           };
-          const messageId = `message-${c.trustClass}`;
-          const db = getDb();
-          db.insert(messages)
-            .values({
-              id: messageId,
-              conversationId,
-              role: "user",
-              content: JSON.stringify([{ type: "text", text: "retry me" }]),
-              createdAt: Date.now(),
-            })
-            .run();
-          return { messageId };
-        },
-      );
+          isInteractive?: boolean;
+        };
+        const messageId = `message-${c.trustClass}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      });
 
       expect(capturedOptions?.trustContext?.trustClass).toBe(c.trustClass);
       expect(capturedOptions?.trustContext?.guardianPrincipalId).toBe(
@@ -263,23 +261,21 @@ describe("channel-retry-sweep", () => {
       const eventId = seedFailedEventWithActorRoleOnly(actorRole);
       let processMessageCalled = false;
 
-      await sweepFailedEvents(
-        async (conversationId, _content, _attachmentIds, _options) => {
-          processMessageCalled = true;
-          const messageId = `message-legacy-${actorRole}`;
-          const db = getDb();
-          db.insert(messages)
-            .values({
-              id: messageId,
-              conversationId,
-              role: "user",
-              content: JSON.stringify([{ type: "text", text: "retry me" }]),
-              createdAt: Date.now(),
-            })
-            .run();
-          return { messageId };
-        },
-      );
+      await sweepFailedEvents(async (conversationId, _content, _options) => {
+        processMessageCalled = true;
+        const messageId = `message-legacy-${actorRole}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      });
 
       // Legacy payloads with trustCtx that can't be parsed into canonical form
       // must be marked as failed to prevent privilege escalation — processMessage
@@ -301,23 +297,21 @@ describe("channel-retry-sweep", () => {
     const eventId = seedFailedEventWithTrustClass("invalid_value");
     let processMessageCalled = false;
 
-    await sweepFailedEvents(
-      async (conversationId, _content, _attachmentIds, _options) => {
-        processMessageCalled = true;
-        const messageId = "message-invalid";
-        const db = getDb();
-        db.insert(messages)
-          .values({
-            id: messageId,
-            conversationId,
-            role: "user",
-            content: JSON.stringify([{ type: "text", text: "retry me" }]),
-            createdAt: Date.now(),
-          })
-          .run();
-        return { messageId };
-      },
-    );
+    await sweepFailedEvents(async (conversationId, _content, _options) => {
+      processMessageCalled = true;
+      const messageId = "message-invalid";
+      const db = getDb();
+      db.insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
 
     // trustCtx was present but couldn't be parsed (invalid trustClass),
     // so the event must be failed rather than processed without trust context.
@@ -361,25 +355,23 @@ describe("channel-retry-sweep", () => {
         }
       | undefined;
 
-    await sweepFailedEvents(
-      async (conversationId, _content, _attachmentIds, options) => {
-        capturedOptions = options as {
-          trustContext?: { trustClass?: string; sourceChannel?: string };
-          isInteractive?: boolean;
-        };
-        const messageId = "message-no-ctx";
-        db.insert(messages)
-          .values({
-            id: messageId,
-            conversationId,
-            role: "user",
-            content: JSON.stringify([{ type: "text", text: "retry me" }]),
-            createdAt: Date.now(),
-          })
-          .run();
-        return { messageId };
-      },
-    );
+    await sweepFailedEvents(async (conversationId, _content, options) => {
+      capturedOptions = options as {
+        trustContext?: { trustClass?: string; sourceChannel?: string };
+        isInteractive?: boolean;
+      };
+      const messageId = "message-no-ctx";
+      db.insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
 
     // When trustCtx is absent, the sweep synthesizes an explicit 'unknown'
     // trust context to prevent downstream defaults from granting guardian trust.
@@ -421,7 +413,7 @@ describe("channel-retry-sweep", () => {
     };
 
     let processMessageCalls = 0;
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       processMessageCalls++;
       options?.onEvent?.({
         type: "message_complete",
@@ -487,7 +479,7 @@ describe("channel-retry-sweep", () => {
       .where(eq(channelInboundEvents.id, inbound.eventId))
       .run();
 
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
         text: "Already delivered live response.",
@@ -590,7 +582,7 @@ describe("channel-retry-sweep", () => {
       ts: "1700000000.000044",
     });
 
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
         text: "Live retry response.",
@@ -686,7 +678,7 @@ describe("channel-retry-sweep", () => {
       throw new Error("fetch failed before progress callback");
     };
 
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
         text: "Live retry response.",

package/src/__tests__/circuit-breaker-pipeline.test.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for the `circuitBreaker` plugin pipeline.
  *
- * The default plugin (`plugins/defaults/circuit-breaker.ts`) replaces the
+ * The default plugin (`plugins/defaults/circuit-breaker/register.ts`) replaces the
  * inline compaction circuit-breaker logic that previously lived in
  * `daemon/conversation-agent-loop.ts`. These tests exercise the default
  * plugin through the pipeline runner and assert the threshold (3 consecutive
@@ -30,8 +30,8 @@ import type { TrustContext } from "../daemon/trust-context.js";
 import {
   COMPACTION_CIRCUIT_COOLDOWN_MS,
   COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
-  defaultCircuitBreakerPlugin,
-} from "../plugins/defaults/circuit-breaker.js";
+} from "../plugins/defaults/circuit-breaker/middlewares/circuitBreaker.js";
+import { defaultCircuitBreakerPlugin } from "../plugins/defaults/circuit-breaker/register.js";
 import { runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,

package/src/__tests__/clawhub-files.test.ts

@@ -291,6 +291,7 @@ describe("toSlimSkill", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.status).toBe("available");
     expect(slim!.origin).toBe("clawhub");
+    expect(slim!.category).toBe("knowledge");
 
     // Clawhub-specific fields
     const clawhub = slim as unknown as Record<string, unknown>;

package/src/__tests__/compaction-events.test.ts

@@ -10,12 +10,8 @@
  */
 import { describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  AgentLoopConfig,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
@@ -221,11 +217,8 @@ mock.module("../memory/auto-analysis-enqueue.js", () => ({
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
-    constructor(
-      _provider: unknown,
-      _systemPrompt: string,
-      _config?: Partial<AgentLoopConfig>,
-    ) {}
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
     getToolTokenBudget() {
       return 0;
     }
@@ -238,11 +231,6 @@ mock.module("../agent/loop.js", () => ({
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }
@@ -301,11 +289,11 @@ function makeConversation(
     id,
     makeProvider(),
     "system prompt",
-    4096,
     (msg) => {
       collected.push(msg);
     },
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 

package/src/__tests__/compaction-pipeline.test.ts

@@ -20,7 +20,7 @@ import type { TrustContext } from "../daemon/trust-context.js";
 import {
   DEFAULT_COMPACTION_PLUGIN_NAME,
   defaultCompactionTerminal,
-} from "../plugins/defaults/compaction.js";
+} from "../plugins/defaults/compaction/terminal.js";
 import { runPipeline } from "../plugins/pipeline.js";
 import {
   type CompactionArgs,