@vellumai/assistant 0.6.6 → 0.7.1

package/src/daemon/conversation.ts

@@ -9,13 +9,13 @@
  * - conversation-tool-setup.ts   — tool definitions, executor, resolveTools callback
  * - conversation-media-retry.ts  — media trimming + raceWithTimeout
  * - conversation-process.ts      — drainQueue, processMessage
- * - conversation-history.ts      — undo, regenerate, consolidateAssistantMessages
+ * - conversation-history.ts      — undo, consolidateAssistantMessages
  * - conversation-surfaces.ts     — handleSurfaceAction, handleSurfaceUndo
  * - conversation-workspace.ts    — refreshWorkspaceTopLevelContext
  * - conversation-usage.ts        — recordUsage
  */
 
-import type { ResolvedSystemPrompt } from "../agent/loop.js";
+import type { AgentLoopConfig, ResolvedSystemPrompt } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
   InterfaceId,
@@ -23,8 +23,13 @@ import type {
   TurnInterfaceContext,
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  contextWindowConfigFromEffective,
+  resolveEffectiveContextWindow,
+} from "../config/llm-context-resolution.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
+import type { ContextWindowConfig } from "../config/types.js";
 import {
   ContextWindowManager,
   type ContextWindowResult,
@@ -36,7 +41,6 @@ import type { AssistantDomainEvents } from "../events/domain-events.js";
 import { createToolAuditListener } from "../events/tool-audit-listener.js";
 import { createToolDomainEventPublisher } from "../events/tool-domain-event-publisher.js";
 import { registerToolMetricsLoggingListener } from "../events/tool-metrics-listener.js";
-import { registerToolNotificationListener } from "../events/tool-notification-listener.js";
 import { registerToolPermissionTelemetryListener } from "../events/tool-permission-telemetry-listener.js";
 import {
   registerToolProfilingListener,
@@ -45,29 +49,24 @@ import {
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
+  getConversation,
   getConversationOriginChannel,
-  updateConversationHostAccess,
+  getConversationOverrideProfileFromRow,
 } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
-import { patternMatchesCandidate } from "../permissions/trust-store.js";
 import type { UserDecision } from "../permissions/types.js";
-import {
-  isConversationHostAccessDecision,
-  isConversationHostAccessEnabled,
-  isConversationHostAccessEnablePrompt,
-} 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 type { Provider } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.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 { ToolLifecycleEvent } from "../tools/types.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import type { AbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
@@ -78,10 +77,7 @@ import {
   trackCompactionOutcome,
 } from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
-import {
-  regenerate as regenerateImpl,
-  undo as undoImpl,
-} from "./conversation-history.js";
+import { undo as undoImpl } from "./conversation-history.js";
 import {
   abortConversation,
   disposeConversation,
@@ -102,9 +98,10 @@ import {
 } from "./conversation-process.js";
 import type { QueueDrainReason } from "./conversation-queue-manager.js";
 import { MessageQueue } from "./conversation-queue-manager.js";
-import type {
-  ChannelCapabilities,
-  TrustContext,
+import {
+  type ChannelCapabilities,
+  getSlackCompactionWatermarkForPrefix,
+  loadSlackChronologicalContext,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
@@ -120,11 +117,7 @@ import {
   createToolExecutor,
 } from "./conversation-tool-setup.js";
 import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
-import { HostBashProxy } from "./host-bash-proxy.js";
-import { HostBrowserProxy } from "./host-browser-proxy.js";
-import type { CuObservationResult } from "./host-cu-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
-import { HostFileProxy } from "./host-file-proxy.js";
 import type {
   ServerMessage,
   SurfaceData,
@@ -145,14 +138,12 @@ const log = getLogger("conversation");
 export interface ConversationMemoryPolicy {
   scopeId: string;
   includeDefaultFallback: boolean;
-  strictSideEffects: boolean;
 }
 
 export const DEFAULT_MEMORY_POLICY: Readonly<ConversationMemoryPolicy> =
   Object.freeze({
     scopeId: "default",
     includeDefaultFallback: false,
-    strictSideEffects: false,
   });
 
 export { findLastUndoableUserMessageIndex } from "./conversation-history.js";
@@ -160,6 +151,7 @@ export type {
   QueueDrainReason,
   QueuePolicy,
 } from "./conversation-queue-manager.js";
+import type { TrustContext } from "./trust-context.js";
 
 export class Conversation {
   public readonly conversationId: string;
@@ -211,23 +203,7 @@ export class Conversation {
   /** @internal */ headlessLock = false;
   /** @internal */ taskRunId?: string;
   /** @internal */ callSessionId?: string;
-  /** @internal */ hostBashProxy?: HostBashProxy;
-  /** @internal */ hostBrowserProxy?: HostBrowserProxy;
   /** @internal */ hostCuProxy?: HostCuProxy;
-  /** @internal */ hostFileProxy?: HostFileProxy;
-  /**
-   * Optional override sender used by `restoreBrowserProxyAvailability` so
-   * 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 registry-routed sender with the SSE hub emitter.
-   *
-   * 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;
   /** @internal */ readonly queue = new MessageQueue();
   /** @internal */ currentActiveSurfaceId?: string;
@@ -242,10 +218,12 @@ export class Conversation {
    */
   /** @internal */ currentTurnTrustContext?: TrustContext;
   /** @internal */ currentTurnChannelCapabilities?: ChannelCapabilities;
+  /** @internal */ currentTurnOverrideProfile?: string;
   /** @internal */ authContext?: AuthContext;
   /** @internal */ loadedHistoryTrustClass?: TrustClass;
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
+  /** @internal */ slackRuntimeContextNotice?: string;
   /** @internal */ assistantId?: string;
   /** @internal */ commandIntent?: {
     type: string;
@@ -303,7 +281,6 @@ export class Conversation {
     string,
     ReturnType<typeof setTimeout>
   >();
-  /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
     surfaceId: string;
@@ -369,10 +346,9 @@ export class Conversation {
     conversationId: string,
     provider: Provider,
     systemPrompt: string,
-    maxTokens: number,
+    maxTokens: number | undefined,
     sendToClient: (msg: ServerMessage) => void,
     workingDir: string,
-    broadcastToAllClients?: (msg: ServerMessage) => void,
     memoryPolicy?: ConversationMemoryPolicy,
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
@@ -384,7 +360,6 @@ export class Conversation {
     this.provider = provider;
     this.workingDir = workingDir;
     this.sendToClient = sendToClient;
-    this.broadcastToAllClients = broadcastToAllClients;
     this.memoryPolicy = memoryPolicy
       ? { ...memoryPolicy }
       : { ...DEFAULT_MEMORY_POLICY };
@@ -424,10 +399,7 @@ export class Conversation {
         );
       }
     });
-    this.secretPrompter = new SecretPrompter(
-      sendToClient,
-      broadcastToAllClients,
-    );
+    this.secretPrompter = new SecretPrompter();
 
     // Register call notifiers (reads ctx properties lazily)
     registerConversationNotifiers(conversationId, this);
@@ -436,9 +408,6 @@ export class Conversation {
     this.executor = new ToolExecutor(this.prompter);
     this.profiler = new ToolProfiler();
     registerToolMetricsLoggingListener(this.eventBus);
-    registerToolNotificationListener(this.eventBus, (msg) =>
-      this.sendToClient(msg),
-    );
     registerToolTraceListener(this.eventBus, this.traceEmitter);
     registerToolProfilingListener(this.eventBus, this.profiler);
     registerToolPermissionTelemetryListener(this.eventBus);
@@ -446,9 +415,7 @@ export class Conversation {
     const publishToolDomainEvent = createToolDomainEventPublisher(
       this.eventBus,
     );
-    const handleToolLifecycleEvent = (
-      event: import("../tools/types.js").ToolLifecycleEvent,
-    ) => {
+    const handleToolLifecycleEvent = (event: ToolLifecycleEvent) => {
       auditToolLifecycleEvent(event);
       return publishToolDomainEvent(event);
     };
@@ -461,7 +428,6 @@ export class Conversation {
       this.secretPrompter,
       this as ToolSetupContext,
       handleToolLifecycleEvent,
-      broadcastToAllClients,
     );
 
     const config = getConfig();
@@ -488,7 +454,7 @@ export class Conversation {
     const resolvedModel: string | undefined = modelOverride;
 
     const resolveSystemPromptCallback = (
-      _history: import("../providers/types.js").Message[],
+      _history: Message[],
     ): ResolvedSystemPrompt => {
       const resolved: ResolvedSystemPrompt = {
         systemPrompt: this.hasSystemPromptOverride
@@ -506,8 +472,10 @@ export class Conversation {
                 onboardingContext: this.getOnboardingContext(),
               });
             })(),
-        maxTokens: configuredMaxTokens,
       };
+      if (configuredMaxTokens !== undefined) {
+        resolved.maxTokens = configuredMaxTokens;
+      }
       if (resolvedModel !== undefined) {
         resolved.model = resolvedModel;
       }
@@ -517,20 +485,31 @@ export class Conversation {
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
     const resolvedSpeed = speedOverride ?? config.llm.default.speed;
     const llmDefault = config.llm.default;
+    const initialContextWindow = resolveEffectiveContextWindow({
+      llm: config.llm,
+      callSite: "mainAgent",
+    });
+    const initialContextWindowConfig = contextWindowConfigFromEffective(
+      llmDefault.contextWindow,
+      initialContextWindow,
+    );
+
+    const agentLoopConfig: Partial<AgentLoopConfig> = {
+      thinking: llmDefault.thinking,
+      effort: llmDefault.effort,
+      ...(fastModeEnabled && resolvedSpeed === "fast"
+        ? { speed: resolvedSpeed }
+        : {}),
+      ...(cacheTtl ? { cacheTtl } : {}),
+    };
+    if (configuredMaxTokens !== undefined) {
+      agentLoopConfig.maxTokens = configuredMaxTokens;
+    }
 
     this.agentLoop = new AgentLoop(
       provider,
       systemPrompt,
-      {
-        maxTokens,
-        maxInputTokens: llmDefault.contextWindow.maxInputTokens,
-        thinking: llmDefault.thinking,
-        effort: llmDefault.effort,
-        ...(fastModeEnabled && resolvedSpeed === "fast"
-          ? { speed: resolvedSpeed }
-          : {}),
-        ...(cacheTtl ? { cacheTtl } : {}),
-      },
+      agentLoopConfig,
       toolDefs.length > 0 ? toolDefs : undefined,
       toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
@@ -539,7 +518,7 @@ export class Conversation {
     this.contextWindowManager = new ContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
-      config: llmDefault.contextWindow,
+      config: initialContextWindowConfig,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
     });
   }
@@ -591,7 +570,11 @@ export class Conversation {
 
     provider
       .sendMessage([warmMessage], tools, systemPrompt, {
-        config: { max_tokens: 1, callSite: "mainAgent" },
+        config: {
+          max_tokens: 1,
+          callSite: "mainAgent",
+          usageTracking: "manual",
+        },
         signal: abort.signal,
       })
       .then(() => {
@@ -661,19 +644,11 @@ export class Conversation {
   updateClient(
     sendToClient: (msg: ServerMessage) => void,
     hasNoClient = false,
-    opts?: { skipProxySenderUpdate?: boolean },
   ): void {
     this.sendToClient = sendToClient;
     this.hasNoClient = hasNoClient;
     this.prompter.updateSender(sendToClient);
-    this.secretPrompter.updateSender(sendToClient);
     this.traceEmitter.updateSender(sendToClient);
-    if (!opts?.skipProxySenderUpdate) {
-      this.hostBashProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostBrowserProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostCuProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostFileProxy?.updateSender(sendToClient, !hasNoClient);
-    }
 
     // Replay last activity state so a reconnecting client sees the current phase
     // instead of being stuck on the last state it received before disconnection.
@@ -694,70 +669,6 @@ export class Conversation {
     return this.sendToClient;
   }
 
-  /** Mark host proxies as unavailable so tool execution uses local fallback. */
-  clearProxyAvailability(): void {
-    this.hostBashProxy?.updateSender(this.sendToClient, false);
-    this.hostBrowserProxy?.updateSender(this.sendToClient, false);
-    this.hostCuProxy?.updateSender(this.sendToClient, false);
-    this.hostFileProxy?.updateSender(this.sendToClient, false);
-  }
-
-  /**
-   * 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);
-      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 in two scenarios:
-   *
-   * 1. **Chrome-extension turns** — only support host_browser (not the full
-   *    desktop proxy set), so calling restoreProxyAvailability() would
-   *    incorrectly re-enable bash/file/CU proxies.
-   * 2. **macOS turns** — when called from queue-drain, the browser proxy
-   *    sender needs to be either the registry-routed sender (when an
-   *    extension connection is present) or the SSE hub sender (when no
-   *    extension is connected). This helper resolves the correct sender
-   *    via `hostBrowserSenderOverride ?? sendToClient`.
-   *
-   * Unlike `restoreProxyAvailability()`, this helper does NOT gate on
-   * `hasNoClient`. The chrome-extension interface is non-interactive (so
-   * `hasNoClient === true`), but it DOES have a connected client that can
-   * service `host_browser_request` events. Gating on `hasNoClient` would
-   * leave the just-constructed proxy unavailable and the only way to make
-   * it available would be to flip `hasNoClient` false, which would
-   * 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 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. When
-   * no override is set (macOS without extension), `sendToClient` is used
-   * so frames reach the desktop client via SSE.
-   *
-   * Callers must only invoke this when they know the current interface
-   * 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;
-    this.hostBrowserProxy?.updateSender(sender, true);
-  }
-
   setSubagentAllowedTools(tools: Set<string> | undefined): void {
     this.subagentAllowedTools = tools;
   }
@@ -817,17 +728,14 @@ export class Conversation {
   }
 
   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({
+        broadcastMessage({
           type: "ui_surface_dismiss",
           conversationId: this.conversationId,
           surfaceId,
@@ -847,10 +755,9 @@ export class Conversation {
       clearTimeout(timer);
     }
     this.recentlyCompletedStandaloneSurfaces.clear();
-    this.hostBashProxy?.dispose();
-    this.hostBrowserProxy?.dispose();
+    // Only dispose the per-conversation CU proxy. Bash/File/Transfer are
+    // singletons — their lifecycle is managed by static disposeInstance().
     this.hostCuProxy?.dispose();
-    this.hostFileProxy?.dispose();
     // CES client is owned by DaemonServer — just drop the reference.
     // Do NOT close it here; the server manages the CES lifecycle.
     this.cesClient = undefined;
@@ -877,8 +784,8 @@ export class Conversation {
   enqueueMessage(
     content: string,
     attachments: UserMessageAttachment[],
-    onEvent: (msg: ServerMessage) => void,
-    requestId: string,
+    onEvent?: (msg: ServerMessage) => void,
+    requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
     metadata?: Record<string, unknown>,
@@ -891,8 +798,8 @@ export class Conversation {
       this,
       content,
       attachments,
-      onEvent,
-      requestId,
+      onEvent ?? this.sendToClient,
+      requestId ?? crypto.randomUUID(),
       activeSurfaceId,
       currentPage,
       metadata,
@@ -953,28 +860,7 @@ export class Conversation {
       return;
     }
 
-    const hostAccessEnablePrompt =
-      this.prompter.isHostAccessEnablePrompt(requestId) ||
-      isConversationHostAccessEnablePrompt(
-        pendingInteractions.get(requestId)?.confirmationDetails,
-      );
-    const effectiveDecision =
-      hostAccessEnablePrompt && !isConversationHostAccessDecision(decision)
-        ? "deny"
-        : decision;
-
-    if (
-      hostAccessEnablePrompt &&
-      effectiveDecision === "allow" &&
-      !isConversationHostAccessEnabled(this.conversationId)
-    ) {
-      updateConversationHostAccess(this.conversationId, true);
-      this.sendToClient({
-        type: "conversation_host_access_updated",
-        conversationId: this.conversationId,
-        hostAccess: true,
-      });
-    }
+    const effectiveDecision = decision;
 
     // Capture toolUseId before resolving (resolution deletes the pending entry)
     const toolUseId = this.prompter.getToolUseId(requestId);
@@ -987,15 +873,11 @@ export class Conversation {
       decisionContext,
     );
 
-    // Mode activation (setTimedMode / setConversationMode) is intentionally NOT
-    // done here. It is handled in permission-checker.ts where the
-    // guardian trust-class and conversation context are available.
-
     // Emit authoritative confirmation state and activity transition centrally
     // so ALL callers (HTTP handlers, /v1/confirm, channel bridges) get
     // consistent events without duplicating emission logic.
     const resolvedState =
-      effectiveDecision === "deny" || effectiveDecision === "always_deny"
+      effectiveDecision === "deny"
         ? ("denied" as const)
         : ("approved" as const);
     this.emitConfirmationStateChanged({
@@ -1037,139 +919,6 @@ export class Conversation {
     } catch {
       // Canonical request tracking should not break the primary approval flow.
     }
-
-    // Cascade to other pending confirmations that match this decision
-    this.cascadePendingApprovals(
-      requestId,
-      effectiveDecision,
-      selectedPattern,
-      hostAccessEnablePrompt,
-    );
-  }
-
-  /**
-   * After resolving one confirmation, auto-resolve other pending
-   * confirmations in the same conversation that match the decision.
-   *
-   * - allow_10m / allow_conversation → approve ALL pending in conversation
-   * - always_allow → approve pattern-matching pending
-   * - always_deny → deny pattern-matching pending
-   * - allow / deny (one-time) → no cascading
-   */
-  private cascadePendingApprovals(
-    primaryRequestId: string,
-    decision: UserDecision,
-    selectedPattern?: string,
-    hostAccessEnablePrompt = false,
-  ): void {
-    // Single-action decisions don't cascade
-    if (decision === "allow" || decision === "deny") {
-      if (!hostAccessEnablePrompt || decision !== "allow") {
-        return;
-      }
-    }
-
-    const pendingRequestIds = this.prompter.getPendingRequestIds();
-    if (pendingRequestIds.length === 0) return;
-
-    for (const candidateId of pendingRequestIds) {
-      if (candidateId === primaryRequestId) continue;
-
-      const interaction = pendingInteractions.get(candidateId);
-      if (!interaction) continue;
-      if (interaction.conversationId !== this.conversationId) continue;
-      if (interaction.kind !== "confirmation") continue;
-
-      if (
-        hostAccessEnablePrompt &&
-        (this.prompter.isHostAccessEnablePrompt(candidateId) ||
-          isConversationHostAccessEnablePrompt(interaction.confirmationDetails))
-      ) {
-        // Enabling computer access is conversation-scoped, so sibling host
-        // prompts should resolve immediately once the first approval lands.
-        pendingInteractions.resolve(candidateId);
-        this.handleConfirmationResponse(
-          candidateId,
-          "allow",
-          undefined,
-          undefined,
-          undefined,
-          {
-            source: "system",
-            causedByRequestId: primaryRequestId,
-          },
-        );
-        continue;
-      }
-
-      const cascadeResult = this.shouldCascade(
-        decision,
-        selectedPattern,
-        interaction.confirmationDetails,
-      );
-      if (!cascadeResult) continue;
-
-      // Consume from pending-interactions tracker
-      pendingInteractions.resolve(candidateId);
-
-      // Resolve via handleConfirmationResponse which emits events and
-      // syncs canonical status. Use simple "allow"/"deny" so the
-      // permission-checker won't save duplicate rules or re-activate
-      // temporary modes. Recursion terminates because allow/deny exit
-      // cascadePendingApprovals early.
-      this.handleConfirmationResponse(
-        candidateId,
-        cascadeResult.allow ? "allow" : "deny",
-        undefined,
-        undefined,
-        undefined,
-        {
-          source: "system",
-          causedByRequestId: primaryRequestId,
-        },
-      );
-    }
-  }
-
-  /**
-   * Determine whether a pending confirmation should be auto-resolved
-   * based on the cascading decision and pattern.
-   */
-  private shouldCascade(
-    decision: UserDecision,
-    selectedPattern: string | undefined,
-    details?: import("../runtime/pending-interactions.js").ConfirmationDetails,
-  ): { allow: boolean } | null {
-    // Temporary overrides apply to the entire conversation
-    if (decision === "allow_10m" || decision === "allow_conversation") {
-      return { allow: true };
-    }
-
-    // Persistent allow: cascade if the pattern matches any allowlist candidate.
-    // "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) {
-        if (patternMatchesCandidate(selectedPattern, option.pattern)) {
-          return { allow: true };
-        }
-      }
-      return null;
-    }
-
-    // Persistent deny: cascade denial if the pattern matches
-    if (decision === "always_deny" && selectedPattern && details) {
-      for (const option of details.allowlistOptions) {
-        if (patternMatchesCandidate(selectedPattern, option.pattern)) {
-          return { allow: false };
-        }
-      }
-      return null;
-    }
-
-    return null;
   }
 
   handleSecretResponse(
@@ -1180,57 +929,6 @@ export class Conversation {
     this.secretPrompter.resolveSecret(requestId, value, delivery);
   }
 
-  resolveHostBash(
-    requestId: string,
-    response: {
-      stdout: string;
-      stderr: string;
-      exitCode: number | null;
-      timedOut: boolean;
-    },
-  ): void {
-    this.hostBashProxy?.resolve(requestId, response);
-  }
-
-  setHostBashProxy(proxy: HostBashProxy | undefined): void {
-    if (this.hostBashProxy && this.hostBashProxy !== proxy) {
-      this.hostBashProxy.dispose();
-    }
-    this.hostBashProxy = proxy;
-  }
-
-  resolveHostBrowser(
-    requestId: string,
-    response: { content: string; isError: boolean },
-  ): void {
-    this.hostBrowserProxy?.resolve(requestId, response);
-  }
-
-  setHostBrowserProxy(proxy: HostBrowserProxy | undefined): void {
-    if (this.hostBrowserProxy && this.hostBrowserProxy !== proxy) {
-      this.hostBrowserProxy.dispose();
-    }
-    this.hostBrowserProxy = proxy;
-  }
-
-  resolveHostFile(
-    requestId: string,
-    response: { content: string; isError: boolean; imageData?: string },
-  ): void {
-    this.hostFileProxy?.resolve(requestId, response);
-  }
-
-  setHostFileProxy(proxy: HostFileProxy | undefined): void {
-    if (this.hostFileProxy && this.hostFileProxy !== proxy) {
-      this.hostFileProxy.dispose();
-    }
-    this.hostFileProxy = proxy;
-  }
-
-  resolveHostCu(requestId: string, observation: CuObservationResult): void {
-    this.hostCuProxy?.resolve(requestId, observation);
-  }
-
   setHostCuProxy(proxy: HostCuProxy | undefined): void {
     if (this.hostCuProxy && this.hostCuProxy !== proxy) {
       this.hostCuProxy.dispose();
@@ -1287,14 +985,51 @@ export class Conversation {
   }
 
   async forceCompact(): Promise<ContextWindowResult> {
+    const conversationRow = getConversation(this.conversationId);
+    const overrideProfile =
+      getConversationOverrideProfileFromRow(conversationRow) ?? null;
+    const config = getConfig();
+    const effectiveContextWindow = resolveEffectiveContextWindow({
+      llm: config.llm,
+      callSite: "mainAgent",
+      overrideProfile: overrideProfile ?? undefined,
+    });
+    (
+      this.contextWindowManager as ContextWindowManager & {
+        updateConfig?: (config: ContextWindowConfig) => void;
+      }
+    ).updateConfig?.(
+      contextWindowConfigFromEffective(
+        config.llm.default.contextWindow,
+        effectiveContextWindow,
+      ),
+    );
+    const slackChronologicalContext =
+      this.channelCapabilities?.channel === "slack"
+        ? loadSlackChronologicalContext(
+            this.conversationId,
+            this.channelCapabilities,
+            {
+              trustClass: this.trustContext?.trustClass,
+              contextSummary: conversationRow?.contextSummary,
+              contextCompactedMessageCount:
+                conversationRow?.contextCompactedMessageCount,
+              slackContextCompactionWatermarkTs:
+                conversationRow?.slackContextCompactionWatermarkTs,
+            },
+          )
+        : null;
+    const messagesToCompact =
+      slackChronologicalContext?.messages ?? this.messages;
     const result = await this.contextWindowManager.maybeCompact(
-      this.messages,
+      messagesToCompact,
       this.abortController?.signal ?? undefined,
       {
         force: true,
         lastCompactedAt: this.contextCompactedAt ?? undefined,
         conversationOriginChannel:
           getConversationOriginChannel(this.conversationId) ?? undefined,
+        overrideProfile,
       },
     );
     // Track circuit-breaker state for user-initiated `/compact` and other
@@ -1310,7 +1045,12 @@ export class Conversation {
       );
     }
     if (result.compacted) {
-      applyCompactionResult(this, result, this.sendToClient, null);
+      applyCompactionResult(this, result, this.sendToClient, null, {
+        slackContextCompactionWatermarkTs: getSlackCompactionWatermarkForPrefix(
+          slackChronologicalContext,
+          result.compactedMessages,
+        ),
+      });
     }
     return result;
   }
@@ -1347,6 +1087,10 @@ export class Conversation {
     this.transportHints = hints;
   }
 
+  setSlackRuntimeContextNotice(notice: string | undefined): void {
+    this.slackRuntimeContextNotice = notice;
+  }
+
   /**
    * Apply client-reported host environment (home dir, username) from
    * transport metadata onto the conversation. Only interfaces whose
@@ -1458,15 +1202,30 @@ export class Conversation {
   async runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     options?: {
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
       callSite?: LLMCallSite;
+      /**
+       * Optional ad-hoc inference-profile override applied to every LLM call
+       * the loop issues for this turn. Forwarded into
+       * {@link runAgentLoopImpl} and threaded through to
+       * {@link AgentLoop.run} so each provider call carries
+       * `config.overrideProfile`. Subagents spawned during the turn inherit
+       * this value via {@link SubagentManager.spawn}.
+       */
+      overrideProfile?: string;
     },
   ): Promise<void> {
-    return runAgentLoopImpl(this, content, userMessageId, onEvent, options);
+    return runAgentLoopImpl(
+      this,
+      content,
+      userMessageId,
+      onEvent ?? this.sendToClient,
+      options,
+    );
   }
 
   drainQueue(reason: QueueDrainReason = "loop_complete"): Promise<void> {
@@ -1476,7 +1235,7 @@ export class Conversation {
   async processMessage(
     content: string,
     attachments: UserMessageAttachment[],
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
@@ -1489,7 +1248,7 @@ export class Conversation {
       this as ProcessConversationContext,
       content,
       attachments,
-      onEvent,
+      onEvent ?? this.sendToClient,
       requestId,
       activeSurfaceId,
       currentPage,
@@ -1508,17 +1267,6 @@ export class Conversation {
     return undoImpl(this as HistoryConversationContext);
   }
 
-  async regenerate(
-    onEvent: (msg: ServerMessage) => void,
-    requestId?: string,
-  ): Promise<void> {
-    return regenerateImpl(
-      this as HistoryConversationContext,
-      onEvent,
-      requestId,
-    );
-  }
-
   // ── Surfaces ─────────────────────────────────────────────────────
 
   handleSurfaceAction(