@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/external-plugin-loader.test.ts

@@ -0,0 +1,482 @@
+/**
+ * Tests for the external plugin loader.
+ *
+ * The loader now owns the timeout / try-catch / `registerPlugin` triple
+ * directly, so tests exercise observable behavior: after
+ * `await loadExternalPlugin(dir)`, what does the registry hold?
+ *
+ * Each test materializes a synthetic plugin directory under a per-file
+ * tempdir. Surface files use plain TypeScript with default exports so
+ * bun can dynamic-import them at runtime without a build step.
+ */
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import { loadExternalPlugin } from "../plugins/external-plugin-loader.js";
+import {
+  getRegisteredPlugins,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+
+const ROOT = join(
+  tmpdir(),
+  `vellum-external-plugin-loader-test-${process.pid}-${Date.now()}`,
+);
+
+function freshPluginDir(name: string): string {
+  const dir = join(ROOT, name);
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function writePackageJson(dir: string, pkg: Record<string, unknown>): void {
+  writeFileSync(join(dir, "package.json"), JSON.stringify(pkg, null, 2));
+}
+
+function writeSurfaceFile(dir: string, relPath: string, body: string): void {
+  const parts = relPath.split("/");
+  parts.pop();
+  if (parts.length > 0) {
+    mkdirSync(join(dir, ...parts), { recursive: true });
+  }
+  writeFileSync(join(dir, relPath), body);
+}
+
+function registeredNames(): string[] {
+  return getRegisteredPlugins().map((p) => p.manifest.name);
+}
+
+beforeEach(() => {
+  resetPluginRegistryForTests();
+});
+
+afterAll(() => {
+  rmSync(ROOT, { recursive: true, force: true });
+  resetPluginRegistryForTests();
+});
+
+describe("loadExternalPlugin — manifest", () => {
+  test("uses package.json name and version", async () => {
+    const dir = freshPluginDir("minimal");
+    writePackageJson(dir, { name: "minimal-plugin", version: "1.2.3" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "minimal-plugin",
+    );
+    expect(registered).toBeDefined();
+    expect(registered?.manifest.version).toBe("1.2.3");
+  });
+
+  test("strips npm scope from name", async () => {
+    const dir = freshPluginDir("scoped");
+    writePackageJson(dir, {
+      name: "@vellumai/simple-memory",
+      version: "0.1.0",
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("simple-memory");
+  });
+
+  test("defaults version to 0.0.0 when package.json omits it", async () => {
+    const dir = freshPluginDir("no-version");
+    writePackageJson(dir, { name: "no-version-plugin" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-version-plugin",
+    );
+    expect(registered?.manifest.version).toBe("0.0.0");
+  });
+});
+
+describe("loadExternalPlugin — plugin-api peerDependency", () => {
+  // Tests anchor against assistantPkg.version (read from the assistant's
+  // own package.json) so the matrix below stays correct across version
+  // bumps. Constructing a range from the live version + nudging up/down
+  // by one keeps the satisfy/un-satisfy cases honest.
+  test("loads when peerDependency range satisfies assistant version", async () => {
+    const dir = freshPluginDir("compat-ok");
+    writePackageJson(dir, {
+      name: "compat-ok",
+      version: "0.1.0",
+      peerDependencies: { "@vellumai/plugin-api": "*" },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-ok");
+  });
+
+  test("loads plugin whose peerDependency range excludes assistant version (logs error)", async () => {
+    // The host-compat gate is soft while the installation flow is in
+    // flux — an unsatisfied range produces a `log.error` but the
+    // plugin still loads. Once installation settles, this case should
+    // harden back into a hard reject.
+    const dir = freshPluginDir("compat-bad");
+    writePackageJson(dir, {
+      name: "compat-bad",
+      version: "0.1.0",
+      // A range that no real assistant version will satisfy.
+      peerDependencies: { "@vellumai/plugin-api": ">=999.0.0" },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-bad");
+  });
+
+  test("loads plugin whose peerDependency range is unparseable (logs error)", async () => {
+    // Same soft-gate rationale as the excluded-range case above.
+    const dir = freshPluginDir("compat-bogus");
+    writePackageJson(dir, {
+      name: "compat-bogus",
+      version: "0.1.0",
+      peerDependencies: { "@vellumai/plugin-api": "not-a-real-range" },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-bogus");
+  });
+
+  test("loads with warning when no peerDependency on plugin-api is declared", async () => {
+    // Absent peerDep is non-fatal — the loader logs a warn and proceeds
+    // with no host-compat claim. The convention is opt-in while the
+    // plugin-api framework is experimental.
+    const dir = freshPluginDir("compat-absent");
+    writePackageJson(dir, {
+      name: "compat-absent",
+      version: "0.1.0",
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-absent");
+  });
+
+  test("loads with warning when peerDependencies is present but lacks plugin-api key", async () => {
+    const dir = freshPluginDir("compat-other-peer");
+    writePackageJson(dir, {
+      name: "compat-other-peer",
+      version: "0.1.0",
+      peerDependencies: { react: "^18.0.0" },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-other-peer");
+  });
+
+  test("malformed package.json is logged and skipped (registry untouched)", async () => {
+    const dir = freshPluginDir("malformed-pkg");
+    writeFileSync(join(dir, "package.json"), "{ this is not json");
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("package.json missing name is logged and skipped", async () => {
+    const dir = freshPluginDir("no-name");
+    writePackageJson(dir, { version: "1.0.0" });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("empty string name is logged and skipped", async () => {
+    const dir = freshPluginDir("empty-name");
+    writePackageJson(dir, { name: "", version: "1.0.0" });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+});
+
+describe("loadExternalPlugin — hooks", () => {
+  test("wires hooks/init.ts default export to plugin.hooks.init", async () => {
+    const dir = freshPluginDir("with-init");
+    writePackageJson(dir, { name: "with-init", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `export default async function init(_ctx: unknown): Promise<void> {
+  (globalThis as Record<string, unknown>).__externalInitCalled = true;
+}
+`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "with-init",
+    );
+    expect(typeof registered?.hooks?.init).toBe("function");
+    await registered?.hooks?.init?.({} as never);
+    expect(
+      (globalThis as Record<string, unknown>).__externalInitCalled,
+    ).toBe(true);
+    delete (globalThis as Record<string, unknown>).__externalInitCalled;
+  });
+
+  test("wires hooks/shutdown.ts default export to plugin.hooks.shutdown", async () => {
+    const dir = freshPluginDir("with-shutdown");
+    writePackageJson(dir, { name: "with-shutdown", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/shutdown.ts",
+      `export default async function shutdown(ctx: { assistantVersion: string }): Promise<void> {
+  (globalThis as Record<string, unknown>).__externalShutdownCalled = true;
+  (globalThis as Record<string, unknown>).__externalShutdownVersion =
+    ctx.assistantVersion;
+}
+`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "with-shutdown",
+    );
+    expect(typeof registered?.hooks?.shutdown).toBe("function");
+    await registered?.hooks?.shutdown?.({ assistantVersion: "9.9.9-test" });
+    expect(
+      (globalThis as Record<string, unknown>).__externalShutdownCalled,
+    ).toBe(true);
+    expect(
+      (globalThis as Record<string, unknown>).__externalShutdownVersion,
+    ).toBe("9.9.9-test");
+    delete (globalThis as Record<string, unknown>).__externalShutdownCalled;
+    delete (globalThis as Record<string, unknown>).__externalShutdownVersion;
+  });
+
+  test("ignores hooks/*.d.ts declaration files alongside hooks/*.js", async () => {
+    // Compiled plugins ship `init.js` + `init.d.ts` side-by-side. The walker
+    // must filter the declaration files out — they have no default-exported
+    // runtime function, and crashing `importDefault` would skip the plugin
+    // wholesale. Regression guard for the .d.ts ingest bug fixed in this PR.
+    const dir = freshPluginDir("with-dts");
+    writePackageJson(dir, { name: "with-dts", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.js",
+      `export default async function init(_ctx) {
+  (globalThis).__externalDtsInitCalled = true;
+}
+`,
+    );
+    writeSurfaceFile(
+      dir,
+      "hooks/init.d.ts",
+      `export default function init(ctx: unknown): Promise<void>;\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "with-dts",
+    );
+    expect(registered).toBeDefined();
+    expect(Object.keys(registered?.hooks ?? {})).toEqual(["init"]);
+    expect(typeof registered?.hooks?.init).toBe("function");
+    await registered?.hooks?.init?.({} as never);
+    expect((globalThis as Record<string, unknown>).__externalDtsInitCalled).toBe(
+      true,
+    );
+    delete (globalThis as Record<string, unknown>).__externalDtsInitCalled;
+  });
+
+  test("plugin.hooks is undefined when neither hook file is present", async () => {
+    const dir = freshPluginDir("no-hooks");
+    writePackageJson(dir, { name: "no-hooks", version: "0.1.0" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-hooks",
+    );
+    expect(registered?.hooks).toBeUndefined();
+  });
+
+  test("hooks/init.ts with no default export is logged and skipped", async () => {
+    const dir = freshPluginDir("init-no-default");
+    writePackageJson(dir, { name: "init-no-default", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `export const init = async () => undefined;\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("hooks/init.ts default export not a function is logged and skipped", async () => {
+    const dir = freshPluginDir("init-not-fn");
+    writePackageJson(dir, { name: "init-not-fn", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `export default { not: "a function" };\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+});
+
+describe("loadExternalPlugin — tools", () => {
+  test("collects every default-exported tool under tools/", async () => {
+    const dir = freshPluginDir("two-tools");
+    writePackageJson(dir, { name: "two-tools", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "tools/alpha.ts",
+      `export default {
+  name: "two_tools_alpha",
+  description: "alpha",
+  defaultRiskLevel: "low" as const,
+  input_schema: { type: "object", properties: {}, required: [] },
+  async execute() { return { content: "a", isError: false }; },
+};
+`,
+    );
+    writeSurfaceFile(
+      dir,
+      "tools/beta.ts",
+      `export default {
+  name: "two_tools_beta",
+  description: "beta",
+  defaultRiskLevel: "low" as const,
+  input_schema: { type: "object", properties: {}, required: [] },
+  async execute() { return { content: "b", isError: false }; },
+};
+`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "two-tools",
+    );
+    const names = (registered?.tools ?? []).map(
+      (t) => (t as { name: string }).name,
+    );
+    expect(names).toEqual(["two_tools_alpha", "two_tools_beta"]);
+  });
+
+  test("plugin.tools is undefined when tools/ is absent", async () => {
+    const dir = freshPluginDir("no-tools");
+    writePackageJson(dir, { name: "no-tools", version: "0.1.0" });
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "no-tools",
+    );
+    expect(registered?.tools).toBeUndefined();
+  });
+
+  test("a tool file with no default export is logged and skipped", async () => {
+    const dir = freshPluginDir("tool-no-default");
+    writePackageJson(dir, { name: "tool-no-default", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "tools/broken.ts",
+      `export const broken = { name: "broken" };\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("a tool default export missing string name is logged and skipped", async () => {
+    const dir = freshPluginDir("tool-no-name");
+    writePackageJson(dir, { name: "tool-no-name", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "tools/nameless.ts",
+      `export default { description: "missing name" };\n`,
+    );
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toHaveLength(0);
+  });
+});
+
+describe("loadExternalPlugin — isolation", () => {
+  test("never throws when a load fails — error is logged and skipped", async () => {
+    const dir = freshPluginDir("definitely-broken");
+    writeFileSync(join(dir, "package.json"), "{ broken");
+
+    await expect(loadExternalPlugin(dir)).resolves.toBeUndefined();
+    expect(registeredNames()).toHaveLength(0);
+  });
+
+  test("times out and skips when build exceeds the timeout", async () => {
+    // hooks/init.ts has a top-level await that never resolves. The build
+    // hangs on dynamic-importing this surface file; the loader's timeout
+    // must rescue the daemon boot.
+    const dir = freshPluginDir("hanging-init");
+    writePackageJson(dir, { name: "hanging-init", version: "0.1.0" });
+    writeSurfaceFile(
+      dir,
+      "hooks/init.ts",
+      `await new Promise(() => {});
+export default async function init(_ctx: unknown): Promise<void> {}
+`,
+    );
+
+    await loadExternalPlugin(dir, { importTimeoutMs: 50 });
+
+    expect(registeredNames()).not.toContain("hanging-init");
+  });
+});
+
+describe("loadExternalPlugin — end-to-end @vellumai/simple-memory", () => {
+  test("loads the in-tree simple-memory plugin", async () => {
+    // Resolve the real on-disk plugin from the worktree. This double-acts
+    // as the loader's contract test against the canonical Phase 0 plugin
+    // and exercises the relative `../src/state.js` imports inside the
+    // plugin's surface files.
+    const pluginDir = join(
+      import.meta.dir,
+      "..",
+      "..",
+      "..",
+      "experimental",
+      "plugins",
+      "simple-memory",
+    );
+
+    await loadExternalPlugin(pluginDir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "simple-memory",
+    );
+    expect(registered).toBeDefined();
+    expect(typeof registered?.hooks?.init).toBe("function");
+    expect(typeof registered?.hooks?.shutdown).toBe("function");
+    const toolNames = (registered?.tools ?? [])
+      .map((t) => (t as { name: string }).name)
+      .sort();
+    expect(toolNames).toEqual([
+      "simple_memory_recall",
+      "simple_memory_remember",
+    ]);
+  });
+});

package/src/__tests__/filing-service.test.ts

@@ -7,6 +7,13 @@ import { LLMSchema } from "../config/schemas/llm.js";
 
 const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 
+// Default the warm-pool gate to OPEN for existing tests — they predate
+// the gate and expect filing's runOnce() to fire on every tick.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 // Mock config loader. Filing's `runOnce()` reads `getConfig().filing`, and
 // `executeRun()` no longer reads `config.speed` (PR 8) — the call site is
 // hardcoded to 'filingAgent' and the resolver picks up `llm.callSites.filingAgent`
@@ -35,8 +42,12 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // Mock conversation store
-const createdConversations: Array<{ title: string; conversationType: string }> =
-  [];
+const createdConversations: Array<{
+  title: string;
+  conversationType: string;
+  source?: string;
+  groupId?: string;
+}> = [];
 let conversationIdCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
@@ -63,7 +74,12 @@ mock.module("../memory/conversation-crud.js", () => ({
   }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
-  createConversation: (opts: { title: string; conversationType: string }) => {
+  createConversation: (opts: {
+    title: string;
+    conversationType: string;
+    source?: string;
+    groupId?: string;
+  }) => {
     createdConversations.push(opts);
     return { id: `conv-${++conversationIdCounter}`, ...opts };
   },
@@ -220,6 +236,10 @@ describe("FilingService", () => {
     expect(createdConversations).toHaveLength(1);
     expect(createdConversations[0].title).toBe("Generating title...");
     expect(createdConversations[0].conversationType).toBe("background");
+    // Confirms FilingService routes through runBackgroundJob:
+    //   source="filing" + runner-default groupId="system:background".
+    expect(createdConversations[0].source).toBe("filing");
+    expect(createdConversations[0].groupId).toBe("system:background");
   });
 
   describe("runCompactionOnce()", () => {
@@ -283,6 +303,146 @@ describe("FilingService", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
 
+    // Helpers for the compaction-retry tests: hold the filing run open by
+    // making processMessage return a manually-resolved promise, so `activeRun`
+    // stays set and runCompactionOnce() sees the contention path.
+    function holdFilingRun(): {
+      release: () => void;
+      filingCalls: () => number;
+      compactionCalls: () => number;
+      waitForFilingStarted: () => Promise<void>;
+    } {
+      let release: (() => void) | undefined;
+      let started = false;
+      let filingCalls = 0;
+      let compactionCalls = 0;
+
+      setTestProcessMessage((...args: unknown[]) => {
+        const callSite = (args[3] as { callSite?: string } | undefined)
+          ?.callSite;
+        if (callSite === "filingAgent") {
+          filingCalls += 1;
+          started = true;
+          return new Promise((resolve) => {
+            release = () => resolve({ messageId: "filing-done" });
+          });
+        }
+        if (callSite === "compactionAgent") {
+          compactionCalls += 1;
+        }
+        return Promise.resolve({ messageId: "mock" });
+      });
+
+      return {
+        release: () => release?.(),
+        filingCalls: () => filingCalls,
+        compactionCalls: () => compactionCalls,
+        waitForFilingStarted: async () => {
+          while (!started) await Promise.resolve();
+        },
+      };
+    }
+
+    test("schedules a near-term retry when filing run is in-flight", async () => {
+      const hold = holdFilingRun();
+      // 5s retry override paired with a production-realistic 24h compaction
+      // interval — the assertion proves retry << interval.
+      const retryMs = 5_000;
+      mockConfig.filing.compactionIntervalMs = 24 * 60 * 60 * 1000;
+      const service = new FilingService({
+        compactionContendedRetryMs: retryMs,
+      });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+
+      const beforeRetry = Date.now();
+      const ran = await service.runCompactionOnce();
+
+      expect(ran).toBe(false);
+      expect(service.nextCompactionAt).not.toBeNull();
+      const nextAt = service.nextCompactionAt!;
+      expect(nextAt - beforeRetry).toBeLessThan(
+        mockConfig.filing.compactionIntervalMs,
+      );
+      expect(nextAt - beforeRetry).toBeLessThanOrEqual(retryMs + 100);
+
+      hold.release();
+      await filingPromise;
+      await service.stop();
+    });
+
+    test("retry fires after filing run completes", async () => {
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 1 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+
+      const skipped = await service.runCompactionOnce();
+      expect(skipped).toBe(false);
+      expect(hold.compactionCalls()).toBe(0);
+
+      hold.release();
+      await filingPromise;
+
+      const start = Date.now();
+      while (hold.compactionCalls() === 0 && Date.now() - start < 1000) {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+      }
+
+      expect(hold.filingCalls()).toBe(1);
+      expect(hold.compactionCalls()).toBe(1);
+
+      await service.stop();
+    });
+
+    test("stop() clears a scheduled compaction retry", async () => {
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 50 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+      await service.runCompactionOnce();
+      expect(service.nextCompactionAt).not.toBeNull();
+
+      hold.release();
+      await filingPromise;
+      await service.stop();
+
+      // After stop, the retry timer must be cleared and never fire.
+      expect(service.nextCompactionAt).toBeNull();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(hold.compactionCalls()).toBe(0);
+    });
+
+    test("stop() prevents retry callback from re-arming a fresh timer", async () => {
+      // Race: the retry callback fires while filing is still in-flight and
+      // stop() has begun. The callback already cleared compactionRetryTimer,
+      // so clearCompactionRetry is a no-op. Without a stopped flag, the
+      // callback's runCompactionOnce() hits the activeRun branch and schedules
+      // a fresh retry, leaving a live timer after stop() resolves.
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 5 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+      await service.runCompactionOnce();
+      expect(service.nextCompactionAt).not.toBeNull();
+
+      // Begin stop without awaiting — it would block on the held filing run.
+      // stop() flips `stopped` synchronously before the retry timer fires.
+      const stopPromise = service.stop();
+
+      // Wait past the retry delay. Without the guard, the callback would call
+      // runCompactionOnce(), observe activeRun, and re-arm a new retry.
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(service.nextCompactionAt).toBeNull();
+
+      hold.release();
+      await filingPromise;
+      await stopPromise;
+
+      expect(service.nextCompactionAt).toBeNull();
+      expect(hold.compactionCalls()).toBe(0);
+    });
+
     test("respects active hours", async () => {
       mockConfig.filing.activeHoursStart = 9;
       mockConfig.filing.activeHoursEnd = 17;

package/src/__tests__/fixtures/mock-chrome-extension.ts

@@ -224,6 +224,11 @@ export function createMockChromeExtension(
         headers: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${options.token}`,
+          // Same-actor binding: identifies this fixture to the daemon's
+          // result-route check. The daemon will reject targeted host_browser
+          // results without this header (or where it doesn't match the
+          // captured target client).
+          "X-Vellum-Client-Id": clientId,
         },
         body: JSON.stringify(body),
       });

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

@@ -34,7 +34,6 @@ const ALLOWLIST = new Set([
 
   // --- Chrome extension (local relay communication, not gateway API consumption) ---
   "clients/chrome-extension/background/worker.ts",
-  "clients/chrome-extension/popup/popup.ts",
   // --- Documentation and comments that mention the port for explanatory purposes ---
   "AGENTS.md", // documents the gateway-only rule itself
   "ARCHITECTURE.md", // architecture overview with port references