@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/plugins/defaults/advisor/tools/advisor.ts

@@ -19,19 +19,26 @@ import { RiskLevel } from "@vellumai/plugin-api";
 import { advisorEnabledForProfile } from "../advisor-gate.js";
 import { getCapture } from "../advisor-state-store.js";
 import { consultAdvisor } from "../consult.js";
+import { buildAdvisorContext } from "../context-pack.js";
 
 const advisorTool: ToolDefinition = {
   name: "advisor",
   description:
     "Consult a stronger advisor model to shape your plan and get strategic guidance. " +
     "Takes NO parameters — your full conversation (the task, every tool call, and every " +
-    "result) is forwarded automatically. Call it BEFORE you start building: it can lay out " +
-    "a plan when you don't have one yet, or review and sharpen the plan you've already " +
-    "drafted. Also call it when you're stuck, when weighing a change in approach, and once " +
-    "before declaring a task complete. Give its guidance serious weight.",
+    "result) is forwarded automatically, along with your available tools and skills, the " +
+    "workspace/project context, and relevant memory. Call it BEFORE you start building: it " +
+    "can lay out a plan when you don't have one yet, or review and sharpen the plan you've " +
+    "already drafted. Also call it when you're stuck, when weighing a change in approach, and " +
+    "once before declaring a task complete. It runs on its own — if you call it alongside " +
+    "other tools, those are held back until you've seen its guidance. Give its guidance " +
+    "serious weight.",
   input_schema: { type: "object", properties: {}, additionalProperties: false },
   // Read-only advice; low risk so the consult isn't gated behind a prompt.
   defaultRiskLevel: RiskLevel.Low,
+  // Runs alone in its turn: the loop defers any sibling tool calls so the model
+  // incorporates the advisor's guidance before acting on anything else.
+  exclusive: true,
   async execute(
     _input: Record<string, unknown>,
     ctx: ToolContext,
@@ -48,10 +55,30 @@ const advisorTool: ToolDefinition = {
     }
     try {
       const capture = getCapture(ctx.conversationId);
+      const messages = capture?.messages ?? [];
+      // Gather the agent's situational context (tools, skills, workspace,
+      // memory) so the advisor reasons with the same awareness the agent has.
+      // Best-effort: a failure here must not block the consult.
+      const runtimeContext = await buildAdvisorContext({
+        conversationId: ctx.conversationId,
+        workingDir: ctx.workingDir,
+        allowedToolNames: ctx.allowedToolNames,
+        // Per-turn trust snapshot — gates personal-memory surfaces off the same
+        // values the executor captured for this invocation, not live state.
+        trustClass: ctx.trustClass,
+        sourceChannel: ctx.executionChannel,
+        transcript: messages,
+        signal: ctx.signal,
+      }).catch(() => null);
       const advice = await consultAdvisor({
         systemPrompt: capture?.systemPrompt ?? null,
-        messages: capture?.messages ?? [],
+        messages,
+        runtimeContext,
         signal: ctx.signal,
+        // Stream the advisor's guidance live as it generates: each delta is
+        // surfaced as a `tool_output_chunk` for this tool call and rendered in
+        // the tool-detail drawer. The complete text is still returned below.
+        onText: (chunk) => ctx.onOutput?.(chunk),
       });
       return { content: advice, isError: false };
     } catch (err) {

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

@@ -12,8 +12,11 @@ import type {
 
 // ─── Mocks ──────────────────────────────────────────────────────────────────
 
-// Control doesSupportVision per-profile from the test.
+// 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).
 let visionProfiles: Set<string>;
+let visionModels: Set<string>;
 let mockProfiles: ModelProfileInfo[];
 let sendMessageResponse = {
   content: [{ type: "text", text: "A red chart showing Q3 revenue." }],
@@ -30,8 +33,10 @@ 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: (profile: ModelProfileInfo) =>
-    visionProfiles.has(profile.key),
+  doesSupportVision: (arg: ModelProfileInfo | string) =>
+    typeof arg === "string"
+      ? visionModels.has(arg)
+      : visionProfiles.has(arg.key),
   getModelProfiles: () => mockProfiles,
   getConfiguredProvider: async () => (providerResolves ? fakeProvider : null),
 }));
@@ -136,6 +141,9 @@ 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" }),
@@ -255,7 +263,10 @@ describe("image-fallback user-prompt-submit hook", () => {
     };
     // Override the mock to track calls.
     mock.module("@vellumai/plugin-api", () => ({
-      doesSupportVision: (p: ModelProfileInfo) => visionProfiles.has(p.key),
+      doesSupportVision: (arg: ModelProfileInfo | string) =>
+        typeof arg === "string"
+          ? visionModels.has(arg)
+          : visionProfiles.has(arg.key),
       getModelProfiles: () => mockProfiles,
       getConfiguredProvider: async () => trackingProvider,
     }));
@@ -273,7 +284,10 @@ describe("image-fallback user-prompt-submit hook", () => {
 
     // Restore the original mock for other tests.
     mock.module("@vellumai/plugin-api", () => ({
-      doesSupportVision: (p: ModelProfileInfo) => visionProfiles.has(p.key),
+      doesSupportVision: (arg: ModelProfileInfo | string) =>
+        typeof arg === "string"
+          ? visionModels.has(arg)
+          : visionProfiles.has(arg.key),
       getModelProfiles: () => mockProfiles,
       getConfiguredProvider: async () =>
         providerResolves ? fakeProvider : null,
@@ -346,9 +360,10 @@ describe("image-fallback post-tool-use hook", () => {
     );
   });
 
-  test("is a no-op when the active model supports vision", async () => {
-    visionProfiles = new Set(["text-only"]); // active profile supports vision
+  test("is a no-op when the model that ran supports vision", async () => {
+    visionModels = new Set(["vision-model"]);
     const ctx = makeToolCtx({
+      model: "vision-model",
       toolResponse: toolResult([imageBlock("shot1")]),
     });
     await postToolUse(ctx);
@@ -398,4 +413,29 @@ 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 active model is text-only, captions
+ * Default `post-tool-use` hook: when the turn's 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,15 +9,14 @@
  * rather than the top-level message content the `user-prompt-submit` hook
  * handles. Both share {@link captionImageBlocks}.
  *
- * 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.
+ * 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.
  */
 
 import {
   doesSupportVision,
-  getModelProfiles,
   type PluginHookFn,
   type PostToolUseContext,
 } from "@vellumai/plugin-api";
@@ -26,13 +25,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.length === 0) return;
+  if (blocks == null || !blocks.some((b) => b.type === "image")) 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;
+  // If the model that ran already supports vision, leave the image in place.
+  if (doesSupportVision(ctx.model)) 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 active model is text-only,
+ * Default `user-prompt-submit` hook: when the turn's 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,13 +7,14 @@
  * The hook runs once per user turn, after the assistant assembles
  * `latestMessages` and before they flow into `agentLoop.run()`. It:
  *
- * 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.
+ * 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.
  * 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 `ImageContent` block with a `[Image …]` text caption via
+ * 3. Replaces each image block with a `[Image …]` text caption via
  *    {@link captionImageBlocks} (which also persists the original and caches
  *    captions across turns).
  *
@@ -22,28 +23,19 @@
  */
 
 import {
-  doesSupportVision,
-  getModelProfiles,
   type PluginHookFn,
   type UserPromptSubmitContext,
 } from "@vellumai/plugin-api";
 
-import { captionImageBlocks } from "../src/caption-blocks.js";
+import {
+  captionImageBlocks,
+  needsImageFallback,
+} from "../src/caption-blocks.js";
 import { findVisionProfile } from "../src/vision-caption.js";
 
 const userPromptSubmit: PluginHookFn<UserPromptSubmitContext> = async (ctx) => {
-  // 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;
+  // If the turn's model already supports vision, nothing to do.
+  if (!needsImageFallback(ctx.modelProfileKey)) return;
 
   // Find a vision-capable profile for captioning.
   const visionProfileKey = findVisionProfile();

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

@@ -1,31 +1,62 @@
 /**
  * Shared image→text substitution for the image-fallback plugin's hooks.
  *
- * Two hooks replace `image` content blocks with a text caption when the active
+ * Two hooks replace `image` content blocks with a text caption when the turn's
  * 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 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.
+ * 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.
  *
- * 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.
+ * 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.
  *
  * 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,
-  ImageContent,
-  PluginLogger,
+import {
+  type ContentBlock,
+  doesSupportVision,
+  getModelProfiles,
+  type ImageContent,
+  type 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/orchestrate.ts

@@ -119,6 +119,10 @@ 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
@@ -378,8 +382,13 @@ 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.
-  const selections = await selectPool({ stable, finder: finderTail }, turn);
+  // 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,
+  );
 
   return {
     selections,

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

@@ -0,0 +1,146 @@
+/**
+ * Tests for `pool-select.ts` `selectPool` — focused on error SURFACING:
+ *   - a provider call that THROWS on every attempt surfaces the underlying
+ *     provider error (e.g. an upstream HTTP 4xx) in the thrown
+ *     `MemoryV3RetrievalUnavailableError` message, rather than the generic
+ *     "no usable selection" string that hid it;
+ *   - a 200 response carrying no usable `tool_use` still throws the generic
+ *     "no usable selection" message;
+ *   - happy paths preserved: explicit ids → selection, omitted ids → keepAll,
+ *     empty pool → [].
+ *
+ * `mock.module` is process-global and leaks into sibling files in a directory
+ * run, so the provider-send-message stub DELEGATES to the real implementation
+ * (keeping the real `extractToolUse`) unless this test is actively running
+ * (`selectMockActive`) — mirrors `prune.test.ts` / `ever-injected-store.test.ts`.
+ */
+
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type {
+  ContentBlock,
+  Provider,
+  ProviderResponse,
+} from "../../../providers/types.js";
+import type { MemoryRoutingTurn, Slug } from "./types.js";
+
+const realProviderSend = {
+  ...(await import("../../../providers/provider-send-message.js")),
+};
+
+let selectMockActive = false;
+let sendMessageImpl: (() => Promise<ProviderResponse>) | null = null;
+
+const mockProvider = {
+  name: "mock-memory-v3-selector",
+  async sendMessage(): Promise<ProviderResponse> {
+    if (!sendMessageImpl) throw new Error("sendMessageImpl not configured");
+    return sendMessageImpl();
+  },
+} as unknown as Provider;
+
+mock.module("../../../providers/provider-send-message.js", () => ({
+  ...realProviderSend,
+  getConfiguredProvider: (
+    ...args: Parameters<typeof realProviderSend.getConfiguredProvider>
+  ) =>
+    selectMockActive
+      ? Promise.resolve(mockProvider)
+      : realProviderSend.getConfiguredProvider(...args),
+}));
+
+const { MemoryV3RetrievalUnavailableError, selectPool } =
+  await import("./pool-select.js");
+
+function response(content: ContentBlock[]): ProviderResponse {
+  return {
+    content,
+    model: "mock",
+    usage: { inputTokens: 0, outputTokens: 0 },
+  } as ProviderResponse;
+}
+
+const turn: MemoryRoutingTurn = {
+  conversationId: "conv-1",
+  turnNumber: 0,
+  currentMessage: "echo something back",
+  recentContext: "",
+};
+
+const pool = {
+  stable: [],
+  finder: [{ slug: "page-a" as Slug, descriptor: "a descriptor" }],
+};
+
+describe("selectPool", () => {
+  beforeEach(() => {
+    selectMockActive = true;
+    sendMessageImpl = null;
+  });
+  afterAll(() => {
+    selectMockActive = false;
+  });
+
+  test("a provider throw surfaces the underlying error in the thrown message", async () => {
+    const upstream = "Together AI API error (400): 400 status code (no body)";
+    sendMessageImpl = async () => {
+      throw new Error(upstream);
+    };
+    let caught: unknown;
+    try {
+      await selectPool(pool, turn);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
+    expect((caught as Error).message).toContain(
+      "provider call failed after retries",
+    );
+    // The real upstream error is no longer hidden behind the generic message.
+    expect((caught as Error).message).toContain(upstream);
+  });
+
+  test("a 200 with no usable tool_use throws the generic message", async () => {
+    sendMessageImpl = async () =>
+      response([{ type: "text", text: "I cannot call the tool." }]);
+    let caught: unknown;
+    try {
+      await selectPool(pool, turn);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
+    expect((caught as Error).message).toBe(
+      "memory-v3 pool selector returned no usable selection after retries",
+    );
+  });
+
+  test("explicit ids select the matching candidates", async () => {
+    sendMessageImpl = async () =>
+      response([
+        {
+          type: "tool_use",
+          id: "call-1",
+          name: "select_pages",
+          input: { ids: [1] },
+        },
+      ]);
+    expect(await selectPool(pool, turn)).toEqual([
+      { slug: "page-a", pinned: false },
+    ]);
+  });
+
+  test("omitted ids keep all candidates (recall-safe)", async () => {
+    sendMessageImpl = async () =>
+      response([
+        { type: "tool_use", id: "call-1", name: "select_pages", input: {} },
+      ]);
+    expect(await selectPool(pool, turn)).toEqual([
+      { slug: "page-a", pinned: false },
+    ]);
+  });
+
+  test("an empty candidate pool returns no selections", async () => {
+    expect(await selectPool({ stable: [], finder: [] }, turn)).toEqual([]);
+  });
+});

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

@@ -50,6 +50,7 @@
 
 import { z } from "zod";
 
+import { loadPromptOverride } from "../../../memory/prompt-override.js";
 import { cachedTextBlock } from "../../../providers/cache-control.js";
 import {
   extractToolUse,
@@ -201,6 +202,28 @@ A page can be relevant because of the current situation — the date or the live
 
 If the conversation is centrally ABOUT a page (rather than only peripherally relevant to it), mark that page as pinned. Call \`select_pages\` with the chosen IDs. Omit \`ids\` only as a recall-safe fallback when you cannot judge the pool (keeps every candidate); return \`[]\` when candidates are present but none are relevant.`;
 
+/**
+ * Resolve the selector system prompt: the file at `overridePath` when it is set
+ * and usable, otherwise the bundled {@link SYSTEM_PROMPT}. Path resolution and
+ * fallback follow the shared override loader (workspace-relative; a missing,
+ * empty, oversized, or unreadable file degrades to the bundled prompt with a
+ * warning). The selector prompt takes no placeholders — the candidate pool is
+ * the user message — so an override file is used verbatim.
+ */
+export function resolveSelectorPrompt(
+  overridePath: string | null,
+  workspaceDir: string,
+): string {
+  return (
+    loadPromptOverride({
+      overridePath,
+      workspaceDir,
+      log,
+      label: "memory-v3 selector prompt",
+    }) ?? SYSTEM_PROMPT
+  );
+}
+
 /** Collapse a descriptor to one line and cap its length for a finder line. */
 function renderSnippet(descriptor: string): string {
   return truncate(descriptor.replace(/\s+/g, " ").trim(), SNIPPET_MAX_CHARS);
@@ -315,10 +338,15 @@ function dedupeBySlug(
  * relevant" signal); an explicit `[]` keeps none; an infrastructure failure
  * (after a short re-prompt retry) keeps none, degrading to the deterministic
  * recall lanes the orchestrator unions in.
+ *
+ * `systemPrompt` is the selector's instruction scaffold; it defaults to the
+ * bundled {@link SYSTEM_PROMPT} and is overridable via `memory.v3.selectorPromptPath`
+ * (resolved by {@link resolveSelectorPrompt} at the call site).
  */
 export async function selectPool(
   pool: SelectorPool,
   turn: MemoryRoutingTurn,
+  systemPrompt: string = SYSTEM_PROMPT,
 ): Promise<SelectedPage[]> {
   // The concatenated numbering: ids 1…m are the stable-prefix cards, ids
   // m+1… are the finder lines.
@@ -401,7 +429,7 @@ export async function selectPool(
     try {
       response = await provider.sendMessage([userMsg], {
         tools: [SELECT_PAGES_TOOL],
-        systemPrompt: SYSTEM_PROMPT,
+        systemPrompt,
         config: {
           callSite: MEMORY_V3_SELECT_CALL_SITE,
           tool_choice: { type: "tool" as const, name: SELECT_PAGES_TOOL_NAME },

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

@@ -56,7 +56,10 @@ import { computeHotSet } from "./hot-set.js";
 import { computeLearnedEdgeGraph } from "./learned-edges.js";
 import type { OrchestrateResult } from "./orchestrate.js";
 import { orchestrate } from "./orchestrate.js";
-import { MemoryV3RetrievalUnavailableError } from "./pool-select.js";
+import {
+  MemoryV3RetrievalUnavailableError,
+  resolveSelectorPrompt,
+} from "./pool-select.js";
 import { ensureSectionCollection } from "./section-dense-store.js";
 import type { SectionNeedle } from "./section-needle.js";
 import { buildSectionNeedle } from "./section-needle.js";
@@ -576,6 +579,10 @@ export async function observeTurn(
       learnedGraph: lanes.learnedGraph,
       learnedPerSeed: v3.learnedEdges.perSeed,
       learnedCap: v3.learnedEdges.cap,
+      selectorPrompt: resolveSelectorPrompt(
+        v3.selectorPromptPath,
+        getWorkspaceDir(),
+      ),
     });
 
     // A zero-selection turn over a non-trivial pool is unusual enough to be

package/src/plugins/mtime-cache.ts

@@ -18,7 +18,13 @@
  * cached entry.
  */
 
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+} from "node:fs";
 import { join } from "node:path";
 
 import { getConfig } from "../config/loader.js";
@@ -648,7 +654,6 @@ export async function populateCacheAtBoot(
       try {
         const initContext: PluginInitContext = {
           config: getConfig().plugins?.[pluginName],
-          credentials: {},
           logger: log.child({ plugin: pluginName }),
           pluginStorageDir: ensurePluginStorageDir(pluginName),
           assistantVersion: APP_VERSION,

package/src/plugins/types.ts

@@ -47,8 +47,6 @@ export interface PluginManifest {
    * own version at load time.
    */
   version: string;
-  /** Credential keys the plugin needs resolved before `init()` runs. */
-  requiresCredential?: string[];
   /**
    * Assistant feature-flag keys that must all be enabled for this plugin to
    * activate. Checked by `bootstrapPlugins` via `isAssistantFeatureFlagEnabled`

package/src/providers/anthropic/client.ts

@@ -786,6 +786,11 @@ export class AnthropicProvider implements Provider {
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
+  /** See {@link Provider.supportsNativeWebSearch}. */
+  get supportsNativeWebSearch(): boolean {
+    return this.useNativeWebSearch;
+  }
+
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,