@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/app-bundler.test.ts

@@ -2,7 +2,7 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 import JSZip from "jszip";
 
@@ -22,7 +22,6 @@ const mockApps = new Map<string, Record<string, unknown>>();
 mock.module("../memory/app-store.js", () => ({
   getApp: (id: string) => mockApps.get(id) ?? null,
   getAppsDir: () => testAppsDir,
-  isMultifileApp: (app: Record<string, unknown>) => app.formatVersion === 2,
 }));
 
 // Mock content-id to avoid pulling in crypto internals
@@ -35,326 +34,11 @@ mock.module("./bundle-signer.js", () => ({
   signBundle: async () => ({}),
 }));
 
-import {
-  extractRemoteUrls,
-  materializeAssets,
-  packageApp,
-} from "../bundler/app-bundler.js";
+import { packageApp } from "../bundler/app-bundler.js";
 import type { AppManifest } from "../bundler/manifest.js";
 
 // ---------------------------------------------------------------------------
-// extractRemoteUrls
-// ---------------------------------------------------------------------------
-
-describe("extractRemoteUrls", () => {
-  test("extracts src attributes with double quotes", () => {
-    const html = '<img src="https://cdn.example.com/logo.png">';
-    expect(extractRemoteUrls(html)).toEqual([
-      "https://cdn.example.com/logo.png",
-    ]);
-  });
-
-  test("extracts src attributes with single quotes", () => {
-    const html = "<img src='https://cdn.example.com/logo.png'>";
-    expect(extractRemoteUrls(html)).toEqual([
-      "https://cdn.example.com/logo.png",
-    ]);
-  });
-
-  test("extracts unquoted src attributes", () => {
-    const html = "<img src=https://cdn.example.com/logo.png>";
-    expect(extractRemoteUrls(html)).toEqual([
-      "https://cdn.example.com/logo.png",
-    ]);
-  });
-
-  test("extracts href attributes", () => {
-    const html =
-      '<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto">';
-    expect(extractRemoteUrls(html)).toEqual([
-      "https://fonts.googleapis.com/css?family=Roboto",
-    ]);
-  });
-
-  test("extracts CSS url() references with double quotes", () => {
-    const html =
-      '<div style="background: url(&quot;https://cdn.example.com/bg.jpg&quot;)"></div>';
-    // The regex matches url("...") literally, not HTML entities
-    expect(extractRemoteUrls(html)).toEqual([]);
-
-    // With actual quotes in a <style> block
-    const html2 =
-      '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
-    expect(extractRemoteUrls(html2)).toEqual([
-      "https://cdn.example.com/bg.jpg",
-    ]);
-  });
-
-  test("extracts CSS url() references with single quotes", () => {
-    const html =
-      "<style>body { background: url('https://cdn.example.com/bg.jpg'); }</style>";
-    expect(extractRemoteUrls(html)).toEqual(["https://cdn.example.com/bg.jpg"]);
-  });
-
-  test("extracts CSS url() references without quotes", () => {
-    const html =
-      "<style>body { background: url(https://cdn.example.com/bg.jpg); }</style>";
-    expect(extractRemoteUrls(html)).toEqual(["https://cdn.example.com/bg.jpg"]);
-  });
-
-  test("ignores relative URLs", () => {
-    const html = '<img src="images/logo.png"><link href="./style.css">';
-    expect(extractRemoteUrls(html)).toEqual([]);
-  });
-
-  test("ignores data URIs", () => {
-    const html = '<img src="data:image/png;base64,iVBORw0KGgo=">';
-    expect(extractRemoteUrls(html)).toEqual([]);
-  });
-
-  test("deduplicates identical URLs", () => {
-    const html = `
-      <img src="https://cdn.example.com/logo.png">
-      <img src="https://cdn.example.com/logo.png">
-    `;
-    expect(extractRemoteUrls(html)).toEqual([
-      "https://cdn.example.com/logo.png",
-    ]);
-  });
-
-  test("extracts multiple different URLs", () => {
-    const html = `
-      <img src="https://cdn.example.com/logo.png">
-      <link href="https://fonts.example.com/style.css">
-      <script src="https://cdn.example.com/app.js"></script>
-    `;
-    const urls = extractRemoteUrls(html);
-    expect(urls).toHaveLength(3);
-    expect(urls).toContain("https://cdn.example.com/logo.png");
-    expect(urls).toContain("https://fonts.example.com/style.css");
-    expect(urls).toContain("https://cdn.example.com/app.js");
-  });
-
-  test("returns empty array for HTML with no remote URLs", () => {
-    const html = "<html><body><p>Hello World</p></body></html>";
-    expect(extractRemoteUrls(html)).toEqual([]);
-  });
-
-  test("handles mixed src, href, and url() in a single document", () => {
-    const html = `
-      <link href="https://example.com/a.css">
-      <img src="https://example.com/b.png">
-      <style>div { background: url(https://example.com/c.jpg); }</style>
-    `;
-    const urls = extractRemoteUrls(html);
-    expect(urls).toHaveLength(3);
-  });
-
-  test("handles HTTP (not just HTTPS)", () => {
-    const html = '<img src="http://cdn.example.com/legacy.png">';
-    expect(extractRemoteUrls(html)).toEqual([
-      "http://cdn.example.com/legacy.png",
-    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// materializeAssets
-// ---------------------------------------------------------------------------
-
-describe("materializeAssets", () => {
-  let originalFetch: typeof globalThis.fetch;
-
-  beforeEach(() => {
-    originalFetch = globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  test("returns unchanged HTML when there are no remote URLs", async () => {
-    const html = "<html><body>No remote assets</body></html>";
-    const result = await materializeAssets(html);
-    expect(result.rewrittenHtml).toBe(html);
-    expect(result.assets).toEqual([]);
-  });
-
-  test("fetches remote assets and rewrites URLs", async () => {
-    const imageUrl = "https://cdn.example.com/image.png";
-    const imageData = Buffer.from("fake-image-data");
-
-    globalThis.fetch = mock((url: string) => {
-      if (url === imageUrl) {
-        return Promise.resolve(new Response(imageData, { status: 200 }));
-      }
-      return Promise.resolve(new Response(null, { status: 404 }));
-    }) as unknown as typeof fetch;
-
-    const html = `<img src="${imageUrl}">`;
-    const result = await materializeAssets(html);
-
-    expect(result.rewrittenHtml).toBe('<img src="assets/e724846245db.png">');
-    expect(result.assets).toHaveLength(1);
-    expect(result.assets[0].archivePath).toBe("assets/e724846245db.png");
-    expect(result.assets[0].data).toEqual(imageData);
-  });
-
-  test("handles multiple distinct assets", async () => {
-    const urls = [
-      "https://cdn.example.com/a.png",
-      "https://cdn.example.com/b.css",
-      "https://cdn.example.com/c.js",
-    ];
-
-    globalThis.fetch = mock((url: string) => {
-      return Promise.resolve(
-        new Response(Buffer.from(`data-for-${url}`), { status: 200 }),
-      );
-    }) as unknown as typeof fetch;
-
-    const html = `
-      <img src="${urls[0]}">
-      <link href="${urls[1]}">
-      <script src="${urls[2]}"></script>
-    `;
-    const result = await materializeAssets(html);
-
-    expect(result.assets).toHaveLength(3);
-
-    const expectedFilenames: Record<string, string> = {
-      "https://cdn.example.com/a.png": "6155f67efa62.png",
-      "https://cdn.example.com/b.css": "5e6d8d571910.css",
-      "https://cdn.example.com/c.js": "20fb1ea9b4c9.js",
-    };
-    for (const url of urls) {
-      expect(result.rewrittenHtml).toContain(
-        `assets/${expectedFilenames[url]}`,
-      );
-      expect(result.rewrittenHtml).not.toContain(url);
-    }
-  });
-
-  test("keeps original URL when fetch returns non-OK status", async () => {
-    const imageUrl = "https://cdn.example.com/missing.png";
-
-    globalThis.fetch = mock(() => {
-      return Promise.resolve(new Response(null, { status: 404 }));
-    }) as unknown as typeof fetch;
-
-    const html = `<img src="${imageUrl}">`;
-    const result = await materializeAssets(html);
-
-    expect(result.rewrittenHtml).toBe(html);
-    expect(result.assets).toEqual([]);
-  });
-
-  test("keeps original URL when fetch throws (network error)", async () => {
-    const imageUrl = "https://cdn.example.com/unreachable.png";
-
-    globalThis.fetch = mock(() => {
-      return Promise.reject(new Error("Network error"));
-    }) as unknown as typeof fetch;
-
-    const html = `<img src="${imageUrl}">`;
-    const result = await materializeAssets(html);
-
-    expect(result.rewrittenHtml).toBe(html);
-    expect(result.assets).toEqual([]);
-  });
-
-  test("partially succeeds: fetched assets are rewritten, failed ones remain", async () => {
-    const goodUrl = "https://cdn.example.com/good.png";
-    const badUrl = "https://cdn.example.com/bad.png";
-
-    globalThis.fetch = mock((url: string) => {
-      if (url === goodUrl) {
-        return Promise.resolve(
-          new Response(Buffer.from("good-data"), { status: 200 }),
-        );
-      }
-      return Promise.resolve(new Response(null, { status: 500 }));
-    }) as unknown as typeof fetch;
-
-    const html = `<img src="${goodUrl}"><img src="${badUrl}">`;
-    const result = await materializeAssets(html);
-
-    expect(result.rewrittenHtml).toContain("assets/691e2a787421.png");
-    expect(result.rewrittenHtml).toContain(badUrl);
-    expect(result.assets).toHaveLength(1);
-  });
-
-  test("deduplicates same URL appearing multiple times in HTML", async () => {
-    const imageUrl = "https://cdn.example.com/icon.png";
-    let fetchCount = 0;
-
-    globalThis.fetch = mock(() => {
-      fetchCount++;
-      return Promise.resolve(
-        new Response(Buffer.from("icon-data"), { status: 200 }),
-      );
-    }) as unknown as typeof fetch;
-
-    const html = `<img src="${imageUrl}"><div style="background: url(${imageUrl})"></div>`;
-    const result = await materializeAssets(html);
-
-    // Should only fetch once since extractRemoteUrls deduplicates
-    expect(fetchCount).toBe(1);
-    expect(result.assets).toHaveLength(1);
-
-    // Both occurrences should be rewritten
-    expect(result.rewrittenHtml).not.toContain(imageUrl);
-    const matches = result.rewrittenHtml.match(/assets\/2f7fc0f99275\.png/g);
-    expect(matches).toHaveLength(2);
-  });
-
-  test("preserves file extensions in asset filenames", async () => {
-    const pngUrl = "https://cdn.example.com/image.png";
-    const cssUrl = "https://cdn.example.com/style.css";
-    const noExtUrl = "https://cdn.example.com/api/data";
-
-    globalThis.fetch = mock(() => {
-      return Promise.resolve(
-        new Response(Buffer.from("data"), { status: 200 }),
-      );
-    }) as unknown as typeof fetch;
-
-    const html = `<img src="${pngUrl}"><link href="${cssUrl}"><img src="${noExtUrl}">`;
-    const result = await materializeAssets(html);
-
-    expect(result.assets).toHaveLength(3);
-
-    const pngAsset = result.assets.find((a) => a.archivePath.endsWith(".png"));
-    const cssAsset = result.assets.find((a) => a.archivePath.endsWith(".css"));
-    const noExtAsset = result.assets.find(
-      (a) => !a.archivePath.endsWith(".png") && !a.archivePath.endsWith(".css"),
-    );
-
-    expect(pngAsset).toBeDefined();
-    expect(cssAsset).toBeDefined();
-    expect(noExtAsset).toBeDefined();
-  });
-
-  test("rewrites CSS url() references alongside src/href", async () => {
-    const cssUrl = "https://cdn.example.com/bg.jpg";
-
-    globalThis.fetch = mock(() => {
-      return Promise.resolve(
-        new Response(Buffer.from("jpg-data"), { status: 200 }),
-      );
-    }) as unknown as typeof fetch;
-
-    const html =
-      '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
-    const result = await materializeAssets(html);
-
-    expect(result.rewrittenHtml).toContain("assets/8550eecd4975.jpg");
-    expect(result.rewrittenHtml).not.toContain(cssUrl);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// packageApp — multifile apps
+// packageApp
 // ---------------------------------------------------------------------------
 
 describe("packageApp", () => {
@@ -368,10 +52,10 @@ describe("packageApp", () => {
   });
 
   /**
-   * Helper: set up a fake multifile app on disk with src/ and dist/ dirs
-   * so that compileApp (which we mock below) can pretend to succeed.
+   * Helper: set up a fake app on disk with src/ and dist/ dirs
+   * so that compileApp can succeed.
    */
-  function setupMultifileApp(appId: string, opts?: { withCss?: boolean }) {
+  function setupApp(appId: string, opts?: { withCss?: boolean }) {
     const appDir = join(testAppsDir, appId);
     const srcDir = join(appDir, "src");
     mkdirSync(srcDir, { recursive: true });
@@ -394,7 +78,7 @@ describe("packageApp", () => {
     // Write the app JSON (getApp reads from {appsDir}/{id}.json)
     const appDef = {
       id: appId,
-      name: "Test Multifile App",
+      name: "Test App",
       description: "A test app",
       schemaJson: "{}",
       htmlDefinition: "<unused>",
@@ -408,26 +92,9 @@ describe("packageApp", () => {
     return appDef;
   }
 
-  function setupLegacyApp(appId: string) {
-    const appDir = join(testAppsDir, appId);
-    mkdirSync(appDir, { recursive: true });
-
-    const appDef = {
-      id: appId,
-      name: "Test Legacy App",
-      schemaJson: "{}",
-      htmlDefinition: "<html><body>Hello legacy</body></html>",
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    };
-    writeFileSync(join(testAppsDir, `${appId}.json`), JSON.stringify(appDef));
-    mockApps.set(appId, appDef);
-    return appDef;
-  }
-
-  test("packages a multifile app with compiled dist/ files in the zip", async () => {
+  test("packages an app with compiled dist/ files in the zip", async () => {
     const appId = "multi-test-1";
-    setupMultifileApp(appId, { withCss: true });
+    setupApp(appId, { withCss: true });
 
     const result = await packageApp(appId);
     const zipData = await readFile(result.bundlePath);
@@ -452,9 +119,9 @@ describe("packageApp", () => {
     expect(cssContent).toContain("margin");
   });
 
-  test("sets format_version to 2 in manifest for multifile apps", async () => {
+  test("sets format_version to 2 in manifest", async () => {
     const appId = "multi-test-2";
-    setupMultifileApp(appId);
+    setupApp(appId);
 
     const result = await packageApp(appId);
     const zipData = await readFile(result.bundlePath);
@@ -465,7 +132,7 @@ describe("packageApp", () => {
 
     expect(manifest.format_version).toBe(2);
     expect(manifest.entry).toBe("index.html");
-    expect(manifest.name).toBe("Test Multifile App");
+    expect(manifest.name).toBe("Test App");
   });
 
   test("compile failure produces a clear error", async () => {
@@ -498,30 +165,9 @@ describe("packageApp", () => {
     );
   });
 
-  test("legacy app packaging remains unchanged (format_version 1)", async () => {
-    const appId = "legacy-test-1";
-    setupLegacyApp(appId);
-
-    const result = await packageApp(appId);
-    const zipData = await readFile(result.bundlePath);
-    const zip = await JSZip.loadAsync(zipData);
-
-    const manifestJson = await zip.file("manifest.json")!.async("string");
-    const manifest: AppManifest = JSON.parse(manifestJson);
-
-    expect(manifest.format_version).toBe(1);
-
-    // Legacy app should have index.html with the original content
-    const indexContent = await zip.file("index.html")!.async("string");
-    expect(indexContent).toContain("Hello legacy");
-
-    // Should NOT have main.js (not a compiled app)
-    expect(zip.file("main.js")).toBeNull();
-  });
-
-  test("multifile app without CSS omits main.css from zip", async () => {
+  test("app without CSS omits main.css from zip", async () => {
     const appId = "multi-no-css";
-    setupMultifileApp(appId, { withCss: false });
+    setupApp(appId, { withCss: false });
 
     const result = await packageApp(appId);
     const zipData = await readFile(result.bundlePath);

package/src/__tests__/app-compiler.test.ts

@@ -196,7 +196,6 @@ console.log("styled");`,
 
     expect(result.ok).toBe(false);
     expect(result.errors.length).toBeGreaterThan(0);
-    expect(result.errors[0].text).toContain("not in the allowed list");
     expect(result.errors[0].text).toContain("left-pad");
   });
 

package/src/__tests__/app-executors.test.ts

@@ -1,4 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../bundler/app-compiler.js", () => ({
+  compileApp: async () => ({
+    ok: true,
+    errors: [],
+    warnings: [],
+    durationMs: 0,
+  }),
+}));
 
 import type { AppDefinition } from "../memory/app-store.js";
 import type { AppStore } from "../tools/apps/executors.js";

package/src/__tests__/approval-hardcoded-copy-guard.test.ts

@@ -14,7 +14,7 @@ import { join } from "path";
 const SCANNED_FILES = [
   "runtime/channel-approvals.ts",
   "runtime/routes/channel-routes.ts",
-  "runtime/channel-guardian-service.ts",
+  "runtime/channel-verification-service.ts",
 ];
 
 const BANNED_PATTERNS: { pattern: RegExp; description: string }[] = [

package/src/__tests__/approval-primitive.test.ts

@@ -15,8 +15,6 @@ mock.module("../util/platform.js", () => ({
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -146,7 +144,7 @@ describe("approval-primitive / mintGrantFromDecision", () => {
         callSessionId: "call-1",
         requesterExternalUserId: "user-1",
         guardianExternalUserId: "guardian-1",
-        executionChannel: "voice",
+        executionChannel: "phone",
       }),
     );
     expect(result.ok).toBe(true);
@@ -155,7 +153,7 @@ describe("approval-primitive / mintGrantFromDecision", () => {
     expect(result.grant.callSessionId).toBe("call-1");
     expect(result.grant.requesterExternalUserId).toBe("user-1");
     expect(result.grant.guardianExternalUserId).toBe("guardian-1");
-    expect(result.grant.executionChannel).toBe("voice");
+    expect(result.grant.executionChannel).toBe("phone");
   });
 });
 

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

@@ -9,7 +9,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/ipc-protocol.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Session } from "../daemon/session.js";
 
 const testDir = realpathSync(

package/src/__tests__/asset-materialize-tool.test.ts

@@ -44,10 +44,7 @@ import {
   linkAttachmentToMessage,
   uploadAttachment,
 } from "../memory/attachments-store.js";
-import {
-  addMessage,
-  createConversation,
-} from "../memory/conversation-store.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { assetMaterializeTool } from "../tools/assets/materialize.js";
 import type { ToolContext } from "../tools/types.js";

package/src/__tests__/asset-search-tool.test.ts

@@ -43,10 +43,7 @@ import {
   linkAttachmentToMessage,
   uploadAttachment,
 } from "../memory/attachments-store.js";
-import {
-  addMessage,
-  createConversation,
-} from "../memory/conversation-store.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { searchAttachments } from "../tools/assets/search.js";
 import { assetSearchTool } from "../tools/assets/search.js";

package/src/__tests__/assistant-attachments.test.ts

@@ -278,6 +278,29 @@ describe("drainDirectiveDisplayBuffer", () => {
     expect(result.bufferedRemainder).toBe("");
   });
 
+  test("inserts space when inline directive is stripped with no surrounding whitespace", () => {
+    const input = 'sentence.<vellum-attachment path="out.png" />Next sentence.';
+    const result = drainDirectiveDisplayBuffer(input);
+    expect(result.emitText).toBe("sentence. Next sentence.");
+    expect(result.bufferedRemainder).toBe("");
+  });
+
+  test("does not insert space when stripped directive already has trailing whitespace", () => {
+    const input =
+      'sentence. <vellum-attachment path="out.png" />Next sentence.';
+    const result = drainDirectiveDisplayBuffer(input);
+    expect(result.emitText).toBe("sentence. Next sentence.");
+    expect(result.bufferedRemainder).toBe("");
+  });
+
+  test("does not insert space when stripped directive already has leading whitespace on next char", () => {
+    const input =
+      'sentence.<vellum-attachment path="out.png" /> Next sentence.';
+    const result = drainDirectiveDisplayBuffer(input);
+    expect(result.emitText).toBe("sentence. Next sentence.");
+    expect(result.bufferedRemainder).toBe("");
+  });
+
   test("preserves invalid directives as plain text", () => {
     const input = 'Bad <vellum-attachment source="bad" path="x.txt" /> tag';
     const result = drainDirectiveDisplayBuffer(input);

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -53,7 +53,7 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
   getHistoryPath: () => join(TEST_DIR, "history"),
   getHooksDir: () => join(TEST_DIR, "hooks"),
-  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+
   getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
   getSandboxWorkingDir: () => TEST_DIR,
   getInterfacesDir: () => join(TEST_DIR, "interfaces"),
@@ -63,10 +63,6 @@ mock.module("../util/platform.js", () => ({
   getPlatformName: () => "linux",
   getClipboardCommand: () => null,
   readSessionToken: () => null,
-  removeSocketFile: () => {},
-  migratePath: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migrateToDataLayout: () => {},
 }));
 
 const noopLogger = new Proxy({} as Record<string, unknown>, {
@@ -98,8 +94,8 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const realUserReference = require("../config/user-reference.js");
-mock.module("../config/user-reference.js", () => ({
+const realUserReference = require("../prompts/user-reference.js");
+mock.module("../prompts/user-reference.js", () => ({
   ...realUserReference,
   resolveUserReference: () => "TestUser",
   resolveUserPronouns: () => null,
@@ -112,7 +108,7 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
   listCredentialMetadata: () => [],
 }));
 
-const { buildSystemPrompt } = await import("../config/system-prompt.js");
+const { buildSystemPrompt } = await import("../prompts/system-prompt.js");
 const { isAssistantFeatureFlagEnabled } =
   await import("../config/assistant-feature-flags.js");
 const { skillFlagKey } = await import("../config/skill-state.js");

package/src/__tests__/assistant-id-boundary-guard.test.ts

@@ -88,7 +88,7 @@ describe("assistant ID boundary", () => {
     // should now use DAEMON_INTERNAL_ASSISTANT_ID instead.
     const daemonScopingFiles = [
       "runtime/actor-trust-resolver.ts",
-      "runtime/guardian-outbound-actions.ts",
+      "runtime/verification-outbound-actions.ts",
       "daemon/handlers/config-channels.ts",
       "runtime/routes/channel-route-shared.ts",
       "calls/relay-server.ts",
@@ -318,14 +318,14 @@ describe("assistant ID boundary", () => {
       import.meta.dir,
       "..",
       "daemon",
-      "ipc-contract",
+      "message-types",
       "integrations.ts",
     );
     const content = readFileSync(ipcContractPath, "utf-8");
 
     // Extract the interface blocks for the request types and verify
     // none of them declare an assistantId property.
-    const requestTypeNames = ["GuardianVerificationRequest"];
+    const requestTypeNames = ["ChannelVerificationSessionRequest"];
 
     for (const typeName of requestTypeNames) {
       // Find the interface/type block — match from the type name to the next
@@ -376,7 +376,7 @@ describe("assistant ID boundary", () => {
       import.meta.dir,
       "..",
       "runtime",
-      "guardian-outbound-actions.ts",
+      "verification-outbound-actions.ts",
     );
     const content = readFileSync(actionsPath, "utf-8");
 
@@ -390,7 +390,7 @@ describe("assistant ID boundary", () => {
       const idx = content.indexOf(name);
       expect(
         idx,
-        `Expected to find ${name} in guardian-outbound-actions.ts`,
+        `Expected to find ${name} in verification-outbound-actions.ts`,
       ).toBeGreaterThan(-1);
 
       const blockStart = content.indexOf("{", idx);

package/src/__tests__/attachments-store.test.ts

@@ -50,10 +50,7 @@ import {
   uploadAttachment,
   validateAttachmentUpload,
 } from "../memory/attachments-store.js";
-import {
-  addMessage,
-  createConversation,
-} from "../memory/conversation-store.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 
 initializeDb();