@vellumai/assistant 0.6.3 → 0.6.4

package/src/daemon/conversation-queue-manager.ts

@@ -114,6 +114,30 @@ export class MessageQueue {
     return item;
   }
 
+  /**
+   * Read-only access to a queued message by index without mutating the queue.
+   * Returns `undefined` when the index is out of range.
+   */
+  peek(index: number = 0): QueuedMessage | undefined {
+    return this.items[index];
+  }
+
+  /**
+   * Pop up to `count` messages FIFO and return them in order.
+   * Decrements the byte budget for each popped item using the same
+   * accounting as `shift` / `removeByRequestId`, keeping the bookkeeping
+   * centralized here rather than at call sites.
+   */
+  shiftN(count: number): QueuedMessage[] {
+    const n = Math.min(Math.max(0, count), this.items.length);
+    if (n === 0) return [];
+    const removed = this.items.splice(0, n);
+    for (const item of removed) {
+      this.currentBytes -= estimateItemBytes(item);
+    }
+    return removed;
+  }
+
   clear(): void {
     this.items = [];
     this.currentBytes = 0;

package/src/daemon/conversation-runtime-assembly.ts

@@ -611,7 +611,8 @@ const PKB_SYSTEM_REMINDER =
   "<system_reminder>" +
   "\n**CRITICAL:** you MUST read any PKB files that might be relevant to this conversation — " +
   "INDEX.md is your table of contents. Don't wait to be asked. " +
-  "Use `remember` OFTEN for EVERY new fact you learn IMMEDIATELY, don't wait for the next turn." +
+  "Use `remember` OFTEN for EVERY new fact you learn IMMEDIATELY, don't wait for the next turn. " +
+  "Corrections to things you had wrong are the highest-priority remembers — never skip them." +
   "\n</system_reminder>";
 
 /**
@@ -876,6 +877,12 @@ export interface UnifiedTurnContextOptions {
   interfaceName?: string;
   channelName?: string;
   actorContext?: InboundActorContext | null;
+  /**
+   * Human-readable duration since the previous user message (e.g. "14h ago",
+   * "yesterday", "3d ago"). Only populated when the gap exceeds 12 hours so
+   * the model can acknowledge long absences; otherwise omitted.
+   */
+  timeSinceLastMessage?: string | null;
 }
 
 /**
@@ -908,6 +915,9 @@ export function buildUnifiedTurnContextBlock(
 
   const lines: string[] = ["<turn_context>"];
   lines.push(`current_time: ${options.timestamp}`);
+  if (options.timeSinceLastMessage) {
+    lines.push(`time_since_last_message: ${options.timeSinceLastMessage}`);
+  }
   if (options.interfaceName) {
     lines.push(`interface: ${options.interfaceName}`);
   }

package/src/daemon/conversation-slash.ts

@@ -172,6 +172,42 @@ function resolveCommandsList(context?: SlashContext): string[] {
   ];
 }
 
+/**
+ * Pure classifier: returns the kind of slash resolution `resolveSlash` would
+ * produce for `content`, without triggering any side effects.
+ *
+ * Queue-drain lookahead (`buildPassthroughBatch`) uses this to decide whether
+ * to include a queued message in a contiguous passthrough batch. `resolveSlash`
+ * itself runs side effects (e.g. `/pair` registers a pairing request and
+ * writes a QR PNG), so calling it during lookahead and then again in the real
+ * drain would execute those side effects twice — the second call sees the
+ * first registration and fails with "active pairing already in progress".
+ */
+export function classifySlash(
+  content: string,
+): "passthrough" | "compact" | "unknown" {
+  const trimmed = content.trim();
+  if (
+    trimmed === "/model" ||
+    (trimmed.startsWith("/model ") && trimmed !== "/models")
+  ) {
+    return "unknown";
+  }
+  const shortcutMatch = trimmed.match(/^\/([a-z0-9-]+)(\s|$)/i);
+  if (
+    shortcutMatch &&
+    DEPRECATED_MODEL_SHORTCUTS.has(shortcutMatch[1].toLowerCase())
+  ) {
+    return "unknown";
+  }
+  if (trimmed === "/models") return "unknown";
+  if (trimmed === "/pair") return "unknown";
+  if (trimmed === "/compact") return "compact";
+  if (trimmed === "/status") return "unknown";
+  if (trimmed === "/commands") return "unknown";
+  return "passthrough";
+}
+
 /**
  * Resolve built-in slash commands (/models, /status, /commands, /compact, /pair).
  * Returns `unknown` with a deterministic message, `compact` for forced compaction,

package/src/daemon/conversation-surfaces.ts

@@ -17,6 +17,8 @@ import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
 import { buildConversationErrorMessage } from "./conversation-error.js";
+import { launchConversation } from "./conversation-launch.js";
+import type { TrustContext } from "./conversation-runtime-assembly.js";
 import type {
   CardSurfaceData,
   DynamicPageSurfaceData,
@@ -234,6 +236,10 @@ function normalizeTaskProgressCardPatch(
  */
 export interface SurfaceConversationContext {
   readonly conversationId: string;
+  /** Assistant id (if known) — used when publishing launch-triggered events. */
+  readonly assistantId?: string;
+  /** Inherited to spawned conversations in the `launch_conversation` action path. */
+  readonly trustContext?: TrustContext;
   readonly channelCapabilities?: {
     channel: string;
     supportsDynamicUi: boolean;
@@ -278,6 +284,7 @@ export interface SurfaceConversationContext {
       data?: Record<string, unknown>;
     }>;
     display?: string;
+    persistent?: boolean;
   }>;
   /** Optional proxy for delegating computer-use actions to a connected desktop client. */
   hostCuProxy?: import("./host-cu-proxy.js").HostCuProxy;
@@ -645,12 +652,75 @@ export function buildDeselectionDescription(
   return "";
 }
 
-export function handleSurfaceAction(
+export type SurfaceActionResult =
+  | { accepted: true; conversationId: string }
+  | { accepted: false; error: string }
+  | void;
+
+export async function handleSurfaceAction(
   ctx: SurfaceConversationContext,
   surfaceId: string,
   actionId: string,
   data?: Record<string, unknown>,
-): void {
+): Promise<SurfaceActionResult> {
+  // `launch_conversation` actions spawn a fresh conversation inline instead
+  // of round-tripping through the LLM with a `[User action on card surface:
+  // ...]` chat message. This dispatch must run BEFORE the pending-vs-not
+  // branching below: `ui_show` unconditionally calls
+  // `pendingSurfaceActions.set(...)` for any interactive card (regardless of
+  // the `persistent` flag), so on the very first click of a freshly-rendered
+  // launcher card `pending` is already set. Without this hoist the launch
+  // branch would fall through into the pending path and the LLM round-trip
+  // would happen on every click.
+  if (
+    data &&
+    typeof data === "object" &&
+    (data as Record<string, unknown>)._action === "launch_conversation"
+  ) {
+    const payload = data as Record<string, unknown>;
+    const title = typeof payload.title === "string" ? payload.title : "";
+    const seedPrompt =
+      typeof payload.seedPrompt === "string" ? payload.seedPrompt : "";
+    const anchorMessageId =
+      typeof payload.anchorMessageId === "string"
+        ? payload.anchorMessageId
+        : undefined;
+    if (!title || !seedPrompt) {
+      return { accepted: false, error: "missing_title_or_seedPrompt" };
+    }
+    // Launch actions don't consume the surface — persistent launcher cards
+    // keep accepting clicks afterward. Drop the pending entry (if any) so
+    // sibling button presses on the same card aren't blocked behind a stale
+    // expectation that this surface still owes an answer to the LLM.
+    ctx.pendingSurfaceActions.delete(surfaceId);
+    // `ctx` is the origin Conversation — inherit its trust context so the
+    // spawned conversation keeps guardian / trust-class state.
+    //
+    // `launchConversation` is the sole emitter of `open_conversation` for
+    // this path. We pass `focus: false` so the client registers a sidebar
+    // entry for the spawned conversation without switching focus away from
+    // the origin — critical for fan-out UX where one click launches
+    // multiple conversations.
+    //
+    // The helper also kicks off the seed turn fire-and-forget, so this
+    // `await` resolves as soon as the conversation is created + titled +
+    // published to the event hub. The HTTP POST /v1/surface-actions
+    // response returns promptly — the seed turn runs in the background.
+    const originTrustContext = ctx.trustContext;
+    const { conversationId } = await launchConversation({
+      title,
+      seedPrompt,
+      focus: false,
+      ...(anchorMessageId ? { anchorMessageId } : {}),
+      ...(originTrustContext ? { originTrustContext } : {}),
+    });
+    log.info(
+      { originConversationId: ctx.conversationId, conversationId, surfaceId },
+      "launch_conversation dispatched inline from surface action",
+    );
+    return { accepted: true, conversationId };
+  }
+
   const pending = ctx.pendingSurfaceActions.get(surfaceId);
 
   // When surfaces are restored from history (e.g. onboarding cards), there is
@@ -1202,7 +1272,13 @@ export function buildCompletionSummary(
           : undefined;
       return cancelLabel ? `User chose: "${cancelLabel}"` : "Cancelled";
     }
-    if (actionId === "confirm") return "Confirmed";
+    if (actionId === "confirm") {
+      const confirmLabel =
+        typeof surfaceData?.confirmLabel === "string"
+          ? surfaceData.confirmLabel
+          : undefined;
+      return confirmLabel ? `User chose: "${confirmLabel}"` : "Confirmed";
+    }
     // Preserve the actual action ID so the LLM knows the user's exact choice
     // (e.g. "deny", "no", "reject") rather than misreporting it as confirmed.
     return `User selected: ${actionId}`;
@@ -1249,7 +1325,13 @@ export function buildUserFacingLabel(
           : undefined;
       return cancelLabel ?? "Cancelled";
     }
-    if (actionId === "confirm") return "Confirmed";
+    if (actionId === "confirm") {
+      const confirmLabel =
+        typeof surfaceData?.confirmLabel === "string"
+          ? surfaceData.confirmLabel
+          : undefined;
+      return confirmLabel ?? "Confirmed";
+    }
     return `Selected: ${actionId}`;
   }
   if (surfaceType === "form") return "Submitted";
@@ -1378,6 +1460,11 @@ export async function surfaceProxyResolver(
     }
 
     const display = (input.display as string) === "panel" ? "panel" : "inline";
+    // `persistent: true` keeps the card visible through action clicks (only
+    // marks the clicked action as spent). Forward the flag so
+    // `SurfaceManager.showSurface` on the client sees it — without this the
+    // field is dropped and every card dismisses on first click.
+    const persistent = input.persistent === true ? true : undefined;
 
     const mappedActions = actions?.map((a) => ({
       id: a.id,
@@ -1406,6 +1493,7 @@ export async function surfaceProxyResolver(
         dataKeys: Object.keys(data),
         actionCount: mappedActions?.length ?? 0,
         display,
+        persistent: persistent ?? false,
         conversationId: ctx.conversationId,
       },
       "Sending ui_surface_show to client",
@@ -1420,6 +1508,7 @@ export async function surfaceProxyResolver(
       data,
       actions: mappedActions,
       display,
+      ...(persistent ? { persistent: true } : {}),
     } as unknown as UiSurfaceShow);
 
     // Track surface for persistence with the message
@@ -1430,6 +1519,7 @@ export async function surfaceProxyResolver(
       data,
       actions: mappedActions,
       display,
+      ...(persistent ? { persistent: true } : {}),
     });
 
     if (awaitAction) {

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,8 @@ 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;
 }
 
 // ── buildToolDefinitions ─────────────────────────────────────────────
@@ -170,6 +173,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 +195,17 @@ export function createToolExecutor(
       callSessionId: ctx.callSessionId,
       triggeredBySurfaceAction:
         ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? "") ?? false,
+      // 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 +225,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 +240,7 @@ export function createToolExecutor(
             data: s.data,
             actions: s.actions,
             display: s.display,
+            ...(s.persistent ? { persistent: true } : {}),
           });
         }
       },

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");
@@ -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

@@ -28,6 +28,7 @@ import type { Speed } from "../config/schemas/inference.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,6 +44,7 @@ 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 {
   updateConversationContextWindow,
@@ -60,13 +62,16 @@ import {
 } from "../permissions/v2-consent-policy.js";
 import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import type { Message } from "../providers/types.js";
+import { resolveModelIntent } from "../providers/model-intents.js";
+import type { Message, ModelIntent } from "../providers/types.js";
 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 * 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";
@@ -104,6 +109,7 @@ import {
   createSurfaceMutex,
   handleSurfaceAction as handleSurfaceActionImpl,
   handleSurfaceUndo as handleSurfaceUndoImpl,
+  type SurfaceActionResult,
 } from "./conversation-surfaces.js";
 import type { ToolSetupContext } from "./conversation-tool-setup.js";
 import {
@@ -196,15 +202,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;
@@ -268,6 +274,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 +304,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 +338,8 @@ export class Conversation {
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
     cacheTtl?: "5m" | "1h",
+    modelIntent?: ModelIntent,
+    modelOverride?: string,
   ) {
     this.conversationId = conversationId;
     this.systemPrompt = systemPrompt;
@@ -424,10 +441,18 @@ export class Conversation {
     const hasSystemPromptOverride = systemPrompt !== buildSystemPrompt();
     this.hasSystemPromptOverride = hasSystemPromptOverride;
 
+    // If an explicit modelOverride is supplied, use it verbatim. Otherwise,
+    // if modelIntent is set, resolve it against the active provider's
+    // intent → model mapping. The AgentLoop passes the resulting string
+    // through to `providerConfig.model` on every turn.
+    const resolvedModel: string | undefined =
+      modelOverride ??
+      (modelIntent ? resolveModelIntent(provider.name, modelIntent) : undefined);
+
     const resolveSystemPromptCallback = (
       _history: import("../providers/types.js").Message[],
     ): ResolvedSystemPrompt => {
-      const resolved = {
+      const resolved: ResolvedSystemPrompt = {
         systemPrompt: this.hasSystemPromptOverride
           ? systemPrompt
           : (() => {
@@ -440,10 +465,14 @@ 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;
     };
 
@@ -481,6 +510,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 +613,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 +648,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 +691,8 @@ export class Conversation {
     }
     this.messages = [...messages];
     this.contextWindowManager.nonPersistedPrefixCount = messages.length;
+    this.contextWindowManager.summaryIsInjected =
+      getSummaryFromContextMessage(messages[0]) != null;
   }
 
   /**
@@ -667,8 +718,8 @@ export class Conversation {
     return this.stale;
   }
 
-  abort(): void {
-    abortConversation(this);
+  abort(reason?: AbortReason): void {
+    abortConversation(this, reason);
   }
 
   dispose(): void {
@@ -1130,6 +1181,13 @@ 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;
   }
@@ -1334,8 +1392,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 {