@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/plugins/defaults/image-fallback/__tests__/image-fallback.test.ts

@@ -12,11 +12,8 @@ import type {
 
 // ─── Mocks ──────────────────────────────────────────────────────────────────
 
-// Control doesSupportVision from the test: by profile key for the
-// user-prompt-submit path (ModelProfileInfo) and by model id for the
-// post-tool-use path (bare string).
+// Control doesSupportVision per-profile from the test.
 let visionProfiles: Set<string>;
-let visionModels: Set<string>;
 let mockProfiles: ModelProfileInfo[];
 let sendMessageResponse = {
   content: [{ type: "text", text: "A red chart showing Q3 revenue." }],
@@ -33,10 +30,8 @@ const fakeProvider = {
 // Mock @vellumai/plugin-api — only the runtime handles the plugin imports.
 // `extractAllText` stays real (imported from the relative path, not plugin-api).
 mock.module("@vellumai/plugin-api", () => ({
-  doesSupportVision: (arg: ModelProfileInfo | string) =>
-    typeof arg === "string"
-      ? visionModels.has(arg)
-      : visionProfiles.has(arg.key),
+  doesSupportVision: (profile: ModelProfileInfo) =>
+    visionProfiles.has(profile.key),
   getModelProfiles: () => mockProfiles,
   getConfiguredProvider: async () => (providerResolves ? fakeProvider : null),
 }));
@@ -141,9 +136,6 @@ function makeToolCtx(
 
 beforeEach(() => {
   visionProfiles = new Set<string>(["vision-profile"]);
-  // "text-only-model" (the default post-tool-use ctx.model) is absent, so it
-  // reads as text-only; a vision model id is added per-test.
-  visionModels = new Set<string>();
   mockProfiles = [
     profile("text-only", { label: "Text Only", isActive: true }),
     profile("vision-profile", { label: "Vision" }),
@@ -263,10 +255,7 @@ describe("image-fallback user-prompt-submit hook", () => {
     };
     // Override the mock to track calls.
     mock.module("@vellumai/plugin-api", () => ({
-      doesSupportVision: (arg: ModelProfileInfo | string) =>
-        typeof arg === "string"
-          ? visionModels.has(arg)
-          : visionProfiles.has(arg.key),
+      doesSupportVision: (p: ModelProfileInfo) => visionProfiles.has(p.key),
       getModelProfiles: () => mockProfiles,
       getConfiguredProvider: async () => trackingProvider,
     }));
@@ -284,10 +273,7 @@ describe("image-fallback user-prompt-submit hook", () => {
 
     // Restore the original mock for other tests.
     mock.module("@vellumai/plugin-api", () => ({
-      doesSupportVision: (arg: ModelProfileInfo | string) =>
-        typeof arg === "string"
-          ? visionModels.has(arg)
-          : visionProfiles.has(arg.key),
+      doesSupportVision: (p: ModelProfileInfo) => visionProfiles.has(p.key),
       getModelProfiles: () => mockProfiles,
       getConfiguredProvider: async () =>
         providerResolves ? fakeProvider : null,
@@ -360,10 +346,9 @@ describe("image-fallback post-tool-use hook", () => {
     );
   });
 
-  test("is a no-op when the model that ran supports vision", async () => {
-    visionModels = new Set(["vision-model"]);
+  test("is a no-op when the active model supports vision", async () => {
+    visionProfiles = new Set(["text-only"]); // active profile supports vision
     const ctx = makeToolCtx({
-      model: "vision-model",
       toolResponse: toolResult([imageBlock("shot1")]),
     });
     await postToolUse(ctx);
@@ -413,29 +398,4 @@ describe("image-fallback post-tool-use hook", () => {
     const text = (ctx.toolResponse.contentBlocks![0] as { text: string }).text;
     expect(text).not.toContain("saved to");
   });
-
-  test("is a no-op when contentBlocks carry no image", async () => {
-    const textBlock = { type: "text" as const, text: "just text" };
-    const ctx = makeToolCtx({ toolResponse: toolResult([textBlock]) });
-    await postToolUse(ctx);
-    expect(ctx.toolResponse.contentBlocks![0]).toEqual(textBlock);
-  });
-
-  test("gates on ctx.model, not the workspace active profile", async () => {
-    // The active profile is vision-capable, but the model that actually ran
-    // (ctx.model) is text-only — the model that ran must win, so the image is
-    // captioned.
-    mockProfiles = [
-      profile("vision-active", { isActive: true }),
-      profile("vision-profile", {}),
-    ];
-    visionProfiles = new Set(["vision-active", "vision-profile"]);
-    visionModels = new Set<string>(); // "text-only-model" is text-only
-    const ctx = makeToolCtx({
-      model: "text-only-model",
-      toolResponse: toolResult([imageBlock("shot1")]),
-    });
-    await postToolUse(ctx);
-    expect(ctx.toolResponse.contentBlocks![0].type).toBe("text");
-  });
 });

package/src/plugins/defaults/image-fallback/hooks/post-tool-use.ts

@@ -1,5 +1,5 @@
 /**
- * Default `post-tool-use` hook: when the turn's model is text-only, captions
+ * Default `post-tool-use` hook: when the active model is text-only, captions
  * the image blocks a tool returns (e.g. a `browser_screenshot`) and
  * substitutes the caption as a text block so the result stays sendable to a
  * provider that would otherwise reject the raw image.
@@ -9,14 +9,15 @@
  * rather than the top-level message content the `user-prompt-submit` hook
  * handles. Both share {@link captionImageBlocks}.
  *
- * Capability is read straight off `ctx.model` — the provider-reported model id
- * for the turn that issued this tool call — so the decision tracks the model
- * that actually ran, including a text-only override. The substitution is in
- * place, so the persisted/displayed tool result carries the caption too.
+ * The active model is resolved from the workspace's active profile — the
+ * post-tool-use context carries the running model, and the active profile is
+ * what the loop is executing this turn. If that profile supports vision, the
+ * hook is a no-op and the image reaches the model untouched.
  */
 
 import {
   doesSupportVision,
+  getModelProfiles,
   type PluginHookFn,
   type PostToolUseContext,
 } from "@vellumai/plugin-api";
@@ -25,13 +26,13 @@ import { captionImageBlocks } from "../src/caption-blocks.js";
 import { findVisionProfile } from "../src/vision-caption.js";
 
 const postToolUse: PluginHookFn<PostToolUseContext> = async (ctx) => {
-  // Cheapest gate first: bail unless the tool actually returned an image,
-  // before touching the model catalog or resolving a vision profile.
   const blocks = ctx.toolResponse.contentBlocks;
-  if (blocks == null || !blocks.some((b) => b.type === "image")) return;
+  if (blocks == null || blocks.length === 0) return;
 
-  // If the model that ran already supports vision, leave the image in place.
-  if (doesSupportVision(ctx.model)) return;
+  // If the active model already supports vision, leave the image in place.
+  const activeProfile = getModelProfiles().find((p) => p.isActive);
+  if (activeProfile == null) return;
+  if (doesSupportVision(activeProfile)) return;
 
   // Find a vision-capable profile for captioning.
   const visionProfileKey = findVisionProfile();

package/src/plugins/defaults/image-fallback/hooks/user-prompt-submit.ts

@@ -1,5 +1,5 @@
 /**
- * Default `user-prompt-submit` hook: when the turn's model is text-only,
+ * Default `user-prompt-submit` hook: when the active model is text-only,
  * captions image blocks via a vision-capable profile and substitutes the
  * caption as a text block so the model can still reason about the image's
  * content.
@@ -7,14 +7,13 @@
  * The hook runs once per user turn, after the assistant assembles
  * `latestMessages` and before they flow into `agentLoop.run()`. It:
  *
- * 1. Checks whether the turn's model needs image→text fallback via
- *    {@link needsImageFallback} (resolving the turn's `modelProfileKey`, or the
- *    workspace's active profile when the key is `null`). If the model handles
- *    images, the hook is a no-op.
+ * 1. Resolves the active profile from `modelProfileKey` (or the workspace's
+ *    active profile when the key is `null`) and checks `doesSupportVision`.
+ *    If the model already handles images, the hook is a no-op.
  * 2. Finds a vision-capable profile for captioning via `findVisionProfile`.
  *    If none exists, images are replaced with a fail-open placeholder so the
  *    model at least knows an image was present.
- * 3. Replaces each image block with a `[Image …]` text caption via
+ * 3. Replaces each `ImageContent` block with a `[Image …]` text caption via
  *    {@link captionImageBlocks} (which also persists the original and caches
  *    captions across turns).
  *
@@ -23,19 +22,28 @@
  */
 
 import {
+  doesSupportVision,
+  getModelProfiles,
   type PluginHookFn,
   type UserPromptSubmitContext,
 } from "@vellumai/plugin-api";
 
-import {
-  captionImageBlocks,
-  needsImageFallback,
-} from "../src/caption-blocks.js";
+import { captionImageBlocks } from "../src/caption-blocks.js";
 import { findVisionProfile } from "../src/vision-caption.js";
 
 const userPromptSubmit: PluginHookFn<UserPromptSubmitContext> = async (ctx) => {
-  // If the turn's model already supports vision, nothing to do.
-  if (!needsImageFallback(ctx.modelProfileKey)) return;
+  // Resolve the active profile from modelProfileKey, falling back to the
+  // workspace's active profile when the key is null (profile unchanged since
+  // the last notified turn).
+  const profiles = getModelProfiles();
+  const activeProfile =
+    ctx.modelProfileKey != null
+      ? profiles.find((p) => p.key === ctx.modelProfileKey)
+      : profiles.find((p) => p.isActive);
+  if (activeProfile == null) return;
+
+  // If the active model already supports vision, nothing to do.
+  if (doesSupportVision(activeProfile)) return;
 
   // Find a vision-capable profile for captioning.
   const visionProfileKey = findVisionProfile();

package/src/plugins/defaults/image-fallback/src/caption-blocks.ts

@@ -1,62 +1,31 @@
 /**
  * Shared image→text substitution for the image-fallback plugin's hooks.
  *
- * Two hooks replace `image` content blocks with a text caption when the turn's
+ * Two hooks replace `image` content blocks with a text caption when the active
  * model can't process images: `user-prompt-submit` handles user-attached
  * images, and `post-tool-use` handles images a tool returns (e.g. a browser
- * screenshot). This module holds what they share — deciding whether a profile
- * needs the fallback ({@link needsImageFallback}) and the per-block
- * substitution ({@link captionImageBlocks}): persist the original image to a
- * known location, caption it via a vision-capable profile, and swap in a
- * `[Image …]` text block.
+ * screenshot). This module holds the per-block substitution they share —
+ * persist the original image to a known location, caption it via a
+ * vision-capable profile, and swap in a `[Image …]` text block.
  *
- * The substitution mutates the blocks in place, so the caption replaces the
- * image everywhere the block is referenced (the provider-bound history and the
- * persisted/displayed copy alike) — a text-only turn does not keep the raw
- * image around.
- *
- * The caption text states up front that the model can't view images and the
- * image was auto-described to text, so the model treats the block as a derived
- * description rather than a verbatim transcript.
+ * The caption text states up front that the active model can't view images and
+ * the image was auto-described to text, so the model treats the block as a
+ * derived description rather than a verbatim transcript.
  *
  * Fail-open is the dominant error mode: a captioning failure leaves a
  * placeholder text block rather than the raw image (which a text-only provider
  * would reject) or nothing (which would lose information).
  */
 
-import {
-  type ContentBlock,
-  doesSupportVision,
-  getModelProfiles,
-  type ImageContent,
-  type PluginLogger,
+import type {
+  ContentBlock,
+  ImageContent,
+  PluginLogger,
 } from "@vellumai/plugin-api";
 
 import { persistImage } from "./image-persist.js";
 import { captionImage } from "./vision-caption.js";
 
-/**
- * Whether the profile a turn runs needs image→text fallback (i.e. it can't
- * process images itself).
- *
- * Used by `user-prompt-submit`, whose context carries the profile key rather
- * than the resolved model id: prefer the turn's `modelProfileKey` — which
- * carries a text-only override even when the workspace's active profile is
- * vision-capable — and fall back to the active profile only when the key is
- * `null` (profile unchanged since the last notified turn). Returns `false` when
- * no profile resolves or the resolved model already supports vision, in which
- * case the image reaches the model untouched.
- */
-export function needsImageFallback(modelProfileKey: string | null): boolean {
-  const profiles = getModelProfiles();
-  const activeProfile =
-    modelProfileKey != null
-      ? profiles.find((p) => p.key === modelProfileKey)
-      : profiles.find((p) => p.isActive);
-  if (activeProfile == null) return false;
-  return !doesSupportVision(activeProfile);
-}
-
 /**
  * Replace every `image` block in `blocks` (in place) with a text caption so a
  * text-only model can still reason about the image's content. Returns the

package/src/plugins/defaults/memory-v3-shadow/__tests__/injection.test.ts

@@ -67,17 +67,13 @@ let pruneConfig: {
   maxResidentBytes: number;
   targetResidentBytes: number;
 } | null = null;
-/** Canned orchestrate result per turnIndex; `null` simulates an ordinary miss. */
-let turnResults = new Map<number, OrchestrateResult | null | Error>();
+/** Canned orchestrate result per turnIndex; `null` simulates a failed turn. */
+let turnResults = new Map<number, OrchestrateResult | null>();
 const observeTurnSpy = mock(
   async (
     _conversationId: string,
     turnIndex: number,
-  ): Promise<OrchestrateResult | null> => {
-    const value = turnResults.get(turnIndex) ?? null;
-    if (value instanceof Error) throw value;
-    return value;
-  },
+  ): Promise<OrchestrateResult | null> => turnResults.get(turnIndex) ?? null,
 );
 
 const logCalls: Array<{ data: unknown; msg: string }> = [];
@@ -203,9 +199,6 @@ const {
 } = await import("../ever-injected-store.js");
 const { V3_CARDS_INJECTION_HEADER } = await import("../render-injection.js");
 const { flushPruneValveForTests } = await import("../prune.js");
-const { drainConversationNotices, resetConversationNoticesForTests } =
-  await import("../../../../daemon/conversation-notices.js");
-const { MemoryV3RetrievalUnavailableError } = await import("../pool-select.js");
 
 // ─── helpers ────────────────────────────────────────────────────────────────
 
@@ -320,7 +313,6 @@ beforeEach(async () => {
   logCalls.length = 0;
   testDb = makeDb();
   resetMemoryV3InjectorStateForTests();
-  resetConversationNoticesForTests();
 });
 
 afterAll(async () => {
@@ -343,28 +335,6 @@ describe("memoryV3Injector — frozen net-new cards", () => {
     expect(getActiveSlugs("conv-1")).toEqual(new Set());
   });
 
-  test("live retrieval failure queues a degraded-memory notice", async () => {
-    liveEnabled = true;
-    turnResults.set(
-      0,
-      new MemoryV3RetrievalUnavailableError("selector unavailable"),
-    );
-
-    await expect(produceCardsWithoutCommit("conv-1", 0)).resolves.toBeNull();
-
-    expect(drainConversationNotices("conv-1")).toEqual([
-      {
-        type: "conversation_notice",
-        conversationId: "conv-1",
-        source: "memory_v3",
-        code: "UNKNOWN",
-        userMessage:
-          "Memory is temporarily unavailable, so this response may not use your saved memories. You can retry in a moment.",
-        errorCategory: "memory_v3_degraded",
-      },
-    ]);
-  });
-
   test("turn 1 renders cards; turn 2 re-selecting the same pages renders ZERO new cards", async () => {
     liveEnabled = true;
     turnResults.set(0, result(["page-a", "page-b"]));

package/src/plugins/defaults/memory-v3-shadow/__tests__/pool-select.test.ts

@@ -26,7 +26,6 @@
  * The provider is stubbed so no network calls fire; mirrors selector.test.ts.
  */
 
-import { createRequire } from "node:module";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
@@ -36,7 +35,6 @@ import type {
   SendMessageOptions,
   ToolUseContent,
 } from "../../../../providers/types.js";
-import { ProviderError } from "../../../../util/errors.js";
 import type { MemoryRoutingTurn } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -45,11 +43,6 @@ import type { MemoryRoutingTurn } from "../types.js";
 // ---------------------------------------------------------------------------
 
 let providerStub: Provider | null = null;
-const registryReal = {
-  ...(createRequire(import.meta.url)(
-    "../../../../providers/registry.js",
-  ) as Record<string, unknown>),
-};
 
 interface ProviderCall {
   messages: Message[];
@@ -64,12 +57,6 @@ mock.module("../../../../providers/provider-send-message.js", () => ({
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
 }));
 
-mock.module("../../../../providers/registry.js", () => ({
-  ...registryReal,
-  getProviderRoutingSource: (providerName: string) =>
-    providerName === "managed" ? "managed-proxy" : "user-key",
-}));
-
 mock.module("../../../../util/logger.js", () => ({
   getLogger: () => ({
     warn: (...args: unknown[]) => warnCalls.push({ args }),
@@ -266,9 +253,10 @@ describe("selectPool — id mapping", () => {
 });
 
 // ---------------------------------------------------------------------------
-// selectPool — infrastructure failures THROW. A deliberate empty selection and
-// an empty pool (covered above) still return normally; only a genuine infra
-// failure throws so callers can log it distinctly from an empty selection.
+// selectPool — infrastructure failures THROW (no silent degradation). A
+// deliberate empty selection and an empty pool (covered above) still return
+// normally; only a genuine infra failure throws so the LIVE injector can
+// hard-fail the turn instead of shipping it with no memory.
 // ---------------------------------------------------------------------------
 
 describe("selectPool — infrastructure failures throw", () => {
@@ -383,38 +371,6 @@ describe("selectPool — infrastructure failures throw", () => {
     ]);
   });
 
-  test("managed provider 402 attaches a non-terminal credits notice", async () => {
-    providerStub = {
-      name: "managed",
-      sendMessage: async (messages, options) => {
-        providerCalls.push({ messages, options });
-        throw new ProviderError(
-          "Together AI API error (402): 402 status code (no body)",
-          "managed",
-          402,
-        );
-      },
-    };
-    let caught: unknown;
-    try {
-      await selectPool(makePool(), makeTurn("x"));
-    } catch (err) {
-      caught = err;
-    }
-
-    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
-    const notice = (
-      caught as InstanceType<typeof MemoryV3RetrievalUnavailableError>
-    ).conversationNotice;
-    expect(notice).toEqual({
-      source: "memory_v3",
-      code: "PROVIDER_BILLING",
-      userMessage:
-        "You've run out of credits. Add funds to continue using the assistant.",
-      errorCategory: "credits_exhausted",
-    });
-  });
-
   test("provider throw redacts sensitive message details in diagnostics", async () => {
     const providerSecret = ["sk-proj-", "a".repeat(40)].join("");
     const message = `provider rejected Authorization: Bearer ${providerSecret}`;

package/src/plugins/defaults/memory-v3-shadow/__tests__/shadow-plugin.test.ts

@@ -808,7 +808,7 @@ describe("memory-v3 shadow plugin", () => {
   });
 });
 
-describe("memory-v3 infrastructure-failure handling", () => {
+describe("memory-v3 infrastructure-failure handling (hard-fail vs swallow)", () => {
   const throwInfra = () =>
     orchestrateSpy.mockImplementationOnce(async () => {
       throw new MemoryV3RetrievalUnavailableError(
@@ -816,12 +816,14 @@ describe("memory-v3 infrastructure-failure handling", () => {
       );
     });
 
-  test("LIVE injector logs and degrades to no v3 block on an infra failure", async () => {
+  test("LIVE injector HARD-FAILS the turn on an infra failure (no silent memory loss)", async () => {
     liveEnabled = true;
     shadowEnabled = false;
     throwInfra();
 
-    expect(await produce("conv-infra-live", 0)).toBeNull();
+    await expect(produce("conv-infra-live", 0)).rejects.toThrow(
+      MemoryV3RetrievalUnavailableError,
+    );
   });
 
   test("SHADOW injector swallows an infra failure (v2 fallback) — no throw, no block", async () => {
@@ -830,7 +832,7 @@ describe("memory-v3 infrastructure-failure handling", () => {
     throwInfra();
 
     // Shadow mode: v2 retrieval still ran this turn, so the v3 injector returns
-    // null.
+    // null rather than failing the turn.
     expect(await produce("conv-infra-shadow", 0)).toBeNull();
   });
 
@@ -851,6 +853,8 @@ describe("memory-v3 infrastructure-failure handling", () => {
       throw new Error("some unexpected non-infra bug");
     });
 
+    // Only INFRA failures hard-fail; any other error stays non-fatal so a bug
+    // in one lane can't take every turn down.
     expect(await produce("conv-nonfatal-live", 0)).toBeNull();
   });
 });

package/src/plugins/defaults/memory-v3-shadow/injector.ts

@@ -63,10 +63,6 @@
 import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../config/loader.js";
 import { isMemoryV3Live } from "../../../config/memory-v3-gate.js";
-import {
-  type PendingConversationNotice,
-  queueConversationNotice,
-} from "../../../daemon/conversation-notices.js";
 import { isPersonalMemoryAllowed } from "../../../daemon/trust-context.js";
 import {
   wrapMemoryBlock,
@@ -124,26 +120,6 @@ function lruSet<V>(map: Map<string, V>, key: string, value: V): void {
   map.set(key, value);
 }
 
-function queueMemoryV3ConversationNotice(
-  err: MemoryV3RetrievalUnavailableError,
-  ctx: TurnContext,
-  live: boolean,
-): void {
-  if (!live) return;
-  const notice: PendingConversationNotice = err.conversationNotice ?? {
-    source: "memory_v3",
-    code: "UNKNOWN",
-    userMessage:
-      "Memory is temporarily unavailable, so this response may not use your saved memories. You can retry in a moment.",
-    errorCategory: "memory_v3_degraded",
-  };
-  queueConversationNotice(
-    ctx.conversationId,
-    `memory_v3:${ctx.turnIndex}:${notice.errorCategory ?? notice.code}`,
-    notice,
-  );
-}
-
 // ─── shared per-turn orchestration memo ─────────────────────────────────────
 
 interface ObservedTurn {
@@ -269,16 +245,16 @@ export const memoryV3Injector: Injector = {
     try {
       observed = await observeTurnOnce(ctx.conversationId, ctx.turnIndex);
     } catch (err) {
-      if (err instanceof MemoryV3RetrievalUnavailableError) {
-        queueMemoryV3ConversationNotice(err, ctx, live);
-        log.error(
-          {
-            err: err.message,
-            conversationId: ctx.conversationId,
-            mode: live ? "live" : "shadow",
-          },
-          "memory-v3 selection failed; skipping v3 memory for this turn",
-        );
+      // A memory-v3 INFRASTRUCTURE failure (the selector lost its provider —
+      // e.g. a transient CES credential blip). Under `memory-v3-live` the
+      // user-prompt-submit hook already skipped v2 retrieval, so swallowing
+      // here would ship the turn with NO memory at all — exactly the silent
+      // degradation we want to eliminate. Hard-fail the turn instead (a clean,
+      // retryable error). In shadow mode v2 still ran this turn, so fall back
+      // to it (return null). Non-infra errors are already swallowed inside
+      // observeTurn; anything else reaching here stays non-fatal.
+      if (live && err instanceof MemoryV3RetrievalUnavailableError) {
+        throw err;
       }
       return null;
     }
@@ -429,16 +405,12 @@ export const memoryV3SpotlightInjector: Injector = {
         placement: "after-memory-prefix",
       };
     } catch (err) {
+      // Live-only injector: an infra failure must hard-fail the turn. The cards
+      // injector (ordered ahead of this one) normally throws first, so this
+      // path is defensive — it keeps the behavior correct if the cards injector
+      // is ever disabled or reordered.
       if (err instanceof MemoryV3RetrievalUnavailableError) {
-        queueMemoryV3ConversationNotice(err, ctx, true);
-        log.error(
-          {
-            err: err.message,
-            conversationId: ctx.conversationId,
-          },
-          "memory-v3 spotlight selection failed; skipping spotlight",
-        );
-        return null;
+        throw err;
       }
       log.warn(
         {

package/src/plugins/defaults/memory-v3-shadow/orchestrate.ts

@@ -119,10 +119,6 @@ export interface OrchestrateDeps {
   /** Hard cap on total learned-lane surfaced articles; `0` disables the pass
    *  (canonical value: `memory.v3.learnedEdges.cap`). */
   learnedCap?: number;
-  /** The selector's system prompt. Omitted → the selector's bundled default.
-   *  The live caller resolves `memory.v3.selectorPromptPath` (workspace-relative
-   *  file override) via `resolveSelectorPrompt` and threads the result here. */
-  selectorPrompt?: string;
 }
 
 /** A finder-lane candidate: the slug, the descriptor that justified it, and
@@ -382,13 +378,8 @@ export async function orchestrate(
 
   // Step 3: a SINGLE forced-tool select over the cache-ordered pool. The
   // selections come back slug-deduped (pinned flags ORed) — `selectPool`'s
-  // contract. `selectorPrompt` is the (optionally overridden) instruction
-  // scaffold; `undefined` falls through to the bundled default.
-  const selections = await selectPool(
-    { stable, finder: finderTail },
-    turn,
-    deps.selectorPrompt,
-  );
+  // contract.
+  const selections = await selectPool({ stable, finder: finderTail }, turn);
 
   return {
     selections,