@vellumai/assistant 0.4.44 → 0.4.45

package/src/__tests__/diagnostics-export.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Tests for the diagnostics export route handler.
+ *
+ * Validates anchor message resolution, including the fallback chain
+ * (specific ID → most recent assistant → any message → empty conversation).
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = mkdtempSync(join(tmpdir(), "diagnostics-export-test-"));
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
+import { diagnosticsRouteDefinitions } from "../runtime/routes/diagnostics-routes.js";
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const routes = diagnosticsRouteDefinitions();
+const exportRoute = routes.find((r) => r.endpoint === "diagnostics/export")!;
+
+async function callExport(body: Record<string, unknown>): Promise<Response> {
+  const req = new Request("http://localhost/v1/diagnostics/export", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const url = new URL(req.url);
+  return exportRoute.handler({
+    req,
+    url,
+    server: null as never,
+    authContext: {} as never,
+    params: {},
+  });
+}
+
+const db = () => getSqlite();
+
+function seedConversation(id: string): void {
+  const now = Date.now();
+  db().run(
+    "INSERT INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
+    [id, "Test", now, now],
+  );
+}
+
+function seedMessage(
+  id: string,
+  conversationId: string,
+  role: string,
+  content: string,
+  createdAt: number,
+): void {
+  db().run(
+    "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+    [id, conversationId, role, content, createdAt],
+  );
+}
+
+function cleanDb(): void {
+  db().run("DELETE FROM messages");
+  db().run("DELETE FROM conversations");
+}
+
+beforeEach(() => {
+  cleanDb();
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("diagnostics export", () => {
+  test("returns 400 when conversationId is missing", async () => {
+    const res = await callExport({});
+    expect(res.status).toBe(400);
+  });
+
+  test("succeeds with specific anchorMessageId", async () => {
+    const convId = "conv-1";
+    const msgId = "msg-assistant-1";
+    const now = Date.now();
+
+    seedConversation(convId);
+    seedMessage("msg-user-1", convId, "user", "hello", now - 1000);
+    seedMessage(msgId, convId, "assistant", "world", now);
+
+    const res = await callExport({
+      conversationId: convId,
+      anchorMessageId: msgId,
+    });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean; filePath: string };
+    expect(json.success).toBe(true);
+    expect(json.filePath).toContain("diagnostics-");
+  });
+
+  test("falls back to most recent assistant message when anchorMessageId is omitted", async () => {
+    const convId = "conv-2";
+    const now = Date.now();
+
+    seedConversation(convId);
+    seedMessage("msg-user-1", convId, "user", "hello", now - 1000);
+    seedMessage("msg-assistant-1", convId, "assistant", "world", now);
+
+    const res = await callExport({ conversationId: convId });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean };
+    expect(json.success).toBe(true);
+  });
+
+  test("falls back to any message when no assistant messages exist (race condition fix)", async () => {
+    const convId = "conv-3";
+    const now = Date.now();
+
+    seedConversation(convId);
+    // Only a user message — assistant response hasn't been persisted yet
+    seedMessage("msg-user-1", convId, "user", "hello", now);
+
+    const res = await callExport({ conversationId: convId });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean; filePath: string };
+    expect(json.success).toBe(true);
+    expect(json.filePath).toContain("diagnostics-");
+  });
+
+  test("succeeds with empty conversation (no messages at all)", async () => {
+    const convId = "conv-4";
+
+    seedConversation(convId);
+    // No messages at all — conversation was just created
+
+    const res = await callExport({ conversationId: convId });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean; filePath: string };
+    expect(json.success).toBe(true);
+    expect(json.filePath).toContain("diagnostics-");
+  });
+
+  test("falls back to any-message when anchorMessageId is provided but not found", async () => {
+    const convId = "conv-5";
+    const now = Date.now();
+
+    seedConversation(convId);
+    seedMessage("msg-user-1", convId, "user", "hello", now);
+
+    // anchorMessageId doesn't exist — should fall through all the way
+    const res = await callExport({
+      conversationId: convId,
+      anchorMessageId: "nonexistent-msg-id",
+    });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean };
+    expect(json.success).toBe(true);
+  });
+});

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -19,7 +19,6 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
   getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
   ensureDataDir: () => {},
-  getSocketPath: () => join(TEST_DIR, "vellum.sock"),
   getPidPath: () => join(TEST_DIR, "vellum.pid"),
   getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -114,7 +114,7 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
     enforceRoutingIntentMock.mockReturnValue(enforcedDecision);
 
     const result = await emitNotificationSignal({
-      sourceEventName: "reminder.fired",
+      sourceEventName: "schedule.notify",
       sourceChannel: "scheduler",
       sourceSessionId: "rem-1",
       attentionHints: {
@@ -160,7 +160,7 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
     );
 
     await emitNotificationSignal({
-      sourceEventName: "reminder.fired",
+      sourceEventName: "schedule.notify",
       sourceChannel: "scheduler",
       sourceSessionId: "rem-2",
       attentionHints: {
@@ -196,7 +196,7 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
     );
 
     await emitNotificationSignal({
-      sourceEventName: "reminder.fired",
+      sourceEventName: "schedule.notify",
       sourceChannel: "scheduler",
       sourceSessionId: "rem-3",
       attentionHints: {

package/src/__tests__/entity-extractor.test.ts

@@ -20,7 +20,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__/entity-search.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__/ephemeral-permissions.test.ts

@@ -21,7 +21,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"),
@@ -95,9 +94,8 @@ describe("ephemeral-permissions", () => {
       expect(fileReadRule.priority).toBe(75);
       expect(fileReadRule.createdAt).toBeGreaterThan(0);
 
-      // allowHighRisk is set because task runs execute asynchronously
-      // without interactive confirmation — pre-approved via preflight
-      expect(fileReadRule.allowHighRisk).toBe(true);
+      // Ephemeral task rules should not auto-allow high-risk tools
+      expect(fileReadRule.allowHighRisk).toBeUndefined();
 
       // Check other rules have correct tool names
       expect(rules[1].tool).toBe("bash");

package/src/__tests__/file-read-tool.test.ts

@@ -92,3 +92,89 @@ describe("file_read tool (sandbox)", () => {
     expect(result.content).toContain("outside the working directory");
   });
 });
+
+// ── Image file support ────────────────────────────────────────────────
+
+// Minimal valid JPEG: FF D8 FF E0 header
+const JPEG_HEADER = Buffer.from([
+  0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01,
+  0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
+]);
+
+// Minimal valid PNG header
+const PNG_HEADER = Buffer.from([
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49,
+  0x48, 0x44, 0x52,
+]);
+
+describe("file_read image support", () => {
+  test("returns image content block for .jpg file", async () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "photo.jpg"), JPEG_HEADER);
+
+    const result = await fileReadTool.execute(
+      { path: "photo.jpg" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Image loaded");
+    expect(result.content).toContain("image/jpeg");
+    expect((result as any).contentBlocks).toBeDefined();
+    expect((result as any).contentBlocks[0].type).toBe("image");
+    expect((result as any).contentBlocks[0].source.media_type).toBe(
+      "image/jpeg",
+    );
+  });
+
+  test("returns image content block for .png file", async () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "screenshot.png"), PNG_HEADER);
+
+    const result = await fileReadTool.execute(
+      { path: "screenshot.png" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("image/png");
+    expect((result as any).contentBlocks).toBeDefined();
+  });
+
+  test("ignores offset/limit for image files", async () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "img.jpg"), JPEG_HEADER);
+
+    const result = await fileReadTool.execute(
+      { path: "img.jpg", offset: 5, limit: 10 },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Image loaded");
+  });
+
+  test("returns error for missing image file", async () => {
+    const dir = makeTempDir();
+
+    const result = await fileReadTool.execute(
+      { path: "missing.jpg" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("file not found");
+  });
+
+  test("blocks image path traversal outside working dir", async () => {
+    const dir = makeTempDir();
+
+    const result = await fileReadTool.execute(
+      { path: "../../etc/secret.png" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("outside the working directory");
+  });
+});

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

@@ -10,7 +10,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__/frontmatter.test.ts

@@ -74,15 +74,6 @@ describe("parseFrontmatterFields", () => {
     expect(result).not.toBeNull();
     expect(result!.fields.name).toBe("Test");
     expect(result!.fields.description).toBe("Desc");
-    expect(Object.keys(result!.fields)).toHaveLength(2);
-  });
-
-  test("skips lines without a colon separator", () => {
-    const input = '---\nname: "Test"\nno-colon-here\n---\nBody';
-    const result = parseFrontmatterFields(input);
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!.fields)).toHaveLength(1);
-    expect(result!.fields.name).toBe("Test");
   });
 
   // -- Escape sequence handling (double-quoted) --
@@ -110,8 +101,6 @@ describe("parseFrontmatterFields", () => {
   });
 
   test("handles \\\\n correctly (escaped backslash followed by n, not newline)", () => {
-    // \\n in the source → the regex sees \\n → should produce \ followed by n (literal)
-    // The single-pass regex handles: \\ → \ and the trailing n is not part of an escape
     const result = parseFrontmatterFields('---\npath: "back\\\\name"\n---\n');
     expect(result!.fields.path).toBe("back\\name");
   });
@@ -164,17 +153,6 @@ describe("parseFrontmatterFields", () => {
 
   // -- Edge cases with quoting --
 
-  test("value that starts with quote but does not end with matching quote is treated as unquoted", () => {
-    // "hello world (no closing quote) — should be treated as the raw value
-    const result = parseFrontmatterFields('---\nname: "hello world\n---\n');
-    expect(result!.fields.name).toBe('"hello world');
-  });
-
-  test("mismatched quotes (double-start, single-end) treated as unquoted", () => {
-    const result = parseFrontmatterFields("---\nname: \"hello'\n---\n");
-    expect(result!.fields.name).toBe("\"hello'");
-  });
-
   test("empty double-quoted value", () => {
     const result = parseFrontmatterFields('---\nname: ""\n---\n');
     expect(result!.fields.name).toBe("");
@@ -190,26 +168,26 @@ describe("parseFrontmatterFields", () => {
     expect(result!.fields.name).toBe("  spaced  ");
   });
 
-  test("value with only whitespace (no quotes) is trimmed", () => {
-    const result = parseFrontmatterFields("---\nname:    \n---\n");
-    expect(result!.fields.name).toBe("");
-  });
+  // -- YAML array values --
 
-  // -- JSON array values --
+  test("YAML inline array is parsed as a native array", () => {
+    const result = parseFrontmatterFields("---\nincludes: [a, b]\n---\n");
+    expect(result!.fields.includes).toEqual(["a", "b"]);
+  });
 
-  test("JSON array value is preserved as raw string", () => {
+  test("JSON-style array value is parsed as a native array", () => {
     const result = parseFrontmatterFields('---\nincludes: ["a","b"]\n---\n');
-    expect(result!.fields.includes).toBe('["a","b"]');
+    expect(result!.fields.includes).toEqual(["a", "b"]);
   });
 
   // -- Boolean-like values --
 
-  test("boolean-like values are preserved as strings", () => {
+  test("boolean values are parsed as native booleans", () => {
     const result = parseFrontmatterFields(
       "---\nuser-invocable: false\ndisable-model-invocation: true\n---\n",
     );
-    expect(result!.fields["user-invocable"]).toBe("false");
-    expect(result!.fields["disable-model-invocation"]).toBe("true");
+    expect(result!.fields["user-invocable"]).toBe(false);
+    expect(result!.fields["disable-model-invocation"]).toBe(true);
   });
 
   // -- CRLF handling --
@@ -226,9 +204,74 @@ describe("parseFrontmatterFields", () => {
   // -- Multiple escape sequences in one value --
 
   test("handles multiple escape sequences in a single double-quoted value", () => {
-    // File content between quotes: a\nb\rc\\
-    // After unescape: a<newline>b<cr>c<backslash>
     const result = parseFrontmatterFields('---\ndesc: "a\\nb\\rc\\\\"\n---\n');
     expect(result!.fields.desc).toBe("a\nb\rc\\");
   });
+
+  // -- YAML nested metadata parsing --
+
+  test("parses YAML nested metadata as proper object", () => {
+    const input = [
+      "---",
+      'name: "Test"',
+      'description: "A test skill"',
+      "metadata:",
+      '  emoji: "\uD83D\uDD0C"',
+      "  vellum:",
+      '    display-name: "Test Skill"',
+      "    user-invocable: false",
+      "---",
+      "Body",
+    ].join("\n");
+    const result = parseFrontmatterFields(input);
+    expect(result).not.toBeNull();
+    expect(result!.fields.name).toBe("Test");
+    expect(result!.fields.metadata).toEqual({
+      emoji: "\uD83D\uDD0C",
+      vellum: {
+        "display-name": "Test Skill",
+        "user-invocable": false,
+      },
+    });
+  });
+
+  test("parses YAML metadata with arrays and nested objects", () => {
+    const input = [
+      "---",
+      'name: "Test"',
+      'description: "A test skill"',
+      "metadata:",
+      "  vellum:",
+      "    os:",
+      "      - darwin",
+      "      - linux",
+      "    requires:",
+      "      bins:",
+      "        - node",
+      "        - npm",
+      "---",
+      "Body",
+    ].join("\n");
+    const result = parseFrontmatterFields(input);
+    expect(result).not.toBeNull();
+    const meta = result!.fields.metadata as Record<string, unknown>;
+    const vellum = meta.vellum as Record<string, unknown>;
+    expect(vellum.os).toEqual(["darwin", "linux"]);
+    expect(vellum.requires).toEqual({ bins: ["node", "npm"] });
+  });
+
+  test("returns null for invalid YAML frontmatter", () => {
+    // Tabs are invalid in YAML indentation — should return null
+    const input = "---\nname: valid\nbad:\n\t- indentation\n---\nBody";
+    const result = parseFrontmatterFields(input);
+    expect(result).toBeNull();
+  });
+
+  test("handles empty frontmatter block", () => {
+    const input = "---\n\n---\nBody";
+    const result = parseFrontmatterFields(input);
+    expect(result).not.toBeNull();
+    expect(result!.fields).toEqual({});
+    expect(result!.body).toBe("Body");
+  });
 });

package/src/__tests__/gateway-only-enforcement.test.ts

@@ -25,7 +25,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__/gateway-only-guard.test.ts

@@ -22,7 +22,7 @@ const ALLOWLIST = new Set([
   // Matched by prefix check below: gateway/
 
   // --- Intentional local daemon-control paths ---
-  "clients/shared/IPC/DaemonClient.swift",
+  "clients/shared/Network/DaemonClient.swift",
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
   ".claude/skills/update/SKILL.md", // daemon health check script

package/src/__tests__/guardian-action-conversation-turn.test.ts

@@ -12,7 +12,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-action-followup-executor.test.ts

@@ -12,7 +12,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-action-followup-store.test.ts

@@ -10,7 +10,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-action-grant-mint-consume.test.ts

@@ -24,7 +24,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-action-late-reply.test.ts

@@ -10,7 +10,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-action-store.test.ts

@@ -10,7 +10,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-action-sweep.test.ts

@@ -10,7 +10,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-decision-primitive-canonical.test.ts

@@ -10,7 +10,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-dispatch.test.ts

@@ -13,7 +13,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"),
@@ -273,7 +272,7 @@ describe("guardian-dispatch", () => {
           channel: "vellum",
           destination: "vellum",
           status: "failed",
-          errorMessage: "IPC unavailable",
+          errorMessage: "delivery unavailable",
           conversationId: "conv-vellum-3",
         },
       ],

package/src/__tests__/guardian-grant-minting.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"),
@@ -124,6 +123,7 @@ function registerPendingInteraction(
   const handleConfirmationResponse = mock(() => {});
   const mockSession = {
     handleConfirmationResponse,
+    ensureActorScopedHistory: async () => {},
   } as unknown as Session;
 
   pendingInteractions.register(requestId, {

package/src/__tests__/guardian-outbound-http.test.ts

@@ -29,7 +29,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-principal-id-roundtrip.test.ts

@@ -12,7 +12,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"),