@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/sync-message-contract.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildSyncChangedMessage,
+  conversationMessagesSyncTag,
+  type ServerMessage,
+  SYNC_TAGS,
+  SyncChangedMessageSchema,
+} from "../daemon/message-protocol.js";
+
+describe("sync message contract", () => {
+  test("sync_changed is assignable to ServerMessage", () => {
+    const message: ServerMessage = {
+      type: "sync_changed",
+      tags: [SYNC_TAGS.assistantAvatar],
+    };
+
+    expect(message).toEqual({
+      type: "sync_changed",
+      tags: [SYNC_TAGS.assistantAvatar],
+    });
+  });
+
+  test("buildSyncChangedMessage dedupes tags", () => {
+    const message = buildSyncChangedMessage([
+      SYNC_TAGS.assistantAvatar,
+      SYNC_TAGS.assistantAvatar,
+      conversationMessagesSyncTag("conversation-123"),
+    ]);
+
+    expect(message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.assistantAvatar,
+        "conversation:conversation-123:messages",
+      ],
+    });
+  });
+
+  test("schema rejects malformed sync_changed payloads", () => {
+    expect(() =>
+      SyncChangedMessageSchema.parse({
+        type: "sync_changed",
+        tags: [],
+      }),
+    ).toThrow();
+
+    expect(() =>
+      SyncChangedMessageSchema.parse({
+        type: "sync_changed",
+        tags: [""],
+      }),
+    ).toThrow();
+
+    expect(() =>
+      SyncChangedMessageSchema.parse({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+        cursor: 1,
+      }),
+    ).toThrow();
+  });
+});

package/src/__tests__/task-scheduler.test.ts

@@ -7,6 +7,57 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// Mock the shared `runBackgroundJob` runner so the scheduler's fresh-bootstrap
+// talk-mode path stays observable. Each invocation creates a new conversation
+// row and pushes the prompt onto the per-test handler set via
+// `onRunBackgroundJobCall`. `run_task:` schedules use a different code path
+// and do not invoke this runner.
+let onRunBackgroundJobCall:
+  | ((info: {
+      conversationId: string;
+      prompt: string;
+      trustContext: { sourceChannel: string; trustClass: string };
+    }) => void)
+  | null = null;
+mock.module("../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: {
+    prompt: string;
+    groupId?: string;
+    trustContext: { sourceChannel: string; trustClass: string };
+  }) => {
+    const { createConversation } =
+      await import("../memory/conversation-crud.js");
+    const conv = createConversation({
+      title: "(test stub)",
+      conversationType: "background",
+      source: "schedule",
+      ...(opts.groupId ? { groupId: opts.groupId } : {}),
+    });
+    onRunBackgroundJobCall?.({
+      conversationId: conv.id,
+      prompt: opts.prompt,
+      trustContext: opts.trustContext,
+    });
+    return { conversationId: conv.id, ok: true };
+  },
+}));
+
+// Capture `emitNotificationSignal` calls so tests can assert that scheduled
+// task failures surface via the notification pipeline (home feed + native).
+const emitNotificationCalls: Array<Record<string, unknown>> = [];
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (params: Record<string, unknown>) => {
+    emitNotificationCalls.push(params);
+    return {
+      signalId: "stub-signal",
+      deduplicated: false,
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    };
+  },
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
@@ -111,6 +162,8 @@ describe("scheduler run_task detection", () => {
     db.run("DELETE FROM tasks");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
+    onRunBackgroundJobCall = null;
+    emitNotificationCalls.length = 0;
   });
 
   test("run_task:<id> messages trigger runTask instead of processMessage", async () => {
@@ -163,7 +216,7 @@ describe("scheduler run_task detection", () => {
     expect(typeof runTaskCalls[0].options?.taskRunId).toBe("string");
   });
 
-  test("regular messages still go through processMessage normally", async () => {
+  test("regular messages route through the runBackgroundJob runner", async () => {
     // Create a regular schedule (no run_task: prefix)
     const schedule = createSchedule({
       name: "Regular Schedule",
@@ -174,36 +227,32 @@ describe("scheduler run_task detection", () => {
 
     forceScheduleDue(schedule.id);
 
-    const processedMessages: Array<{
+    const runnerCalls: Array<{
       conversationId: string;
-      message: string;
-      options?: { trustClass?: string; taskRunId?: string };
+      prompt: string;
+      trustContext: { sourceChannel: string; trustClass: string };
     }> = [];
-    const processMessage = async (
-      conversationId: string,
-      message: string,
-      options?: { trustClass?: string; taskRunId?: string },
-    ) => {
-      processedMessages.push({ conversationId, message, options });
+    onRunBackgroundJobCall = (info) => {
+      runnerCalls.push(info);
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
 
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    // processMessage should have been called with the regular message
-    expect(
-      processedMessages.some((m) => m.message === "Do something normal"),
-    ).toBe(true);
-    expect(
-      processedMessages.some(
-        (m) =>
-          m.message === "Do something normal" &&
-          m.options?.trustClass === "guardian" &&
-          m.options?.taskRunId === undefined,
-      ),
-    ).toBe(true);
+    // The runner should have been invoked with the schedule message and a
+    // guardian trust context, mirroring the historical inline `processMessage`
+    // call that the migration replaced.
+    expect(runnerCalls.length).toBe(1);
+    expect(runnerCalls[0].prompt).toBe("Do something normal");
+    expect(runnerCalls[0].trustContext).toEqual({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    });
   });
 
   test("handles task not found gracefully", async () => {
@@ -232,5 +281,21 @@ describe("scheduler run_task detection", () => {
     expect(runs.length).toBeGreaterThanOrEqual(1);
     expect(runs[0].status).toBe("error");
     expect(runs[0].error).toContain("Task not found");
+
+    // Failed scheduled tasks must surface via the notification pipeline so
+    // they reach the home feed and native macOS notifications. The shape
+    // mirrors what `runBackgroundJob` emits for its own failures.
+    const failureSignal = emitNotificationCalls.find(
+      (p) => p.sourceEventName === "activity.failed",
+    );
+    expect(failureSignal).toBeDefined();
+    expect(failureSignal?.sourceChannel).toBe("scheduler");
+    const payload = failureSignal?.contextPayload as Record<string, unknown>;
+    expect(payload.jobName).toBe("task:nonexistent-task-id");
+    expect(payload.errorKind).toBe("exception");
+    expect(typeof payload.errorMessage).toBe("string");
+    expect(failureSignal?.dedupeKey).toMatch(
+      /^activity-failed:task:nonexistent-task-id:\d{4}-\d{2}-\d{2}$/,
+    );
   });
 });

package/src/__tests__/tool-execution-pipeline.benchmark.test.ts

@@ -30,16 +30,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Allow toggling between no-rule and matched-rule paths
-let mockRuleResponse: import("../permissions/types.js").TrustRule | null = null;
-
-mock.module("../permissions/trust-store.js", () => ({
-  addRule: () => {},
-  findHighestPriorityRule: () => mockRuleResponse,
-  onRulesChanged: () => {},
-  clearCache: () => {},
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
@@ -302,38 +292,6 @@ describe("Tool execution pipeline benchmark", () => {
     expect(results[0].decision).toBe("allow");
   });
 
-  test("check: matched allow-rule path for medium-risk tool", async () => {
-    // Exercise the code path where findHighestPriorityRule returns a matching
-    // allow rule, rather than always falling through to the no-rule default.
-    mockRuleResponse = {
-      id: "bench:allow-file_write",
-      tool: "file_write",
-      pattern: "**",
-      scope: "/tmp",
-      decision: "allow",
-      priority: 90,
-      createdAt: Date.now(),
-    };
-
-    try {
-      const { timings, results } = await benchmarkAsync(
-        () => check("file_write", { path: "/tmp/out.txt" }, "/tmp"),
-        ITERATIONS,
-      );
-
-      const p50 = percentile(timings, 50);
-      const p95 = percentile(timings, 95);
-
-      expect(p50).toBeLessThan(10);
-      expect(p95).toBeLessThan(20);
-      // Medium-risk with a matching allow rule should auto-allow
-      expect(results[0].decision).toBe("allow");
-      expect(results[0].matchedRule?.id).toBe("bench:allow-file_write");
-    } finally {
-      mockRuleResponse = null;
-    }
-  });
-
   test("check: permission cost is stable across different input paths", async () => {
     // Verify that the permission check cost doesn't vary with input path length/complexity.
     // Actual tool-execution-time independence is tested in the ToolExecutor section below.

package/src/__tests__/tool-executor.test.ts

@@ -73,6 +73,11 @@ let cachedAssessmentOverride:
       riskLevel: string;
       reason: string;
       scopeOptions: Array<{ pattern: string; label: string }>;
+      allowlistOptions?: Array<{
+        label: string;
+        description: string;
+        pattern: string;
+      }>;
       directoryScopeOptions?: Array<{ scope: string; label: string }>;
       matchType: string;
     }
@@ -202,6 +207,32 @@ describe("ToolExecutor allowedToolNames gating", () => {
     expect(result.content).toBe("ok");
   });
 
+  test("canonicalizes app-builder create_app alias before active-tool gating", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["app_create"]);
+    const result = await executor.execute(
+      "create_app",
+      { name: "Calculator" },
+      makeContext({ allowedToolNames: allowed }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("ok");
+  });
+
+  test("preserves exact active create_app tool before applying compatibility aliases", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["create_app", "app_create"]);
+    const result = await executor.execute(
+      "create_app",
+      { name: "Custom App" },
+      makeContext({ allowedToolNames: allowed }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(lastCheckArgs?.toolName).toBe("create_app");
+  });
+
   test("blocks execution when tool is NOT in the allowed set", async () => {
     const executor = new ToolExecutor(makePrompter());
     const allowed = new Set(["file_read", "bash"]);
@@ -1123,4 +1154,128 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
       { scope: "/tmp", label: "Anywhere in tmp/" },
     ]);
   });
+
+  test("auto-approved tool result includes riskAllowlistOptions when classifier emits them (Minimatch-glob shape for save path)", async () => {
+    cachedAssessmentOverride = {
+      riskLevel: "medium",
+      reason: "Reads workspace files",
+      // Display ladder (regex shape — not for save).
+      scopeOptions: [
+        { pattern: "^echo\\b.*hello$", label: "echo hello" },
+        { pattern: "^echo\\b", label: "echo *" },
+      ],
+      // Save ladder (Minimatch-glob shape — what gateway matches against).
+      allowlistOptions: [
+        {
+          label: "echo hello",
+          description: "This exact command",
+          pattern: "echo hello",
+        },
+        {
+          label: "echo *",
+          description: "Any echo command",
+          pattern: "action:echo",
+        },
+      ],
+      matchType: "registry",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_read",
+      { path: "README.md" },
+      makeContext({ requireFreshApproval: true }),
+    );
+
+    expect(result.isError).toBe(false);
+    // Both shapes flow through independently — same labels, different patterns.
+    expect(result.riskScopeOptions).toEqual([
+      { pattern: "^echo\\b.*hello$", label: "echo hello" },
+      { pattern: "^echo\\b", label: "echo *" },
+    ]);
+    expect(result.riskAllowlistOptions).toEqual([
+      {
+        label: "echo hello",
+        description: "This exact command",
+        pattern: "echo hello",
+      },
+      {
+        label: "echo *",
+        description: "Any echo command",
+        pattern: "action:echo",
+      },
+    ]);
+  });
+
+  test("riskAllowlistOptions is undefined when classifier did not produce allowlist (e.g. web-risk classifier)", async () => {
+    cachedAssessmentOverride = {
+      riskLevel: "low",
+      reason: "GET request to public URL",
+      scopeOptions: [{ pattern: "https://example.com/.*", label: "example.com" }],
+      // allowlistOptions intentionally omitted — some classifiers don't emit them.
+      matchType: "registry",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_read",
+      { path: "README.md" },
+      makeContext({ requireFreshApproval: true }),
+    );
+
+    expect(result.isError).toBe(false);
+    // Display ladder still flows; save ladder is absent so the client must
+    // fall back to a synthesized option (or omit save).
+    expect(result.riskScopeOptions).toEqual([
+      { pattern: "https://example.com/.*", label: "example.com" },
+    ]);
+    expect(result.riskAllowlistOptions).toBeUndefined();
+  });
+
+  test("riskAllowlistOptions is undefined when no classifier ran (MCP tools)", async () => {
+    // cachedAssessmentOverride is undefined — no classifier ran.
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_read",
+      { path: "README.md" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.riskScopeOptions).toBeUndefined();
+    expect(result.riskAllowlistOptions).toBeUndefined();
+  });
+
+  test("denied tool result still carries riskAllowlistOptions for the rule editor save path", async () => {
+    checkResultOverride = { decision: "deny", reason: "Blocked by deny rule" };
+    cachedAssessmentOverride = {
+      riskLevel: "high",
+      reason: "Recursive force delete",
+      scopeOptions: [{ pattern: "^rm\\s+-rf", label: "rm -rf *" }],
+      allowlistOptions: [
+        {
+          label: "rm -rf *",
+          description: "Any rm -rf command",
+          pattern: "action:rm",
+        },
+      ],
+      matchType: "registry",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_read",
+      { path: "anything" },
+      makeContext({ requireFreshApproval: true }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.riskAllowlistOptions).toEqual([
+      {
+        label: "rm -rf *",
+        description: "Any rm -rf command",
+        pattern: "action:rm",
+      },
+    ]);
+  });
 });