@vellumai/assistant 0.6.3 → 0.6.5

package/src/daemon/conversation-tool-setup.ts

@@ -30,6 +30,7 @@ import { isAllowDecision } from "../permissions/types.js";
 import { isPermissionControlsV2Enabled } from "../permissions/v2-consent-policy.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
+import { getTaskRunRules } from "../tasks/ephemeral-permissions.js";
 import { coreAppProxyTools } from "../tools/apps/definitions.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -118,6 +119,10 @@ export interface ToolSetupContext extends SurfaceConversationContext {
   hostFileProxy?: import("./host-file-proxy.js").HostFileProxy;
   /** CES RPC client for credential execution operations. Injected when CES tools are enabled and the CES process is available. */
   cesClient?: CesClient;
+  /** The interface ID of the connected client driving the current turn (e.g. "macos", "chrome-extension"). Propagated into ToolContext for browser backend selection. */
+  readonly transportInterface?: InterfaceId;
+  /** Turn-scoped flag: true when any tool call in the current turn received explicit user approval via interactive prompt. Cleared at turn end. */
+  approvedViaPromptThisTurn?: boolean;
 }
 
 // ── buildToolDefinitions ─────────────────────────────────────────────
@@ -170,6 +175,15 @@ export function createToolExecutor(
       markDoordashStepInProgress(ctx, input);
     }
 
+    // Unwrap skill_execute dispatch so downstream context (notably
+    // batchAuthorizedByTask) is keyed on the tool that will actually run.
+    // Task rules in required_tools contain underlying tool names (e.g.
+    // "gmail_archive"), never the outer "skill_execute" dispatcher.
+    const effectiveToolName =
+      name === "skill_execute" && typeof input.tool === "string" && input.tool
+        ? input.tool
+        : name;
+
     // Build the context object shared by both the skill_execute interception
     // path and the regular executor path.
     const toolContext: ToolContext = {
@@ -183,6 +197,18 @@ export function createToolExecutor(
       callSessionId: ctx.callSessionId,
       triggeredBySurfaceAction:
         ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? "") ?? false,
+      approvedViaPrompt: ctx.approvedViaPromptThisTurn || undefined,
+      // A task without required_tools entries (e.g. ad-hoc tasks created with
+      // omitted/empty required_tools, or legacy rows where it was never
+      // populated) correctly gets no batch authorization — that's the
+      // intended stricter contract this check enforces, not a regression to
+      // paper over. Batch tools gate themselves via this flag; callers that
+      // never declared the tool shouldn't get blanket authorization.
+      batchAuthorizedByTask:
+        ctx.taskRunId != null &&
+        getTaskRunRules(ctx.taskRunId).some(
+          (r) => r.tool === effectiveToolName,
+        ),
       requesterExternalUserId: ctx.trustContext?.requesterExternalUserId,
       requesterChatId: ctx.trustContext?.requesterChatId,
       requesterIdentifier: ctx.trustContext?.requesterIdentifier,
@@ -202,6 +228,7 @@ export function createToolExecutor(
       hostFileProxy: ctx.hostFileProxy,
       isPlatformHosted: getIsPlatform(),
       cesClient: ctx.cesClient,
+      transportInterface: ctx.transportInterface,
       onToolLifecycleEvent: handleToolLifecycleEvent,
       sendToClient: (msg) => {
         // Tool context's sendToClient uses a loose { type: string; [key: string]: unknown }
@@ -216,6 +243,7 @@ export function createToolExecutor(
             data: s.data,
             actions: s.actions,
             display: s.display,
+            ...(s.persistent ? { persistent: true } : {}),
           });
         }
       },
@@ -279,6 +307,9 @@ export function createToolExecutor(
       }
 
       const result = await executor.execute(toolName, toolInput, toolContext);
+      if (toolContext.approvedViaPrompt) {
+        ctx.approvedViaPromptThisTurn = true;
+      }
 
       runPostExecutionSideEffects(toolName, toolInput, result, {
         ctx,
@@ -289,6 +320,9 @@ export function createToolExecutor(
     }
 
     const result = await executor.execute(name, input, toolContext);
+    if (toolContext.approvedViaPrompt) {
+      ctx.approvedViaPromptThisTurn = true;
+    }
 
     runPostExecutionSideEffects(name, input, result, {
       ctx,
@@ -390,18 +424,15 @@ export function createProxyApprovalCallback(
 
     // Persist trust rule if the user chose "always allow" or "always deny"
     if (
-      (response.decision === "always_allow" ||
-        response.decision === "always_allow_high_risk") &&
+      response.decision === "always_allow" &&
       response.selectedPattern &&
       response.selectedScope
     ) {
-      const allowHighRisk = response.decision === "always_allow_high_risk";
       log.info(
         {
           toolName,
           pattern: response.selectedPattern,
           scope: response.selectedScope,
-          allowHighRisk,
         },
         "Persisting always-allow trust rule (proxy)",
       );
@@ -411,7 +442,6 @@ export function createProxyApprovalCallback(
         response.selectedScope,
         "allow",
         100,
-        allowHighRisk ? { allowHighRisk: true } : undefined,
       );
     }
     if (

package/src/daemon/conversation-usage.ts

@@ -8,7 +8,10 @@ import type {
   PricingUsage,
 } from "../usage/types.js";
 import { getLogger } from "../util/logger.js";
-import { resolvePricingForUsageWithOverrides } from "../util/pricing.js";
+import {
+  resolvePricingForUsageWithOverrides,
+  usesAnthropicPricingRules,
+} from "../util/pricing.js";
 import type { ServerMessage, UsageStats } from "./message-protocol.js";
 
 const log = getLogger("conversation-usage");
@@ -106,7 +109,7 @@ function resolveStructuredPricing(
       providerName,
       model,
       usage,
-      config.pricingOverrides,
+      config.llm.pricingOverrides,
     );
   } catch (err) {
     log.warn({ err, model, providerName }, "Failed to resolve usage pricing");
@@ -142,16 +145,16 @@ export function recordUsage(
     0,
   );
 
-  const isAnthropic = ctx.providerName === "anthropic";
+  const useAnthropicRules = usesAnthropicPricingRules(ctx.providerName, model);
   const pricingUsage: PricingUsage = {
     directInputTokens,
     outputTokens,
     cacheCreationInputTokens: normalizedCacheCreationInputTokens,
     cacheReadInputTokens: normalizedCacheReadInputTokens,
-    anthropicCacheCreation: isAnthropic
+    anthropicCacheCreation: useAnthropicRules
       ? extractAnthropicCacheCreation(rawResponse)
       : null,
-    speed: isAnthropic ? extractAnthropicSpeed(rawResponse) : null,
+    speed: useAnthropicRules ? extractAnthropicSpeed(rawResponse) : null,
   };
   const pricing = resolveStructuredPricing(
     ctx.providerName,

package/src/daemon/conversation.ts

@@ -24,10 +24,11 @@ import type {
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import type { Speed } from "../config/schemas/inference.js";
+import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
 import {
   ContextWindowManager,
   type ContextWindowResult,
+  getSummaryFromContextMessage,
 } from "../context/window-manager.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { EventBus } from "../events/bus.js";
@@ -43,8 +44,10 @@ import {
 } from "../events/tool-profiling-listener.js";
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { getHookManager } from "../hooks/manager.js";
+import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
+  getConversationOriginChannel,
   updateConversationContextWindow,
   updateConversationHostAccess,
 } from "../memory/conversation-crud.js";
@@ -65,11 +68,17 @@ import type { Provider } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import * as approvalOverrides from "../runtime/conversation-approval-overrides.js";
+import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { ToolExecutor } from "../tools/executor.js";
+import type { OnboardingContext } from "../types/onboarding-context.js";
+import type { AbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import type { AssistantAttachmentDraft } from "./assistant-attachments.js";
-import { runAgentLoopImpl } from "./conversation-agent-loop.js";
+import {
+  runAgentLoopImpl,
+  trackCompactionOutcome,
+} from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
 import {
   regenerate as regenerateImpl,
@@ -104,6 +113,7 @@ import {
   createSurfaceMutex,
   handleSurfaceAction as handleSurfaceActionImpl,
   handleSurfaceUndo as handleSurfaceUndoImpl,
+  type SurfaceActionResult,
 } from "./conversation-surfaces.js";
 import type { ToolSetupContext } from "./conversation-tool-setup.js";
 import {
@@ -184,6 +194,19 @@ export class Conversation {
   /** @internal */ contextWindowManager: ContextWindowManager;
   /** @internal */ contextCompactedMessageCount = 0;
   /** @internal */ contextCompactedAt: number | null = null;
+  /**
+   * Tracks consecutive compaction failures (summary LLM call threw). In-memory
+   * only — resets to 0 on process restart, which is the intended "one free
+   * retry after restart" behavior. Reset to 0 on any successful compaction.
+   */
+  /** @internal */ consecutiveCompactionFailures = 0;
+  /**
+   * When the circuit breaker is open, this timestamp (ms since epoch) marks
+   * when auto-compaction is allowed to resume. Set to `Date.now() + 1h` after
+   * 3 consecutive failures; cleared on a successful compaction. User-initiated
+   * compaction (`force: true`) bypasses the breaker regardless.
+   */
+  /** @internal */ compactionCircuitOpenUntil: number | null = null;
   /** @internal */ currentRequestId?: string;
   /** @internal */ hasNoClient = false;
   /** @internal */ isSubagent = false;
@@ -196,15 +219,15 @@ export class Conversation {
   /** @internal */ hostFileProxy?: HostFileProxy;
   /**
    * Optional override sender used by `restoreBrowserProxyAvailability` so
-   * non-SSE transports (e.g. chrome-extension, whose host_browser_request
-   * frames flow through the ChromeExtensionRegistry WebSocket rather than
-   * the SSE hub) can preserve their registry-routed sender across drain
-   * queue restores. When set, `restoreBrowserProxyAvailability()` uses this
+   * registry-routed transports can preserve their sender across drain queue
+   * restores. When set, `restoreBrowserProxyAvailability()` uses this
    * function instead of `sendToClient` so the drain-queue path doesn't
-   * clobber the chrome-extension sender with the SSE hub emitter.
+   * clobber the registry-routed sender with the SSE hub emitter.
    *
-   * Populated by the POST /messages handler for chrome-extension turns and
-   * cleared when an unrelated interface takes over (see `updateClient`).
+   * Populated by the POST /messages handler when the guardian has an active
+   * extension connection in the `ChromeExtensionRegistry`, regardless of
+   * interface (chrome-extension, macOS, etc.). Cleared when a turn without
+   * an active extension connection takes over.
    */
   /** @internal */ hostBrowserSenderOverride?: (msg: ServerMessage) => void;
   /** @internal */ cesClient?: CesClient;
@@ -232,6 +255,7 @@ export class Conversation {
     languageCode?: string;
   };
   /** @internal */ surfaceActionRequestIds = new Set<string>();
+  /** @internal */ approvedViaPromptThisTurn = false;
   /** @internal */ pendingSurfaceActions = new Map<
     string,
     { surfaceType: SurfaceType }
@@ -259,6 +283,28 @@ export class Conversation {
     string,
     Record<string, unknown>
   >();
+  /**
+   * Pending standalone UI requests keyed by surfaceId.
+   * Daemon-driven surfaces that block the caller until user response or timeout.
+   * @internal
+   */
+  pendingStandaloneSurfaces = new Map<
+    string,
+    {
+      resolve: (result: InteractiveUiResult) => void;
+      timer: ReturnType<typeof setTimeout>;
+      surfaceType: SurfaceType;
+    }
+  >();
+  /**
+   * Short-lived tombstone set of recently-completed standalone surface IDs.
+   * Prevents late client actions from falling through to the LLM path.
+   * @internal
+   */
+  recentlyCompletedStandaloneSurfaces = new Map<
+    string,
+    ReturnType<typeof setTimeout>
+  >();
   /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
@@ -268,6 +314,7 @@ export class Conversation {
     data: SurfaceData;
     actions?: Array<{ id: string; label: string; style?: string }>;
     display?: string;
+    persistent?: boolean;
   }> = [];
   /** @internal */ workspaceTopLevelContext: string | null = null;
   /** @internal */ workspaceTopLevelDirty = true;
@@ -297,6 +344,14 @@ export class Conversation {
   /** @internal */ turnCount = 0;
   public lastAssistantAttachments: AssistantAttachmentDraft[] = [];
   public lastAttachmentWarnings: string[] = [];
+  /**
+   * Pre-chat onboarding context provided by the native client.
+   * In-memory only — not persisted to the DB. Only relevant for the first
+   * turn of a brand-new conversation so the system prompt can personalize
+   * the opener and skip redundant discovery.
+   * @internal
+   */
+  private onboardingContext?: OnboardingContext;
   /** @internal */ currentTurnChannelContext: TurnChannelContext | null = null;
   /** @internal */ currentTurnInterfaceContext: TurnInterfaceContext | null =
     null;
@@ -323,6 +378,7 @@ export class Conversation {
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
     cacheTtl?: "5m" | "1h",
+    modelOverride?: string,
   ) {
     this.conversationId = conversationId;
     this.systemPrompt = systemPrompt;
@@ -369,7 +425,10 @@ export class Conversation {
         );
       }
     });
-    this.secretPrompter = new SecretPrompter(sendToClient);
+    this.secretPrompter = new SecretPrompter(
+      sendToClient,
+      broadcastToAllClients,
+    );
 
     // Register watch/call notifiers (reads ctx properties lazily)
     registerConversationNotifiers(conversationId, this);
@@ -407,7 +466,7 @@ export class Conversation {
     );
 
     const config = getConfig();
-    this.streamThinking = config.thinking.streamThinking ?? false;
+    this.streamThinking = config.llm.default.thinking.streamThinking ?? false;
 
     // CES (Credential Execution Service) — use the shared server-level client.
     // The CES sidecar accepts exactly one bootstrap connection, so the
@@ -424,10 +483,15 @@ export class Conversation {
     const hasSystemPromptOverride = systemPrompt !== buildSystemPrompt();
     this.hasSystemPromptOverride = hasSystemPromptOverride;
 
+    // If an explicit modelOverride is supplied, use it verbatim. Otherwise
+    // leave the model unset and let `RetryProvider`'s call-site resolver pick
+    // it up from `llm.default` / `llm.callSites.<id>` on every turn.
+    const resolvedModel: string | undefined = modelOverride;
+
     const resolveSystemPromptCallback = (
       _history: import("../providers/types.js").Message[],
     ): ResolvedSystemPrompt => {
-      const resolved = {
+      const resolved: ResolvedSystemPrompt = {
         systemPrompt: this.hasSystemPromptOverride
           ? systemPrompt
           : (() => {
@@ -440,24 +504,29 @@ export class Conversation {
                 userPersona: persona.userPersona,
                 channelPersona: persona.channelPersona,
                 userSlug: persona.userSlug,
+                onboardingContext: this.getOnboardingContext(),
               });
             })(),
         maxTokens: configuredMaxTokens,
       };
+      if (resolvedModel !== undefined) {
+        resolved.model = resolvedModel;
+      }
       return resolved;
     };
 
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
-    const resolvedSpeed = speedOverride ?? config.speed;
+    const resolvedSpeed = speedOverride ?? config.llm.default.speed;
+    const llmDefault = config.llm.default;
 
     this.agentLoop = new AgentLoop(
       provider,
       systemPrompt,
       {
         maxTokens,
-        maxInputTokens: config.contextWindow.maxInputTokens,
-        thinking: config.thinking,
-        effort: config.effort,
+        maxInputTokens: llmDefault.contextWindow.maxInputTokens,
+        thinking: llmDefault.thinking,
+        effort: llmDefault.effort,
         ...(fastModeEnabled && resolvedSpeed === "fast"
           ? { speed: resolvedSpeed }
           : {}),
@@ -471,7 +540,7 @@ export class Conversation {
     this.contextWindowManager = new ContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
-      config: config.contextWindow,
+      config: llmDefault.contextWindow,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
     });
 
@@ -481,6 +550,16 @@ export class Conversation {
     });
   }
 
+  // ── Onboarding context ───────────────────────────────────────────
+
+  setOnboardingContext(ctx: OnboardingContext): void {
+    this.onboardingContext = ctx;
+  }
+
+  getOnboardingContext(): OnboardingContext | undefined {
+    return this.onboardingContext;
+  }
+
   // ── Lifecycle ────────────────────────────────────────────────────
 
   async loadFromDb(): Promise<void> {
@@ -574,21 +653,31 @@ export class Conversation {
     this.hostFileProxy?.updateSender(this.sendToClient, false);
   }
 
-  /** Restore host proxy availability based on whether a real client is connected. */
-  restoreProxyAvailability(): void {
+  /**
+   * Restore host proxy availability based on whether a real client is connected.
+   * When `skipBrowser` is true, the browser proxy is left untouched — use this
+   * when `restoreBrowserProxyAvailability()` will handle the browser proxy
+   * separately with the correct registry-routed sender.
+   */
+  restoreProxyAvailability(options?: { skipBrowser?: boolean }): void {
     if (!this.hasNoClient) {
       this.hostBashProxy?.updateSender(this.sendToClient, true);
-      this.hostBrowserProxy?.updateSender(this.sendToClient, true);
+      if (!options?.skipBrowser) {
+        this.hostBrowserProxy?.updateSender(this.sendToClient, true);
+      }
       this.hostCuProxy?.updateSender(this.sendToClient, true);
       this.hostFileProxy?.updateSender(this.sendToClient, true);
     }
   }
 
   /**
-   * Restore host browser proxy availability only. Used for non-desktop
-   * interfaces (e.g. chrome-extension) that support host_browser but not
-   * the full desktop proxy set, so calling restoreProxyAvailability() would
-   * incorrectly re-enable bash/file/CU proxies that should stay disabled.
+   * Restore host browser proxy availability only. Used for interfaces that
+   * support host_browser but not the full desktop proxy set, so calling
+   * restoreProxyAvailability() would incorrectly re-enable bash/file/CU
+   * proxies that should stay disabled. Applicable to chrome-extension turns
+   * (which only support host_browser) and macOS turns with an active
+   * extension connection (which route browser tools through the extension
+   * registry instead of cdp-inspect/local).
    *
    * Unlike `restoreProxyAvailability()`, this helper does NOT gate on
    * `hasNoClient`. The chrome-extension interface is non-interactive (so
@@ -599,16 +688,16 @@ export class Conversation {
    * incorrectly enable host_bash/host_file/host_cu tool gating downstream.
    *
    * When `hostBrowserSenderOverride` is set, that function is used as the
-   * sender instead of `sendToClient`. This is required for the
-   * chrome-extension interface whose host_browser frames route through the
-   * ChromeExtensionRegistry WebSocket rather than the SSE hub: if the
-   * queue-drain path called this helper with `sendToClient`, the
-   * registry-routed sender established at turn-start would be clobbered by
-   * the SSE hub emitter and host_browser_request frames would stop
-   * reaching the extension.
+   * sender instead of `sendToClient`. This is required for any interface
+   * whose host_browser frames route through the ChromeExtensionRegistry
+   * WebSocket rather than the SSE hub: if the queue-drain path called this
+   * helper with `sendToClient`, the registry-routed sender established at
+   * turn-start would be clobbered by the SSE hub emitter and
+   * host_browser_request frames would stop reaching the extension.
    *
    * Callers must only invoke this when they know the current interface
-   * supports host_browser (see `supportsHostProxy(id, "host_browser")`).
+   * supports host_browser (see `supportsHostProxy(id, "host_browser")`)
+   * or has an active extension connection with a registry-routed sender.
    */
   restoreBrowserProxyAvailability(): void {
     const sender = this.hostBrowserSenderOverride ?? this.sendToClient;
@@ -642,6 +731,8 @@ export class Conversation {
     }
     this.messages = [...messages];
     this.contextWindowManager.nonPersistedPrefixCount = messages.length;
+    this.contextWindowManager.summaryIsInjected =
+      getSummaryFromContextMessage(messages[0]) != null;
   }
 
   /**
@@ -667,12 +758,41 @@ export class Conversation {
     return this.stale;
   }
 
-  abort(): void {
-    abortConversation(this);
+  abort(reason?: AbortReason): void {
+    abortConversation(this, reason);
   }
 
   dispose(): void {
     approvalOverrides.clearMode(this.conversationId);
+    // Cancel all pending standalone surfaces so callers get a clean
+    // cancellation instead of hanging forever. Emit dismiss notifications
+    // to the client so surfaces don't remain visually active if the client
+    // reconnects after dispose.
+    const emitDispose =
+      this.broadcastToAllClients ?? this.sendToClient.bind(this);
+    for (const [surfaceId, entry] of this.pendingStandaloneSurfaces) {
+      clearTimeout(entry.timer);
+      try {
+        emitDispose({
+          type: "ui_surface_dismiss",
+          conversationId: this.conversationId,
+          surfaceId,
+        });
+      } catch {
+        // Best-effort: the client may already be disconnected during dispose.
+      }
+      entry.resolve({
+        status: "cancelled",
+        surfaceId,
+        cancellationReason: "resolver_unavailable",
+      });
+    }
+    this.pendingStandaloneSurfaces.clear();
+    // Clear tombstone timers to prevent dangling references after dispose.
+    for (const timer of this.recentlyCompletedStandaloneSurfaces.values()) {
+      clearTimeout(timer);
+    }
+    this.recentlyCompletedStandaloneSurfaces.clear();
     this.hostBashProxy?.dispose();
     this.hostBrowserProxy?.dispose();
     this.hostCuProxy?.dispose();
@@ -711,6 +831,7 @@ export class Conversation {
     options?: { isInteractive?: boolean },
     displayContent?: string,
     transport?: ConversationTransportMetadata,
+    clientMessageId?: string,
   ): { queued: boolean; requestId: string; rejected?: boolean } {
     return enqueueMessageImpl(
       this,
@@ -724,6 +845,7 @@ export class Conversation {
       options,
       displayContent,
       transport,
+      clientMessageId,
     );
   }
 
@@ -876,7 +998,7 @@ export class Conversation {
    * confirmations in the same conversation that match the decision.
    *
    * - allow_10m / allow_conversation → approve ALL pending in conversation
-   * - always_allow / always_allow_high_risk → approve pattern-matching pending
+   * - always_allow → approve pattern-matching pending
    * - always_deny → deny pattern-matching pending
    * - allow / deny (one-time) → no cascading
    */
@@ -970,14 +1092,9 @@ export class Conversation {
     }
 
     // Persistent allow: cascade if the pattern matches any allowlist candidate.
-    // "always_allow" must NOT cascade to high-risk pending confirmations —
-    // only "always_allow_high_risk" has consent for those.
-    if (
-      (decision === "always_allow" || decision === "always_allow_high_risk") &&
-      selectedPattern &&
-      details
-    ) {
-      if (decision === "always_allow" && details.riskLevel === "high") {
+    // "always_allow" must NOT cascade to high-risk pending confirmations.
+    if (decision === "always_allow" && selectedPattern && details) {
+      if (details.riskLevel === "high") {
         return null;
       }
       for (const option of details.allowlistOptions) {
@@ -1119,8 +1236,21 @@ export class Conversation {
     const result = await this.contextWindowManager.maybeCompact(
       this.messages,
       this.abortController?.signal ?? undefined,
-      { force: true, lastCompactedAt: this.contextCompactedAt ?? undefined },
+      {
+        force: true,
+        lastCompactedAt: this.contextCompactedAt ?? undefined,
+        conversationOriginChannel:
+          getConversationOriginChannel(this.conversationId) ?? undefined,
+      },
     );
+    // Track circuit-breaker state for user-initiated `/compact` and other
+    // forced paths so a successful forced compaction clears a stuck counter
+    // and a run of forced failures still trips the breaker. `summaryFailed`
+    // is `undefined` on early-return paths (no eligible messages, disabled,
+    // etc.) — skip those so they don't silently reset the counter.
+    if (result.summaryFailed !== undefined) {
+      trackCompactionOutcome(this, result.summaryFailed, this.sendToClient);
+    }
     if (result.compacted) {
       this.messages = result.messages;
       this.contextCompactedMessageCount += result.compactedPersistedMessages;
@@ -1130,12 +1260,27 @@ export class Conversation {
         result.summaryText,
         this.contextCompactedMessageCount,
       );
+      // Fire auto-analysis on compaction so the reflective agent can
+      // crystallize anything worth remembering before the context window
+      // narrows further.
+      enqueueAutoAnalysisOnCompaction(
+        this.conversationId,
+        this.trustContext?.trustClass,
+      );
     }
     return result;
   }
 
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
+    this.secretPrompter.setChannelContext(
+      caps
+        ? {
+            channel: caps.channel,
+            supportsDynamicUi: caps.supportsDynamicUi,
+          }
+        : undefined,
+    );
   }
 
   setTrustContext(ctx: TrustContext | null): void {
@@ -1275,6 +1420,7 @@ export class Conversation {
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
+      callSite?: LLMCallSite;
     },
   ): Promise<void> {
     return runAgentLoopImpl(this, content, userMessageId, onEvent, options);
@@ -1291,7 +1437,7 @@ export class Conversation {
     requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
-    options?: { isInteractive?: boolean },
+    options?: { isInteractive?: boolean; callSite?: LLMCallSite },
     displayContent?: string,
   ): Promise<string> {
     return processMessageImpl(
@@ -1334,8 +1480,8 @@ export class Conversation {
     surfaceId: string,
     actionId: string,
     data?: Record<string, unknown>,
-  ): void {
-    handleSurfaceActionImpl(this, surfaceId, actionId, data);
+  ): Promise<SurfaceActionResult> {
+    return handleSurfaceActionImpl(this, surfaceId, actionId, data);
   }
 
   handleSurfaceUndo(surfaceId: string): void {