@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/__tests__/ui-voice-picker-surface.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Tests for the `voice_picker` ui_show surface's "never blocks a turn"
+ * invariant.
+ *
+ * The card has no terminal action: it settles when the user picks a voice,
+ * with no button to click. `actions` and `await_action` are generic ui_show
+ * params though, so the model can attach them to any surface, and the web
+ * client latches `awaiting_user_input` on the presence of actions alone with
+ * nothing to clear it. The daemon resolver therefore strips both, and a
+ * pending picker never holds the one-interactive-surface lock.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { UISurfaceShowEventSchema } from "../api/events/ui-surface-show.js";
+import type { AssistantEvent } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  createSurfaceMutex,
+  surfaceProxyResolver,
+} from "../daemon/conversation-surfaces.js";
+import type { SurfaceType } from "../daemon/message-protocol.js";
+import { INTERACTIVE_SURFACE_TYPES } from "../daemon/message-protocol.js";
+import { asConversation } from "./helpers/mock-conversation.js";
+
+function makeContext(sent: AssistantEvent[] = []): Conversation {
+  return asConversation({
+    conversationId: "session-1",
+    emit: (msg) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "ok",
+    withSurface: createSurfaceMutex(),
+  });
+}
+
+function showEvent(sent: AssistantEvent[]) {
+  return UISurfaceShowEventSchema.parse(
+    sent.find((msg) => msg.type === "ui_surface_show"),
+  );
+}
+
+describe("voice_picker never blocks a turn", () => {
+  test("shows with an empty payload and awaits nothing", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "voice_picker",
+      data: {},
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+
+    const parsed = showEvent(sent);
+    expect(parsed.surfaceType).toBe("voice_picker");
+    expect(parsed.actions).toBeUndefined();
+    expect(ctx.pendingSurfaceActions.has(parsed.surfaceId)).toBe(false);
+  });
+
+  test("strips actions the model attached", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "voice_picker",
+      data: {},
+      actions: [{ id: "done", label: "Done", style: "primary" }],
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+
+    const parsed = showEvent(sent);
+    expect(parsed.actions).toBeUndefined();
+    // The persisted copy must match the emitted one, or a history reseed would
+    // resurrect the button the client blocks on.
+    expect(ctx.currentTurnSurfaces[0]?.actions).toBeUndefined();
+    expect(ctx.pendingSurfaceActions.has(parsed.surfaceId)).toBe(false);
+  });
+
+  test("ignores an explicit await_action", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "voice_picker",
+      data: {},
+      await_action: true,
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+    expect(result.content).not.toContain("awaiting_user_action");
+    expect(ctx.pendingSurfaceActions.size).toBe(0);
+  });
+
+  test("a pending picker does not hold the one-interactive-surface lock", async () => {
+    const ctx = makeContext();
+    ctx.pendingSurfaceActions.set("surface-picker", {
+      surfaceType: "voice_picker",
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "choice",
+      data: { options: [{ id: "a", title: "Option A" }] },
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("already awaiting user input");
+  });
+
+  test("voice_picker is not an interactive surface type", () => {
+    expect(INTERACTIVE_SURFACE_TYPES).not.toContain("voice_picker");
+  });
+});

package/src/__tests__/ui-work-result-surface.test.ts

@@ -19,7 +19,7 @@ import { asConversation } from "./helpers/mock-conversation.js";
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

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

@@ -23,11 +23,12 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
   getCachedUserTools,
-  getUserHooksFor,
   resetPluginCacheForTests,
 } from "../plugins/mtime-cache.js";
+import { resetPluginRegistryForTests } from "../plugins/registry.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";
 
 // Isolate every run under its own tempdir so parallel test files (and
@@ -71,6 +72,7 @@ function clearPluginsDir(): void {
 describe("user plugin loader", () => {
   beforeEach(() => {
     resetPluginCacheForTests();
+    resetPluginRegistryForTests();
     clearPluginsDir();
   });
 

package/src/__tests__/verification-control-plane-policy.test.ts

@@ -18,9 +18,7 @@ mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
   classifyRisk: async () => ({ level: "low" }),
   check: async () => ({ decision: "allow", reason: "allowed" }),
-  generateAllowlistOptions: () => [],
   generateScopeOptions: () => [],
-  getCachedAssessment: () => undefined,
 }));
 
 mock.module("../persistence/conversation-crud.js", () => ({

package/src/__tests__/visible-app-context.test.ts

@@ -25,6 +25,7 @@ import {
 import { registerDefaultPluginInjectors } from "../plugins/defaults/index.js";
 import type { Message } from "../providers/types.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // The injector chain is registered by the daemon bootstrap in production; do
 // the same here so `applyRuntimeInjections` walks a non-empty chain.
@@ -151,15 +152,21 @@ describe("visible_app injection", () => {
   ];
 
   function seedConversation(currentTurnVisibleAppId: string | undefined): void {
-    setConversation(CONVERSATION_ID, {
-      conversationId: CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnVisibleAppId,
-      currentTurnTemporalSnapshot: { clientTimezone: null },
-    } as never);
+    setConversation(
+      CONVERSATION_ID,
+      asConversation({
+        conversationId: CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnVisibleAppId,
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+      }),
+    );
   }
 
   afterEach(() => {

package/src/__tests__/voice-config-update.test.ts

@@ -276,6 +276,46 @@ describe("voice_config_update — tts_voice_id (managed/vellum active)", () => {
     expect(result.content).not.toContain("broadcast");
   });
 
+  test("hints the inline picker for the next managed voice change", async () => {
+    makeVellumActive();
+
+    const result = await run(
+      { setting: "tts_voice_id", value: "aura-2-zeus-en" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toStartWith("Vellum managed voice updated to");
+    expect(result.content).toContain(
+      'ui_show { surface_type: "voice_picker", data: {} }',
+    );
+  });
+
+  test("does not hint the picker when the voice is not managed", async () => {
+    writeConfig({ services: { tts: { provider: "elevenlabs" } } });
+    invalidateConfigCache();
+
+    const result = await run(
+      { setting: "tts_voice_id", value: "abc123" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("voice_picker");
+  });
+
+  test("does not hint the picker for a non-voice setting", async () => {
+    makeVellumActive();
+
+    const result = await run(
+      { setting: "conversation_timeout", value: 30 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("voice_picker");
+  });
+
   test("rejects a value with characters invalid for any voice id", async () => {
     makeVellumActive();
 

package/src/__tests__/voice-scoped-grant-consumer.test.ts

@@ -89,7 +89,8 @@ const CALL_SESSION_ID = "call-session-voice-grant-test";
 
 /**
  * Create a mock session that, when runAgentLoop is called, emits a
- * confirmation_request through the updateClient callback before completing.
+ * confirmation_request through the registered event observer before
+ * completing.
  */
 function createMockSession(opts?: {
   confirmationRequestId?: string;
@@ -118,8 +119,9 @@ function createMockSession(opts?: {
     currentRequestId: requestId,
     abort: () => {},
     persistUserMessage: async () => ({ id: "msg-1", deduplicated: false }),
-    updateClient: (cb: (msg: AssistantEvent) => void, _reset?: boolean) => {
+    addEventObserver: (cb: (msg: AssistantEvent) => void) => {
       clientCallback = cb;
+      return () => {};
     },
     handleConfirmationResponse: (
       reqId: string,
@@ -138,7 +140,7 @@ function createMockSession(opts?: {
       _messageId: string,
       options?: { onEvent?: (msg: AssistantEvent) => void },
     ) => {
-      // Emit a confirmation_request through the client callback
+      // Emit a confirmation_request through the event observer
       if (clientCallback) {
         clientCallback({
           type: "confirmation_request",

package/src/__tests__/voice-session-bridge.test.ts

@@ -61,7 +61,7 @@ function makeStreamingSession(events: AssistantEvent[]): Conversation {
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
     setVoiceCallControlPrompt: () => {},
-    updateClient: () => {},
+    addEventObserver: () => () => {},
     ensureActorScopedHistory: async () => {},
     runAgentLoop: async (
       _content: string,
@@ -116,7 +116,7 @@ function makePersistingStreamingSession(
       turnInterfaceContext = ctx;
     },
     setVoiceCallControlPrompt: () => {},
-    updateClient: () => {},
+    addEventObserver: () => () => {},
     ensureActorScopedHistory: async () => {},
     runAgentLoop: async (
       _content: string,
@@ -254,7 +254,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));
@@ -321,6 +321,51 @@ describe("voice-session-bridge", () => {
     expect(capturedOptions?.callSite).toBe("callAgent");
   });
 
+  test("startVoiceTurn declares the turn interactive so approval prompts are raised for its observer", async () => {
+    // A caller is on the line. If the turn ran non-interactive the permission
+    // checker would deny an approval-gated tool before any prompt existed, and
+    // the bridge's approval observer (auto-resolve for a non-guardian caller, a
+    // real card for the guardian) would never get to decide. Presence is per
+    // turn, so the bridge has to say so.
+    const conversation = createConversation("voice bridge interactive test");
+    const events: AssistantEvent[] = [
+      { type: "message_complete", conversationId: conversation.id },
+    ];
+
+    let capturedOptions: Record<string, unknown> | undefined;
+    const session = {
+      ...makeStreamingSession(events),
+      runAgentLoop: async (
+        _content: string,
+        _messageId: string,
+        options?: Record<string, unknown>,
+      ) => {
+        capturedOptions = options;
+        const onEvent =
+          (options as { onEvent?: (msg: AssistantEvent) => void })?.onEvent ??
+          (() => {});
+        for (const event of events) {
+          onEvent(event);
+        }
+      },
+    } as unknown as Conversation;
+
+    injectDeps(() => session);
+
+    await startVoiceTurn({
+      conversationId: conversation.id,
+      content: "Hello",
+      isInbound: true,
+      onTextDelta: () => {},
+      onComplete: () => {},
+      onError: () => {},
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(capturedOptions?.isInteractive).toBe(true);
+  });
+
   test("external AbortSignal triggers turn abort", async () => {
     const conversation = createConversation("voice bridge signal test");
     let abortCalled = false;
@@ -339,7 +384,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));
@@ -704,13 +749,14 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
-        // Simulate the prompter emitting a confirmation_request via the
-        // updateClient callback (this is how the real prompter works).
+        // Simulate the conversation emitting a confirmation_request to its
+        // event observer (this is how the real conversation fans out).
         clientHandler({
           type: "confirmation_request",
           requestId: "req-voice-1",
@@ -796,8 +842,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -879,8 +926,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -946,8 +994,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1009,8 +1058,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1061,13 +1111,20 @@ describe("voice-session-bridge", () => {
   // broadcast in voice-session-bridge.ts's confirmation_request branch. The
   // fake's handleConfirmationResponse mirrors production's synchronous
   // `interaction_resolved` broadcast so the wire order is observable through
-  // the event hub, which serializes publishes in call order.
+  // the event hub, which serializes publishes in call order. Its `emit`
+  // mirrors a real conversation's: the sink (the hub) delivers first, then
+  // observers run, so the bridge's resolution lands after the request.
   function makeConfirmationOrderingSession(
     conversationId: string,
     requestId: string,
   ): Conversation {
     let clientHandler: (msg: AssistantEvent) => void = () => {};
+    const emit = (msg: AssistantEvent) => {
+      broadcastMessage(msg);
+      clientHandler(msg);
+    };
     return {
+      emit,
       isProcessing: () => false,
       persistUserMessage: async () => ({
         id: "test-msg-id",
@@ -1080,12 +1137,13 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
-        clientHandler({
+        emit({
           type: "confirmation_request",
           requestId,
           toolName: "host_bash",
@@ -1222,8 +1280,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (handler: (msg: AssistantEvent) => void) => {
+      addEventObserver: (handler: (msg: AssistantEvent) => void) => {
         clientHandler = handler;
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
@@ -1290,7 +1349,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -1349,7 +1408,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: recordLast("setTurnChannelContext"),
       setTurnInterfaceContext: recordLast("setTurnInterfaceContext"),
       setVoiceCallControlPrompt: recordLast("setVoiceCallControlPrompt"),
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
       handleConfirmationResponse: () => {},
@@ -1391,15 +1450,12 @@ describe("voice-session-bridge", () => {
     expect(session.forcePromptSideEffects).toBe(false);
   });
 
-  test("cleanup on early persistUserMessage throw does not detach prior client sender", async () => {
+  test("cleanup on early persistUserMessage throw does not detach a prior turn's observer", async () => {
     const conversation = createConversation(
       "voice bridge sender detach guard test",
     );
 
-    const updateClientCalls: Array<{
-      callback: unknown;
-      replace: boolean | undefined;
-    }> = [];
+    const addEventObserverCalls: unknown[] = [];
 
     const session = {
       isProcessing: () => false,
@@ -1415,8 +1471,9 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: (callback: unknown, replace?: boolean) => {
-        updateClientCalls.push({ callback, replace });
+      addEventObserver: (observer: unknown) => {
+        addEventObserverCalls.push(observer);
+        return () => {};
       },
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {},
@@ -1451,10 +1508,9 @@ describe("voice-session-bridge", () => {
     expect(caught?.message).toBe(
       "persist failed before bridge installed callback",
     );
-    // The bridge never reached its `conversation.updateClient(...)` install
-    // site, so cleanup must not touch updateClient — otherwise it would
-    // detach a sender installed by a prior turn on the same conversation.
-    expect(updateClientCalls).toEqual([]);
+    // The bridge never reached its `conversation.addEventObserver(...)`
+    // install site, so no observer was registered for cleanup to detach.
+    expect(addEventObserverCalls).toEqual([]);
   });
 
   test("pre-aborted signal triggers immediate abort", async () => {
@@ -1475,7 +1531,7 @@ describe("voice-session-bridge", () => {
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
       setVoiceCallControlPrompt: () => {},
-      updateClient: () => {},
+      addEventObserver: () => () => {},
       ensureActorScopedHistory: async () => {},
       runAgentLoop: async () => {
         await new Promise((r) => setTimeout(r, 200));

package/src/__tests__/worker-entrypoint-guards.test.ts

@@ -18,10 +18,18 @@ import { Glob } from "bun";
  * - start the PID-file identity guard — the PID file is a worker's sole
  *   tracking handle, so a worker the file stops naming can never be
  *   stopped externally and must evict itself.
+ *
+ * The subset that hosts real agent conversations
+ * ({@link CONVERSATION_RUNNING_ENTRYPOINTS}) must additionally register the
+ * default plugins' hooks and injectors, since hook dispatch is process-global
+ * and a worker that skips it runs conversations with no plugin behavior at all
+ * (no image captioning or vision-rejection recovery, no tool-result
+ * truncation, no runtime injections).
  */
 
 const DISABLE_CALL = "disableStreamSeqStamping()";
 const PID_GUARD_CALL = "startWorkerPidFileGuard(";
+const PLUGIN_SURFACE_CALL = "registerWorkerPluginSurface(";
 
 /** Shape of a shutdown that schedules `process.exit` instead of calling it. */
 const DEFERRED_EXIT = ".finally(() => process.exit";
@@ -44,6 +52,16 @@ const WORK_START_MARKERS: Record<string, string> = {
   "routes/worker.ts": 'server.on("connection"',
 };
 
+/**
+ * The entrypoints whose work wakes real agent conversations. `monitoring` (a
+ * resource sampler) and `routes` (an HTTP route host) run no conversations, so
+ * they carry no plugin surface.
+ */
+const CONVERSATION_RUNNING_ENTRYPOINTS: ReadonlySet<string> = new Set([
+  "schedule/worker.ts",
+  "plugins/defaults/memory/worker.ts",
+]);
+
 function findWorkerEntrypoints(): string[] {
   const srcRoot = join(process.cwd(), "src");
   const glob = new Glob("**/worker.ts");
@@ -137,4 +155,40 @@ describe("worker entrypoint guards", () => {
         "worker superseded at startup before it runs orphaned work.",
     ).toEqual([]);
   });
+
+  test("the conversation-running entrypoints are all discovered workers", () => {
+    const discovered = new Set(findWorkerEntrypoints());
+    const unknown = [...CONVERSATION_RUNNING_ENTRYPOINTS].filter(
+      (file) => !discovered.has(file),
+    );
+    expect(
+      unknown,
+      "CONVERSATION_RUNNING_ENTRYPOINTS names an entrypoint the glob does " +
+        "not find — the worker moved or was renamed.",
+    ).toEqual([]);
+  });
+
+  test("every conversation-running entrypoint registers the default plugin surface before starting work", () => {
+    const offenders = [...CONVERSATION_RUNNING_ENTRYPOINTS]
+      .sort()
+      .filter((file) => {
+        const source = readFileSync(join(process.cwd(), "src", file), "utf8");
+        const marker = WORK_START_MARKERS[file];
+        if (marker == null) {
+          return true;
+        }
+        const registerAt = source.indexOf(PLUGIN_SURFACE_CALL);
+        const workAt = source.indexOf(marker);
+        return registerAt < 0 || workAt < 0 || registerAt > workAt;
+      });
+    expect(
+      offenders,
+      `A worker that wakes agent conversations must call ` +
+        `${PLUGIN_SURFACE_CALL}) before its work-start call (see ` +
+        "WORK_START_MARKERS). Hook dispatch is process-global, so without it " +
+        "the conversations this process runs get no default plugin behavior: " +
+        "no vision-rejection recovery, no tool-result truncation, no runtime " +
+        "injections.",
+    ).toEqual([]);
+  });
 });