@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/host-browser-e2e-cloud.test.ts

@@ -225,8 +225,7 @@ describe("host_browser cloud-hosted e2e round-trip", () => {
     // Same fixture as the HTTP happy path, but configured to return
     // results over the /v1/browser-relay WebSocket instead of POSTing
     // /v1/host-browser-result. This exercises the runtime WS
-    // `message` handler's host_browser_result dispatch path added in
-    // PR2 of the browser-use remediation plan.
+    // `message` handler's host_browser_result dispatch path.
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
@@ -309,8 +308,7 @@ describe("host_browser cloud-hosted e2e round-trip", () => {
   });
 
   test("abort: late /v1/host-browser-result POST after cancel is ignored (no ghost completion)", async () => {
-    // Regression for PR6 of the browser-use remediation plan. The
-    // daemon-side proxy must treat a late result POST — arriving
+    // The daemon-side proxy must treat a late result POST — arriving
     // after the caller has already been resolved with "Aborted" —
     // as a benign race, not a noisy false-positive timeout. It must
     // also NOT resolve the caller a second time.
@@ -434,6 +432,142 @@ describe("host_browser cloud-hosted e2e round-trip", () => {
   });
 });
 
+// ── macOS message ingress with connected extension ──────────────────
+//
+// Verifies the end-to-end path for macOS-originated turns when the user
+// has the chrome extension connected. On macOS, browser commands should
+// route through the registry-backed host browser flow (extension → user's
+// real Chrome session) rather than falling back to local Playwright.
+//
+// The macOS browser backend preference order is:
+//
+//   macOS + extension connected → extension backend (registry-routed)
+//   macOS + extension absent    → cdp-inspect (desktop-auto) → local
+//
+// NOTE: These tests construct a HostBrowserProxy directly and call
+// proxy.request(), which validates the extension relay round-trip but
+// bypasses handleSendMessage / conversation-routes. Full ingress-path
+// coverage (interface propagation, resolveHostBrowserSender wiring, and
+// CDP factory candidate selection) is exercised by the route-level tests
+// in conversation-routes-disk-view.test.ts.
+//
+// If future refactors break the wiring between conversation-routes
+// (`resolveHostBrowserSender`) and the CDP factory's candidate list, those
+// route-level tests will fail.
+
+describe("macOS message ingress with connected extension", () => {
+  let server: RuntimeHttpServer;
+  let port: number;
+  let runtimeBaseUrl: string;
+
+  beforeEach(async () => {
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+    pendingInteractions.clear();
+    __resetChromeExtensionRegistryForTests();
+
+    port = 20000 + Math.floor(Math.random() * 200);
+    runtimeBaseUrl = `http://127.0.0.1:${port}`;
+    server = new RuntimeHttpServer({ port });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server?.stop();
+    pendingInteractions.clear();
+    __resetChromeExtensionRegistryForTests();
+  });
+
+  test("macOS turn routes Browser.getVersion through the registry-backed extension, not local Playwright", async () => {
+    // Arrange: connect a mock extension for a given guardianId.
+    const guardianId = `test-guardian-macos-${crypto.randomUUID()}`;
+    const token = mintActorToken(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // Build a proxy bound to the guardian's extension connection, mimicking
+    // the wiring that conversation-routes.ts performs for macOS turns when
+    // the ChromeExtensionRegistry has an active entry for the guardian.
+    const { proxy } = createBoundProxy(guardianId, "conv-macos-ext");
+
+    // Act: issue a CDP command through the proxy (same as how browser tools
+    // dispatch commands during a macOS turn with extension override).
+    const result = await proxy.request(
+      { cdpMethod: "Browser.getVersion" },
+      "conv-macos-ext",
+    );
+
+    // Assert: the command reached the mock extension (not local Playwright)
+    // and the round-trip completed successfully.
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Chrome/MockTest");
+
+    const received = mockExt.receivedRequests();
+    expect(received).toHaveLength(1);
+    expect(received[0].cdpMethod).toBe("Browser.getVersion");
+    expect(received[0].conversationId).toBe("conv-macos-ext");
+
+    proxy.dispose();
+    await mockExt.stop();
+  });
+
+  test("macOS turn with extension disconnected mid-conversation does not hang (proxy detects unavailability)", async () => {
+    // Arrange: connect a mock extension then forcibly disconnect it.
+    const guardianId = `test-guardian-macos-disco-${crypto.randomUUID()}`;
+    const token = mintActorToken(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // The proxy is bound while the extension is still connected.
+    const { proxy } = createBoundProxy(guardianId, "conv-macos-disco");
+
+    // Disconnect the extension before sending any commands.
+    mockExt.forceDisconnect();
+
+    // Wait for the registry to notice the close event.
+    await waitFor(
+      () => getChromeExtensionRegistry().get(guardianId) === undefined,
+    );
+
+    // Act: attempt a CDP command through the proxy. The registry send should
+    // fail because the connection is gone, and the proxy's sendToClient
+    // wrapper throws immediately.
+    try {
+      await proxy.request(
+        { cdpMethod: "Browser.getVersion", timeout_seconds: 0.5 },
+        "conv-macos-disco",
+      );
+      // If we reach here, the test should still verify the result indicates
+      // an error rather than a successful extension round-trip.
+      expect(true).toBe(false); // Should not reach here
+    } catch {
+      // Expected: the send failed because the extension is disconnected.
+      // This confirms the macOS path detects disconnection rather than
+      // silently routing to the wrong backend.
+    }
+
+    proxy.dispose();
+    await mockExt.stop();
+  });
+});
+
 // ── Local wait helpers ──────────────────────────────────────────────
 
 async function waitFor(

package/src/__tests__/host-browser-e2e-self-hosted.test.ts

@@ -321,7 +321,7 @@ describe("host-browser E2E — self-hosted native messaging path", () => {
   }
 
   // -------------------------------------------------------------------------
-  // Dev-only `~/.vellum/daemon-token` fallback
+  // Dev-only daemon-token fallback (per-instance protected dir)
   // -------------------------------------------------------------------------
 
   describe("dev daemon-token fallback path", () => {
@@ -338,9 +338,9 @@ describe("host-browser E2E — self-hosted native messaging path", () => {
     test("a token written to a local file round-trips through verifyHostBrowserCapability", () => {
       // Emulate the `writeDaemonTokenFallback` lifecycle: mint a fresh
       // capability token, persist it to a 0600 file (the production
-      // helper writes to `~/.vellum/daemon-token`, but we use a tempdir
-      // so the test doesn't clobber real dev state), then read it back
-      // and verify.
+      // helper writes to `<protectedDir>/daemon-token`, but we use a
+      // tempdir so the test doesn't clobber real dev state), then read
+      // it back and verify.
       //
       // This path is what the Mac app's manual "paste daemon token"
       // pairing UI ends up exercising — the file on disk is the only

package/src/__tests__/host-browser-ws-events-e2e.test.ts

@@ -284,6 +284,109 @@ describe("host_browser WS event + invalidation e2e", () => {
     await mockExt.stop();
   });
 
+  test("keepalive frames are accepted without closing the socket or producing warnings", async () => {
+    const guardianId = `guardian-${crypto.randomUUID()}`;
+    const { token } = mintHostBrowserCapability(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+      resultTransport: "ws",
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // Grab the initial timestamps so we can verify that keepalive
+    // bumps lastKeepaliveAt but NOT lastActiveAt (routing field).
+    const connBefore = getChromeExtensionRegistry().get(guardianId)!;
+    const lastActiveBefore = connBefore.lastActiveAt;
+
+    // Small delay to ensure Date.now() advances at least 1ms.
+    await new Promise((r) => setTimeout(r, 15));
+
+    // Send a keepalive frame (the extension sends these periodically
+    // to prevent the runtime from considering the connection stale).
+    // The frame may contain extra keys (e.g. timestamp) that the
+    // runtime should silently ignore (lenient validation).
+    mockExt.sendRaw(JSON.stringify({ type: "keepalive", ts: Date.now() }));
+
+    // Wait for the touch to propagate — touch() updates
+    // lastKeepaliveAt (not lastActiveAt) to avoid routing interference.
+    await waitFor(() => {
+      const conn = getChromeExtensionRegistry().get(guardianId);
+      return conn !== undefined && (conn.lastKeepaliveAt ?? 0) > 0;
+    });
+
+    const connAfter = getChromeExtensionRegistry().get(guardianId)!;
+    expect(connAfter.lastKeepaliveAt).toBeGreaterThan(0);
+    // lastActiveAt must remain unchanged — keepalives must not affect routing.
+    expect(connAfter.lastActiveAt).toBe(lastActiveBefore);
+
+    // Verify the socket is still alive by sending a normal host_browser_event
+    // frame after the keepalive — if the socket had been torn down, this
+    // would never arrive.
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    mockExt.sendHostBrowserEvent({ method: "Page.loadEventFired" });
+    await waitFor(() => observed.length === 1);
+    expect(observed[0].method).toBe("Page.loadEventFired");
+
+    unsubscribe();
+    await mockExt.stop();
+  });
+
+  test("normal host_browser flows still pass after keepalive traffic", async () => {
+    const guardianId = `guardian-${crypto.randomUUID()}`;
+    const { token } = mintHostBrowserCapability(guardianId);
+
+    const { createMockChromeExtension } =
+      await import("./fixtures/mock-chrome-extension.js");
+    const mockExt = createMockChromeExtension({
+      runtimeBaseUrl,
+      token,
+      resultTransport: "ws",
+    });
+    await mockExt.start();
+    await mockExt.waitForConnection();
+    await waitForRegistryEntry(guardianId);
+
+    // Simulate a burst of keepalive frames (as would happen during an
+    // idle period with the extension's alarm-based keepalive ticker).
+    for (let i = 0; i < 5; i++) {
+      mockExt.sendRaw(JSON.stringify({ type: "keepalive" }));
+    }
+
+    // Small delay to let all keepalive frames process.
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Now send a host_browser_event and verify it still fans out
+    // correctly — proving keepalive traffic does not interfere with
+    // normal message processing.
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    mockExt.sendHostBrowserEvent({
+      method: "Network.requestWillBeSent",
+      params: { requestId: "req-42", url: "https://example.com/api" },
+      cdpSessionId: "session-xyz",
+    });
+
+    await waitFor(() => observed.length === 1);
+    expect(observed[0].method).toBe("Network.requestWillBeSent");
+    expect(observed[0].params).toEqual({
+      requestId: "req-42",
+      url: "https://example.com/api",
+    });
+    expect(observed[0].cdpSessionId).toBe("session-xyz");
+
+    unsubscribe();
+    await mockExt.stop();
+  });
+
   test("malformed host_browser_event frames are dropped without tearing down the socket", async () => {
     const guardianId = `guardian-${crypto.randomUUID()}`;
     const { token } = mintHostBrowserCapability(guardianId);

package/src/__tests__/host-cu-proxy.test.ts

@@ -792,26 +792,21 @@ describe("HostCuProxy", () => {
     function spySignal(source: AbortSignal): Spied {
       const addCalls: string[] = [];
       const removeCalls: string[] = [];
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const s = source as any;
       const origAdd = source.addEventListener.bind(source);
       const origRemove = source.removeEventListener.bind(source);
       s.addEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         addCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origAdd as any)(type, ...rest);
       };
       s.removeEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         removeCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origRemove as any)(type, ...rest);
       };
       return { signal: source, addCalls, removeCalls };

package/src/__tests__/identity-intro-cache.test.ts

@@ -2,7 +2,8 @@
  * Unit tests for the identity intro cache (identity-intro-cache.ts).
  *
  * Validates TTL-based expiration, content-hash-based invalidation when
- * workspace identity files change, and round-trip get/set behavior.
+ * workspace identity files or the guardian persona content change, and
+ * round-trip get/set behavior.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -44,6 +45,14 @@ mock.module("node:fs", () => ({
   },
 }));
 
+// Mocked guardian persona — mutable so tests can change it and verify cache
+// invalidation based on the per-user persona file content.
+let guardianPersonaContent: string | null = null;
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  resolveGuardianPersona: () => guardianPersonaContent,
+}));
+
 // ---------------------------------------------------------------------------
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
@@ -63,6 +72,7 @@ afterEach(() => {
   for (const key of Object.keys(workspaceFiles)) {
     delete workspaceFiles[key];
   }
+  guardianPersonaContent = null;
 });
 
 // ---------------------------------------------------------------------------
@@ -77,7 +87,7 @@ describe("identity intro cache", () => {
   test("round-trip: set then get returns cached text", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     workspaceFiles["SOUL.md"] = "Be playful.";
-    workspaceFiles["USER.md"] = "The user likes coffee.";
+    guardianPersonaContent = "The user likes coffee.";
 
     setCachedIntro("Hey, I'm Atlas.");
     const cached = getCachedIntro();
@@ -131,24 +141,24 @@ describe("identity intro cache", () => {
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("busts cache when USER.md changes", () => {
-    workspaceFiles["USER.md"] = "Likes coffee.";
+  test("busts cache when guardian persona content changes", () => {
+    guardianPersonaContent = "Likes coffee.";
     setCachedIntro("Good morning!");
 
-    // Change USER.md
-    workspaceFiles["USER.md"] = "Likes tea.";
+    // Change guardian persona (e.g. user edited users/<slug>.md)
+    guardianPersonaContent = "Likes tea.";
 
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("cache survives when files are unchanged", () => {
+  test("cache remains valid when guardian persona is unchanged", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     workspaceFiles["SOUL.md"] = "Be chill.";
-    workspaceFiles["USER.md"] = "Likes sunsets.";
+    guardianPersonaContent = "Likes sunsets.";
 
     setCachedIntro("Atlas here.");
 
-    // Read twice — both should return the cached value
+    // Read twice with the same guardian persona — both should return the cached value
     expect(getCachedIntro()?.text).toBe("Atlas here.");
     expect(getCachedIntro()?.text).toBe("Atlas here.");
   });
@@ -156,7 +166,7 @@ describe("identity intro cache", () => {
   test("computeIdentityContentHash is deterministic", () => {
     workspaceFiles["IDENTITY.md"] = "test";
     workspaceFiles["SOUL.md"] = "test2";
-    workspaceFiles["USER.md"] = "test3";
+    guardianPersonaContent = "test3";
 
     const hash1 = computeIdentityContentHash();
     const hash2 = computeIdentityContentHash();
@@ -164,6 +174,26 @@ describe("identity intro cache", () => {
     expect(hash1).toMatch(/^[a-f0-9]{64}$/); // SHA-256 hex
   });
 
+  test("computeIdentityContentHash changes when guardian persona changes", () => {
+    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
+    workspaceFiles["SOUL.md"] = "Be playful.";
+    guardianPersonaContent = "Likes coffee.";
+    const hash1 = computeIdentityContentHash();
+
+    guardianPersonaContent = "Likes tea.";
+    const hash2 = computeIdentityContentHash();
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("computeIdentityContentHash handles null guardian persona", () => {
+    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
+    guardianPersonaContent = null;
+
+    const hash = computeIdentityContentHash();
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
   test("computeIdentityContentHash changes when file content changes", () => {
     workspaceFiles["IDENTITY.md"] = "v1";
     const hash1 = computeIdentityContentHash();

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -1,102 +1,45 @@
 /**
- * Tests for initFeatureFlagOverrides() — the async gateway fetch that
+ * Tests for initFeatureFlagOverrides() — the async IPC call that
  * pre-populates the feature flag cache before CLI program construction.
+ *
+ * Uses the shared mock-gateway-ipc utility (installed in test-preload.ts)
+ * which mocks node:net so no test connects to a real gateway socket.
  */
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 
+import {
+  mockGatewayIpc,
+  resetMockGatewayIpc,
+} from "../__tests__/mock-gateway-ipc.js";
 import {
   clearFeatureFlagOverridesCache,
   initFeatureFlagOverrides,
   isAssistantFeatureFlagEnabled,
 } from "../config/assistant-feature-flags.js";
-import * as tokenService from "../runtime/auth/token-service.js";
-import { getMockFetchCalls, mockFetch, resetMockFetch } from "./mock-fetch.js";
-
-const VALID_HEX_KEY = "ab".repeat(32);
 
 beforeEach(() => {
   clearFeatureFlagOverridesCache();
-  tokenService._resetSigningKeyForTesting();
-
-  // Set up a signing key so mintEdgeRelayToken() works
-  process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
-  tokenService.initAuthSigningKey(tokenService.resolveSigningKey());
+  resetMockGatewayIpc();
 });
 
 afterEach(() => {
-  resetMockFetch();
   clearFeatureFlagOverridesCache();
-  tokenService._resetSigningKeyForTesting();
-  delete process.env.ACTOR_TOKEN_SIGNING_KEY;
+  resetMockGatewayIpc();
 });
 
 describe("initFeatureFlagOverrides", () => {
-  it("populates cache from gateway fetch response", async () => {
-    mockFetch(
-      "/v1/feature-flags",
-      { method: "GET" },
-      {
-        body: {
-          flags: [
-            {
-              key: "foo-enabled",
-              enabled: true,
-              label: "Foo",
-              defaultEnabled: false,
-              description: "",
-            },
-            {
-              key: "bar-enabled",
-              enabled: true,
-              label: "Bar",
-              defaultEnabled: true,
-              description: "",
-            },
-          ],
-        },
-        status: 200,
-      },
-    );
+  it("populates cache from gateway IPC response", async () => {
+    mockGatewayIpc({ "foo-enabled": true, "bar-enabled": true });
 
     await initFeatureFlagOverrides();
 
     const config = {} as any;
     expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
     expect(isAssistantFeatureFlagEnabled("bar-enabled", config)).toBe(true);
-
-    // Verify fetch was called with correct URL and auth header
-    const calls = getMockFetchCalls();
-    expect(calls.length).toBe(1);
-    expect(calls[0].path).toContain("/v1/feature-flags");
-    const headers = calls[0].init.headers as Record<string, string> | undefined;
-    expect(headers).toHaveProperty("Authorization");
-  });
-
-  it("sends a valid Bearer JWT in the Authorization header", async () => {
-    mockFetch(
-      "/v1/feature-flags",
-      { method: "GET" },
-      { body: { flags: [] }, status: 200 },
-    );
-
-    await initFeatureFlagOverrides();
-
-    const calls = getMockFetchCalls();
-    expect(calls.length).toBe(1);
-    const headers = calls[0].init.headers as Record<string, string> | undefined;
-    const authHeader = headers?.Authorization;
-
-    expect(authHeader).toBeDefined();
-    expect(authHeader).toMatch(/^Bearer /);
-
-    // Verify it's a valid JWT (three dot-separated base64url segments)
-    const token = authHeader!.replace("Bearer ", "");
-    const parts = token.split(".");
-    expect(parts.length).toBe(3);
   });
 
-  it("falls back gracefully when gateway is unreachable", async () => {
-    mockFetch("/v1/feature-flags", { method: "GET" }, { status: 500 });
+  it("falls back gracefully when gateway socket is unavailable", async () => {
+    mockGatewayIpc(null, { error: true });
 
     // Should not throw
     await initFeatureFlagOverrides();
@@ -106,62 +49,45 @@ describe("initFeatureFlagOverrides", () => {
     expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
   });
 
-  it("falls back gracefully on non-OK HTTP status", async () => {
-    mockFetch(
-      "/v1/feature-flags",
-      { method: "GET" },
-      { body: "Unauthorized", status: 401 },
-    );
+  it("respects false values from gateway IPC", async () => {
+    mockGatewayIpc({ "gated-feature": true, "disabled-feature": false });
 
     await initFeatureFlagOverrides();
 
-    // Undeclared flags default to true without overrides
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("gated-feature", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("disabled-feature", config)).toBe(
+      false,
+    );
   });
 
-  it("initializes signing key lazily when not yet set", async () => {
-    // Reset signing key to simulate fresh CLI subprocess
-    tokenService._resetSigningKeyForTesting();
-    delete process.env.ACTOR_TOKEN_SIGNING_KEY;
-
-    expect(tokenService.isSigningKeyInitialized()).toBe(false);
-
-    mockFetch(
-      "/v1/feature-flags",
-      { method: "GET" },
-      {
-        body: {
-          flags: [{ key: "expected-enabled", enabled: true }],
-        },
-        status: 200,
-      },
-    );
+  it("does not cache empty gateway response", async () => {
+    mockGatewayIpc({});
 
     await initFeatureFlagOverrides();
 
-    // Signing key should have been initialized during the fetch
-    expect(tokenService.isSigningKeyInitialized()).toBe(true);
-
-    // And the flag should be resolved correctly
+    // Undeclared flags without overrides default to true (not false from
+    // a cached empty map)
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("expected-enabled", config)).toBe(
-      true,
-    );
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
   });
 
-  it("does not cache empty gateway response", async () => {
-    mockFetch(
-      "/v1/feature-flags",
-      { method: "GET" },
-      { body: { flags: [] }, status: 200 },
-    );
+  it("does not re-fetch when cache is already populated", async () => {
+    mockGatewayIpc({ "first-call": true });
+
+    await initFeatureFlagOverrides();
+
+    // Change what IPC would return — if the guard is broken and init
+    // re-fetches, "first-call" would flip to false.
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "first-call": false, "second-call": true });
 
     await initFeatureFlagOverrides();
 
-    // Undeclared flags without overrides default to true (not false from
-    // a cached empty map)
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    // first-call must still be true (from the cached first fetch)
+    expect(isAssistantFeatureFlagEnabled("first-call", config)).toBe(true);
+    // second-call should not be in the cache since init was a no-op
+    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(true); // defaults to true (undeclared)
   });
 });