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

package/src/__tests__/suggestion-routes.test.ts

@@ -52,6 +52,7 @@ const mockGetMessages = mock((_conversationId: string) => [
 mock.module("../memory/conversation-crud.js", () => ({
   getMessages: mockGetMessages,
   getConversation: (_id: string) => null,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const mockGetConfiguredProvider = mock(async () => ({
@@ -441,7 +442,7 @@ describe("GET /v1/suggestion", () => {
       role: string;
       content: Array<{ type: string; text: string }>;
     }>;
-    const options = callArgs[3] as {
+    const options = callArgs[1] as {
       config?: {
         stop_sequences?: string[];
         max_tokens?: number;
@@ -556,7 +557,7 @@ describe("GET /v1/suggestion", () => {
 
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
     const callArgs = provider.sendMessage.mock.calls[0] as unknown[];
-    const options = callArgs[3] as
+    const options = callArgs[1] as
       | { config?: { callSite?: string } }
       | undefined;
     expect(options?.config?.callSite).toBe("replySuggestion");
@@ -594,7 +595,7 @@ describe("GET /v1/suggestion", () => {
 
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
     const callArgs = provider.sendMessage.mock.calls[0] as unknown[];
-    const options = callArgs[3] as
+    const options = callArgs[1] as
       | {
           config?: {
             temperature?: number;

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.");
@@ -171,6 +225,44 @@ describe("buildSystemPrompt", () => {
     expect(result).toContain("# Soul\n\nBe thoughtful.");
   });
 
+  test("gates off the unmodified bundled IDENTITY.md template when no BOOTSTRAP.md is present", () => {
+    // Regression: the seeded IDENTITY.md ships with `_`-comment lines, so
+    // the raw workspace body never equals the comment-stripped bundled
+    // template. `isTemplateContent` must comment-strip BOTH sides — otherwise
+    // detection fails and the `08-identity` transform leaks the blank
+    // template scaffolding into every fresh post-onboarding prompt.
+    const bundledIdentity = readFileSync(
+      join(import.meta.dirname, "..", "prompts", "templates", "IDENTITY.md"),
+      "utf-8",
+    );
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), bundledIdentity);
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "# Soul\n\nBe thoughtful.");
+    const result = buildSystemPrompt();
+    // SOUL still renders; the template scaffolding must not.
+    expect(result).toContain("# Soul\n\nBe thoughtful.");
+    expect(result).not.toContain("(not yet chosen)");
+  });
+
+  test("includes the unmodified bundled IDENTITY.md template during bootstrap", () => {
+    // The mirror case: when BOOTSTRAP.md is active the template is included
+    // verbatim so the model can see the field structure and produce a valid
+    // file_write on the first turn.
+    const bundledIdentity = readFileSync(
+      join(import.meta.dirname, "..", "prompts", "templates", "IDENTITY.md"),
+      "utf-8",
+    );
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), bundledIdentity);
+    writeFileSync(
+      join(TEST_DIR, "BOOTSTRAP.md"),
+      "# First run\n\nGet started.",
+    );
+    const result = buildSystemPrompt();
+    // The bundled template's placeholder scaffolding (the `(not yet chosen)`
+    // field markers) renders verbatim during bootstrap — the mirror of the
+    // gating test above, which asserts it is absent without BOOTSTRAP.md.
+    expect(result).toContain("(not yet chosen)");
+  });
+
   test("trims whitespace from file content", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "\n  Be kind  \n\n");
     const result = buildSystemPrompt();
@@ -581,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__/test-preload-verifier.ts

@@ -0,0 +1,68 @@
+/**
+ * Test preload verifier — runs immediately after test-preload.ts.
+ *
+ * Bun already exits with code 1 when a preload throws, has an unresolvable
+ * import, or doesn't exist on disk (verified empirically). This file is
+ * the explicit check for the remaining failure mode: the main preload
+ * ran successfully but didn't actually isolate workspace state (e.g. a
+ * future refactor of test-preload.ts introduces a logic bug that no-ops
+ * the env override).
+ *
+ * Without this verifier, that failure mode would silently let tests
+ * resolve `VELLUM_WORKSPACE_DIR` to the real `/workspace` and potentially
+ * destroy live data.
+ *
+ * Order matters: bunfig.toml lists this AFTER test-preload.ts so the
+ * main preload's env writes are observable here.
+ *
+ * No source-module imports — only node stdlib (matches the same rule
+ * test-preload.ts enforces).
+ *
+ * Positive assertion: `VELLUM_WORKSPACE_DIR` MUST resolve under
+ * `os.tmpdir()`. This mirrors exactly what test-preload.ts does
+ * (`mkdtempSync(join(tmpdir(), "vellum-test-"))`), so any other value
+ * indicates the preload either didn't run or didn't take effect.
+ */
+
+import { realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { sep } from "node:path";
+
+function fail(reason: string): never {
+  throw new Error(
+    [
+      `Test preload verifier failed: ${reason}.`,
+      "",
+      "test-preload.ts ran but did not isolate workspace state. Common",
+      "causes:",
+      "  - a logic bug in test-preload.ts (env override removed/reordered)",
+      "  - a preload phase threw silently and the verifier still picked up",
+      "    partial state",
+    ].join("\n"),
+  );
+}
+
+function canonicalize(p: string): string {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+
+const workspaceDir = process.env.VELLUM_WORKSPACE_DIR?.trim();
+if (!workspaceDir) {
+  fail("VELLUM_WORKSPACE_DIR is not set after main preload");
+}
+
+const resolvedWorkspace = canonicalize(workspaceDir);
+const tmpRoot = canonicalize(tmpdir());
+
+if (
+  resolvedWorkspace !== tmpRoot &&
+  !resolvedWorkspace.startsWith(tmpRoot + sep)
+) {
+  fail(
+    `VELLUM_WORKSPACE_DIR resolves to ${resolvedWorkspace}, which is not under ${tmpRoot}`,
+  );
+}