@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/conversation-sync-tags.test.ts

@@ -1,3 +1,5 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import {
@@ -8,14 +10,15 @@ import {
   projectAssistantMessage,
   recordConversationSeenSignal,
 } from "../memory/conversation-attention-store.js";
-import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as CONVERSATION_LIST_ROUTES } from "../runtime/routes/conversation-list-routes.js";
 import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { waitFor } from "./helpers/wait-for.js";
 
 initializeDb();
@@ -70,10 +73,19 @@ describe("conversation sync tags", () => {
   });
 
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
   });
 
-  test("rename emits legacy title/list events and conversation metadata sync tags", async () => {
+  test("rename emits the typed title event and a metadata-only sync tag (no list umbrella)", async () => {
+    // Rename is a content-only change: the row stays in place, the list
+    // shape is unchanged, only the title field flips. Web patches the
+    // single cached row via the typed `conversation_title_updated` event
+    // (`patchConversation` in `metadata-handlers.ts`) and the per-
+    // conversation `sync_changed` metadata tag is included as a belt-and-
+    // suspenders signal for sibling-tab consumers that missed the typed
+    // event. The legacy `conversation_list_invalidated` broadcast is
+    // scoped to `targetInterfaceId: "macos"` and therefore not visible to
+    // this process-type subscriber.
     const conversation = createConversation("Old title");
     const route = findRoute(
       CONVERSATION_MANAGEMENT_ROUTES,
@@ -85,23 +97,55 @@ describe("conversation sync tags", () => {
         pathParams: { id: conversation.id },
         body: { name: "New title" },
       });
-    }, 3);
+    }, 2);
 
     expect(received.map((event) => event.message.type)).toEqual([
       "conversation_title_updated",
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[2]!.message).toEqual({
+    expect(received[1]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    // Defense-in-depth: the umbrella `conversationsList` tag would force
+    // web to redrain the full paginated list — we deliberately omit it
+    // for content-only reasons.
+    expect((received[1]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
+    );
+    // The legacy invalidation broadcast is macOS-scoped and must not
+    // reach this process-type subscriber.
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("create emits legacy list invalidation and list/metadata sync tags", async () => {
+  test("agent-loop title updates emit metadata-only sync tags (no list umbrella)", () => {
+    const source = readFileSync(
+      join(import.meta.dir, "..", "daemon", "conversation-agent-loop.ts"),
+      "utf-8",
+    );
+    const titleUpdateBlocks =
+      source.match(
+        /type: "conversation_title_updated"[\s\S]{0,500}?type: "sync_changed"[\s\S]{0,250}?tags: \[[\s\S]*?\]/g,
+      ) ?? [];
+
+    expect(titleUpdateBlocks.length).toBeGreaterThanOrEqual(2);
+    for (const block of titleUpdateBlocks) {
+      expect(block).not.toContain("SYNC_TAGS.conversationsList");
+    }
+  });
+
+  test("create emits a sync_changed with the conversationsList umbrella tag", async () => {
+    // Create is shape-changing — a row is added to the paginated list,
+    // so web must redrain the list (cannot patch a row it has never
+    // fetched). The umbrella `conversationsList` tag is the signal for
+    // that redrain. Per-conversation metadata is included so any future
+    // single-row consumer can patch the freshly added row in place
+    // without an extra GET. The legacy macOS-only invalidation broadcast
+    // is not visible to process subscribers.
     const route = findRoute(
       CONVERSATION_MANAGEMENT_ROUTES,
       "createConversation",
@@ -113,23 +157,33 @@ describe("conversation sync tags", () => {
         body: { conversationKey: "sync-create-test" },
       })) as { id: string };
       conversationId = result.id;
-    }, 2);
+    }, 1);
 
     expect(conversationId).toBeDefined();
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
       tags: [
         SYNC_TAGS.conversationsList,
         conversationMetadataSyncTag(conversationId!),
       ],
     });
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("reorder emits list invalidation and metadata sync tags for touched conversations", async () => {
+  test("reorder emits a sync_changed with the umbrella tag and per-conversation metadata tags", async () => {
+    // Reorder changes the row position in the paginated list — also
+    // shape-changing. The umbrella `conversationsList` tag forces a
+    // redrain so the new ordering shows. Per-conversation metadata tags
+    // are bundled in to give any single-row consumer a hint that the
+    // touched conversations' positions have moved (currently web
+    // consumes only the umbrella tag; metadata tags are forward-compat).
     const first = createConversation("First");
     const second = createConversation("Second");
     const route = findRoute(
@@ -146,13 +200,12 @@ describe("conversation sync tags", () => {
           ],
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
       tags: [
         SYNC_TAGS.conversationsList,
@@ -160,9 +213,28 @@ describe("conversation sync tags", () => {
         conversationMetadataSyncTag(second.id),
       ],
     });
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("record seen emits list invalidation and metadata sync tags for the touched conversation", async () => {
+  test("record seen emits only a per-conversation metadata sync tag (no list umbrella)", async () => {
+    // Seen state is per-conversation attention metadata, not list-
+    // shaped. The old behavior emitted `sync_changed` carrying the
+    // umbrella `conversationsList` tag, which forced every subscribed
+    // web client to redrain the full paginated sidebar on every
+    // conversation switch that landed on an unseen conversation (~14
+    // requests at ~300 conversations). The current behavior emits a
+    // single `sync_changed` with only the per-conversation
+    // `conversation:<id>:metadata` tag, which web consumes by GET-and-
+    // patching the single cached row via `refreshConversationRow`.
+    //
+    // The legacy `conversation_list_invalidated` broadcast is still
+    // emitted for macOS (which has no per-row patcher) but is scoped
+    // to `targetInterfaceId: "macos"` and therefore not visible to
+    // this process-type subscriber.
     const conversation = createConversation("Attention");
     projectAssistantMessage({
       conversationId: conversation.id,
@@ -181,22 +253,32 @@ describe("conversation sync tags", () => {
           source: "test",
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
     });
+    // Defense-in-depth: the umbrella `conversationsList` tag would
+    // force the very paginated-list drain this redesign exists to
+    // avoid. It must not appear here.
+    expect((received[0]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
+    );
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
   });
 
-  test("mark unread emits list invalidation and metadata sync tags for the touched conversation", async () => {
+  test("mark unread emits only a per-conversation metadata sync tag (no list umbrella)", async () => {
+    // Symmetric with `record seen`: mark-unread flips the per-conversation
+    // hasUnseen flag back to true. Same per-conversation sync tag, same
+    // absence of list-level fan-out.
     const conversation = createConversation("Attention");
     projectAssistantMessage({
       conversationId: conversation.id,
@@ -218,18 +300,119 @@ describe("conversation sync tags", () => {
           conversationId: conversation.id,
         },
       });
-    }, 2);
+    }, 1);
 
     expect(received.map((event) => event.message.type)).toEqual([
-      "conversation_list_invalidated",
       "sync_changed",
     ]);
-    expect(received[1]!.message).toEqual({
+    expect(received[0]!.message).toEqual({
       type: "sync_changed",
-      tags: [
-        SYNC_TAGS.conversationsList,
-        conversationMetadataSyncTag(conversation.id),
-      ],
+      tags: [conversationMetadataSyncTag(conversation.id)],
+    });
+    expect((received[0]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
+    );
+    expect(
+      received.some(
+        (event) => event.message.type === "conversation_list_invalidated",
+      ),
+    ).toBe(false);
+  });
+
+  test("addMessage('assistant') emits a metadata sync tag when attention state transitions", async () => {
+    // When an assistant message transitions a conversation from seen to
+    // unseen, `addMessage` emits `conversation:<id>:metadata` so the web
+    // sidebar picks up the attention state change without a full list
+    // refetch. This is the fix for LUM-1907: background processes that
+    // add assistant messages (notification delivery, proactive artifacts)
+    // now automatically notify clients.
+    const conversation = createConversation("Attention sync");
+
+    const received = await captureEvents(async () => {
+      await addMessage(
+        conversation.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: "hello" }]),
+      );
+    }, 1);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "sync_changed",
+    ]);
+    expect(received[0]!.message).toEqual({
+      type: "sync_changed",
+      tags: [conversationMetadataSyncTag(conversation.id)],
+    });
+  });
+
+  test("addMessage('assistant') does not emit a metadata sync tag when already unseen", async () => {
+    // When the conversation is already unseen (attention cursor was
+    // already past the seen cursor), a subsequent assistant message
+    // should NOT emit a metadata tag — no state transition occurred.
+    const conversation = createConversation("Already unseen");
+    await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "first" }]),
+    );
+
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+    try {
+      await addMessage(
+        conversation.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: "second" }]),
+      );
+      // Brief wait to ensure no event is emitted
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const metadataEvents = received.filter(
+        (event) =>
+          event.message.type === "sync_changed" &&
+          (event.message as { tags: string[] }).tags.some((tag: string) =>
+            tag.includes(":metadata"),
+          ),
+      );
+      expect(metadataEvents).toHaveLength(0);
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("addMessage('user') does not emit a metadata sync tag", async () => {
+    // User messages never affect attention state — only assistant
+    // messages advance the attention cursor via projectAssistantMessage.
+    const conversation = createConversation("User message");
+
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
     });
+    try {
+      await addMessage(
+        conversation.id,
+        "user",
+        JSON.stringify([{ type: "text", text: "hello" }]),
+      );
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const metadataEvents = received.filter(
+        (event) =>
+          event.message.type === "sync_changed" &&
+          (event.message as { tags: string[] }).tags.some((tag: string) =>
+            tag.includes(":metadata"),
+          ),
+      );
+      expect(metadataEvents).toHaveLength(0);
+    } finally {
+      subscription.dispose();
+    }
   });
 });

package/src/__tests__/conversation-title-service.test.ts

@@ -37,6 +37,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversation: mockGetConversation,
   getMessages: mockGetMessages,
   updateConversationTitle: mockUpdateConversationTitle,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../providers/provider-send-message.js", () => ({

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -295,6 +295,36 @@ describe("session-tool-setup app refresh side effects", () => {
       });
     });
 
+    test("canonicalizes legacy computer_use_press_key skill_execute alias before dispatch", async () => {
+      const ctx = makeCtx({ allowedToolNames: new Set(["computer_use_key"]) });
+      const executor = makeFakeExecutor({ content: "ok", isError: false });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("skill_execute", {
+        tool: "computer_use_press_key",
+        input: {
+          key: "Space",
+          modifiers: ["Command"],
+          reasoning: "Open Spotlight",
+        },
+        activity: "Opening Spotlight",
+      });
+
+      const calls = executor.execute.mock.calls as unknown[][];
+      expect(calls[0][0]).toBe("computer_use_key");
+      expect(calls[0][1]).toEqual({
+        key: "cmd+space",
+        reasoning: "Open Spotlight",
+      });
+    });
+
     test("preserves exact active create_app skill tool when app_create is also active", async () => {
       const ctx = makeCtx({
         allowedToolNames: new Set(["create_app", "app_create"]),

package/src/__tests__/conversation-usage.test.ts

@@ -36,6 +36,7 @@ mock.module("../memory/conversation-crud.js", () => ({
       estimatedCost,
     });
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { recordUsage } from "../daemon/conversation-usage.js";

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -87,6 +87,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -110,6 +111,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationContextWindow: () => {},
   deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -116,6 +116,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -144,7 +145,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   setLastNotifiedInferenceProfile: () => {},
   getConversationOverrideProfileFromRow: () => undefined,
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -244,6 +246,9 @@ mock.module("../agent/loop.js", () => ({
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
     ): Promise<Message[]> {
+      // Prime the assistant row anchor — production code emits this from
+      // `AgentLoop.run` just before `provider.sendMessage`.
+      await onEvent({ type: "llm_call_started" });
       runCalls.push(messages);
       agentLoopScript(onEvent);
       onEvent({

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -114,6 +114,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -141,7 +142,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   setLastNotifiedInferenceProfile: () => {},
   getConversationOverrideProfileFromRow: () => undefined,
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -228,6 +230,9 @@ mock.module("../agent/loop.js", () => ({
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
     ): Promise<Message[]> {
+      // Prime the assistant row anchor — production code emits this from
+      // `AgentLoop.run` just before `provider.sendMessage`.
+      await onEvent({ type: "llm_call_started" });
       agentLoopScript(onEvent);
       onEvent({
         type: "usage",

package/src/__tests__/credential-broker-browser-fill.test.ts

@@ -28,8 +28,8 @@ mock.module("../util/logger.js", () => ({
 // Use encrypted backend with a temp store path
 // ---------------------------------------------------------------------------
 
-import { _setStorePath } from "../security/encrypted-store.js";
 import { _resetBackend } from "../security/secure-keys.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 const TEST_DIR = join(
   tmpdir(),
@@ -74,7 +74,7 @@ describe("CredentialBroker.browserFill", () => {
     for (const entry of readdirSync(TEST_DIR)) {
       rmSync(join(TEST_DIR, entry), { recursive: true, force: true });
     }
-    _setStorePath(STORE_PATH);
+    setStorePathForTesting(STORE_PATH);
     _resetBackend();
     _setMetadataPath(join(TEST_DIR, "metadata.json"));
     broker = new CredentialBroker();
@@ -82,7 +82,7 @@ describe("CredentialBroker.browserFill", () => {
 
   afterEach(() => {
     _setMetadataPath(null);
-    _setStorePath(null);
+    setStorePathForTesting(null);
     _resetBackend();
   });
 

package/src/__tests__/credential-broker-server-use.test.ts

@@ -27,8 +27,8 @@ mock.module("../util/logger.js", () => ({
 // Use encrypted backend with a temp store path
 // ---------------------------------------------------------------------------
 
-import { _setStorePath } from "../security/encrypted-store.js";
 import { _resetBackend } from "../security/secure-keys.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 const TEST_DIR = join(
   tmpdir(),
@@ -69,7 +69,7 @@ describe("CredentialBroker.serverUse", () => {
 
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
-    _setStorePath(STORE_PATH);
+    setStorePathForTesting(STORE_PATH);
     _resetBackend();
     _setMetadataPath(join(TEST_DIR, "metadata.json"));
     broker = new CredentialBroker();
@@ -77,7 +77,7 @@ describe("CredentialBroker.serverUse", () => {
 
   afterEach(() => {
     _setMetadataPath(null);
-    _setStorePath(null);
+    setStorePathForTesting(null);
     _resetBackend();
     rmSync(TEST_DIR, { recursive: true, force: true });
   });
@@ -464,7 +464,7 @@ describe("CredentialBroker.serverUseById", () => {
 
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
-    _setStorePath(STORE_PATH);
+    setStorePathForTesting(STORE_PATH);
     _resetBackend();
     _setMetadataPath(join(TEST_DIR, "metadata.json"));
     broker = new CredentialBroker();
@@ -472,7 +472,7 @@ describe("CredentialBroker.serverUseById", () => {
 
   afterEach(() => {
     _setMetadataPath(null);
-    _setStorePath(null);
+    setStorePathForTesting(null);
     _resetBackend();
     rmSync(TEST_DIR, { recursive: true, force: true });
   });

package/src/__tests__/credential-execution-client.test.ts

@@ -8,7 +8,15 @@
  * 4. The CES RPC client correctly frames requests and validates responses.
  */
 
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { describe, expect, test } from "bun:test";
 
@@ -22,6 +30,7 @@ import {
   createCesClient,
 } from "../credential-execution/client.js";
 import {
+  discoverCesWithRetry,
   discoverLocalCes,
   discoverManagedCes,
 } from "../credential-execution/executable-discovery.js";
@@ -147,6 +156,68 @@ describe("managed CES discovery", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Managed discovery retry — absorbs the sidecar's socket re-bind window
+// ---------------------------------------------------------------------------
+
+describe("discoverCesWithRetry", () => {
+  function withManagedEnv(socketPath: string): () => void {
+    const savedSocket = process.env["CES_BOOTSTRAP_SOCKET"];
+    const savedSocketDir = process.env["CES_BOOTSTRAP_SOCKET_DIR"];
+    const savedContainerized = process.env["IS_CONTAINERIZED"];
+    delete process.env["CES_BOOTSTRAP_SOCKET_DIR"];
+    process.env["CES_BOOTSTRAP_SOCKET"] = socketPath;
+    process.env["IS_CONTAINERIZED"] = "true";
+    return () => {
+      const restore = (key: string, value: string | undefined) => {
+        if (value !== undefined) process.env[key] = value;
+        else delete process.env[key];
+      };
+      restore("CES_BOOTSTRAP_SOCKET", savedSocket);
+      restore("CES_BOOTSTRAP_SOCKET_DIR", savedSocketDir);
+      restore("IS_CONTAINERIZED", savedContainerized);
+    };
+  }
+
+  test("returns unavailable after polling when the socket never appears", async () => {
+    const socketPath = join(tmpdir(), `ces-retry-missing-${Date.now()}.sock`);
+    const restore = withManagedEnv(socketPath);
+    try {
+      const start = Date.now();
+      const result = await discoverCesWithRetry({
+        timeoutMs: 200,
+        intervalMs: 20,
+      });
+      expect(result.mode).toBe("unavailable");
+      // It must actually have waited rather than failing on the first probe.
+      expect(Date.now() - start).toBeGreaterThanOrEqual(150);
+    } finally {
+      restore();
+    }
+  });
+
+  test("resolves to managed once the socket is re-bound mid-poll", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "ces-retry-"));
+    const socketPath = join(dir, "ces.sock");
+    const restore = withManagedEnv(socketPath);
+    try {
+      // Simulate the sidecar re-binding its bootstrap socket shortly after
+      // the assistant begins probing.
+      setTimeout(() => writeFileSync(socketPath, ""), 80);
+
+      const result = await discoverCesWithRetry({
+        timeoutMs: 2_000,
+        intervalMs: 20,
+      });
+      expect(result.mode).toBe("managed");
+      expect((result as { socketPath: string }).socketPath).toBe(socketPath);
+    } finally {
+      restore();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // CES client — transport and framing
 // ---------------------------------------------------------------------------