@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

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

@@ -16,7 +16,11 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../../providers/provider-send-message.js";
-import type { Message } from "../../../providers/types.js";
+import type {
+  Message,
+  ProviderEvent,
+  ToolDefinition,
+} from "../../../providers/types.js";
 import { ADVISOR_CONFIG } from "./config.js";
 import { advisorRequestText, buildAdvisorSystem } from "./steering.js";
 import { toAdvisorMessages } from "./transcript.js";
@@ -26,6 +30,26 @@ 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
@@ -45,7 +69,22 @@ 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 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. */
@@ -73,17 +112,37 @@ export async function consultAdvisor(params: ConsultParams): Promise<string> {
   }
 
   // Append the consult instruction as the final user turn, then run a
-  // 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.
+  // 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),
+    systemPrompt: buildAdvisorSystem(
+      params.systemPrompt,
+      params.runtimeContext,
+    ),
+    ...(webEnabled ? { tools: [ADVISOR_WEB_SEARCH_TOOL] } : {}),
+    // 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,
-      tool_choice: { type: "none" },
+      tool_choice: webEnabled ? { type: "auto" } : { type: "none" },
     },
     signal: withTimeout(params.signal, ADVISOR_CONFIG.timeoutMs),
   });

package/src/plugins/defaults/advisor/context-pack.ts

@@ -0,0 +1,288 @@
+/**
+ * Assemble the runtime context the advisor needs to make grounded
+ * recommendations — the same situational awareness the executing agent has:
+ *  - the tools available to it this turn,
+ *  - the skills it can load,
+ *  - the loaded workspace / project context, NOW.md, PKB, and open documents,
+ *  - and relevant memory pulled through the recall search.
+ *
+ * The advisor already receives the agent's transcript and system prompt; this
+ * adds the situational context that lives *outside* the prompt (tools and
+ * skills are passed to the model as a separate catalog, not inlined) plus a
+ * fresh, task-focused memory recall.
+ *
+ * Personal-memory surfaces are gated to the same policy the main agent's
+ * memory injectors apply: the recall search honors `canAccessMemory` (like the
+ * `recall` tool), and NOW.md / PKB honor `isPersonalMemoryAllowed` (plus the
+ * scratchpad-injection toggle for NOW.md). The advisor tool is low-risk and can
+ * run on remote/trusted-contact turns, so without these gates it could forward
+ * private content the main agent itself would not receive.
+ *
+ * Every section is best-effort: each source is wrapped so a failure or empty
+ * result drops just that section, never the consult. Daemon- and memory-side
+ * modules are pulled in via dynamic `import()` so this plugin module — loaded
+ * at bootstrap through `defaults/index.ts` — never forms a static import cycle
+ * with them. The result is a single string injected into the advisor's system
+ * prompt (see `buildAdvisorSystem`), or `null` when nothing could be gathered.
+ */
+
+import type { ChannelId } from "../../../channels/types.js";
+import type { TrustContext } from "../../../daemon/trust-context.js";
+import type { Message } from "../../../providers/types.js";
+import type { TrustClass } from "../../../runtime/actor-trust-resolver.js";
+
+export interface AdvisorContextSources {
+  conversationId: string;
+  workingDir: string;
+  /** The live tool set the executor sees this turn (`ToolContext.allowedToolNames`). */
+  allowedToolNames?: ReadonlySet<string>;
+  /**
+   * Trust class of the turn's actor, from the per-turn `ToolContext.trustClass`
+   * snapshot. Gates the memory recall and (with {@link sourceChannel}) the
+   * personal-memory surfaces.
+   */
+  trustClass: TrustClass;
+  /**
+   * Channel the turn originates on, from the per-turn `ToolContext.executionChannel`
+   * snapshot. Combined with {@link trustClass} to evaluate personal-memory
+   * access exactly as the injectors do, off the same per-turn snapshot rather
+   * than the mutable live conversation trust.
+   */
+  sourceChannel?: string;
+  /** The captured transcript, used to derive the recall query. */
+  transcript: ReadonlyArray<Message>;
+  signal?: AbortSignal;
+}
+
+/** Cap a block so the assembled context never balloons the consult prompt. */
+function truncate(text: string, max: number): string {
+  const trimmed = text.trim();
+  return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max)}…`;
+}
+
+/** First sentence (or a capped prefix) of a tool/skill description. */
+function summarize(description: string | undefined, max = 160): string {
+  if (!description) return "";
+  const firstSentence = description.split(/(?<=[.!?])\s/)[0] ?? description;
+  return truncate(firstSentence, max);
+}
+
+/** Pull the most recent user-authored text to seed the memory recall query. */
+export function deriveRecallQuery(
+  transcript: ReadonlyArray<Message>,
+): string | null {
+  for (let i = transcript.length - 1; i >= 0; i--) {
+    const message = transcript[i];
+    if (message.role !== "user") continue;
+    const text = message.content
+      .map((block) => (block.type === "text" ? block.text : ""))
+      .join(" ")
+      .trim();
+    if (text.length > 0) return truncate(text, 500);
+  }
+  return null;
+}
+
+/** `## Available tools` — the live tool set the agent can act with this turn. */
+async function buildToolsSection(
+  allowedToolNames: ReadonlySet<string> | undefined,
+): Promise<string | null> {
+  if (!allowedToolNames || allowedToolNames.size === 0) return null;
+  try {
+    const { getTool } = await import("../../../tools/registry.js");
+    const lines: string[] = [];
+    for (const name of [...allowedToolNames].sort()) {
+      // The advisor advises; it never recommends consulting itself.
+      if (name === "advisor") continue;
+      const summary = summarize(getTool(name)?.description);
+      lines.push(summary ? `- ${name} — ${summary}` : `- ${name}`);
+    }
+    if (lines.length === 0) return null;
+    return `## Available tools (what the agent can do)\n${lines.join("\n")}`;
+  } catch {
+    return null;
+  }
+}
+
+/** `## Available skills` — the skills the agent can load via `skill_load`. */
+async function buildSkillsSection(): Promise<string | null> {
+  try {
+    const { loadSkillCatalog } = await import("../../../config/skills.js");
+    const catalog = loadSkillCatalog();
+    if (catalog.length === 0) return null;
+    const lines = catalog.slice(0, 60).map((skill) => {
+      const summary = summarize(skill.description);
+      const when = skill.activationHints?.length
+        ? ` (use when: ${truncate(skill.activationHints.join("; "), 120)})`
+        : "";
+      const label = skill.displayName || skill.name || skill.id;
+      return `- ${label} (${skill.id})${summary ? ` — ${summary}` : ""}${when}`;
+    });
+    const more =
+      catalog.length > 60 ? `\n- …and ${catalog.length - 60} more` : "";
+    return `## Available skills (load with skill_load)\n${lines.join("\n")}${more}`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whether personal-memory surfaces (NOW.md, PKB) may be exposed to the advisor
+ * — the same `isPersonalMemoryAllowed` gate the runtime memory injectors apply.
+ *
+ * Derived from the per-turn trust snapshot (`ToolContext.trustClass` /
+ * `executionChannel`, threaded in via {@link AdvisorContextSources}), NOT the
+ * live `findConversation().trustContext`: that conversation state is mutable
+ * and a concurrent guardian/meta command could flip it to guardian mid-flight,
+ * granting a remote/non-guardian turn access its own snapshot was never given.
+ * Fail-closed: if the gate can't be resolved, returns false.
+ */
+async function personalMemoryAllowedForAdvisor(
+  trustClass: TrustClass,
+  sourceChannel: string | undefined,
+): Promise<boolean> {
+  try {
+    const { isPersonalMemoryAllowed } =
+      await import("../../../daemon/trust-context.js");
+    // `isPersonalMemoryAllowed` reads only `sourceChannel` + `trustClass`; build
+    // a minimal trust context from the per-turn snapshot. The channel may be
+    // absent (local/internal turns), which the gate treats as non-remote.
+    const snapshot = {
+      sourceChannel: sourceChannel as ChannelId | undefined,
+      trustClass,
+    } as TrustContext;
+    return isPersonalMemoryAllowed(snapshot);
+  } catch {
+    return false;
+  }
+}
+
+/** `## Workspace & project context` — the loaded environment around the agent. */
+async function buildWorkspaceSection(
+  sources: AdvisorContextSources,
+): Promise<string | null> {
+  const { conversationId } = sources;
+  const parts: string[] = [];
+
+  // The `<workspace>` directory listing is not personal memory — the agent's
+  // own file tools already operate in this cwd — so it is surfaced ungated, the
+  // same way the workspace-context injector does.
+  try {
+    const { resolveWorkspaceTopLevelContext } =
+      await import("../../../daemon/conversation-workspace.js");
+    const workspace = resolveWorkspaceTopLevelContext(conversationId);
+    if (workspace) parts.push(truncate(workspace, 2500));
+  } catch {
+    /* best-effort */
+  }
+
+  // NOW.md and PKB are personal-memory surfaces. Gate them behind the same
+  // `isPersonalMemoryAllowed` policy (and, for NOW.md, the scratchpad-injection
+  // toggle) the runtime injectors use, evaluated off the per-turn trust
+  // snapshot, so a low-risk advisor consult cannot forward private content the
+  // main agent would never receive.
+  if (
+    await personalMemoryAllowedForAdvisor(
+      sources.trustClass,
+      sources.sourceChannel,
+    )
+  ) {
+    try {
+      const [{ readNowScratchpad }, { getConfig }] = await Promise.all([
+        import("../../../daemon/now-scratchpad.js"),
+        import("../../../config/loader.js"),
+      ]);
+      if (getConfig().memory.retrieval.scratchpadInjection.enabled) {
+        const now = readNowScratchpad();
+        if (now) parts.push(`NOW.md scratchpad:\n${truncate(now, 1500)}`);
+      }
+    } catch {
+      /* best-effort */
+    }
+
+    try {
+      const { readPkbContext } = await import("../../../memory/pkb/context.js");
+      const pkb = readPkbContext();
+      if (pkb) parts.push(truncate(pkb, 1500));
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  try {
+    const { buildActiveDocuments } =
+      await import("../../../daemon/conversation-runtime-assembly.js");
+    const docs = buildActiveDocuments(conversationId);
+    if (docs && docs.length > 0) {
+      const titles = docs
+        .slice(0, 20)
+        .map((doc) => `- ${doc.title} (${doc.wordCount} words)`)
+        .join("\n");
+      parts.push(`Open documents:\n${titles}`);
+    }
+  } catch {
+    /* best-effort */
+  }
+
+  if (parts.length === 0) return null;
+  return `## Workspace & project context\n${parts.join("\n\n")}`;
+}
+
+/** `## Relevant memory (recall)` — a fresh, task-focused recall search. */
+async function buildMemorySection(
+  sources: AdvisorContextSources,
+): Promise<string | null> {
+  try {
+    const { resolveCapabilities } =
+      await import("../../../runtime/capabilities.js");
+    // Recall reads sensitive local context; honor the same trust gate the
+    // `recall` tool applies. Non-guardian turns get no fresh recall here.
+    if (!resolveCapabilities(sources.trustClass).canAccessMemory) return null;
+
+    const query = deriveRecallQuery(sources.transcript);
+    if (!query) return null;
+
+    const [{ runDeterministicRecallSearch }, { getConfig }] = await Promise.all(
+      [
+        import("../../../memory/context-search/search.js"),
+        import("../../../config/loader.js"),
+      ],
+    );
+
+    const { evidence } = await runDeterministicRecallSearch(
+      { query, max_results: 8 },
+      {
+        workingDir: sources.workingDir,
+        conversationId: sources.conversationId,
+        config: getConfig(),
+        signal: sources.signal,
+      },
+    );
+    if (evidence.length === 0) return null;
+
+    const lines = evidence.slice(0, 8).map((item) => {
+      const excerpt = truncate(item.excerpt, 220);
+      return `- [${item.source}] ${item.title} (${item.locator}): ${excerpt}`;
+    });
+    return `## Relevant memory (recall: "${truncate(query, 120)}")\n${lines.join("\n")}`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Gather the advisor's runtime context block, or `null` if nothing is
+ * available. Sections run concurrently; each is independently best-effort.
+ */
+export async function buildAdvisorContext(
+  sources: AdvisorContextSources,
+): Promise<string | null> {
+  const sections = await Promise.all([
+    buildToolsSection(sources.allowedToolNames),
+    buildSkillsSection(),
+    buildWorkspaceSection(sources),
+    buildMemorySection(sources),
+  ]);
+  const present = sections.filter((s): s is string => s !== null);
+  return present.length > 0 ? present.join("\n\n") : null;
+}

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

@@ -33,9 +33,15 @@ 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.
 
@@ -54,8 +60,14 @@ 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.`;
-  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>`;
+  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;
 }
 
 /**

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/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,
+    });
   }
 
   /**