@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/__tests__/skills.test.ts

@@ -825,6 +825,38 @@ describe("always-candidate frontmatter parsing", () => {
       .map(({ id, chars }) => `${id}: ${chars}`);
     expect(overrun).toEqual([]);
   });
+
+  test("the bundled acp skill's card fits the default budget", async () => {
+    // `acp` owns Claude Code and Codex setup, sign-in, and delegation, and the
+    // terms that route those turns to it live in this card. The card is
+    // hard-truncated at the default budget, so an overrun drops the trailing
+    // hints and the whole avoid-when list from what the selector sees.
+    const { DEFAULT_CARD_CHARS, buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    expect(acp).toBeDefined();
+
+    // A card that overran is cut to exactly the budget, so staying under it is
+    // what proves nothing was dropped. `avoid-when` is appended last and is
+    // therefore the first content a truncation eats.
+    const card = buildSkillContent(acp!);
+    expect(card.length).toBeLessThan(DEFAULT_CARD_CHARS);
+    expect(card).toContain("Avoid when:");
+  });
+
+  test("the bundled acp card carries its setup and sign-in vocabulary", async () => {
+    // A "configure Claude Code" or "let's do the auth" turn only reaches this
+    // skill if the card actually says it covers setup and authentication;
+    // delegation-only wording routes those turns to a terminal skill instead.
+    const { buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    const card = buildSkillContent(acp!).toLowerCase();
+
+    for (const term of ["set up", "install", "authenticate", "connect"]) {
+      expect(card).toContain(term);
+    }
+  });
 });
 
 describe("bundled skill categories", () => {

package/src/__tests__/slack-edit-ordering-characterization.test.ts

@@ -59,7 +59,6 @@ async function applyEdit(eventId: string, content: string): Promise<void> {
     conversationExternalId: CHANNEL,
     externalMessageId: eventId,
     sourceMessageId: ORIGINAL_TS,
-    canonicalAssistantId: "self",
     assistantId: "self",
     content,
   });

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -184,8 +184,11 @@ import {
   clearConversations,
   setConversation,
 } from "../daemon/conversation-registry.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
+import { mockAuthContext } from "./helpers/mock-actor-context.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // Seed the workspace `llm` config per-case. The real loader schema-merges the
 // raw fragment over defaults exactly as the code path reads it.
@@ -304,26 +307,29 @@ describe("SubagentManager — provider call-site routing", () => {
   test("copies parent guardian and auth context into spawned conversation", async () => {
     setLlmConfig(makeLlmFixture());
 
-    const parentTrustContext = {
+    const parentTrustContext: TrustContext = {
       sourceChannel: "vellum",
       trustClass: "guardian",
       guardianPrincipalId: "guardian-1",
       guardianExternalUserId: "guardian-1",
     };
-    const parentAuthContext = {
+    const parentAuthContext = mockAuthContext({
       subject: "local:self:parent-perms",
       actorPrincipalId: "guardian-1",
-    };
+    });
 
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-perms", {
-      trustContext: parentTrustContext,
-      getAuthContext: () => parentAuthContext,
-      assistantId: "self",
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-perms",
+      asConversation({
+        trustContext: parentTrustContext,
+        getAuthContext: () => parentAuthContext,
+        assistantId: "self",
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {
@@ -354,11 +360,14 @@ describe("SubagentManager — provider call-site routing", () => {
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-scoped", {
-      enabledPlugins: parentScope,
-      getAuthContext: () => undefined,
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-scoped",
+      asConversation({
+        enabledPlugins: parentScope,
+        getAuthContext: () => undefined,
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {
@@ -383,11 +392,14 @@ describe("SubagentManager — provider call-site routing", () => {
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-unscoped", {
-      enabledPlugins: null,
-      getAuthContext: () => undefined,
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-unscoped",
+      asConversation({
+        enabledPlugins: null,
+        getAuthContext: () => undefined,
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {

package/src/__tests__/subagent-spawn-and-await.test.ts

@@ -207,6 +207,7 @@ import {
   setConversation,
 } from "../daemon/conversation-registry.js";
 import { SubagentAbortedError, SubagentManager } from "../subagent/manager.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 function makeConfig(overrides: Record<string, unknown> = {}) {
   return {
@@ -229,16 +230,19 @@ function registerFakeParent(parentConversationId: string): {
   enqueuedCount: () => number;
 } {
   let enqueued = 0;
-  setConversation(parentConversationId, {
-    // Accessors read by setUpSubagent when copying trust/auth context.
-    trustContext: undefined,
-    getAuthContext: () => undefined,
-    assistantId: undefined,
-    enqueueMessage: () => {
-      enqueued += 1;
-      return { rejected: false, queued: true };
-    },
-  } as never);
+  setConversation(
+    parentConversationId,
+    asConversation({
+      // Accessors read by setUpSubagent when copying trust/auth context.
+      trustContext: undefined,
+      getAuthContext: () => undefined,
+      assistantId: undefined,
+      enqueueMessage: () => {
+        enqueued += 1;
+        return { rejected: false, queued: true, requestId: "req-fake" };
+      },
+    }),
+  );
   return { enqueuedCount: () => enqueued };
 }
 

package/src/__tests__/turn-events-store.test.ts

@@ -331,3 +331,46 @@ describe("queryUnreportedTurnEvents", () => {
     expect(() => stampTurnOutcome("no-such-message", "failed")).not.toThrow();
   });
 });
+
+describe("unfinalized rows and turn accounting", () => {
+  test("an in-flight grouped tool-result row is not a real user turn", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const first = await insertUserMessageAt(conv.id, "real question", 1000);
+    // The grouped tool-result row: user-role, reserved unfinalized while
+    // tool output streams, content a { ref } that does not contain the
+    // tool_result text the content exclusions match. Without the finalized
+    // predicate it counts as a phantom user turn until the fold.
+    const inflight = await insertUserMessageAt(
+      conv.id,
+      JSON.stringify({ ref: "conversations/conv/inflight/x.jsonl" }),
+      2000,
+    );
+    getDb().run(`UPDATE messages SET finalized = 0 WHERE id = '${inflight}'`);
+    const second = await insertUserMessageAt(conv.id, "second question", 3000);
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const ids = events
+      .filter((e) => e.conversationId === conv.id)
+      .map((e) => e.id);
+
+    expect(ids).toEqual([first, second]);
+    const byId = Object.fromEntries(events.map((e) => [e.id, e]));
+    expect(byId[first].turnIndex).toBe(1);
+    expect(byId[second].turnIndex).toBe(2);
+  });
+
+  test("a persisted empty-display user row still counts as a turn", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const real = await insertUserMessageAt(conv.id, "real question", 1000);
+    // A hidden send persists its user row with [] content (displayContent "")
+    // and still runs a turn, so [] rows must stay in turn accounting.
+    const hidden = await insertUserMessageAt(conv.id, "[]", 2000);
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const ids = events
+      .filter((e) => e.conversationId === conv.id)
+      .map((e) => e.id);
+
+    expect(ids).toEqual([real, hidden]);
+  });
+});

package/src/__tests__/ui-shape-teaching.test.ts

@@ -5,6 +5,7 @@ import { uiShowTool } from "../tools/ui-surface/definitions.js";
 import {
   SURFACE_SHAPE_DOCS,
   SURFACE_TYPE_NAMES,
+  UI_SHOW_TYPE_DOCS,
   uiShowTeachingError,
 } from "../tools/ui-surface/surface-shape-docs.js";
 
@@ -290,6 +291,12 @@ describe("ui_show displayable payloads proxy through", () => {
         surfaceType: "channel_setup",
         input: { surface_type: "channel_setup", data: { channel: "telegram" } },
       },
+      {
+        // The picker reads its own voice and catalog, so an empty payload is
+        // the whole contract and there is no missing-content state to teach.
+        surfaceType: "voice_picker",
+        input: { surface_type: "voice_picker", data: {} },
+      },
     ];
 
   for (const { surfaceType, input } of cases) {
@@ -347,4 +354,30 @@ describe("uiShowTeachingError", () => {
       expect(uiShowTool.description).toContain(name);
     }
   });
+
+  test("voice_picker is a cold type that accepts an empty payload", () => {
+    expect(
+      uiShowTeachingError({ surface_type: "voice_picker", data: {} }),
+    ).toBeNull();
+    expect(UI_SHOW_TYPE_DOCS).toContain(
+      `voice_picker (${SURFACE_SHAPE_DOCS.voice_picker!.purpose})`,
+    );
+    expect(UI_SHOW_TYPE_DOCS).not.toContain("- voice_picker:");
+  });
+
+  test("voice_picker steering reaches the model through the cold index", () => {
+    // Asserted on the built description rather than the doc entry: a cold
+    // type's `shape` reaches the model only through a teaching error, and an
+    // empty payload has no missing-content state to raise one, so steering
+    // parked there would be dead.
+    for (const directive of [
+      "change, hear, or pick a voice",
+      "rather than describing voices in prose",
+      "attach no actions and never set await_action",
+      "during a live voice call answer in speech",
+    ]) {
+      expect(UI_SHOW_TYPE_DOCS).toContain(directive);
+      expect(uiShowTool.description).toContain(directive);
+    }
+  });
 });

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",
+    sendToClient: (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__/user-plugin-loader.test.ts

@@ -23,9 +23,9 @@ 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 { loadUserPlugins } from "../plugins/user-loader.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__/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([]);
+  });
 });

package/src/__tests__/worker-plugin-surface.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Tests for {@link registerWorkerPluginSurface}, the default-plugin surface
+ * that sidecar worker processes install at startup.
+ *
+ * A worker that wakes real agent conversations shares the daemon's
+ * process-global hook and injector registries, so registering the defaults is
+ * what gives those conversations the same behavior as daemon conversations.
+ * Registration must populate both tables and stay idempotent, and it must do so
+ * without running any plugin `init` hook (the memory plugin's init starts the
+ * memory jobs worker process itself).
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getHookEntriesFor } from "../hooks/registry.js";
+import {
+  clearInjectorRegistry,
+  getRegisteredInjectors,
+} from "../plugins/injector-registry.js";
+import { resetPluginRegistryForTests } from "../plugins/registry.js";
+import { registerWorkerPluginSurface } from "../plugins/worker-plugin-surface.js";
+
+async function hookOwnersFor(name: string): Promise<string[]> {
+  const entries = await getHookEntriesFor(name);
+  return entries.map((entry) => entry.owner.id);
+}
+
+describe("registerWorkerPluginSurface", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    clearInjectorRegistry();
+  });
+
+  test("serves the default plugins' hooks from the process-global registry", async () => {
+    expect(await hookOwnersFor("post-model-call")).not.toContain(
+      "default-image-fallback",
+    );
+
+    registerWorkerPluginSurface();
+
+    // The vision-rejection recovery that a worker without this surface never
+    // ran, plus an oversized-tool-result guard on the other hook surface.
+    expect(await hookOwnersFor("post-model-call")).toContain(
+      "default-image-fallback",
+    );
+    expect(await hookOwnersFor("post-tool-use")).toContain(
+      "default-tool-result-truncate",
+    );
+  });
+
+  test("registers the injector-only defaults' runtime injectors", () => {
+    expect(
+      getRegisteredInjectors().some((i) => i.name === "unified-turn-context"),
+    ).toBe(false);
+
+    registerWorkerPluginSurface();
+
+    // `default-turn-context` contributes no hooks, so its injections only reach
+    // a worker's conversations through the injector registry.
+    expect(
+      getRegisteredInjectors().some((i) => i.name === "unified-turn-context"),
+    ).toBe(true);
+  });
+
+  test("is idempotent: a second call neither throws nor duplicates", async () => {
+    registerWorkerPluginSurface();
+    const hooksAfterFirst = await hookOwnersFor("post-model-call");
+    const injectorsAfterFirst = getRegisteredInjectors().map((i) => i.name);
+
+    expect(() => registerWorkerPluginSurface()).not.toThrow();
+
+    expect(await hookOwnersFor("post-model-call")).toEqual(hooksAfterFirst);
+    expect(getRegisteredInjectors().map((i) => i.name)).toEqual(
+      injectorsAfterFirst,
+    );
+  });
+});