@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240206.7c2bca6

package/src/plugin-api/model-profiles.ts

@@ -1,11 +1,14 @@
 import { getConfig } from "../config/loader.js";
+import { isDispatchableProfile } from "../config/profile-dispatchability.js";
 import { orderProfileKeys } from "../config/profile-order.js";
 import type { ModelProfileInfo } from "./types.js";
 
 /**
  * List the workspace inference profiles a plugin can route to, in the order the
  * `/model` picker presents them (`llm.profileOrder` first, then the rest
- * alphabetically). Disabled profiles are included and flagged via
+ * alphabetically). Metadata-only entries without a provider, model, or mix are
+ * not routing targets, so plugins never see them. Disabled profiles are
+ * included and flagged via
  * {@link ModelProfileInfo.isDisabled}; weighted "mix" profiles are included and
  * flagged via {@link ModelProfileInfo.isMix}, since a mix is itself a valid
  * routing target (it resolves to one constituent per conversation).
@@ -20,6 +23,7 @@ export function getModelProfiles(): ModelProfileInfo[] {
   for (const key of orderProfileKeys(profiles, llm.profileOrder)) {
     const entry = profiles[key];
     if (entry == null) continue;
+    if (!isDispatchableProfile(entry)) continue;
     result.push({
       key,
       label: entry.label ?? key,

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

@@ -0,0 +1,173 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ModelProfileInfo } from "./types.js";
+
+// ─── Mock config ────────────────────────────────────────────────────────────
+
+interface MockProfileEntry {
+  provider?: string;
+  model?: string;
+  status?: string;
+  mix?: Array<{ profile: string; weight: number }>;
+}
+
+let mockProfiles: Record<string, MockProfileEntry> = {};
+let mockDefault: { provider?: string; model?: string } = {
+  provider: "anthropic",
+  model: "claude-opus-4-6",
+};
+
+const realConfigLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realConfigLoader,
+  getConfig: () => ({
+    llm: {
+      profiles: mockProfiles,
+      default: mockDefault,
+    },
+  }),
+  getConfigReadOnly: () => ({
+    llm: {
+      profiles: mockProfiles,
+      default: mockDefault,
+    },
+  }),
+}));
+
+// Real model catalog — don't mock it, the test exercises real catalog lookups.
+const { doesSupportVision } = await import("./vision-support.js");
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function profile(key: string): ModelProfileInfo {
+  return {
+    key,
+    label: key,
+    description: null,
+    isActive: false,
+    isDisabled: false,
+    isMix: false,
+  };
+}
+
+function setMockConfig(
+  profiles: Record<string, MockProfileEntry>,
+  def: { provider?: string; model?: string } = {},
+) {
+  mockProfiles = profiles;
+  mockDefault = { provider: "anthropic", model: "claude-opus-4-6", ...def };
+}
+
+beforeEach(() => {
+  mockProfiles = {};
+  mockDefault = { provider: "anthropic", model: "claude-opus-4-6" };
+});
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("doesSupportVision", () => {
+  test("returns true for a known vision-capable model", () => {
+    setMockConfig({
+      "vision-profile": { provider: "anthropic", model: "claude-opus-4-6" },
+    });
+    expect(doesSupportVision(profile("vision-profile"))).toBe(true);
+  });
+
+  test("returns false for a known text-only model", () => {
+    setMockConfig({
+      "text-profile": {
+        provider: "fireworks",
+        model: "accounts/fireworks/models/glm-5p2",
+      },
+    });
+    expect(doesSupportVision(profile("text-profile"))).toBe(false);
+  });
+
+  test("returns false for an unknown profile key not in config", () => {
+    setMockConfig({});
+    expect(doesSupportVision(profile("nonexistent"))).toBe(false);
+  });
+
+  test("returns false for an unknown provider/model pair", () => {
+    setMockConfig({
+      "unknown-model": { provider: "unknown-provider", model: "unknown-model" },
+    });
+    expect(doesSupportVision(profile("unknown-model"))).toBe(false);
+  });
+
+  test("inherits provider from llm.default when profile only sets model", () => {
+    setMockConfig(
+      { "model-only": { model: "claude-opus-4-6" } },
+      { provider: "anthropic" },
+    );
+    expect(doesSupportVision(profile("model-only"))).toBe(true);
+  });
+
+  test("inherits model from llm.default when profile only sets provider", () => {
+    // llm.default → anthropic/claude-opus-4-6 (vision-capable)
+    setMockConfig({ "provider-only": { provider: "anthropic" } });
+    expect(doesSupportVision(profile("provider-only"))).toBe(true);
+  });
+
+  test("mix profile returns true when any arm supports vision", () => {
+    setMockConfig({
+      "mix-profile": {
+        mix: [
+          { profile: "text-arm", weight: 0.5 },
+          { profile: "vision-arm", weight: 0.5 },
+        ],
+      },
+      "text-arm": {
+        provider: "fireworks",
+        model: "accounts/fireworks/models/glm-5p2",
+      },
+      "vision-arm": { provider: "anthropic", model: "claude-opus-4-6" },
+    });
+    expect(doesSupportVision(profile("mix-profile"))).toBe(true);
+  });
+
+  test("mix profile returns false when all arms are text-only", () => {
+    setMockConfig({
+      "mix-profile": {
+        mix: [
+          { profile: "text-arm-1", weight: 0.5 },
+          { profile: "text-arm-2", weight: 0.5 },
+        ],
+      },
+      "text-arm-1": {
+        provider: "fireworks",
+        model: "accounts/fireworks/models/glm-5p2",
+      },
+      "text-arm-2": {
+        provider: "fireworks",
+        model: "accounts/fireworks/models/glm-5p2",
+      },
+    });
+    expect(doesSupportVision(profile("mix-profile"))).toBe(false);
+  });
+});
+
+describe("doesSupportVision with a bare string", () => {
+  test("returns true for a known vision-capable model id", () => {
+    expect(doesSupportVision("claude-opus-4-6")).toBe(true);
+  });
+
+  test("returns false for a known text-only model id", () => {
+    expect(doesSupportVision("accounts/fireworks/models/glm-5p2")).toBe(false);
+  });
+
+  test("falls back to resolving the string as a profile key", () => {
+    // "vision-profile" is not a catalog model id, so it resolves as a profile
+    // key → anthropic/claude-opus-4-6 (vision-capable).
+    setMockConfig({
+      "vision-profile": { provider: "anthropic", model: "claude-opus-4-6" },
+    });
+    expect(doesSupportVision("vision-profile")).toBe(true);
+  });
+
+  test("returns false for a string that is neither a model nor a profile", () => {
+    setMockConfig({});
+    expect(doesSupportVision("some-unknown-string")).toBe(false);
+  });
+});

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

@@ -0,0 +1,113 @@
+/**
+ * Vision-support resolution for plugin consumption.
+ *
+ * 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.
+ */
+
+import { getConfig } from "../config/loader.js";
+import {
+  getCatalogProviderForModel,
+  PROVIDER_CATALOG,
+} from "../providers/model-catalog.js";
+import type { ModelProfileInfo } from "./types.js";
+
+/**
+ * Whether the given model or profile 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.
+ */
+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 {
+  const { llm } = getConfig();
+  const entry = llm.profiles[profileKey];
+  if (entry == null) return undefined;
+
+  if (entry.mix != null) {
+    let sawUnknown = false;
+    for (const arm of entry.mix) {
+      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;
+  }
+
+  return resolveEntryVision(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.
+ */
+function resolveEntryVision(
+  entry: { provider?: string; model?: string },
+  llm: { default?: { provider?: string; model?: string } },
+): boolean | undefined {
+  const provider = entry.provider ?? llm.default?.provider;
+  const model = entry.model ?? llm.default?.model;
+
+  // Infer provider from model when missing (mirrors the resolver's
+  // withImpliedProviderForKnownModel).
+  const effectiveProvider =
+    provider ??
+    (typeof model === "string" ? getCatalogProviderForModel(model) : undefined);
+
+  if (typeof effectiveProvider !== "string" || typeof model !== "string") {
+    return undefined;
+  }
+
+  const catalogProvider = PROVIDER_CATALOG.find(
+    (p) => p.id === effectiveProvider,
+  );
+  const catalogModel = catalogProvider?.models.find((m) => m.id === model);
+  return catalogModel?.supportsVision;
+}

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

@@ -8,12 +8,19 @@ 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 streamDeltas: string[] = [];
 
 const fakeProvider = {
   name: "mock-advisor-provider",
   async sendMessage(messages: unknown, options: unknown) {
     sendMessageArgs = { messages, options } as Record<string, unknown>;
     if (sendMessageError) throw sendMessageError;
+    const onEvent = (
+      options as { onEvent?: (e: { type: string; text?: string }) => void }
+    ).onEvent;
+    if (onEvent) {
+      for (const text of streamDeltas) onEvent({ type: "text_delta", text });
+    }
     return {
       content: [{ type: "text", text: responseText }],
       model: "mock-model",
@@ -49,6 +56,7 @@ beforeEach(() => {
   responseText = "Use a channel-based worker pool; drain on shutdown.";
   sendMessageError = null;
   providerResolves = true;
+  streamDeltas = [];
   resetAdvisorStateForTests();
 });
 
@@ -123,6 +131,29 @@ 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", () => {
@@ -150,4 +181,19 @@ 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,7 +16,7 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../../providers/provider-send-message.js";
-import type { Message } from "../../../providers/types.js";
+import type { Message, ProviderEvent } from "../../../providers/types.js";
 import { ADVISOR_CONFIG } from "./config.js";
 import { advisorRequestText, buildAdvisorSystem } from "./steering.js";
 import { toAdvisorMessages } from "./transcript.js";
@@ -46,6 +46,14 @@ export interface ConsultParams {
   systemPrompt: string | null;
   messages: ReadonlyArray<Message>;
   signal?: AbortSignal;
+  /**
+   * Optional sink for the advisor's generated text as it streams. Each call
+   * receives an incremental chunk (a provider `text_delta`). Wiring this to the
+   * tool's `onOutput` surfaces the consult live as `tool_output_chunk` while the
+   * advisor model is still generating; the complete guidance is still returned
+   * as the resolved string.
+   */
+  onText?: (chunk: string) => void;
 }
 
 /** Combine the caller's signal with a consult timeout. */
@@ -78,8 +86,17 @@ export async function consultAdvisor(params: ConsultParams): Promise<string> {
   // than an advisor-specific cap.
   const messages: Message[] = [...history, userMessage(advisorRequestText())];
 
+  const { onText } = params;
   const response = await provider.sendMessage(messages, {
     systemPrompt: buildAdvisorSystem(params.systemPrompt),
+    // Forward the model's visible text deltas to the caller's sink so the
+    // guidance streams live. Other event types (thinking, usage) ride their
+    // own channels and are intentionally not surfaced as tool output.
+    onEvent: onText
+      ? (event: ProviderEvent) => {
+          if (event.type === "text_delta" && event.text) onText(event.text);
+        }
+      : undefined,
     config: {
       callSite: ADVISOR_CALL_SITE,
       ...override,

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

@@ -52,6 +52,10 @@ const advisorTool: ToolDefinition = {
         systemPrompt: capture?.systemPrompt ?? null,
         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/compaction/window-manager.ts

@@ -28,6 +28,7 @@ import {
   estimatePromptTokens,
   estimateToolsTokens,
 } from "../../../context/token-estimator.js";
+import { findConversationOrSubagent } from "../../../daemon/conversation-registry.js";
 import type { InjectionMode } from "../../../daemon/conversation-runtime-assembly.js";
 import type {
   ContentBlock,
@@ -220,7 +221,6 @@ export interface OverflowRecoveryOptions {
 
 export interface ContextWindowManagerOptions {
   provider: Provider;
-  systemPrompt: string | (() => string);
   config: ContextWindowConfig;
   /** Pre-computed tool token budget to include in all estimations. */
   toolTokenBudget?: number;
@@ -286,7 +286,6 @@ function extractText(content: ContentBlock[]): string {
 
 export class ContextWindowManager {
   private readonly provider: Provider;
-  private readonly _systemPrompt: string | (() => string);
   private config: ContextWindowConfig;
   private readonly toolTokenBudget: number;
   private readonly conversationId: string | undefined;
@@ -300,7 +299,6 @@ export class ContextWindowManager {
    * rows. Decremented after a successful compaction.
    */
   private _nonPersistedPrefixCount = 0;
-  private _resolvedSystemPrompt: string | undefined;
   /**
    * Reducer state for the in-progress overflow-recovery ladder, held across
    * the successive {@link reduceOverflowOneRung} calls of a single turn so the
@@ -324,7 +322,6 @@ export class ContextWindowManager {
 
   constructor(options: ContextWindowManagerOptions) {
     this.provider = options.provider;
-    this._systemPrompt = options.systemPrompt;
     this.config = options.config;
     this.toolTokenBudget = options.toolTokenBudget ?? 0;
     this.conversationId = options.conversationId;
@@ -365,18 +362,8 @@ export class ContextWindowManager {
   }
 
   private get systemPrompt(): string {
-    if (this._resolvedSystemPrompt !== undefined)
-      return this._resolvedSystemPrompt;
-    const resolved =
-      typeof this._systemPrompt === "function"
-        ? this._systemPrompt()
-        : this._systemPrompt;
-    this._resolvedSystemPrompt = resolved;
-    return resolved;
-  }
-
-  private clearSystemPromptCache(): void {
-    this._resolvedSystemPrompt = undefined;
+    const conversation = findConversationOrSubagent(this.conversationId);
+    return conversation?.systemPrompt ?? "";
   }
 
   private resolveCompactionConfig(): CompactionConfig {
@@ -393,14 +380,24 @@ export class ContextWindowManager {
    * turn re-resolves it (the system prompt is lazy and may have changed).
    */
   estimateInputTokens(messages: Message[]): number {
-    try {
-      return estimatePromptTokens(messages, this.systemPrompt, {
-        providerName: this.estimationProviderName,
-        toolTokenBudget: this.toolTokenBudget,
-      });
-    } finally {
-      this.clearSystemPromptCache();
-    }
+    return estimatePromptTokens(messages, this.systemPrompt, {
+      providerName: this.estimationProviderName,
+      toolTokenBudget: this.toolTokenBudget,
+    });
+  }
+
+  /**
+   * The resolved system prompt and tool definitions for the current turn —
+   * the same composition {@link estimateInputTokens} sizes against. Exposed as
+   * plain data so the daemon can run an out-of-band provider `count_tokens`
+   * request without re-deriving the prompt; the count call itself lives on the
+   * daemon, not this plugin.
+   */
+  get tokenCountInputs(): {
+    systemPrompt: string;
+    tools: ToolDefinition[] | undefined;
+  } {
+    return { systemPrompt: this.systemPrompt, tools: this.resolveTools?.() };
   }
 
   /**
@@ -412,18 +409,14 @@ export class ContextWindowManager {
   shouldCompact(messages: Message[]): ShouldCompactResult {
     const compaction = this.resolveCompactionConfig();
     if (!compaction.enabled) return { needed: false, estimatedTokens: 0 };
-    try {
-      const estimated = estimatePromptTokens(messages, this.systemPrompt, {
-        providerName: this.estimationProviderName,
-        toolTokenBudget: this.toolTokenBudget,
-      });
-      const threshold = Math.floor(
-        this.config.maxInputTokens * compaction.autoThreshold,
-      );
-      return { needed: estimated >= threshold, estimatedTokens: estimated };
-    } finally {
-      this.clearSystemPromptCache();
-    }
+    const estimated = estimatePromptTokens(messages, this.systemPrompt, {
+      providerName: this.estimationProviderName,
+      toolTokenBudget: this.toolTokenBudget,
+    });
+    const threshold = Math.floor(
+      this.config.maxInputTokens * compaction.autoThreshold,
+    );
+    return { needed: estimated >= threshold, estimatedTokens: estimated };
   }
 
   async maybeCompact(
@@ -431,11 +424,7 @@ export class ContextWindowManager {
     signal?: AbortSignal,
     options?: ContextWindowCompactOptions,
   ): Promise<ContextWindowResult> {
-    try {
-      return await this._maybeCompact(messages, signal, options);
-    } finally {
-      this.clearSystemPromptCache();
-    }
+    return await this._maybeCompact(messages, signal, options);
   }
 
   /**
@@ -452,11 +441,7 @@ export class ContextWindowManager {
     options: OverflowRecoveryRungOptions,
     signal?: AbortSignal,
   ): Promise<ReducerStepResult> {
-    try {
-      return await this._reduceOverflowOneRung(messages, options, signal);
-    } finally {
-      this.clearSystemPromptCache();
-    }
+    return await this._reduceOverflowOneRung(messages, options, signal);
   }
 
   /**
@@ -810,24 +795,20 @@ export class ContextWindowManager {
         "ContextWindowManager has no conversationId — cannot run emergency compaction",
       );
     }
-    try {
-      return await runEmergencyCompaction({
-        conversationId: this.conversationId,
-        messages,
-        provider: this.provider,
-        systemPrompt: this.systemPrompt,
-        tools: undefined,
-        compaction: this.resolveCompactionConfig(),
-        maxInputTokens: this.config.maxInputTokens,
-        previousEstimatedInputTokens: options.previousEstimatedInputTokens,
-        force: true,
-        signal,
-        overrideProfile: options.overrideProfile ?? null,
-        nonPersistedPrefixCount: this._nonPersistedPrefixCount,
-      });
-    } finally {
-      this.clearSystemPromptCache();
-    }
+    return await runEmergencyCompaction({
+      conversationId: this.conversationId,
+      messages,
+      provider: this.provider,
+      systemPrompt: this.systemPrompt,
+      tools: undefined,
+      compaction: this.resolveCompactionConfig(),
+      maxInputTokens: this.config.maxInputTokens,
+      previousEstimatedInputTokens: options.previousEstimatedInputTokens,
+      force: true,
+      signal,
+      overrideProfile: options.overrideProfile ?? null,
+      nonPersistedPrefixCount: this._nonPersistedPrefixCount,
+    });
   }
 
   /**

package/src/plugins/defaults/empty-response/hooks/post-model-call.ts

@@ -16,10 +16,12 @@
  *    at least one prior assistant turn this run, and no earlier turn this run
  *    already delivered visible text. The hook re-queries the model with
  *    `NUDGE_TEXT` (a tool trail exists to summarize, so a retry can recover a
- *    real answer). The retry is bounded to one pass per run by a one-shot
- *    per-conversation mark this hook sets; the sibling `stop` hook (see
- *    `./stop.ts`) clears it when the turn terminates, so the next run nudges
- *    afresh.
+ *    real answer). Main-agent turns only: background, subagent, and compaction
+ *    calls have no user awaiting a summary, so per the post-model-call contract
+ *    the nudge self-gates on {@link PostModelCallContext.callSite}. The retry is
+ *    bounded to one pass per run by a one-shot per-conversation mark this hook
+ *    sets; the sibling `stop` hook (see `./stop.ts`) clears it when the turn
+ *    terminates, so the next run nudges afresh.
  *
  * Every other case leaves the decision at `"stop"` (the model said its piece,
  * or there is nothing to act on).
@@ -146,6 +148,13 @@ const postModelCall: PluginHookFn<PostModelCallContext> = async (ctx) => {
     !priorAssistantHadVisibleText;
 
   if (isEmptyTurnAfterTools) {
+    // Only the user-facing reply gets the re-query nudge. Background, subagent,
+    // and compaction calls have no user awaiting a summary, and the
+    // post-model-call contract requires self-gating on call site to avoid
+    // re-querying them. The refusal-rewrite above is a user-facing terminal
+    // fallback, not a re-query, so it stays ungated.
+    if (ctx.callSite !== "mainAgent") return;
+
     // Re-query once to recover a real answer. The one-shot per-conversation
     // mark makes the hook self-limiting: a second empty turn this run finds the
     // mark already set and lets the turn end rather than nudging again.