@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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

@@ -5,7 +5,7 @@ import {
   conversationMessagesSyncTag,
   type ServerMessage,
   SYNC_TAGS,
-  SyncChangedMessageSchema,
+  SyncChangedEventSchema,
 } from "../daemon/message-protocol.js";
 
 describe("sync message contract", () => {
@@ -39,26 +39,32 @@ describe("sync message contract", () => {
 
   test("schema rejects malformed sync_changed payloads", () => {
     expect(() =>
-      SyncChangedMessageSchema.parse({
+      SyncChangedEventSchema.parse({
         type: "sync_changed",
         tags: [],
       }),
     ).toThrow();
 
     expect(() =>
-      SyncChangedMessageSchema.parse({
+      SyncChangedEventSchema.parse({
         type: "sync_changed",
         tags: [""],
       }),
     ).toThrow();
+  });
 
-    expect(() =>
-      SyncChangedMessageSchema.parse({
-        type: "sync_changed",
-        tags: [SYNC_TAGS.assistantAvatar],
-        cursor: 1,
-      }),
-    ).toThrow();
+  test("schema strips unknown server-stamped fields", () => {
+    const parsed = SyncChangedEventSchema.parse({
+      type: "sync_changed",
+      tags: [SYNC_TAGS.assistantAvatar],
+      cursor: 1,
+    });
+
+    expect(parsed).toEqual({
+      type: "sync_changed",
+      tags: [SYNC_TAGS.assistantAvatar],
+    });
+    expect("cursor" in parsed).toBe(false);
   });
 
   test("buildSyncChangedMessage includes originClientId when provided", () => {
@@ -85,10 +91,7 @@ describe("sync message contract", () => {
   });
 
   test("buildSyncChangedMessage trims and drops blank originClientId", () => {
-    const blank = buildSyncChangedMessage(
-      [SYNC_TAGS.assistantAvatar],
-      "   ",
-    );
+    const blank = buildSyncChangedMessage([SYNC_TAGS.assistantAvatar], "   ");
     expect("originClientId" in blank).toBe(false);
 
     const trimmed = buildSyncChangedMessage(
@@ -104,7 +107,7 @@ describe("sync message contract", () => {
 
   test("schema accepts a string originClientId and rejects non-string types", () => {
     expect(() =>
-      SyncChangedMessageSchema.parse({
+      SyncChangedEventSchema.parse({
         type: "sync_changed",
         tags: [SYNC_TAGS.assistantAvatar],
         originClientId: "client-abc",
@@ -112,7 +115,7 @@ describe("sync message contract", () => {
     ).not.toThrow();
 
     expect(() =>
-      SyncChangedMessageSchema.parse({
+      SyncChangedEventSchema.parse({
         type: "sync_changed",
         tags: [SYNC_TAGS.assistantAvatar],
         originClientId: 42,

package/src/__tests__/system-prompt.test.ts

@@ -89,6 +89,24 @@ mock.module("../prompts/persona-resolver.js", () => ({
   resolveGuardianPersona: () => mockPersona.guardianPersona,
 }));
 
+const mockOauthConnections: Array<{
+  provider: string;
+  status: string;
+  accountInfo?: string | null;
+}> = [];
+const mockManagedConnections: Array<{
+  provider: string;
+  accountInfo?: string | null;
+}> = [];
+
+mock.module("../oauth/oauth-store.js", () => ({
+  listConnections: () => mockOauthConnections,
+}));
+
+mock.module("../credential-execution/managed-catalog.js", () => ({
+  getCachedManagedConnections: () => mockManagedConnections,
+}));
+
 // Import after mock
 const { buildSystemPrompt, ensurePromptFiles, stripCommentLines } =
   await import("../prompts/system-prompt.js");
@@ -100,6 +118,8 @@ describe("buildSystemPrompt", () => {
     // no-guardian baseline.
     mockPersona.userSlug = null;
     mockPersona.guardianPersona = null;
+    mockOauthConnections.length = 0;
+    mockManagedConnections.length = 0;
   });
 
   afterEach(() => {
@@ -152,6 +172,40 @@ describe("buildSystemPrompt", () => {
     expect(identityIdx).toBeLessThan(soulIdx);
   });
 
+  test("renders runtime-computed dynamic sections after workspace-only static sections", () => {
+    const systemPromptsDir = join(TEST_DIR, "prompts", "system");
+    mkdirSync(systemPromptsDir, { recursive: true });
+    writeFileSync(
+      join(systemPromptsDir, "99-org-policy.md"),
+      "# Org policy\n\nMostly static workspace policy.\n",
+    );
+    mockManagedConnections.push({
+      provider: "google",
+      accountInfo: "user@example.com",
+    });
+
+    const result = buildSystemPrompt();
+
+    const staticIdx = result.indexOf("Mostly static workspace policy.");
+    const dynamicIdx = result.indexOf("# Connected Services");
+    expect(staticIdx).toBeGreaterThan(-1);
+    expect(dynamicIdx).toBeGreaterThan(-1);
+    expect(dynamicIdx).toBeGreaterThan(staticIdx);
+  });
+
+  test("side-chain prompt options still include IDENTITY.md and SOUL.md", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "# Identity\n\nI am Vellum.");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "# Soul\n\nBe thoughtful.");
+
+    const result = buildSystemPrompt({
+      excludeBootstrap: true,
+      excludeCustomPrefix: true,
+    });
+
+    expect(result).toContain("# Identity\n\nI am Vellum.");
+    expect(result).toContain("# Soul\n\nBe thoughtful.");
+  });
+
   test("ignores empty SOUL.md", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "   \n  \n  ");
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "# Identity\n\nI am Vellum.");
@@ -619,6 +673,26 @@ describe("buildSystemPrompt", () => {
       expect(result).toContain("Batch independent tool calls");
     });
 
+    test("bundled communication section renders and sorts before the parallel-tool-calls block", () => {
+      // `01-communication` sorts ahead of `01-parallel-tool-calls`, so the
+      // communication guidance leads the operational sections.
+      const result = buildSystemPrompt();
+      expect(result).toContain("## Communication");
+      // The core rule: deliberation belongs in private thinking, not text.
+      expect(result).toContain(
+        "in your private thinking — never in user-facing text",
+      );
+      // Closes by deferring to the user's established communication preferences.
+      expect(result).toContain(
+        "Always prioritize communication preferences that you've established",
+      );
+      const communicationIdx = result.indexOf("## Communication");
+      const parallelIdx = result.indexOf("<use_parallel_tool_calls>");
+      expect(communicationIdx).toBeGreaterThan(-1);
+      expect(parallelIdx).toBeGreaterThan(-1);
+      expect(communicationIdx).toBeLessThan(parallelIdx);
+    });
+
     test("workspace prefix with frontmatter renders body at the very top", () => {
       mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
       writeFileSync(

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

@@ -24,6 +24,7 @@ mock.module("../runtime/background-job-runner.js", () => ({
     prompt: string;
     groupId?: string;
     trustContext: { sourceChannel: string; trustClass: string };
+    onConversationCreated?: (conversationId: string) => void;
   }) => {
     const { createConversation } =
       await import("../memory/conversation-crud.js");
@@ -33,6 +34,7 @@ mock.module("../runtime/background-job-runner.js", () => ({
       source: "schedule",
       ...(opts.groupId ? { groupId: opts.groupId } : {}),
     });
+    opts.onConversationCreated?.(conv.id);
     onRunBackgroundJobCall?.({
       conversationId: conv.id,
       prompt: opts.prompt,
@@ -60,12 +62,17 @@ mock.module("../notifications/emit-signal.js", () => ({
 
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { recordUsageEvent } from "../memory/llm-usage-store.js";
 import {
   createSchedule,
   getSchedule,
   getScheduleRuns,
 } from "../schedule/schedule-store.js";
-import { startScheduler } from "../schedule/scheduler.js";
+import { getScheduleUsageSummaries } from "../schedule/schedule-usage-store.js";
+import {
+  runScheduleDueWorkOnce,
+  startScheduler,
+} from "../schedule/scheduler.js";
 import { scheduleTask } from "../tasks/task-scheduler.js";
 import { createTask } from "../tasks/task-store.js";
 
@@ -160,6 +167,7 @@ describe("scheduler run_task detection", () => {
     db.run("DELETE FROM cron_jobs");
     db.run("DELETE FROM task_runs");
     db.run("DELETE FROM tasks");
+    db.run("DELETE FROM llm_usage_events");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
     onRunBackgroundJobCall = null;
@@ -298,4 +306,157 @@ describe("scheduler run_task detection", () => {
       /^activity-failed:task:nonexistent-task-id:\d{4}-\d{2}-\d{2}$/,
     );
   });
+
+  test("opens a task-backed schedule run before task processing and backfills the real conversation id", async () => {
+    const task = createTask({
+      title: "Usage Attribution Task",
+      template: "Spend scheduled tokens",
+    });
+    const schedule = scheduleTask({
+      taskId: task.id,
+      name: "Usage Attribution Schedule",
+      cronExpression: "* * * * *",
+    });
+    forceScheduleDue(schedule.id);
+
+    const from = Date.now() - 1000;
+    let processingConversationId: string | null = null;
+    let usageEventCreatedAt: number | null = null;
+    let runsDuringProcessing: ReturnType<typeof getScheduleRuns> = [];
+
+    const result = await runScheduleDueWorkOnce(
+      async (conversationId) => {
+        processingConversationId = conversationId;
+        runsDuringProcessing = getScheduleRuns(schedule.id);
+        const event = recordUsageEvent(
+          {
+            conversationId,
+            runId: null,
+            requestId: "req-scheduled-task-usage",
+            actor: "main_agent",
+            callSite: "mainAgent",
+            inferenceProfile: "balanced",
+            provider: "anthropic",
+            model: "claude-sonnet-4-20250514",
+            inputTokens: 100,
+            outputTokens: 50,
+            cacheCreationInputTokens: 0,
+            cacheReadInputTokens: 0,
+            rawUsage: null,
+          },
+          { estimatedCostUsd: 0.25, pricingStatus: "priced" },
+        );
+        usageEventCreatedAt = event.createdAt;
+      },
+      () => {},
+    );
+    const to = Date.now() + 1000;
+
+    expect(result.completed).toBe(1);
+    expect(result.failed).toBe(0);
+    expect(processingConversationId).not.toBeNull();
+    expect(usageEventCreatedAt).not.toBeNull();
+    expect(runsDuringProcessing).toHaveLength(1);
+    expect(runsDuringProcessing[0].status).toBe("running");
+    expect(runsDuringProcessing[0].conversationId).toBeNull();
+    expect(runsDuringProcessing[0].startedAt).toBeLessThanOrEqual(
+      usageEventCreatedAt!,
+    );
+
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs).toHaveLength(1);
+    expect(runs[0].id).toBe(runsDuringProcessing[0].id);
+    expect(runs[0].status).toBe("ok");
+    expect(runs[0].conversationId).toBe(processingConversationId);
+    expect(runs[0].startedAt).toBeLessThanOrEqual(usageEventCreatedAt!);
+    expect(runs[0].finishedAt).not.toBeNull();
+    expect(runs[0].finishedAt!).toBeGreaterThanOrEqual(usageEventCreatedAt!);
+
+    const summary = getScheduleUsageSummaries({ from, to }).find(
+      (row) => row.scheduleId === schedule.id,
+    );
+    expect(summary).toEqual({
+      scheduleId: schedule.id,
+      runCount: 1,
+      totalEstimatedCostUsd: 0.25,
+      eventCount: 1,
+    });
+  });
+
+  test("opens a normal execute schedule run before fresh background processing and records the conversation id", async () => {
+    const schedule = createSchedule({
+      name: "Usage Attribution Message Schedule",
+      cronExpression: "* * * * *",
+      message: "Spend scheduled message tokens",
+      syntax: "cron",
+    });
+    forceScheduleDue(schedule.id);
+
+    const from = Date.now() - 1000;
+    let processingConversationId: string | null = null;
+    let usageEventCreatedAt: number | null = null;
+    let runsDuringProcessing: ReturnType<typeof getScheduleRuns> = [];
+
+    onRunBackgroundJobCall = (info) => {
+      processingConversationId = info.conversationId;
+      runsDuringProcessing = getScheduleRuns(schedule.id);
+      const event = recordUsageEvent(
+        {
+          conversationId: info.conversationId,
+          runId: null,
+          requestId: "req-scheduled-message-usage",
+          actor: "main_agent",
+          callSite: "mainAgent",
+          inferenceProfile: "balanced",
+          provider: "anthropic",
+          model: "claude-sonnet-4-20250514",
+          inputTokens: 80,
+          outputTokens: 20,
+          cacheCreationInputTokens: 0,
+          cacheReadInputTokens: 0,
+          rawUsage: null,
+        },
+        { estimatedCostUsd: 0.1, pricingStatus: "priced" },
+      );
+      usageEventCreatedAt = event.createdAt;
+    };
+
+    const result = await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+    const to = Date.now() + 1000;
+
+    expect(result.completed).toBe(1);
+    expect(result.failed).toBe(0);
+    expect(processingConversationId).not.toBeNull();
+    expect(usageEventCreatedAt).not.toBeNull();
+    expect(runsDuringProcessing).toHaveLength(1);
+    expect(runsDuringProcessing[0].status).toBe("running");
+    expect(runsDuringProcessing[0].conversationId).toBe(
+      processingConversationId,
+    );
+    expect(runsDuringProcessing[0].startedAt).toBeLessThanOrEqual(
+      usageEventCreatedAt!,
+    );
+
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs).toHaveLength(1);
+    expect(runs[0].id).toBe(runsDuringProcessing[0].id);
+    expect(runs[0].status).toBe("ok");
+    expect(runs[0].conversationId).toBe(processingConversationId);
+    expect(runs[0].startedAt).toBeLessThanOrEqual(usageEventCreatedAt!);
+    expect(runs[0].finishedAt).not.toBeNull();
+    expect(runs[0].finishedAt!).toBeGreaterThanOrEqual(usageEventCreatedAt!);
+
+    const summary = getScheduleUsageSummaries({ from, to }).find(
+      (row) => row.scheduleId === schedule.id,
+    );
+    expect(summary).toEqual({
+      scheduleId: schedule.id,
+      runCount: 1,
+      totalEstimatedCostUsd: 0.1,
+      eventCount: 1,
+    });
+  });
 });

package/src/__tests__/terminal-tools.test.ts

@@ -1,8 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { ShellOutputResult } from "../tools/shared/shell-output.js";
-import type { Tool } from "../tools/types.js";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mock modules ────────────────────────────────────────────────────────────
 
@@ -64,6 +61,7 @@ mock.module("../tools/network/script-proxy/index.js", () => ({
 
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
+import { formatShellOutput } from "../tools/shared/shell-output.js";
 import {
   ALWAYS_INJECTED_ENV_VARS,
   buildSanitizedEnv,
@@ -71,6 +69,7 @@ import {
   KATA_SAFE_ENV_VARS,
   SAFE_ENV_VARS,
 } from "../tools/terminal/safe-env.js";
+import { shellTool } from "../tools/terminal/shell.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 //  Safe Environment — buildSanitizedEnv()
@@ -142,7 +141,7 @@ describe("buildSanitizedEnv", () => {
     expect(env.LC_CTYPE).toBe("UTF-8");
   });
 
-  test("only includes Kata apt variables when sandbox runtime is kata", () => {
+  test("only includes Kata apt variables for Kata-family sandbox runtimes", () => {
     process.env.VELLUM_SANDBOX_RUNTIME = "gvisor";
     process.env.PATH = "/usr/bin";
     process.env.VELLUM_APT_DATA_ROOT = "/data/system";
@@ -163,6 +162,11 @@ describe("buildSanitizedEnv", () => {
       "/data/system/usr/local/lib",
     );
     expect(env.LD_LIBRARY_PATH.split(":")).not.toContain("/host/lib");
+
+    process.env.VELLUM_SANDBOX_RUNTIME = "cloud-hypervisor";
+    env = buildSanitizedEnv();
+    expect(env.VELLUM_APT_DATA_ROOT).toBe("/data/system");
+    expect(env.PATH.split(":")).toContain("/data/system/usr/bin");
   });
 
   test("defaults LANG and LC_ALL to UTF-8 when unset", () => {
@@ -210,13 +214,6 @@ describe("buildSanitizedEnv", () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("Shell tool input validation", () => {
-  let shellTool: Tool;
-
-  beforeEach(async () => {
-    const mod = await import("../tools/terminal/shell.js");
-    shellTool = mod.shellTool;
-  });
-
   const baseContext = {
     workingDir: testTmpDir,
     conversationId: "test-conv-1",
@@ -308,19 +305,6 @@ describe("Shell tool input validation", () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("formatShellOutput", () => {
-  let formatShellOutput: (
-    stdout: string,
-    stderr: string,
-    code: number | null,
-    timedOut: boolean,
-    timeoutSec: number,
-  ) => ShellOutputResult;
-
-  beforeEach(async () => {
-    const mod = await import("../tools/shared/shell-output.js");
-    formatShellOutput = mod.formatShellOutput;
-  });
-
   test("successful command with output", () => {
     const result = formatShellOutput("hello world", "", 0, false, 120);
     expect(result.content).toBe("hello world");

package/src/__tests__/thread-backfill.test.ts

@@ -1284,7 +1284,7 @@ describe("triggerSlackThreadBackfillIfNeeded — gap detection and persistence",
         content: [
           {
             type: "text",
-            text: "[mar 4 2026 8:38 PM MT assistant] earlier assistant reply",
+            text: "earlier assistant reply",
           },
         ],
       },
@@ -2028,6 +2028,7 @@ function buildSlackDmRequest(
 }
 
 interface SlackInboundProcessOptions {
+  attachmentIds?: string[];
   displayContent?: string;
   transport?: {
     channelId?: string;
@@ -2111,7 +2112,6 @@ function flattenText(messages: Message[]): string {
 interface CapturedSlackProcessMessage {
   conversationId: string;
   content: string;
-  attachmentIds?: string[];
   options?: SlackInboundProcessOptions;
 }
 
@@ -2146,10 +2146,9 @@ async function handleAndCaptureLiveSlackProcessMessage(
   const processMessage = async (
     conversationId: string,
     content: string,
-    attachmentIds?: string[],
     options?: SlackInboundProcessOptions,
   ): Promise<{ messageId: string }> => {
-    captured = { conversationId, content, attachmentIds, options };
+    captured = { conversationId, content, options };
     const messageId = persistSlackInboundFromProcessMessage(
       conversationId,
       content,
@@ -2212,7 +2211,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       _conversationId: string,
       _content: string,
-      _attachmentIds?: string[],
       options?: {
         transport?: { hints?: string[] };
       },
@@ -2327,7 +2325,7 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     expect(captured.content.match(/<external_content/g)?.length).toBe(1);
     expect(captured.content).toContain('<external_content source="slack"');
     expect(captured.content).toContain("\n\n</external_content>");
-    expect(captured.attachmentIds).toEqual(["att-slack-file"]);
+    expect(captured.options?.attachmentIds).toEqual(["att-slack-file"]);
     expect(captured.options?.displayContent).toBe("");
 
     const persisted = readMessagesByConversation(captured.conversationId);
@@ -2370,7 +2368,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       conversationId: string,
       content: string,
-      _attachmentIds?: string[],
       options?: SlackInboundProcessOptions,
     ): Promise<{ messageId: string }> => {
       const messageId = persistSlackInboundFromProcessMessage(
@@ -2495,7 +2492,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       conversationId: string,
       content: string,
-      _attachmentIds?: string[],
       options?: SlackInboundProcessOptions,
     ): Promise<{ messageId: string }> => ({
       messageId: persistSlackInboundFromProcessMessage(
@@ -2551,7 +2547,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       conversationId: string,
       content: string,
-      _attachmentIds?: string[],
       options?: SlackInboundProcessOptions,
     ): Promise<{ messageId: string }> => ({
       messageId: persistSlackInboundFromProcessMessage(