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

package/src/plugin-api/vision-support.ts

@@ -3,17 +3,10 @@
  *
  * A plugin that gates image processing on vision capability (e.g. an
  * image-to-text fallback for text-only models) calls {@link doesSupportVision}
- * instead of hardcoding model names. One entry point serves both shapes a
- * caller might hold:
- * - a concrete model id (e.g. the provider-reported model that just ran), and
- * - a profile — either a {@link ModelProfileInfo} or a bare profile key —
- *   resolved through `llm.profiles` to an effective `(provider, model)`.
- *
- * A bare string is tried as a model id first and then as a profile key, so the
- * two callers share one function. Resolution returns `false` when nothing
- * resolves (rather than failing open): a consumer gating an image→text
- * fallback wants an unknown model treated as "can't show images" — caption it —
- * over silently shipping a raw image to a provider that may reject it.
+ * instead of hardcoding model names. The function resolves the effective
+ * (provider, model) for a profile — merging with `llm.default` to fill gaps,
+ * inferring the provider for model-only profiles via the catalog — and then
+ * looks up `supportsVision` in the model catalog.
  */
 
 import { getConfig } from "../config/loader.js";
@@ -24,74 +17,46 @@ import {
 import type { ModelProfileInfo } from "./types.js";
 
 /**
- * Whether the given model or profile can process image input.
+ * Whether a profile's resolved model can process image input.
  *
- * `modelOrProfile` may be a concrete model id, a profile key, or a
- * {@link ModelProfileInfo}. A bare string is resolved as a model id first and,
- * failing that, as a profile key. Returns `false` when nothing resolves.
- */
-export function doesSupportVision(
-  modelOrProfile: ModelProfileInfo | string,
-): boolean {
-  if (typeof modelOrProfile === "string") {
-    // Concrete model id first, then fall back to treating it as a profile key.
-    return (
-      modelVision(modelOrProfile) ?? profileVision(modelOrProfile) ?? false
-    );
-  }
-  return profileVision(modelOrProfile.key) ?? false;
-}
-
-/**
- * Catalog vision flag for a concrete model id, or `undefined` when the catalog
- * doesn't know the model. The same model id carries the same capability under
- * every provider that offers it, so the first catalog match wins.
+ * Resolution mirrors the host's call-site resolver:
+ * - The profile's `(provider, model)` fields are merged over `llm.default` so
+ *   a profile that only sets `model` (or only `provider`) inherits the other
+ *   from the workspace default.
+ * - When `provider` is still missing but `model` is a known catalog model,
+ *   the provider is inferred via `getCatalogProviderForModel` (same logic as
+ *   the resolver's `withImpliedProviderForKnownModel`).
+ * - For a mix profile, returns `true` if any constituent arm supports vision
+ *   (the mix can route to it) and `false` only if every arm is text-only.
+ * - Unknown `(provider, model)` pairs default to `true` (fail-open), matching
+ *   the config GET route's `enrichProfilesWithVisionFlag`.
  */
-function modelVision(model: string): boolean | undefined {
-  for (const provider of PROVIDER_CATALOG) {
-    const catalogModel = provider.models.find((m) => m.id === model);
-    if (catalogModel != null) return catalogModel.supportsVision ?? false;
-  }
-  return undefined;
-}
-
-/**
- * Resolve a profile key through `llm.profiles` to its vision capability, or
- * `undefined` when the key is unknown or resolves to a model the catalog
- * doesn't know. A mix profile resolves to `true` if any arm supports vision
- * (the mix can route to it) and `false` only once every arm is a known
- * text-only model.
- */
-function profileVision(profileKey: string): boolean | undefined {
+export function doesSupportVision(profile: ModelProfileInfo): boolean {
   const { llm } = getConfig();
-  const entry = llm.profiles[profileKey];
-  if (entry == null) return undefined;
+  const entry = llm.profiles[profile.key];
+  if (entry == null) return true;
 
+  // Mix: fail-open if any arm supports vision.
   if (entry.mix != null) {
-    let sawUnknown = false;
-    for (const arm of entry.mix) {
+    return entry.mix.some((arm) => {
       const armEntry = llm.profiles[arm.profile];
-      const armVision =
-        armEntry == null ? undefined : resolveEntryVision(armEntry, llm);
-      if (armVision === true) return true;
-      if (armVision == null) sawUnknown = true;
-    }
-    return sawUnknown ? undefined : false;
+      if (armEntry == null) return true;
+      return resolveEntrySupportsVision(armEntry, llm);
+    });
   }
 
-  return resolveEntryVision(entry, llm);
+  return resolveEntrySupportsVision(entry, llm);
 }
 
 /**
  * Resolve whether a concrete (non-mix) profile entry supports vision by
- * merging its fields over `llm.default` and inferring the provider when only
- * the model is set. Returns `undefined` when the effective `(provider, model)`
- * can't be determined or isn't in the catalog.
+ * merging its fields over `llm.default` and inferring the provider when
+ * only the model is set.
  */
-function resolveEntryVision(
+function resolveEntrySupportsVision(
   entry: { provider?: string; model?: string },
   llm: { default?: { provider?: string; model?: string } },
-): boolean | undefined {
+): boolean {
   const provider = entry.provider ?? llm.default?.provider;
   const model = entry.model ?? llm.default?.model;
 
@@ -102,12 +67,12 @@ function resolveEntryVision(
     (typeof model === "string" ? getCatalogProviderForModel(model) : undefined);
 
   if (typeof effectiveProvider !== "string" || typeof model !== "string") {
-    return undefined;
+    return true; // fail-open
   }
 
   const catalogProvider = PROVIDER_CATALOG.find(
     (p) => p.id === effectiveProvider,
   );
   const catalogModel = catalogProvider?.models.find((m) => m.id === model);
-  return catalogModel?.supportsVision;
+  return catalogModel?.supportsVision ?? true;
 }

package/src/plugins/defaults/advisor/__tests__/consult.test.ts

@@ -8,26 +8,12 @@ let sendMessageArgs: Record<string, unknown> | null = null;
 let responseText = "Use a channel-based worker pool; drain on shutdown.";
 let sendMessageError: Error | null = null;
 let providerResolves = true;
-let providerSupportsWeb = false;
-let streamDeltas: string[] = [];
-let streamEvents: Array<Record<string, unknown>> = [];
 
 const fakeProvider = {
   name: "mock-advisor-provider",
-  get supportsNativeWebSearch() {
-    return providerSupportsWeb;
-  },
   async sendMessage(messages: unknown, options: unknown) {
     sendMessageArgs = { messages, options } as Record<string, unknown>;
     if (sendMessageError) throw sendMessageError;
-    const onEvent = (
-      options as { onEvent?: (e: Record<string, unknown>) => void }
-    ).onEvent;
-    if (onEvent) {
-      // Activity (search/thinking) streams before the final advice text.
-      for (const ev of streamEvents) onEvent(ev);
-      for (const text of streamDeltas) onEvent({ type: "text_delta", text });
-    }
     return {
       content: [{ type: "text", text: responseText }],
       model: "mock-model",
@@ -43,14 +29,6 @@ mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => (providerResolves ? fakeProvider : null),
 }));
 
-// Keep the tool tests focused on the consult wiring: stub the context pack so
-// they don't reach into the registry / workspace / memory sources (those have
-// their own coverage). The consult itself never imports this module.
-mock.module("../context-pack.js", () => ({
-  buildAdvisorContext: async () => null,
-  deriveRecallQuery: () => null,
-}));
-
 const { consultAdvisor } = await import("../consult.js");
 const advisorTool = (await import("../tools/advisor.js")).default;
 const { recordSystemPrompt, recordMessages, resetAdvisorStateForTests } =
@@ -71,9 +49,6 @@ beforeEach(() => {
   responseText = "Use a channel-based worker pool; drain on shutdown.";
   sendMessageError = null;
   providerResolves = true;
-  providerSupportsWeb = false;
-  streamDeltas = [];
-  streamEvents = [];
   resetAdvisorStateForTests();
 });
 
@@ -125,104 +100,6 @@ describe("consultAdvisor", () => {
     expect(options.systemPrompt).toContain("You are a coding agent.");
   });
 
-  test("stays tool-less when the provider has no native web search", async () => {
-    providerSupportsWeb = false;
-    await consultAdvisor({ systemPrompt: null, messages: [userMsg("hi")] });
-    const options = sendMessageArgs?.options as { tools?: unknown };
-    expect(options.tools).toBeUndefined();
-    expect(optionConfig().tool_choice).toEqual({ type: "none" });
-  });
-
-  test("enables native web search when the provider supports it", async () => {
-    providerSupportsWeb = true;
-    await consultAdvisor({ systemPrompt: null, messages: [userMsg("hi")] });
-
-    const options = sendMessageArgs?.options as {
-      tools?: Array<{ name: string }>;
-    };
-    expect(options.tools?.map((t) => t.name)).toEqual(["web_search"]);
-    // tool_choice must not be `none`, or the provider suppresses its server tool.
-    expect(optionConfig().tool_choice).toEqual({ type: "auto" });
-  });
-
-  test("streams web-search activity to onText, not just the final advice", async () => {
-    providerSupportsWeb = true;
-    streamEvents = [
-      { type: "server_tool_start", name: "web_search", toolUseId: "s1", input: {} },
-      {
-        type: "server_tool_complete",
-        toolUseId: "s1",
-        isError: false,
-        resolvedInput: { query: "vellum streaming" },
-      },
-    ];
-    streamDeltas = ["Here is ", "the advice."];
-    const chunks: string[] = [];
-
-    await consultAdvisor({
-      systemPrompt: null,
-      messages: [userMsg("hi")],
-      onText: (c) => chunks.push(c),
-    });
-
-    const joined = chunks.join("");
-    // The drawer isn't silent during the search prefix...
-    expect(joined).toContain("Searching the web");
-    expect(joined).toContain("Searched: vellum streaming");
-    // ...and the advice text still streams.
-    expect(joined).toContain("Here is the advice.");
-  });
-
-  test("surfaces a failure note (not 'Searched') when a web search errors", async () => {
-    providerSupportsWeb = true;
-    streamEvents = [
-      { type: "server_tool_start", name: "web_search", toolUseId: "s1", input: {} },
-      {
-        type: "server_tool_complete",
-        toolUseId: "s1",
-        isError: true,
-        errorCode: "query_too_long",
-        resolvedInput: { query: "an overly long query" },
-      },
-    ];
-    streamDeltas = ["Proceeding without search."];
-    const chunks: string[] = [];
-
-    await consultAdvisor({
-      systemPrompt: null,
-      messages: [userMsg("hi")],
-      onText: (c) => chunks.push(c),
-    });
-
-    const joined = chunks.join("");
-    expect(joined).toContain("Web search failed");
-    expect(joined).not.toContain("🔎 Searched:");
-    // The consult still continues and streams its guidance.
-    expect(joined).toContain("Proceeding without search.");
-  });
-
-  test("streams the model's reasoning summary to onText", async () => {
-    streamEvents = [{ type: "thinking_delta", thinking: "weighing tradeoffs" }];
-    const chunks: string[] = [];
-    await consultAdvisor({
-      systemPrompt: null,
-      messages: [userMsg("hi")],
-      onText: (c) => chunks.push(c),
-    });
-    expect(chunks.join("")).toContain("weighing tradeoffs");
-  });
-
-  test("embeds the runtime context in the advisor system prompt", async () => {
-    await consultAdvisor({
-      systemPrompt: "You are a coding agent.",
-      messages: [userMsg("hi")],
-      runtimeContext: "## Available tools\n- bash — run commands",
-    });
-    const options = sendMessageArgs?.options as { systemPrompt: string };
-    expect(options.systemPrompt).toContain("<agent_runtime_context>");
-    expect(options.systemPrompt).toContain("- bash — run commands");
-  });
-
   test("soft-fails when no provider is configured", async () => {
     providerResolves = false;
     const advice = await consultAdvisor({
@@ -246,29 +123,6 @@ describe("consultAdvisor", () => {
     });
     expect(advice).toContain("no guidance");
   });
-
-  test("streams the model's text deltas to `onText` as it generates", async () => {
-    streamDeltas = ["Use a ", "channel-based ", "worker pool."];
-    const chunks: string[] = [];
-
-    const advice = await consultAdvisor({
-      systemPrompt: null,
-      messages: [userMsg("hi")],
-      onText: (c) => chunks.push(c),
-    });
-
-    // Each visible delta is forwarded live...
-    expect(chunks).toEqual(["Use a ", "channel-based ", "worker pool."]);
-    // ...and the complete guidance is still returned.
-    expect(advice).toBe(responseText);
-  });
-
-  test("registers no `onEvent` sink when `onText` is absent", async () => {
-    streamDeltas = ["x"];
-    await consultAdvisor({ systemPrompt: null, messages: [userMsg("hi")] });
-    const options = sendMessageArgs?.options as { onEvent?: unknown };
-    expect(options.onEvent).toBeUndefined();
-  });
 });
 
 describe("advisor tool.execute", () => {
@@ -296,19 +150,4 @@ describe("advisor tool.execute", () => {
     expect(result?.content).toContain("advisor unavailable");
     expect(result?.content).toContain("kaboom");
   });
-
-  test("streams the consult live via `ctx.onOutput`", async () => {
-    recordMessages("c3", [userMsg("hi")]);
-    streamDeltas = ["plan: ", "do X"];
-    const out: string[] = [];
-
-    const result = await advisorTool.execute?.({}, {
-      conversationId: "c3",
-      onOutput: (c: string) => out.push(c),
-    } as never);
-
-    expect(out).toEqual(["plan: ", "do X"]);
-    expect(result?.isError).toBe(false);
-    expect(result?.content).toBe(responseText);
-  });
 });

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

@@ -16,11 +16,7 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../../providers/provider-send-message.js";
-import type {
-  Message,
-  ProviderEvent,
-  ToolDefinition,
-} from "../../../providers/types.js";
+import type { Message } from "../../../providers/types.js";
 import { ADVISOR_CONFIG } from "./config.js";
 import { advisorRequestText, buildAdvisorSystem } from "./steering.js";
 import { toAdvisorMessages } from "./transcript.js";
@@ -30,26 +26,6 @@ import { toAdvisorMessages } from "./transcript.js";
 // on via `llm.advisorProfile`, which we float above the call-site layers.
 const ADVISOR_CALL_SITE: LLMCallSite = "advisor";
 
-/**
- * The single tool the consult may attach: a `web_search`-named tool that
- * provider-native search (Anthropic/OpenAI) substitutes for its server-side
- * web tool. Only passed when `provider.supportsNativeWebSearch` is true, so the
- * provider runs the search itself and returns results inline — no agent loop,
- * which keeps the consult a one-shot completion.
- */
-const ADVISOR_WEB_SEARCH_TOOL: ToolDefinition = {
-  name: "web_search",
-  description:
-    "Search the web for current information to ground your guidance.",
-  input_schema: {
-    type: "object",
-    properties: {
-      query: { type: "string", description: "The search query." },
-    },
-    required: ["query"],
-  },
-};
-
 /**
  * Resolve the routing override for the advisor consult. When the workspace has
  * set `llm.advisorProfile`, force it above the call-site layers so it is
@@ -69,22 +45,7 @@ function advisorOverride(): {
 export interface ConsultParams {
   systemPrompt: string | null;
   messages: ReadonlyArray<Message>;
-  /**
-   * The agent's runtime context (available tools and skills, workspace/project
-   * context, recalled memory), gathered by the tool from its `ToolContext`.
-   * Embedded in the advisor's system prompt so its advice is grounded in what
-   * the agent can actually do. Omitted/null when nothing could be gathered.
-   */
-  runtimeContext?: string | null;
   signal?: AbortSignal;
-  /**
-   * Optional sink for the advisor's live activity as it generates: incremental
-   * advice text, the reasoning summary (when surfaced), and a note per web
-   * search. Wiring this to the tool's `onOutput` surfaces the consult live as
-   * `tool_output_chunk` while the advisor is still working; the complete
-   * guidance is still returned as the resolved string. See `advisorActivitySink`.
-   */
-  onText?: (chunk: string) => void;
 }
 
 /** Combine the caller's signal with a consult timeout. */
@@ -93,55 +54,6 @@ function withTimeout(signal: AbortSignal | undefined, ms: number): AbortSignal {
   return signal ? AbortSignal.any([signal, timeout]) : timeout;
 }
 
-/**
- * Build the streaming sink for a consult: forward the advisor's live activity
- * to `onText` so the tool-output drawer streams throughout the consult instead
- * of sitting silent until the final advice lands.
- *
- * The consult searches the web (up to 5×) and reasons over full context before
- * writing its guidance. Forwarding the visible advice text alone would leave
- * the drawer blank for that whole prefix, so the sink also surfaces the
- * reasoning summary (when the model emits one) and a one-line note per web
- * search — a success note with the query, or a failure note when the search
- * errors. The complete guidance is still returned by `consultAdvisor`; the
- * renderer swaps it in once the tool result arrives.
- */
-function advisorActivitySink(
-  onText: (chunk: string) => void,
-): (event: ProviderEvent) => void {
-  return (event) => {
-    switch (event.type) {
-      case "text_delta":
-        if (event.text) onText(event.text);
-        break;
-      case "thinking_delta":
-        if (event.thinking) onText(event.thinking);
-        break;
-      case "server_tool_start":
-        if (event.name === "web_search") onText("\n🔎 Searching the web…\n");
-        break;
-      case "server_tool_complete": {
-        const rawQuery = event.resolvedInput?.["query"];
-        const query = typeof rawQuery === "string" ? rawQuery.trim() : "";
-        if (event.isError) {
-          // A failed search (e.g. `query_too_long`, `max_uses_exceeded`) must
-          // not be announced as a success — the advisor proceeds without it.
-          onText(
-            query
-              ? `\n⚠️ Web search failed: ${query}\n`
-              : "\n⚠️ Web search failed.\n",
-          );
-        } else if (query) {
-          onText(`\n🔎 Searched: ${query}\n`);
-        }
-        break;
-      }
-      default:
-        break;
-    }
-  };
-}
-
 /**
  * Returns the advisor's guidance text, or a short benign notice when the
  * advisor can't run. Callers should surface the string as a non-error tool
@@ -161,33 +73,17 @@ export async function consultAdvisor(params: ConsultParams): Promise<string> {
   }
 
   // Append the consult instruction as the final user turn, then run a
-  // completion through the resolved provider. No `max_tokens` is set, so the
-  // resolver applies the profile's normal output budget rather than an
-  // advisor-specific cap.
+  // tool-less completion through the resolved provider. No `max_tokens` is
+  // set, so the resolver applies the profile's normal output budget rather
+  // than an advisor-specific cap.
   const messages: Message[] = [...history, userMessage(advisorRequestText())];
 
-  // Give the advisor live web access when — and only when — the resolved
-  // provider runs search server-side (provider-native). Passing a `web_search`
-  // tool to a non-native provider would surface a client tool call this
-  // one-shot consult cannot execute, so we gate strictly on the capability and
-  // otherwise keep the consult tool-less.
-  const webEnabled = provider.supportsNativeWebSearch === true;
-
-  const { onText } = params;
   const response = await provider.sendMessage(messages, {
-    systemPrompt: buildAdvisorSystem(
-      params.systemPrompt,
-      params.runtimeContext,
-    ),
-    ...(webEnabled ? { tools: [ADVISOR_WEB_SEARCH_TOOL] } : {}),
-    // Stream the consult's activity live (advice text, reasoning summary, and a
-    // note per web search) so the drawer isn't blank while the advisor searches
-    // and reasons before writing its guidance. See `advisorActivitySink`.
-    onEvent: onText ? advisorActivitySink(onText) : undefined,
+    systemPrompt: buildAdvisorSystem(params.systemPrompt),
     config: {
       callSite: ADVISOR_CALL_SITE,
       ...override,
-      tool_choice: webEnabled ? { type: "auto" } : { type: "none" },
+      tool_choice: { type: "none" },
     },
     signal: withTimeout(params.signal, ADVISOR_CONFIG.timeoutMs),
   });

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

@@ -33,15 +33,9 @@ export function stripSteering(systemPrompt: string | null): string | null {
  * System prompt for the advisor sub-call. Frames the advisor's role and, for
  * context, quotes the executor's own system prompt (as the advisor tool does —
  * the advisor sees the system prompt as context about the executor's task).
- *
- * `runtimeContext`, when present, carries the agent's situational context that
- * lives outside its system prompt — available tools and skills, workspace /
- * project context, and recalled memory (see `buildAdvisorContext`) — so the
- * advisor can ground its recommendations in what the agent can actually do.
  */
 export function buildAdvisorSystem(
   originalSystemPrompt: string | null,
-  runtimeContext?: string | null,
 ): string {
   const base = `You are a senior advisor consulted by another AI agent working on a task — most often at the planning stage, before it starts building, but sometimes partway through. The entire conversation above is the agent's working context: its task or goal, every tool call it has made, and every result it has seen. The agent has paused to consult you because you bring a second, independent perspective it cannot get from inside its own reasoning loop. Your job is to maximize its odds of completing the task correctly and efficiently.
 
@@ -60,14 +54,8 @@ How to advise:
 - Stay in your lane. Advise the agent; do not role-play as it, write its final deliverable, or take its next action for it. If the agent is already on the right track, confirm it and sharpen the plan rather than manufacturing objections.
 
 Write as much as the guidance genuinely needs, and no more.`;
-  let prompt = base;
-  if (originalSystemPrompt) {
-    prompt += `\n\nFor context, the agent is operating under this system prompt:\n<agent_system_prompt>\n${originalSystemPrompt}\n</agent_system_prompt>`;
-  }
-  if (runtimeContext) {
-    prompt += `\n\nThe agent's runtime context — the tools and skills available to it, the loaded workspace/project context, and relevant memory — follows. Ground your recommendations in what the agent can actually do and what is around it; reference specific tools, skills, files, or memory where relevant.\n<agent_runtime_context>\n${runtimeContext}\n</agent_runtime_context>`;
-  }
-  return prompt;
+  if (!originalSystemPrompt) return base;
+  return `${base}\n\nFor context, the agent is operating under this system prompt:\n<agent_system_prompt>\n${originalSystemPrompt}\n</agent_system_prompt>`;
 }
 
 /**

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

@@ -19,26 +19,19 @@ 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, 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.",
+    "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.",
   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,
@@ -55,30 +48,10 @@ 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,
-        runtimeContext,
+        messages: capture?.messages ?? [],
         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/exploration-drift/hooks/post-tool-use.ts

@@ -1,6 +1,6 @@
 /**
  * Default `post-tool-use` hook: when a turn's exploration tool calls (bash,
- * code_search, file_read, file_list) show drift — a long unbroken run with no text sent to
+ * file_read, file_list) show drift — a long unbroken run with no text sent to
  * the user, or the model re-issuing the exact same call — surface a notice
  * via `additionalContext` that coaches it to (a) give the user a brief
  * progress summary and (b) delegate the rest of the investigation to an
@@ -105,7 +105,6 @@ const LOOP_PRONE_MODEL_PATTERN = /kimi-k2[p.]6|minimax-m3/i;
 /** Read-only exploration tools whose unbroken runs indicate inline drift. */
 const EXPLORATION_TOOL_NAMES: ReadonlySet<string> = new Set([
   "bash",
-  "code_search",
   "file_read",
   "file_list",
 ]);