@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/daemon/conversation-agent-loop.ts

@@ -4,18 +4,15 @@
  * This module contains the core agent loop orchestration: pre-flight
  * setup, event handling, retry logic, history reconstruction, and
  * completion event emission.  The Conversation class delegates its
- * runAgentLoop method here via the AgentLoopConversationContext interface.
+ * runAgentLoop method here, passing itself as the loop context.
  */
 
 import { v4 as uuid } from "uuid";
 
-import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type {
   AgentEvent,
-  AgentLoop,
   AgentLoopExitReason,
   CheckpointDecision,
-  MidLoopCompaction,
 } from "../agent/loop.js";
 import { createAssistantMessage } from "../agent/message-types.js";
 import type {
@@ -24,7 +21,6 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import {
   contextWindowConfigFromEffective,
   type EffectiveContextWindow,
@@ -37,18 +33,14 @@ import {
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
-import { runEmergencyCompaction } from "../context/compactor.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
 } from "../context/post-turn-tool-result-truncation.js";
 import {
   estimatePromptTokens,
-  estimatePromptTokensWithTools,
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
-import type { ContextWindowManager } from "../context/window-manager.js";
-import type { ToolProfiler } from "../events/tool-profiling-listener.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import {
   clearSentryConversationContext,
@@ -62,66 +54,48 @@ import {
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
-  getConversationOverrideProfileFromRow,
   getLastUserTimestampBefore,
   getMessageById,
   provenanceFromTrustContext,
+  resolveOverrideProfile,
   updateConversationContextWindow,
   updateConversationSlackContextWatermark,
-  updateMessageMetadata,
 } from "../memory/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import { isReplaceableTitle } from "../memory/conversation-title-service.js";
-import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import {
   backfillMessageIdOnLogs,
   recordSyntheticAgentErrorMessageLog,
 } from "../memory/llm-request-log-store.js";
 import { enqueueMemoryRetrospectiveOnCompaction } from "../memory/memory-retrospective-enqueue.js";
-import type { PermissionPrompter } from "../permissions/prompter.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import type { UserPromptSubmitContext } from "../plugin-api/types.js";
-import { defaultCompactionTerminal } from "../plugins/defaults/compaction/terminal.js";
+import {
+  createInitialReducerState,
+  reduceContextOverflow,
+  type ReducerState,
+} from "../plugins/defaults/compaction/context-overflow-reducer.js";
+import { computeCorrectedOverflowTarget } from "../plugins/defaults/compaction/corrected-target.js";
 import { deepRepairHistory } from "../plugins/defaults/history-repair/terminal.js";
-import postCompactReinject from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
-import userPromptSubmitMemoryRetrieval, {
-  type MemoryRetrievalHookContext,
-} from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.js";
-import { DEFAULT_TIMEOUTS, runHook, runPipeline } from "../plugins/pipeline.js";
-import { getMiddlewaresFor } from "../plugins/registry.js";
-import type {
-  CompactionArgs,
-  CompactionResult,
-  OverflowReduceArgs,
-  OverflowReduceResult,
-  TurnContext as PluginTurnContext,
-} from "../plugins/types.js";
-import { PluginExecutionError, PluginTimeoutError } from "../plugins/types.js";
+import { runHook } from "../plugins/pipeline.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
-import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
+import { isUntrustedTrustClass } from "../runtime/actor-trust-resolver.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
-import { getSubagentManager } from "../subagent/index.js";
+import type { ActivationMomentParam } from "../telemetry/activation-funnel.js";
 import type { UsageActor } from "../usage/actors.js";
 import { getLogger } from "../util/logger.js";
 import { timeAgo } from "../util/time.js";
 import { truncate } from "../util/truncate.js";
 import { getWorkspaceGitService } from "../workspace/git-service.js";
 import { commitTurnChanges } from "../workspace/turn-commit.js";
-import {
-  type AssistantAttachmentDraft,
-  cleanAssistantContent,
-} from "./assistant-attachments.js";
+import { cleanAssistantContent } from "./assistant-attachments.js";
 import { resolveOverflowAction } from "./context-overflow-policy.js";
-import {
-  createInitialReducerState,
-  reduceContextOverflow,
-  type ReducerState,
-} from "./context-overflow-reducer.js";
+import type { Conversation } from "./conversation.js";
 import {
   createEventHandlerState,
   dispatchAgentEvent,
@@ -140,35 +114,19 @@ import {
   isUserCancellation,
 } from "./conversation-error.js";
 import { raceWithTimeout } from "./conversation-media-retry.js";
-import type { MessageQueue } from "./conversation-queue-manager.js";
-import type { QueueDrainReason } from "./conversation-queue-manager.js";
-import type {
-  ChannelCapabilities,
-  InboundActorContext,
-  InjectionMode,
-} from "./conversation-runtime-assembly.js";
+import type { InjectionMode } from "./conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
-  buildActiveDocuments,
-  buildActiveSurfaceContext,
-  buildSubagentStatusBlock,
-  buildUnifiedTurnContextBlock,
-  buildWorkspaceTopLevelContext,
   getSlackCompactionWatermarkForPrefix,
-  inboundActorContextFromTrust,
-  inboundActorContextFromTrustContext,
-  loadSlackActiveThreadFocusBlock,
   loadSlackChronologicalContext,
+  resolveTurnInboundActorContext,
+  resolveTurnModelProfileLabel,
   type SlackChronologicalContext,
   stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
-import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import { markSurfaceCompleted } from "./conversation-surfaces.js";
 import { recordUsage } from "./conversation-usage.js";
-import {
-  formatTurnTimestamp,
-  resolveTurnTimezoneContext,
-} from "./date-context.js";
+import { resolveTurnTimezoneContext } from "./date-context.js";
 import { getDiskPressureStatus } from "./disk-pressure-guard.js";
 import { classifyDiskPressureTurnPolicy } from "./disk-pressure-policy.js";
 import type {
@@ -177,15 +135,12 @@ import type {
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
-import type { ConfirmationStateChanged } from "./message-types/messages.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import {
+  oversizedImageReplacement,
   persistUnsendableImageDowngrades,
-  UNSENDABLE_IMAGE_NOTE,
 } from "./persist-unsendable-image.js";
-import type { TraceEmitter } from "./trace-emitter.js";
 import { resolveTrustClass, type TrustContext } from "./trust-context.js";
-import { stripHistoricalWebSearchResults } from "./web-search-history.js";
 
 const log = getLogger("conversation-agent-loop");
 
@@ -206,23 +161,42 @@ const TOOL_FRIENDLY_LABEL: Record<string, string> = {
   skill_execute: "Run Skill Tool",
 };
 
-type GitServiceInitializer = {
-  ensureInitialized(): Promise<void>;
-};
-
 function formatDiskPressureBlockedMessage(): string {
   return "Storage is critically low, so background processes are paused and remote messages are ignored until the guardian frees enough space. Remote senders should try again later.";
 }
 
+// ── Image-recovery helpers ───────────────────────────────────────────
+
+/**
+ * True when a message's content holds an image the provider may have rejected
+ * for being oversized — either a top-level image block (user upload) or one
+ * nested inside a tool_result's contentBlocks (e.g. a browser screenshot).
+ */
+function messageHasImageBlock(content: ContentBlock[]): boolean {
+  return content.some(
+    (b) =>
+      b.type === "image" ||
+      (b.type === "tool_result" &&
+        (b.contentBlocks?.some((cb) => cb.type === "image") ?? false)),
+  );
+}
+
+/**
+ * Replace an oversized image with its downscaled form or an unsendable note,
+ * leaving still-sendable images untouched. Delegates to the shared
+ * {@link oversizedImageReplacement} so the in-memory recovery and the durable
+ * persist pass apply the identical provider-cap gate.
+ */
+function recoverImageBlock(
+  block: Extract<ContentBlock, { type: "image" }>,
+): ContentBlock {
+  return oversizedImageReplacement(block) ?? block;
+}
+
 // ── Plugin pipeline helpers ──────────────────────────────────────────
-//
-// Canonical {@link PluginTurnContext} builder threaded into every
-// `runPipeline` call inside `runAgentLoopImpl`. The orchestrator composes
-// the context on demand at each call site from ambient state rather than
-// carrying a persistent `TurnContext` instance across the turn.
 
 /**
- * Synthetic fallback trust context used when the orchestrator fires a pipeline
+ * Synthetic fallback trust context used when the orchestrator fires a hook
  * before the per-turn trust snapshot has been captured (e.g. invocations that
  * bypass `processMessage` / `drainQueue`). We bias to `unknown` rather than
  * `guardian` so a missing snapshot cannot accidentally grant elevated trust
@@ -233,65 +207,23 @@ const FALLBACK_TURN_TRUST: TrustContext = {
   trustClass: "unknown",
 };
 
-/**
- * Build the {@link TurnContext} passed to {@link runPipeline}.
- *
- * Canonical source of truth for every pipeline call site inside the agent
- * loop. Every `runPipeline` invocation in `runAgentLoopImpl` (and in the
- * handlers that share its ambient state) must route through this helper
- * rather than constructing a `TurnContext` literal inline — this keeps
- * `turnIndex`, trust resolution, and the `contextWindowManager` attachment
- * consistent across pipeline slots, which in turn keeps structured logs
- * filtered by `conversationId`/`turnIndex` coherent across slots.
- *
- * Behavior:
- * - `turnIndex` is always `ctx.turnCount` — the orchestrator-owned
- *   0-based turn counter. Reading from a single source avoids the
- *   earlier inconsistency (`ctx.turnCount`, `ctx.messages.length - 1`,
- *   `ctx.messages.length`, and `0` were all used for the same turn).
- * - Trust pulls from the per-turn snapshot first, then the conversation-
- *   level context, then {@link FALLBACK_TURN_TRUST}. The cascade matches
- *   the one inside the orchestrator's inline injection assembly so
- *   middleware reads the same trust class the runtime sees.
- * - `contextWindowManager` is attached unconditionally. Pipelines that
- *   don't need it can ignore it; the default compaction plugin reads it
- *   via the typed optional field on `TurnContext`.
- */
-function buildPluginTurnContext(
-  ctx: AgentLoopConversationContext,
-  requestId: string,
-): PluginTurnContext {
-  const trust =
-    ctx.currentTurnTrustContext ?? ctx.trustContext ?? FALLBACK_TURN_TRUST;
-  return {
-    requestId,
-    conversationId: ctx.conversationId,
-    turnIndex: ctx.turnCount,
-    trust,
-    contextWindowManager: ctx.contextWindowManager,
-    callSite: ctx.currentCallSite,
-  };
-}
-
 /**
  * Trust class of the actor whose turn is in progress, for the compactor's
  * image manifest filter. Prefers the turn-start snapshot
- * ({@link AgentLoopConversationContext.currentTurnTrustContext}) over the live
+ * ({@link Conversation.currentTurnTrustContext}) over the live
  * trust context so compaction running in a later tool iteration can't pick up
  * a concurrent request's actor.
  */
 function resolveTurnActorTrustClass(
-  ctx: AgentLoopConversationContext,
+  ctx: Conversation,
 ): TrustContext["trustClass"] | undefined {
   return (ctx.currentTurnTrustContext ?? ctx.trustContext)?.trustClass;
 }
 
-// ── Context Interface ────────────────────────────────────────────────
-
 /**
  * Per-surface entry tracked on the current turn. Inline shape kept stable so
  * routes and persistence helpers can consume it via a named import instead of
- * `infer`-extracting from {@link AgentLoopConversationContext}.
+ * `infer`-extracting from {@link Conversation}.
  */
 export interface AssistantSurface {
   surfaceId: string;
@@ -308,182 +240,20 @@ export interface AssistantSurface {
   persistent?: boolean;
   /** Id of the tool call that produced this surface (the `ui_show` proxy tool). Persisted so app previews can gate on the tool result's arrival rather than whole-turn streaming state. */
   toolCallId?: string;
-}
-
-export interface AgentLoopConversationContext {
-  readonly conversationId: string;
-  messages: Message[];
-  isProcessing(): boolean;
-  setProcessing(value: boolean): void;
-  abortController: AbortController | null;
-  currentRequestId?: string;
-  /**
-   * The {@link LLMCallSite} of the in-flight turn, set at turn start from
-   * `options?.callSite ?? "mainAgent"`. Read by {@link buildPluginTurnContext}
-   * so pipeline/injector plugins can tell the main reply apart from
-   * background agent-loop work (compaction, subagents, …) on this same
-   * conversation. Per-turn mutable, mirroring {@link currentRequestId}.
-   */
-  currentCallSite?: LLMCallSite;
-
-  readonly agentLoop: AgentLoop;
-  readonly provider: Provider;
-  readonly systemPrompt: string;
-
-  readonly contextWindowManager: ContextWindowManager;
-  contextCompactedMessageCount: number;
-  contextCompactedAt: number | null;
-  /**
-   * Set by `applyCompactionResult` when compaction strips runtime injections
-   * from the preserved tail. The next agent loop turn promotes this into a
-   * `compactedThisTurn` signal so NOW.md, PKB, and the v2 static block are
-   * re-injected on the first turn following `/compact` (which runs outside
-   * the agent loop and so has no other way to surface that compaction
-   * happened just before this turn).
-   */
-  pendingPostCompactReinject: boolean;
-
-  readonly graphMemory: ConversationGraphMemory;
-
-  currentActiveSurfaceId?: string;
-  currentPage?: string;
-  readonly surfaceState: Map<
-    string,
-    {
-      surfaceType: SurfaceType;
-      data: SurfaceData;
-      title?: string;
-      actions?: Array<{
-        id: string;
-        label: string;
-        style?: string;
-        data?: Record<string, unknown>;
-      }>;
-    }
-  >;
-  pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
-  surfaceActionRequestIds: Set<string>;
-  approvedViaPromptThisTurn?: boolean;
-  currentTurnSurfaces: AssistantSurface[];
-
-  workingDir: string;
-  workspaceTopLevelContext: string | null;
-  workspaceTopLevelDirty: boolean;
-  channelCapabilities?: ChannelCapabilities;
-  /** Per-turn snapshot of trustContext, frozen at message-processing start. */
-  currentTurnTrustContext?: TrustContext;
-  /** Per-turn snapshot of channelCapabilities, frozen at message-processing start. */
-  currentTurnChannelCapabilities?: ChannelCapabilities;
-  /**
-   * Current inference-profile override for this turn. Read by
-   * `createToolExecutor` so `ToolContext.overrideProfile` carries the same
-   * profile the agent loop is sending to the provider. Refreshed between
-   * model calls so an explicitly confirmed profile session opened mid-turn
-   * is inherited by later tool executions and nested subagents.
-   */
-  currentTurnOverrideProfile?: string;
   /**
-   * Set by the `switch_inference_profile` tool when the model self-selects a
-   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
-   * agent loop so the next LLM call uses the switched profile. Reset at
-   * turn start.
+   * Commit-timing activation-rail tag (daemon-only). Persisted into the
+   * server-side `ui_surface` history block — NOT the client `ui_surface_show`
+   * message — so `restoreSurfaceStateFromHistory` can rehydrate the tag and a
+   * post-reload commit still records its funnel milestone. Show-timing moments
+   * record at render and are never stored here.
    */
-  toolRoutedProfile?: string;
-  commandIntent?: { type: string; payload?: string; languageCode?: string };
-  trustContext?: TrustContext;
-  /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
-  taskRunId?: string;
-  assistantId?: string;
-  voiceCallControlPrompt?: string;
-  transportHints?: string[];
-  clientTimezone?: string;
-
-  readonly coreToolNames: Set<string>;
-  allowedToolNames?: Set<string>;
-  diskPressureCleanupModeActive?: boolean;
-  toolsDisabledDepth: number;
-  preactivatedSkillIds?: string[];
-  readonly skillProjectionState: Map<string, string>;
-  readonly skillProjectionCache: SkillProjectionCache;
-
-  readonly traceEmitter: TraceEmitter;
-  readonly profiler: ToolProfiler;
-  usageStats: UsageStats;
-  turnCount: number;
-
-  lastAssistantAttachments: AssistantAttachmentDraft[];
-  lastAttachmentWarnings: string[];
-
-  hasNoClient: boolean;
-  /** True when this conversation is itself a subagent (suppresses subagent status injection). */
-  isSubagent?: boolean;
-  headlessLock?: boolean;
-  readonly streamThinking: boolean;
-  readonly prompter: PermissionPrompter;
-  readonly queue: MessageQueue;
-
-  emitActivityState(
-    phase:
-      | "idle"
-      | "thinking"
-      | "streaming"
-      | "tool_running"
-      | "awaiting_confirmation",
-    reason:
-      | "message_dequeued"
-      | "thinking_delta"
-      | "first_text_delta"
-      | "tool_use_start"
-      | "preview_start"
-      | "tool_result_received"
-      | "confirmation_requested"
-      | "confirmation_resolved"
-      | "context_compacting"
-      | "message_complete"
-      | "generation_cancelled"
-      | "error_terminal",
-    options?: {
-      anchor?: "assistant_turn" | "user_turn" | "global";
-      requestId?: string;
-      statusText?: string;
-    },
-  ): void;
-  emitConfirmationStateChanged(
-    params: ConfirmationStateChanged extends {
-      type: infer _;
-    }
-      ? Omit<ConfirmationStateChanged, "type">
-      : never,
-  ): void;
-
-  /**
-   * Optional callback invoked by the Conversation when a confirmation state changes.
-   * The agent loop registers this to track requestId → toolUseId mappings
-   * and record confirmation outcomes for persistence.
-   */
-  onConfirmationOutcome?: (
-    requestId: string,
-    state: string,
-    toolUseId?: string,
-  ) => void;
-
-  getWorkspaceGitService?: (workspaceDir: string) => GitServiceInitializer;
-  commitTurnChanges?: typeof commitTurnChanges;
-
-  refreshWorkspaceTopLevelContextIfNeeded(): void;
-  markWorkspaceTopLevelDirty(): void;
-  getQueueDepth(): number;
-  hasQueuedMessages(): boolean;
-  canHandoffAtCheckpoint(): boolean;
-  drainQueue(reason: QueueDrainReason): Promise<void>;
-  getTurnChannelContext(): TurnChannelContext | null;
-  getTurnInterfaceContext(): TurnInterfaceContext | null;
+  activationMoment?: ActivationMomentParam;
 }
 
 // ── runAgentLoop ─────────────────────────────────────────────────────
 
 export async function runAgentLoopImpl(
-  ctx: AgentLoopConversationContext,
+  ctx: Conversation,
   content: string,
   userMessageId: string,
   onEvent: (msg: ServerMessage) => void,
@@ -556,26 +326,22 @@ export async function runAgentLoopImpl(
   // `resolveCallSiteConfig`, picking up any user overrides under
   // `llm.callSites.mainAgent` (falling back to `llm.default` when absent).
   const turnCallSite: LLMCallSite = options?.callSite ?? "mainAgent";
-  // Expose the turn's call site to plugin pipeline/injector contexts (read by
-  // buildPluginTurnContext) so plugins can scope behaviour to the main reply.
+  // Expose the turn's call site on the live conversation so the runtime
+  // injection assembly self-resolves it for the turn's plugin contexts.
   ctx.currentCallSite = turnCallSite;
 
-  // Read the conversation row once for both the override-profile derivation
-  // below and the title-replaceability check at turn start. Later reads in
-  // this function (post-turn truncation, disk sync, home-feed emission)
-  // intentionally re-read because state can change during the turn.
-  const turnStartConversation = getConversation(ctx.conversationId);
-
   // Optional per-turn inference-profile override. Plumbed through to every
   // LLM call the loop emits and inherited by any subagents spawned during
   // this turn. Caller-supplied `options.overrideProfile` (e.g.
   // SubagentManager forwarding the parent's pinned profile into the
-  // spawned subagent's background conversation) wins over the row read
-  // so the agent loop's own background-skip rule doesn't zero out an
-  // explicitly inherited override.
+  // spawned subagent's background conversation) wins over the conversation's
+  // own override so the agent loop's background-skip rule doesn't zero out an
+  // explicitly inherited override. The override state is mirrored onto the
+  // live conversation (hydrated on load, kept current by the HTTP setters and
+  // the expiry reaper), so the derivation reads `ctx` rather than re-fetching
+  // the row.
   const userExplicitOverride =
-    options?.overrideProfile ??
-    getConversationOverrideProfileFromRow(turnStartConversation);
+    options?.overrideProfile ?? resolveOverrideProfile(ctx);
 
   const config = getConfig();
 
@@ -588,9 +354,7 @@ export async function runAgentLoopImpl(
 
   const readCurrentOverrideProfile = (): string | undefined =>
     options?.overrideProfile ??
-    getConversationOverrideProfileFromRow(
-      getConversation(ctx.conversationId),
-    ) ??
+    resolveOverrideProfile(ctx) ??
     ctx.toolRoutedProfile;
 
   const effectiveContextWindow = resolveEffectiveContextWindow({
@@ -608,11 +372,7 @@ export async function runAgentLoopImpl(
     }).contextWindow,
     currentEffectiveContextWindow,
   );
-  const contextWindowManager =
-    ctx.contextWindowManager as ContextWindowManager & {
-      updateConfig?: (config: ContextWindowConfig) => void;
-    };
-  contextWindowManager.updateConfig?.(currentContextWindowConfig);
+  ctx.contextWindowManager.updateConfig(currentContextWindowConfig);
 
   let appliedOverrideProfile = turnOverrideProfile;
   let emittedToolRoutedProfile: string | undefined;
@@ -632,7 +392,7 @@ export async function runAgentLoopImpl(
         }).contextWindow,
         currentEffectiveContextWindow,
       );
-      contextWindowManager.updateConfig?.(currentContextWindowConfig);
+      ctx.contextWindowManager.updateConfig(currentContextWindowConfig);
       appliedOverrideProfile = currentOverrideProfile;
       rlog.info(
         { overrideProfile: currentOverrideProfile ?? null },
@@ -751,11 +511,17 @@ export async function runAgentLoopImpl(
 
   const isInteractiveResolved =
     options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
+  // Whether the in-flight turn has no human present to answer clarification
+  // questions. Derived from the loop's `isInteractive` option (which can fall
+  // back to mutable client/headless state that flips mid-turn), so it is
+  // resolved once here and threaded into every re-injection — including the
+  // post-compaction hook — rather than re-read per assembly call.
+  const isNonInteractive = !isInteractiveResolved;
   const diskPressureDecision = classifyDiskPressureTurnPolicy(
     getDiskPressureStatus(),
     {
-      conversationType: turnStartConversation?.conversationType ?? null,
-      conversationSource: turnStartConversation?.source ?? null,
+      conversationType: ctx.conversationType ?? null,
+      conversationSource: ctx.source ?? null,
       callSite: turnCallSite,
       isInteractive: isInteractiveResolved,
       sourceChannel:
@@ -772,10 +538,6 @@ export async function runAgentLoopImpl(
         : null,
     },
   );
-  const diskPressureContext =
-    diskPressureDecision.action === "allow-cleanup-mode"
-      ? { cleanupModeActive: true }
-      : null;
   ctx.diskPressureCleanupModeActive =
     diskPressureDecision.action === "allow-cleanup-mode";
 
@@ -879,22 +641,7 @@ export async function runAgentLoopImpl(
     }
 
     const isFirstMessage = ctx.messages.length === 1;
-    // Promote a pending post-compaction re-inject signal (e.g. from `/compact`)
-    // into `compactedThisTurn` so NOW.md / PKB / v2 static blocks land on this
-    // turn even when no mid-turn compaction fires. Clear the flag immediately
-    // so this fires exactly once per `/compact` event.
-    const consumedPostCompactReinject = ctx.pendingPostCompactReinject;
-    ctx.pendingPostCompactReinject = false;
-    state.shouldInjectWorkspace = isFirstMessage || consumedPostCompactReinject;
-    let compactedThisTurn = consumedPostCompactReinject;
-    let slackCompactedThisTurn = false;
     const isSlackConversation = ctx.channelCapabilities?.channel === "slack";
-    let currentSlackContextSummary =
-      turnStartConversation?.contextSummary ?? null;
-    let currentSlackContextCompactedMessageCount =
-      turnStartConversation?.contextCompactedMessageCount ?? 0;
-    let currentSlackContextCompactionWatermarkTs =
-      turnStartConversation?.slackContextCompactionWatermarkTs ?? null;
     const loadCurrentSlackChronologicalContext =
       (): SlackChronologicalContext | null => {
         if (!isSlackConversation) return null;
@@ -903,18 +650,15 @@ export async function runAgentLoopImpl(
           ctx.channelCapabilities!,
           {
             trustClass: ctx.trustContext?.trustClass,
-            contextSummary: currentSlackContextSummary,
-            contextCompactedMessageCount:
-              currentSlackContextCompactedMessageCount,
+            contextSummary: ctx.contextSummary,
+            contextCompactedMessageCount: ctx.contextCompactedMessageCount,
             slackContextCompactionWatermarkTs:
-              currentSlackContextCompactionWatermarkTs,
+              ctx.slackContextCompactionWatermarkTs,
           },
         );
       };
     let slackChronologicalContext: SlackChronologicalContext | null =
       loadCurrentSlackChronologicalContext();
-    const messagesForStartOfTurnCompaction =
-      slackChronologicalContext?.messages ?? ctx.messages;
     const getSlackProvenanceContextForCompactionBasis = (
       messages: Message[],
       compactedMessages: number,
@@ -1001,15 +745,6 @@ export async function runAgentLoopImpl(
       await applyCompactionResult(ctx, result, onEvent, reqId, {
         slackContextCompactionWatermarkTs: slackWatermarkTs,
       });
-      currentSlackContextSummary = result.summaryText;
-      currentSlackContextCompactedMessageCount =
-        ctx.contextCompactedMessageCount;
-      if (slackWatermarkTs) {
-        currentSlackContextCompactionWatermarkTs = slackWatermarkTs;
-      }
-      if (isSlackConversation) {
-        slackCompactedThisTurn = true;
-      }
       slackChronologicalContext = projectSlackProvenanceAfterCompaction(
         provenanceContext,
         compactedBasis,
@@ -1017,88 +752,6 @@ export async function runAgentLoopImpl(
       );
     };
 
-    const compactCheck = ctx.contextWindowManager.shouldCompact(
-      messagesForStartOfTurnCompaction,
-    );
-    // Skip auto-compaction while the circuit breaker is open. Force paths
-    // and user-initiated /compact bypass this check.
-    const autoCompactAllowed =
-      !(await ctx.agentLoop.compactionCircuit.isOpen(ctx));
-    if (compactCheck.needed && autoCompactAllowed) {
-      ctx.emitActivityState("thinking", "context_compacting", {
-        requestId: reqId,
-      });
-    }
-    const compactionOptions = {
-      precomputedEstimate: compactCheck.estimatedTokens,
-      overrideProfile: resolveCurrentOverrideProfile() ?? null,
-      actorTrustClass: resolveTurnActorTrustClass(ctx),
-    };
-    let compacted: Awaited<
-      ReturnType<typeof ctx.contextWindowManager.maybeCompact>
-    > | null = null;
-    if (autoCompactAllowed) {
-      try {
-        compacted = (await runPipeline<CompactionArgs, CompactionResult>(
-          "compaction",
-          getMiddlewaresFor("compaction"),
-          (args) =>
-            defaultCompactionTerminal(args, buildPluginTurnContext(ctx, reqId)),
-          {
-            messages: messagesForStartOfTurnCompaction,
-            signal: abortController.signal,
-            options: compactionOptions,
-          },
-          buildPluginTurnContext(ctx, reqId),
-          DEFAULT_TIMEOUTS.compaction,
-        )) as Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>;
-      } catch (err) {
-        if (err instanceof PluginTimeoutError) {
-          // Pipeline exceeded its budget. Record the failure so the circuit
-          // breaker tracks consecutive timeouts (it trips after three),
-          // then degrade gracefully by skipping compaction this turn —
-          // the turn proceeds with the un-compacted history rather than
-          // hard-failing. The inner summary call has been aborted by the
-          // runner's signal-linking, so updateSummary's local fallback
-          // also ran before this catch block is reached.
-          rlog.warn(
-            { err, phase: "start-of-turn-compaction" },
-            "Compaction pipeline timed out — skipping compaction this turn",
-          );
-          await ctx.agentLoop.compactionCircuit.recordOutcome(
-            ctx,
-            true,
-            onEvent,
-          );
-          compacted = null;
-        } else {
-          throw err;
-        }
-      }
-    }
-    // Only track circuit-breaker state when a summary LLM call actually ran.
-    // `summaryFailed` is `undefined` on early returns (compaction disabled,
-    // below threshold, no eligible messages, truncation-only
-    // path) — treating those as "successful" compactions would silently reset
-    // the 3-strike counter and break the invariant.
-    if (compacted && compacted.summaryFailed !== undefined) {
-      await ctx.agentLoop.compactionCircuit.recordOutcome(
-        ctx,
-        compacted.summaryFailed,
-        onEvent,
-      );
-    }
-    if (compacted?.compacted) {
-      await applySuccessfulCompaction(
-        compacted,
-        messagesForStartOfTurnCompaction,
-      );
-      state.shouldInjectWorkspace = true;
-      if (compacted.compactedPersistedMessages > 0) {
-        compactedThisTurn = true;
-      }
-    }
-
     // Register confirmation outcome tracker so the agent loop can link
     // confirmation decisions to tool_use_ids for persistence.
     ctx.onConfirmationOutcome = (requestId, confirmationState, toolUseId) => {
@@ -1143,39 +796,16 @@ export async function runAgentLoopImpl(
       hostTimeZone,
     });
 
-    // Resolve the inbound actor context for the unified <turn_context> block.
-    // When the conversation carries enough identity info, use the unified
-    // actor trust resolver so member status/policy and guardian binding details
-    // are fresh for this turn. The conversation runtime context remains the source
-    // for policy gating; this block is model-facing grounding metadata.
-    let resolvedInboundActorContext: InboundActorContext | null = null;
-    if (ctx.trustContext) {
-      const gc = ctx.trustContext;
-      if (gc.requesterExternalUserId && gc.requesterChatId) {
-        const actorTrust = resolveActorTrust({
-          assistantId: ctx.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
-          sourceChannel: gc.sourceChannel,
-          conversationExternalId: gc.requesterChatId,
-          actorExternalId: gc.requesterExternalUserId,
-          actorDisplayName: gc.requesterSenderDisplayName,
-        });
-        resolvedInboundActorContext = inboundActorContextFromTrust(actorTrust);
-      } else {
-        resolvedInboundActorContext = inboundActorContextFromTrustContext(gc);
-      }
-    }
-
-    // Resolve the channel/interface labels and the guardian flag for this
-    // turn. These derive only from the captured turn context and the resolved
-    // actor trust class — never from retrieval — so they settle before context
-    // assembly.
-    const interfaceName =
-      capturedTurnInterfaceContext.userMessageInterface ?? undefined;
-    const channelName =
-      capturedTurnChannelContext?.userMessageChannel ?? undefined;
-    const isGuardian =
-      resolvedInboundActorContext?.trustClass === "guardian" ||
-      !resolvedInboundActorContext;
+    // Unified `<turn_context>` actor input for this turn (model-facing grounding
+    // metadata; the conversation runtime context remains the source for policy
+    // gating). Resolved once at turn start and threaded per call site (like
+    // `modelProfile`) so post-compaction re-injection receives it as an explicit
+    // hook input rather than re-deriving it from live state that can flip
+    // mid-turn.
+    const actorContext = resolveTurnInboundActorContext(
+      ctx.trustContext,
+      ctx.assistantId,
+    );
 
     // Surface long gaps between user messages so the model can acknowledge
     // the absence naturally. Gated at >12h to avoid noisy injection during
@@ -1196,6 +826,19 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // Freeze the turn-start client timezone and long-absence gap on the
+    // conversation so `applyRuntimeInjections` sources them from live state —
+    // like the channel/voice/transport hints. Frozen here (rather than read
+    // live in assembly) because the live `ctx.clientTimezone` is overwritten
+    // when a newer message for the same conversation arrives mid-turn, which
+    // would otherwise leak a queued message's timezone into the in-flight turn.
+    // The `current_time` value is computed fresh at each injection point, so
+    // it is not part of this snapshot.
+    ctx.currentTurnTemporalSnapshot = {
+      clientTimezone: timezoneContext.clientTimezone,
+      timeSinceLastMessage,
+    };
+
     // Resolve the effective profile key for this turn and detect changes.
     // Only inject model_profile into the turn context when the profile
     // changed since the last turn (or on the first turn of a conversation)
@@ -1204,519 +847,73 @@ export async function runAgentLoopImpl(
       turnOverrideProfile ??
       config.llm.activeProfile ??
       resolveDefaultProfileKey("mainAgent", config.llm);
-    const lastNotified = turnStartConversation?.lastNotifiedInferenceProfile;
-    let modelProfileStr: string | null = null;
-    if (effectiveProfileKey != null && effectiveProfileKey !== lastNotified) {
-      const profileEntry = config.llm.profiles?.[effectiveProfileKey];
-      const resolved = resolveCallSiteConfig(turnCallSite, config.llm, {
-        overrideProfile: turnOverrideProfile ?? undefined,
-      });
-      const label = profileEntry?.label ?? effectiveProfileKey;
-      modelProfileStr = resolved.model ? `${label} (${resolved.model})` : label;
+    const lastNotified = ctx.lastNotifiedInferenceProfile;
+    const modelProfileKey =
+      effectiveProfileKey != null && effectiveProfileKey !== lastNotified
+        ? effectiveProfileKey
+        : null;
+    // The key is threaded to the memory hook as plain turn data; the rendered
+    // `Label (model)` line for the mid-loop re-injection sites is resolved from
+    // it here so both paths share one derivation.
+    const modelProfileStr = resolveTurnModelProfileLabel(
+      modelProfileKey,
+      turnCallSite,
+      config.llm,
+    );
+    if (modelProfileKey != null) {
       // Record the notification for persistence on delivery rather than here:
       // the model only "learns" the profile once it receives this turn
       // context, signalled by the first `message_complete`. Persisting inline
       // would mark the profile notified even if the turn is cancelled or fails
       // before the model ever sees the notice.
-      state.pendingNotifiedInferenceProfile = effectiveProfileKey;
+      state.pendingNotifiedInferenceProfile = modelProfileKey;
     }
 
-    // Memory retrieval — fetches PKB, NOW.md, and memory-graph outputs and
-    // persists the retrieval's own side effects (injected-block metadata,
-    // recall log, `memory_recalled` event). Runs at the early "prompt
-    // submitted, before context assembly" moment because its outputs feed the
-    // injection and overflow-reduction transforms below. It is shaped as the
-    // `user-prompt-submit-temp` hook handler but invoked directly for now: it
-    // must run early, while the canonical late `user-prompt-submit` hook
-    // (history repair, title) runs after those transforms, so the two cannot
-    // share a fire site until compaction is cleared from the gap between them.
+    // Trust class and injection mode, resolved once at turn start for the
+    // post-compaction re-injection sites further down, which re-apply the
+    // runtime injections (gated on trust) onto the compacted history.
     const isTrustedActor = resolveTrustClass(ctx.trustContext) === "guardian";
-    const memoryCtx: MemoryRetrievalHookContext = {
-      graphMemory: ctx.graphMemory,
-      config: getConfig(),
-      onEvent,
-      isTrustedActor,
-      conversationId: ctx.conversationId,
-      userMessageId,
-      logger: rlog,
-      // An external cancel aborts `prepareMemory` instead of letting it run
-      // to completion after the turn has already been torn down.
-      signal: abortController.signal,
-      latestMessages: ctx.messages,
-    };
-    await userPromptSubmitMemoryRetrieval(memoryCtx);
-
-    // The retriever owns its side effects (injected-block metadata, recall
-    // log, `memory_recalled` event) and records the dense/sparse PKB query
-    // pair on the graph handle for the PKB-reminder injector to read back; the
-    // loop only reuses the injected message list downstream.
-    let runMessages = memoryCtx.latestMessages;
-
-    // Capture wall-clock "now" at its point of use, after the blocking memory
-    // retrieval, so the injected `<turn_context>` timestamp reflects current
-    // time rather than the moment the turn began.
-    const timestamp = formatTurnTimestamp({
-      timeZone: timezoneContext.effectiveTimezone,
-    });
-
-    // Build unified turn context block that replaces the separate temporal,
-    // channel, interface, and actor context blocks.
-    const baseTurnContext = {
-      timestamp,
-      interfaceName,
-      channelName,
-      configuredUserTimezone: timezoneContext.configuredUserTimezone,
-      clientTimezone: timezoneContext.clientTimezone,
-      detectedTimezone: timezoneContext.detectedTimezone,
-      timeSinceLastMessage,
-      modelProfile: modelProfileStr,
-    };
-    const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
-      isGuardian
-        ? baseTurnContext
-        : {
-            ...baseTurnContext,
-            actorContext: resolvedInboundActorContext,
-          },
-    );
-
-    // The `remember` tool handles scratchpad-style memory writes directly to the graph.
-
-    // Subagent status injection — gives the parent LLM visibility into active/completed children.
-    // Skipped when this conversation IS a subagent (no nesting) or has no children.
-    const subagentStatusBlock = ctx.isSubagent
-      ? null
-      : buildSubagentStatusBlock(
-          getSubagentManager().getChildrenOf(ctx.conversationId),
-        );
-
-    // For any Slack conversation (channels and DMs alike), build a
-    // chronological transcript from the persisted message rows so the
-    // model sees one channel-wide view instead of the gateway's per-turn
-    // hints. DMs render as a flat sequence (no thread tags), channels
-    // include sibling threads.
-    const slackConversationForInjection = isSlackConversation
-      ? (getConversation(ctx.conversationId) ?? turnStartConversation)
-      : turnStartConversation;
-    if (isSlackConversation && !slackCompactedThisTurn) {
-      slackChronologicalContext ??= loadSlackChronologicalContext(
-        ctx.conversationId,
-        ctx.channelCapabilities!,
-        {
-          trustClass: ctx.trustContext?.trustClass,
-          contextSummary: slackConversationForInjection?.contextSummary,
-          contextCompactedMessageCount:
-            slackConversationForInjection?.contextCompactedMessageCount,
-          slackContextCompactionWatermarkTs:
-            slackConversationForInjection?.slackContextCompactionWatermarkTs,
-        },
-      );
-    }
-    const slackChronologicalMessages =
-      slackChronologicalContext?.messages ?? null;
-
-    // Active-thread focus block: when the inbound user message belongs to
-    // a Slack thread, append a non-persisted `<active_thread>` tail block
-    // to the final user turn listing the thread's parent + replies. Helps
-    // the model orient when the channel transcript is long and
-    // interleaved. Replays strip the block via RUNTIME_INJECTION_PREFIXES.
-    // DMs short-circuit to null inside `loadSlackActiveThreadFocusBlock`
-    // since DMs do not have threads.
-    const slackActiveThreadFocusBlock = isSlackConversation
-      ? loadSlackActiveThreadFocusBlock(
-          ctx.conversationId,
-          ctx.channelCapabilities!,
-          {
-            trustClass: ctx.trustContext?.trustClass,
-            contextCompactedMessageCount:
-              slackConversationForInjection?.contextCompactedMessageCount,
-            slackContextCompactionWatermarkTs:
-              slackConversationForInjection?.slackContextCompactionWatermarkTs,
-          },
-        )
-      : null;
-
-    state.reducerCompacted = compactedThisTurn;
-
-    // memory-v3-live: when on, the provider anchors its long-TTL cache
-    // breakpoint on the most recent STABLE user message, since the latest user
-    // message now carries the volatile per-turn `<memory>` block the v3
-    // injector emits. The matching v2-suppression strip is owned by
-    // `applyRuntimeInjections`, which reads the same flag itself. Flag off →
-    // bit-for-bit identical to today's v2 path.
-    const memoryV3Live = isAssistantFeatureFlagEnabled(
-      "memory-v3-live",
-      getConfig(),
-    );
-
-    // Shared injection options — reused whenever we need to re-inject after reduction.
-    const injectionOpts = {
-      diskPressureContext,
-      // Resolved from the conversation's surface state here, where the
-      // runtime injector is the only consumer of the active-surface block.
-      activeSurface: buildActiveSurfaceContext({
-        currentActiveSurfaceId: ctx.currentActiveSurfaceId,
-        currentPage: ctx.currentPage,
-        surfaceState: ctx.surfaceState,
-      }),
-      // Resolved here, where the runtime injector is the only consumer of the
-      // active-documents block.
-      activeDocuments: buildActiveDocuments(ctx.conversationId),
-      workspaceTopLevelContext: buildWorkspaceTopLevelContext(
-        ctx,
-        state.shouldInjectWorkspace,
-      ),
-      channelCapabilities: ctx.channelCapabilities ?? null,
-      channelCommandContext: ctx.commandIntent ?? null,
-      unifiedTurnContext: unifiedTurnContextStr,
-      voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
-      transportHints: ctx.transportHints ?? null,
-      isNonInteractive: !isInteractiveResolved,
-      isBackgroundConversation: isBackgroundConversationType(
-        turnStartConversation?.conversationType,
-      ),
-      subagentStatusBlock,
-      slackChronologicalMessages,
-      slackActiveThreadFocusBlock,
-    } as const;
-
     let currentInjectionMode: InjectionMode = "full";
 
-    // Canonical per-turn TurnContext forwarded to the injector chain. The
-    // per-turn injection inputs are built inside `applyRuntimeInjections`
-    // from the `injectionOpts` bag; we only need to hand in identity +
-    // trust here so third-party injectors see the real turn metadata.
-    const injectionTurnCtx = buildPluginTurnContext(ctx, reqId);
-
-    const injection = await applyRuntimeInjections(runMessages, {
-      ...injectionOpts,
-      slackChronologicalMessages: state.reducerCompacted
-        ? null
-        : injectionOpts.slackChronologicalMessages,
-      mode: currentInjectionMode,
-      turnContext: injectionTurnCtx,
-    });
-    runMessages = injection.messages;
-
-    // Persist injected blocks in message metadata so they survive conversation
-    // reloads (eviction, restart, fork). loadFromDb re-injects from metadata.
-    // Only the first call site persists — the overflow-recovery re-entry sites
-    // send identical bytes and the tail row may not correspond to
-    // `userMessageId`. All blocks are written in a single call to avoid
-    // doubling SQLite SELECT+UPDATE work on every turn.
-    if (
-      injection.blocks.unifiedTurnContext ||
-      injection.blocks.pkbSystemReminder ||
-      injection.blocks.workspaceBlock ||
-      injection.blocks.nowScratchpadBlock ||
-      injection.blocks.pkbContextBlock ||
-      injection.blocks.memoryV2StaticBlock
-    ) {
-      try {
-        const metadataUpdates: Record<string, unknown> = {};
-        if (injection.blocks.unifiedTurnContext) {
-          metadataUpdates.turnContextBlock =
-            injection.blocks.unifiedTurnContext;
-        }
-        if (injection.blocks.pkbSystemReminder) {
-          metadataUpdates.pkbSystemReminderBlock =
-            injection.blocks.pkbSystemReminder;
-        }
-        if (injection.blocks.workspaceBlock) {
-          metadataUpdates.workspaceBlock = injection.blocks.workspaceBlock;
-        }
-        if (injection.blocks.nowScratchpadBlock) {
-          metadataUpdates.nowScratchpadBlock =
-            injection.blocks.nowScratchpadBlock;
-        }
-        if (injection.blocks.pkbContextBlock) {
-          metadataUpdates.pkbContextBlock = injection.blocks.pkbContextBlock;
-        }
-        if (injection.blocks.memoryV2StaticBlock) {
-          metadataUpdates.memoryV2StaticBlock =
-            injection.blocks.memoryV2StaticBlock;
-        }
-        updateMessageMetadata(userMessageId, metadataUpdates);
-      } catch (err) {
-        rlog.warn({ err }, "Failed to persist injection metadata (non-fatal)");
-      }
-    }
-
-    // ── Preflight budget evaluation ──────────────────────────────
-    // After runtime injections are applied, estimate the prompt token count
-    // and proactively invoke the reducer if already above budget. This avoids
-    // a wasted provider round-trip that would just fail with context_too_large.
-    const initialContextBudget = resolveCurrentContextBudget();
-    const overflowRecovery = initialContextBudget.overflowRecovery;
-    const preflightBudget = initialContextBudget.preflightBudget;
-    let reducerState: ReducerState | undefined;
-
-    const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
-    // Canonical calibration key — used by the preflight estimate, the
-    // overflow reducer config, and the convergence-path `estimatePromptTokens`
-    // call. Matches the key recorded by `handleUsage` for wrapper providers
-    // (OpenRouter routing to Anthropic → key is `"anthropic"`).
-    const estimationProviderName = getCalibrationProviderKey(ctx.provider);
-
-    const preflightTokens = estimatePromptTokensWithTools(
-      runMessages,
-      ctx.systemPrompt,
-      ctx.agentLoop.getResolvedTools(runMessages),
-      estimationProviderName,
-    );
-
-    if (overflowRecovery.enabled && preflightTokens > preflightBudget) {
-      rlog.warn(
-        {
-          phase: "preflight",
-          estimatedTokens: preflightTokens,
-          budget: preflightBudget,
-        },
-        "Preflight budget exceeded — running overflow reducer before provider call",
-      );
-
-      // Overflow reduction runs through the plugin pipeline. The default
-      // middleware (`default-overflow-reduce`, registered at bootstrap)
-      // contains the historical tier loop — forced compaction → tool-result
-      // truncation → media stubbing → injection downgrade — plus the
-      // re-inject/re-estimate convergence check. The callbacks below are
-      // the orchestrator-specific side effects that the plugin coordinates
-      // per iteration (activity emission, compaction application, runtime
-      // injection reassembly, token re-estimation). Registered plugins that
-      // wrap the `overflowReduce` slot see each iteration through their own
-      // middleware `next` callback.
-      const messagesForPreflightOverflowReduction =
-        slackChronologicalContext?.messages ?? ctx.messages;
-      const overflowArgs: OverflowReduceArgs = {
-        messages: messagesForPreflightOverflowReduction,
-        runMessages,
-        systemPrompt: ctx.systemPrompt,
-        providerName: estimationProviderName,
-        contextWindow: resolveCurrentContextWindowConfig(),
-        preflightBudget,
-        toolTokenBudget,
-        maxAttempts: resolveCurrentContextBudget().overflowRecovery.maxAttempts,
-        abortSignal: abortController.signal,
-        compactFn: async (msgs, signal, opts) => {
-          // Route the reducer's forced-compaction tier through the
-          // `compaction` pipeline so registered plugins observe these
-          // invocations. Without this, custom compaction middleware only
-          // sees the three orchestrator-owned call sites and misses the
-          // reducer-initiated forced compactions entirely.
-          //
-          // Pipeline timeouts must be caught locally — a `PluginTimeoutError`
-          // bubbling out of here would abort the overflow-reducer tier loop
-          // entirely, skipping fallback tiers (tool-result truncation, media
-          // stubbing, injection downgrade) and bypassing circuit-breaker
-          // bookkeeping. On timeout, record the failure and return a
-          // `compacted: false` result so the reducer falls through to the
-          // next tier.
-          try {
-            return (await runPipeline<CompactionArgs, CompactionResult>(
-              "compaction",
-              getMiddlewaresFor("compaction"),
-              (args) =>
-                defaultCompactionTerminal(
-                  args,
-                  buildPluginTurnContext(ctx, reqId),
-                ),
-              {
-                messages: msgs,
-                signal,
-                options: {
-                  ...(opts ?? {}),
-                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
-                  actorTrustClass: resolveTurnActorTrustClass(ctx),
-                },
-              },
-              buildPluginTurnContext(ctx, reqId),
-              DEFAULT_TIMEOUTS.compaction,
-            )) as Awaited<
-              ReturnType<typeof ctx.contextWindowManager.maybeCompact>
-            >;
-          } catch (err) {
-            if (err instanceof PluginTimeoutError) {
-              rlog.warn(
-                { err, phase: "overflow-reducer-forced-compaction" },
-                "Compaction pipeline timed out — falling through to next reducer tier",
-              );
-              await ctx.agentLoop.compactionCircuit.recordOutcome(
-                ctx,
-                true,
-                onEvent,
-              );
-              return {
-                messages: msgs,
-                compacted: false,
-                previousEstimatedInputTokens: 0,
-                estimatedInputTokens: 0,
-                maxInputTokens: 0,
-                thresholdTokens: 0,
-                compactedMessages: 0,
-                compactedPersistedMessages: 0,
-                summaryCalls: 0,
-                summaryInputTokens: 0,
-                summaryOutputTokens: 0,
-                summaryModel: "",
-                summaryText: "",
-                reason: "compaction pipeline timed out",
-              };
-            }
-            throw err;
-          }
-        },
-        emitActivityState: () => {
-          ctx.emitActivityState("thinking", "context_compacting", {
-            requestId: reqId,
-          });
-        },
-        onCompactionResult: async (result, compactedBasis) => {
-          // Track circuit-breaker state whenever the reducer invoked
-          // compaction. The reducer's forced_compaction tier uses
-          // force:true, so it bypasses the open-circuit check, but we
-          // still want failure tracking to detect a run of broken
-          // summaries and clear the counter on success. Only track when
-          // the summary LLM actually ran — `summaryFailed === undefined`
-          // indicates an early return (no eligible messages,
-          // truncation-only path, etc.) that shouldn't influence the
-          // breaker.
-          if (result.summaryFailed !== undefined) {
-            await ctx.agentLoop.compactionCircuit.recordOutcome(
-              ctx,
-              result.summaryFailed,
-              onEvent,
-            );
-          }
-          if (result.compacted) {
-            await applySuccessfulCompaction(result, compactedBasis);
-            state.shouldInjectWorkspace = true;
-          }
-        },
-        reinjectForMode: async (
-          reducedMessages,
-          mode,
-          stepCompacted,
-          accumulatedCompacted,
-        ) => {
-          // Mirror the pre-PR-23 behavior: `ctx.messages` must track the
-          // reducer's latest output before re-injection runs, because other
-          // sites consulted through `injectionOpts` (`workspaceTopLevelContext`,
-          // slack history, etc.) depend on it and `applyCompactionResult`
-          // only updates `ctx.messages` on a compaction tier. Assigning here
-          // keeps non-compaction tiers (tool-result truncation, media
-          // stubbing, injection downgrade) observable to downstream
-          // injection assembly on the same turn.
-          ctx.messages = reducedMessages;
-
-          // When THIS iteration compacted, it stripped the existing
-          // memory-static block — so we re-inject current content. A later
-          // iteration that only truncates or downgrades must NOT re-force it,
-          // or each round would grow the token count.
-          // Gate: only the iteration that actually compacted re-injects.
-          // (The `<knowledge_base>`, NOW.md, and v2 static `<info>` blocks
-          // self-gate inside their injectors on whether they are already
-          // present in `reducedMessages`.)
-          const injection = await applyRuntimeInjections(reducedMessages, {
-            ...injectionOpts,
-            workspaceTopLevelContext: buildWorkspaceTopLevelContext(
-              ctx,
-              state.shouldInjectWorkspace,
-            ),
-            // Once ANY iteration has compacted `ctx.messages`, the captured
-            // `slackChronologicalMessages` snapshot (built from the full
-            // persisted transcript) would overwrite the compacted history
-            // and undo compaction. Suppress the override from here on —
-            // sticky across subsequent non-compacting iterations.
-            slackChronologicalMessages: accumulatedCompacted
-              ? null
-              : injectionOpts.slackChronologicalMessages,
-            mode,
-            turnContext: buildPluginTurnContext(ctx, reqId),
-          });
-          let next = injection.messages;
-          if (isTrustedActor && mode !== "minimal") {
-            const memResult = ctx.graphMemory.reinjectCachedMemory(next);
-            next = memResult.runMessages;
-          }
-          return next;
-        },
-        estimatePostInjection: (runMsgs) =>
-          estimatePromptTokens(runMsgs, ctx.systemPrompt, {
-            providerName: estimationProviderName,
-            toolTokenBudget,
-          }),
-      };
-
-      const overflowResult = await runPipeline<
-        OverflowReduceArgs,
-        OverflowReduceResult
-      >(
-        "overflowReduce",
-        getMiddlewaresFor("overflowReduce"),
-        // Terminal — only reached when every registered middleware calls
-        // `next` and delegates past the innermost layer. The default plugin
-        // is a terminal itself (it doesn't call `next`), so in practice
-        // this fallback fires only when the default has been explicitly
-        // deregistered (tests) and no user plugin replaces it. Strict-fail
-        // semantics: throw so the missing terminal surfaces as a visible
-        // error instead of silently returning the history untouched.
-        async () => {
-          throw new PluginExecutionError(
-            "overflowReduce pipeline has no terminal handler — every reducer middleware called next() without providing a replacement",
-            "overflowReduce",
-          );
-        },
-        overflowArgs,
-        buildPluginTurnContext(ctx, reqId),
-        DEFAULT_TIMEOUTS.overflowReduce,
-      );
-
-      ctx.messages = overflowResult.messages;
-      runMessages = overflowResult.runMessages;
-      currentInjectionMode = overflowResult.injectionMode;
-      reducerState = overflowResult.reducerState;
-      if (overflowResult.reducerCompacted) {
-        state.reducerCompacted = true;
-      }
-    }
-
-    // Replace historical web_search_tool_result blocks with text summaries.
-    // The opaque `encrypted_content` tokens Anthropic attaches to each result
-    // expire / are route-scoped; replaying a stale token is rejected with
-    // `Invalid encrypted_content in search_result block`. Titles + URLs
-    // preserve enough context for the model on follow-up turns.
-    const webSearchStrip = stripHistoricalWebSearchResults(runMessages);
-    if (webSearchStrip.stats.blocksStripped > 0) {
-      rlog.info(
-        { phase: "pre_run", ...webSearchStrip.stats },
-        "Converted historical web_search_tool_result blocks to text summaries",
-      );
-      runMessages = webSearchStrip.messages;
-    }
-
-    // user-prompt-submit hook: plugins may transform `runMessages` right
-    // before the agent loop receives them. Fires once per user turn at the
-    // primary `agentLoop.run` only — the re-entry / retry calls further down
-    // in this function do not refire it (they're not new user submissions).
-    // Plugins may mutate `ctx.latestMessages` in place OR return a new
-    // context with a fresh array; `runHook` forwards whichever the chain
-    // settles on. Order is plugin registration order.
-    //
-    // Fires BEFORE the agent loop runs so the hook-emitted messages are part
-    // of the loop's input; the loop then reports its own appended output via
-    // `AgentLoopRunResult.newMessages`, which is what persistence consumes.
+    // user-prompt-submit hook chain. Fires once per user turn at the primary
+    // `agentLoop.run` (the re-entry / retry calls further down do not refire it
+    // — they're not new user submissions), before the loop runs so the
+    // hook-assembled messages are part of its input. Memory retrieval runs
+    // first — fetching PKB / NOW.md / memory-graph outputs, persisting its own
+    // side effects (injected-block metadata, recall log, `memory_recalled`
+    // event), and assembling the turn's runtime-injection blocks onto the
+    // history — followed by history repair and title generation, which see the
+    // fully injected history. Plugins may mutate `ctx.latestMessages` in place
+    // OR return a new context with a fresh array; `runHook` forwards whichever
+    // the chain settles on, in plugin registration order. The loop then reports
+    // its own appended output via `AgentLoopRunResult.newMessages`, which
+    // persistence consumes.
     const userPromptCtx: UserPromptSubmitContext = {
       conversationId: ctx.conversationId,
+      userMessageId,
+      requestId: reqId,
       prompt: options?.titleText ?? content,
       originalMessages: ctx.messages,
-      latestMessages: runMessages,
+      latestMessages: ctx.messages,
       logger: rlog,
+      modelProfileKey,
+      isNonInteractive,
     };
     const finalUserPromptCtx = await runHook(
       HOOKS.USER_PROMPT_SUBMIT,
       userPromptCtx,
     );
-    runMessages = finalUserPromptCtx.latestMessages;
+    let runMessages = finalUserPromptCtx.latestMessages;
+
+    // Reducer state, tool-token budget, and calibration provider key consumed
+    // by the post-rejection convergence loop further down. The tool-token
+    // budget is resolved once per turn (the resolved tool set is stable across
+    // the turn); the calibration key matches the key recorded by `handleUsage`
+    // for wrapper providers (OpenRouter routing to Anthropic → key is
+    // `"anthropic"`).
+    let reducerState: ReducerState | undefined;
+    const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
+    const estimationProviderName = getCalibrationProviderKey(ctx.provider);
 
     const shouldGenerateTitle = isReplaceableTitle(
       getConversation(ctx.conversationId)?.title ?? null,
@@ -1750,75 +947,45 @@ export async function runAgentLoopImpl(
 
     rlog.info({ callSite: turnCallSite }, "Starting agent loop run");
 
-    // Thread the orchestrator's canonical per-turn context into the agent
-    // loop so its internal pipeline invocations (e.g. compaction) see the
-    // real conversation identity / trust / contextWindowManager instead of
-    // the synthesized `"agent-loop"` placeholder. The loop clones this value
-    // and overwrites `turnIndex` with its own tool-use iteration counter.
-    const loopTurnCtx = buildPluginTurnContext(ctx, reqId);
-
-    // Hook for the loop-owned mid-loop compaction. The agent loop owns the
-    // trigger (its budget gate), the `compaction` pipeline call, the result
-    // interpretation (circuit-breaker bookkeeping + the exhaustion decision),
-    // and the inline continue; this callback bridges the injection state the
-    // loop is intentionally blind to. Durable persistence is signalled via
-    // events; re-injection stays orchestrator-supplied for now.
-    const midLoopCompaction: MidLoopCompaction = {
-      postCompactionHook: async ({ history, turnContext }) => {
-        // stripInjectionsForCompaction() unconditionally removed the existing
-        // memory-static block, so re-inject the current content regardless of
-        // whether compaction actually ran. The `<knowledge_base>`, NOW.md, and
-        // v2 static `<info>` blocks self-gate inside their injectors on block
-        // presence.
-        const injection = await postCompactReinject({
-          ...injectionOpts,
-          workspaceTopLevelContext: buildWorkspaceTopLevelContext(
-            ctx,
-            state.shouldInjectWorkspace,
-          ),
-          // Suppress the chronological-transcript snapshot once the reducer
-          // has collapsed `ctx.messages`; the captured snapshot reflects the
-          // full persisted transcript and would overwrite compaction.
-          slackChronologicalMessages: state.reducerCompacted
-            ? null
-            : injectionOpts.slackChronologicalMessages,
-          mode: currentInjectionMode,
-          turnContext,
-          history,
-          isTrustedActor,
-          logger: rlog,
-        });
-        return injection.messages;
-      },
-    };
+    // Trust snapshot the loop forwards to its mid-loop in-place compaction
+    // (scoping the compactor's image manifest) and the post-compaction
+    // re-injection. Prefers the per-turn snapshot, then the conversation-level
+    // context, then the fallback — matching the trust the runtime injection
+    // assembly resolves for the same turn. The loop's other turn-identity
+    // fields self-resolve from its own conversation id.
+    const loopTrust =
+      ctx.currentTurnTrustContext ?? ctx.trustContext ?? FALLBACK_TURN_TRUST;
 
     /**
      * Shared closure: runs the agent loop with the orchestrator's turn
      * context and maps the loop's returned checkpoint pause-reason into the
      * orchestrator's yield bookkeeping. Returns the updated history so call
-     * sites consume it exactly as before. Pass `compaction` only for the
-     * primary run, where the loop compacts in place when its budget gate
-     * trips; reruns omit it and keep yielding for budget.
+     * sites consume it exactly as before. Pass `compactInPlace` only for the
+     * primary run: the loop then runs its budget gate before the first call
+     * (subsuming the proactive turn-start compaction) and compacts in place
+     * whenever the gate trips. Reruns omit it, skip the first-call gate, and
+     * keep yielding for budget.
      */
     const runAgentLoop = async (
       msgs: Message[],
-      compaction?: MidLoopCompaction,
+      compactInPlace = false,
     ): Promise<Message[]> => {
       const { history, exitReason, appendedNewMessages, newMessages } =
-        await ctx.agentLoop.run(msgs, eventHandler, {
+        await ctx.agentLoop.run({
+          messages: msgs,
+          onEvent: eventHandler,
           signal: abortController.signal,
           requestId: reqId,
           onCheckpoint,
           callSite: turnCallSite,
-          turnContext: loopTurnCtx,
+          trust: loopTrust,
           overrideProfile: turnOverrideProfile,
           resolveOverrideProfile: resolveCurrentOverrideProfile,
           resolveContextWindow,
-          compaction,
-          // memory-v3-live: the latest user message carries the volatile v3
-          // `<memory>` block, so anchor the provider's long-TTL cache breakpoint
-          // on the most recent stable message instead.
-          mutableLatestUserMessage: memoryV3Live,
+          compactInPlace,
+          isNonInteractive,
+          modelProfile: modelProfileStr,
+          actorContext,
         });
       lastRunAppendedNewMessages = appendedNewMessages;
       lastRunNewMessages = newMessages;
@@ -1832,7 +999,7 @@ export async function runAgentLoopImpl(
       return history;
     };
 
-    let updatedHistory = await runAgentLoop(runMessages, midLoopCompaction);
+    let updatedHistory = await runAgentLoop(runMessages, true);
 
     rlog.info(
       { resultMessageCount: updatedHistory.length },
@@ -1875,8 +1042,6 @@ export async function runAgentLoopImpl(
       // intentionally deferred until there's a concrete plugin-level use case.
       const retryRepair = deepRepairHistory(updatedHistory);
       runMessages = retryRepair.messages;
-      const retryStrip = stripHistoricalWebSearchResults(runMessages);
-      runMessages = retryStrip.messages;
       state.orderingErrorDetected = false;
       state.deferredOrderingError = null;
 
@@ -1892,44 +1057,41 @@ export async function runAgentLoopImpl(
 
     // ── Image-dimension overflow recovery ──────────────────────────
     // When the provider rejects because an image block exceeds its pixel
-    // cap, strip every image block from ctx.messages and retry once.
-    // optimizeImageForTransport already ran at upload time; if sips was
-    // unavailable (non-macOS) it returns the same bytes unchanged.  In
-    // that case we swap the block for a text note so the model can tell
-    // the user what happened instead of hard-failing with a red banner.
+    // or payload cap, recover every oversized image in ctx.messages and
+    // retry once. recoverImageBlock downscales an oversized image, or swaps
+    // it for a text note when resize is a no-op (e.g. sips unavailable
+    // off macOS), while leaving still-sendable images untouched. This covers
+    // both top-level image blocks (user uploads) and images nested inside a
+    // tool_result's contentBlocks (e.g. a browser screenshot), which is where
+    // the rejected block usually lives.
     if (state.imageTooLargeDetected) {
       state.imageTooLargeDetected = false;
       rlog.warn(
         { phase: "image-recovery" },
-        "Image too large — stripping oversized image blocks and retrying",
+        "Image too large — recovering oversized image blocks and retrying",
       );
       ctx.messages = ctx.messages.map((msg) => {
         if (!Array.isArray(msg.content)) return msg;
-        if (!msg.content.some((b) => b.type === "image")) return msg;
+        if (!messageHasImageBlock(msg.content)) return msg;
         return {
           ...msg,
           content: msg.content.flatMap((b): ContentBlock[] => {
-            if (b.type !== "image") return [b];
-            const resized = optimizeImageForTransport(
-              b.source.data,
-              b.source.media_type,
-            );
-            if (resized.data !== b.source.data) {
-              // sips managed to downscale — use the smaller version
+            if (b.type === "image") return [recoverImageBlock(b)];
+            // Images returned by a tool (e.g. browser_screenshot) live in
+            // the tool_result's contentBlocks, not as top-level blocks.
+            // Recover them in place so the tool_use/tool_result pairing
+            // stays intact rather than dropping the whole tool_result.
+            if (b.type === "tool_result" && b.contentBlocks?.length) {
               return [
                 {
                   ...b,
-                  source: {
-                    type: "base64" as const,
-                    media_type: resized.mediaType,
-                    data: resized.data,
-                  },
+                  contentBlocks: b.contentBlocks.map((cb) =>
+                    cb.type === "image" ? recoverImageBlock(cb) : cb,
+                  ),
                 },
               ];
             }
-            // Can't resize — replace with a text annotation so the model
-            // can explain the situation rather than silently dropping context
-            return [{ type: "text" as const, text: UNSENDABLE_IMAGE_NOTE }];
+            return [b];
           }),
         };
       });
@@ -2007,101 +1169,76 @@ export async function runAgentLoopImpl(
         },
       );
       const convergenceBudget = resolveCurrentContextBudget();
-      let correctedTarget = convergenceBudget.preflightBudget;
-      if (actualTokens && estimatedTokensAtOverflow > 0) {
-        const estimationErrorRatio = actualTokens / estimatedTokensAtOverflow;
-        if (estimationErrorRatio > 1.0) {
-          correctedTarget = Math.floor(
-            convergenceBudget.preflightBudget / estimationErrorRatio,
-          );
-          rlog.warn(
-            {
-              phase: "convergence",
-              actualTokens,
-              estimatedTokens: estimatedTokensAtOverflow,
-              estimationErrorRatio: estimationErrorRatio.toFixed(2),
-              preflightBudget: convergenceBudget.preflightBudget,
-              correctedTarget,
-            },
-            "Adjusting compaction target based on observed estimation error",
-          );
-        }
+      const { targetTokens: correctedTarget, estimationErrorRatio } =
+        computeCorrectedOverflowTarget({
+          preflightBudget: convergenceBudget.preflightBudget,
+          actualTokens,
+          estimatedTokens: estimatedTokensAtOverflow,
+        });
+      if (estimationErrorRatio != null) {
+        rlog.warn(
+          {
+            phase: "convergence",
+            actualTokens,
+            estimatedTokens: estimatedTokensAtOverflow,
+            estimationErrorRatio: estimationErrorRatio.toFixed(2),
+            preflightBudget: convergenceBudget.preflightBudget,
+            correctedTarget,
+          },
+          "Adjusting compaction target based on observed estimation error",
+        );
       }
 
-      // ── Emergency mid-turn compaction ────────────────────────────
-      // Before entering the reducer tier loop, attempt a targeted
-      // emergency compaction: summarize everything before the last
-      // tool_use + tool_result pair and let the agent continue with
-      // [summary, last_tool_call, last_tool_result]. This preserves
-      // the agent's most recent action context while aggressively
-      // compressing history. Falls through to reducer tiers on failure.
-      {
-        try {
-          const emergencyConfig = getConfig().compaction;
-          const emergencyResult = await runEmergencyCompaction({
-            conversationId: ctx.conversationId,
-            messages: ctx.messages,
-            provider: ctx.provider,
-            systemPrompt: ctx.systemPrompt,
-            tools: undefined,
-            compaction: emergencyConfig,
-            maxInputTokens: resolveCurrentMaxInputTokens(),
-            previousEstimatedInputTokens: estimatedTokensAtOverflow,
-            force: true,
-            signal: abortController.signal,
-            overrideProfile: resolveCurrentOverrideProfile() ?? null,
-            nonPersistedPrefixCount:
-              ctx.contextWindowManager.nonPersistedPrefixCount,
-          });
-          if (emergencyResult.compacted) {
-            rlog.info(
-              {
-                phase: "convergence",
-                compactedMessages: emergencyResult.compactedMessages,
-                summaryChars: emergencyResult.summaryText.length,
-              },
-              "Emergency mid-turn compaction succeeded — bypassing reducer tiers",
-            );
-            if (emergencyResult.summaryFailed !== undefined) {
-              await ctx.agentLoop.compactionCircuit.recordOutcome(
-                ctx,
-                emergencyResult.summaryFailed,
-                onEvent,
-              );
-            }
-            if (emergencyResult.compacted) {
-              await applySuccessfulCompaction(emergencyResult, ctx.messages);
-              state.shouldInjectWorkspace = true;
-            }
-            // Clear the overflow flag and re-run the agent loop with
-            // the compacted context.
-            state.contextTooLargeDetected = false;
-          }
-        } catch (err) {
-          rlog.warn(
-            { phase: "convergence", err },
-            "Emergency mid-turn compaction failed; continuing to reducer tiers",
-          );
-        }
-        // If emergency compaction failed, fall through to reducer tiers.
-      }
+      // ── Bounded context-overflow convergence driver ─────────────────
+      // The compaction plugin's reduction ladder owns every rung: the
+      // emergency summarize-around-last-tool-pair, the middle tiers (forced
+      // compaction, tool-result truncation, media stubbing, injection
+      // downgrade), and the terminal auto-compress of the latest turn. This
+      // driver applies one rung per iteration, re-injects, and re-runs the
+      // agent loop until the context fits or the ladder is exhausted. The
+      // overflow policy decides whether the terminal auto-compress rung is
+      // permitted; the ladder never makes that policy call itself.
+      const overflowAction = resolveOverflowAction({
+        overflowRecovery: convergenceBudget.overflowRecovery,
+        isInteractive: isInteractiveResolved,
+      });
+      const reducerConfig = {
+        providerName: estimationProviderName,
+        systemPrompt: ctx.systemPrompt,
+        contextWindow: resolveCurrentContextWindowConfig(),
+        targetTokens: correctedTarget,
+        toolTokenBudget,
+        conversationId: ctx.conversationId,
+        overrideProfile: resolveCurrentOverrideProfile() ?? null,
+        actorTrustClass: resolveTurnActorTrustClass(ctx),
+        previousEstimatedInputTokens: estimatedTokensAtOverflow,
+        maxMiddleTierAttempts: convergenceBudget.overflowRecovery.maxAttempts,
+        allowAutoCompressLatestTurn:
+          overflowAction === "auto_compress_latest_turn",
+      };
 
-      let convergenceAttempts = 0;
-      const maxAttempts = convergenceBudget.overflowRecovery.maxAttempts;
+      // Safety backstop against a reduction ladder that never reports
+      // exhaustion: the ladder can apply at most the emergency rung, the
+      // middle-tier attempt budget, and the terminal auto-compress rung, so a
+      // well-behaved reducer always sets `exhausted` within this many steps.
+      // The cap only guards against a misbehaving reducer; it never truncates a
+      // legitimate escalation.
+      const maxConvergenceRungs = reducerConfig.maxMiddleTierAttempts + 2;
+      let convergenceRungs = 0;
 
       while (
         state.contextTooLargeDetected &&
-        convergenceAttempts < maxAttempts &&
-        !reducerState.exhausted
+        !reducerState.exhausted &&
+        convergenceRungs < maxConvergenceRungs
       ) {
-        convergenceAttempts++;
+        convergenceRungs++;
         rlog.warn(
           {
             phase: "convergence",
-            attempt: convergenceAttempts,
+            rung: convergenceRungs,
             appliedTiers: reducerState.appliedTiers,
           },
-          "Context too large — applying next reducer tier",
+          "Context too large — applying next reduction rung",
         );
 
         ctx.emitActivityState("thinking", "context_compacting", {
@@ -2110,20 +1247,8 @@ export async function runAgentLoopImpl(
         const convergenceCompactionBasis = ctx.messages;
         const step = await reduceContextOverflow(
           convergenceCompactionBasis,
-          {
-            providerName: estimationProviderName,
-            systemPrompt: ctx.systemPrompt,
-            contextWindow: resolveCurrentContextWindowConfig(),
-            targetTokens: correctedTarget,
-            toolTokenBudget,
-          },
+          reducerConfig,
           reducerState,
-          (msgs, signal, opts) =>
-            ctx.contextWindowManager.maybeCompact(msgs, signal!, {
-              ...(opts ?? {}),
-              overrideProfile: resolveCurrentOverrideProfile() ?? null,
-              actorTrustClass: resolveTurnActorTrustClass(ctx),
-            }),
           abortController.signal,
         );
 
@@ -2131,16 +1256,14 @@ export async function runAgentLoopImpl(
         ctx.messages = step.messages;
         currentInjectionMode = step.state.injectionMode;
 
-        // See the preflight reducer call above for rationale. Only track when
-        // the summary LLM actually ran — `summaryFailed === undefined`
-        // indicates the reducer's forced compaction took an early-return path
-        // without calling the summary LLM.
+        // Only track when the summary LLM actually ran — `summaryFailed
+        // === undefined` indicates a forced-compaction early-return path that
+        // never called the summary LLM.
         if (
           step.compactionResult &&
           step.compactionResult.summaryFailed !== undefined
         ) {
           await ctx.agentLoop.compactionCircuit.recordOutcome(
-            ctx,
             step.compactionResult.summaryFailed,
             onEvent,
           );
@@ -2151,8 +1274,6 @@ export async function runAgentLoopImpl(
             step.compactionResult,
             convergenceCompactionBasis,
           );
-          state.shouldInjectWorkspace = true;
-          state.reducerCompacted = true;
         }
 
         // Only re-inject the memory-static block when ctx.messages was
@@ -2161,174 +1282,55 @@ export async function runAgentLoopImpl(
         // blocks self-gate inside their injectors on whether they are already
         // present in `ctx.messages`.)
         const injection = await applyRuntimeInjections(ctx.messages, {
-          ...injectionOpts,
-          workspaceTopLevelContext: buildWorkspaceTopLevelContext(
-            ctx,
-            state.shouldInjectWorkspace,
-          ),
-          slackChronologicalMessages: state.reducerCompacted
-            ? null
-            : injectionOpts.slackChronologicalMessages,
+          isNonInteractive,
+          modelProfile: modelProfileStr,
+          actorContext,
           mode: currentInjectionMode,
-          turnContext: buildPluginTurnContext(ctx, reqId),
+          requestId: reqId,
+          conversationId: ctx.conversationId,
         });
         runMessages = injection.messages;
         if (isTrustedActor && currentInjectionMode !== "minimal") {
           ctx.graphMemory.retrackCachedNodes();
         }
-        const convergenceStrip = stripHistoricalWebSearchResults(runMessages);
-        if (convergenceStrip.stats.blocksStripped > 0) {
-          rlog.info(
-            { phase: "convergence", ...convergenceStrip.stats },
-            "Converted historical web_search_tool_result blocks to text summaries",
-          );
-          runMessages = convergenceStrip.messages;
-        }
         state.contextTooLargeDetected = false;
         yieldedForBudget = false;
 
         updatedHistory = await runAgentLoop(runMessages);
 
-        // If the rerun still yields at checkpoint, the turn is still
-        // incomplete — continue reducing through the remaining tiers
-        // instead of silently dropping the incomplete state.
         if (yieldedForBudget && !abortController.signal.aborted) {
-          rlog.warn(
-            {
-              phase: "convergence",
-              attempt: convergenceAttempts,
-              appliedTiers: reducerState.appliedTiers,
-            },
-            "Post-convergence rerun still yielded at checkpoint — continuing reduction",
-          );
-          state.contextTooLargeDetected = true;
-
-          // Fold rerun progress into ctx.messages so the next reducer
-          // tier operates on up-to-date history instead of stale
-          // pre-rerun messages.
-          if (lastRunAppendedNewMessages) {
-            ctx.messages = stripInjectionsForCompaction(updatedHistory);
-            markHistoryStrippedBestEffort(ctx.conversationId);
-          }
-        }
-      }
-
-      // All reducer tiers exhausted but provider still rejects —
-      // consult the overflow policy for latest-turn compression.
-      // The policy either auto-compresses the latest turn or falls
-      // through to the final graceful-error fallback below.
-      if (state.contextTooLargeDetected) {
-        const action = resolveOverflowAction({
-          overflowRecovery,
-          isInteractive: isInteractiveResolved,
-        });
-
-        if (action === "auto_compress_latest_turn") {
-          // Auto-compress without asking — users opt out via the "drop" policy.
-          ctx.emitActivityState("thinking", "context_compacting", {
-            requestId: reqId,
-          });
-          let emergencyCompact: Awaited<
-            ReturnType<typeof ctx.contextWindowManager.maybeCompact>
-          > | null = null;
-          try {
-            emergencyCompact = (await runPipeline<
-              CompactionArgs,
-              CompactionResult
-            >(
-              "compaction",
-              getMiddlewaresFor("compaction"),
-              (args) =>
-                defaultCompactionTerminal(
-                  args,
-                  buildPluginTurnContext(ctx, reqId),
-                ),
+          if (!reducerState.exhausted) {
+            // The rerun still yields and the ladder has a rung left — the turn
+            // is incomplete, so continue reducing instead of silently dropping
+            // the incomplete state.
+            rlog.warn(
               {
-                messages: ctx.messages,
-                signal: abortController.signal,
-                options: {
-                  force: true,
-                  minKeepRecentUserTurns: 0,
-                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
-                },
+                phase: "convergence",
+                appliedTiers: reducerState.appliedTiers,
               },
-              buildPluginTurnContext(ctx, reqId),
-              DEFAULT_TIMEOUTS.compaction,
-            )) as Awaited<
-              ReturnType<typeof ctx.contextWindowManager.maybeCompact>
-            >;
-          } catch (err) {
-            if (err instanceof PluginTimeoutError) {
-              // Emergency compaction timed out. Record the circuit-breaker
-              // failure and fall through to the graceful-error path below
-              // (the unsuccessful-compaction fallback) rather than hard-
-              // failing the turn.
-              rlog.warn(
-                { err, phase: "emergency-compaction" },
-                "Emergency compaction pipeline timed out — continuing with overflow fallback",
-              );
-              await ctx.agentLoop.compactionCircuit.recordOutcome(
-                ctx,
-                true,
-                onEvent,
-              );
-              emergencyCompact = null;
-            } else {
-              throw err;
-            }
-          }
-          // Only track when the summary LLM actually ran; `force: true`
-          // bypasses the auto-threshold gate but not the early-return paths.
-          if (
-            emergencyCompact &&
-            emergencyCompact.summaryFailed !== undefined
-          ) {
-            await ctx.agentLoop.compactionCircuit.recordOutcome(
-              ctx,
-              emergencyCompact.summaryFailed,
-              onEvent,
+              "Post-convergence rerun still yielded at checkpoint — continuing reduction",
             );
-          }
-          if (emergencyCompact?.compacted) {
-            await applySuccessfulCompaction(emergencyCompact, ctx.messages);
-            state.reducerCompacted = true;
-            state.shouldInjectWorkspace = true;
-          }
+            state.contextTooLargeDetected = true;
 
-          // Only re-inject the memory-static block when ctx.messages was
-          // actually stripped; otherwise the existing block is still present.
-          // (The `<knowledge_base>`, NOW.md, and v2 static `<info>` blocks
-          // self-gate inside their injectors on whether they are already
-          // present in `ctx.messages`.)
-          const injection = await applyRuntimeInjections(ctx.messages, {
-            ...injectionOpts,
-            workspaceTopLevelContext: buildWorkspaceTopLevelContext(
-              ctx,
-              state.shouldInjectWorkspace,
-            ),
-            slackChronologicalMessages: state.reducerCompacted
-              ? null
-              : injectionOpts.slackChronologicalMessages,
-            mode: currentInjectionMode,
-            turnContext: buildPluginTurnContext(ctx, reqId),
-          });
-          runMessages = injection.messages;
-          if (isTrustedActor && currentInjectionMode !== "minimal") {
-            ctx.graphMemory.retrackCachedNodes();
-          }
-          const fallbackStrip = stripHistoricalWebSearchResults(runMessages);
-          if (fallbackStrip.stats.blocksStripped > 0) {
-            rlog.info(
-              { phase: "fail_gracefully_compact", ...fallbackStrip.stats },
-              "Converted historical web_search_tool_result blocks to text summaries",
-            );
-            runMessages = fallbackStrip.messages;
+            // Fold rerun progress into ctx.messages so the next rung operates
+            // on up-to-date history instead of stale pre-rerun messages.
+            if (lastRunAppendedNewMessages) {
+              ctx.messages = stripInjectionsForCompaction(updatedHistory);
+              markHistoryStrippedBestEffort(ctx.conversationId);
+            }
+          } else if (
+            !reducerState.appliedTiers.includes("auto_compress_latest_turn")
+          ) {
+            // The ladder is exhausted without the terminal auto-compress rung
+            // (the overflow policy disallowed it, or the middle tiers ran out)
+            // and the turn is still over budget. This is a genuine
+            // unrecoverable overflow — surface `context_too_large` via the
+            // fallback below. The terminal auto-compress rung instead leaves
+            // this false so its post-rerun yield reads as
+            // `budget_yield_unrecovered`.
+            state.contextTooLargeDetected = true;
           }
-          state.contextTooLargeDetected = false;
-
-          updatedHistory = await runAgentLoop(runMessages);
         }
-        // action === "fail_gracefully" falls through to the final error below
       }
 
       // Final fallback: all recovery paths exhausted
@@ -2906,10 +1908,7 @@ export async function runAgentLoopImpl(
 // ── Helper ───────────────────────────────────────────────────────────
 
 function emitUsage(
-  ctx: Pick<
-    AgentLoopConversationContext,
-    "conversationId" | "provider" | "usageStats"
-  >,
+  ctx: Pick<Conversation, "conversationId" | "provider" | "usageStats">,
   inputTokens: number,
   outputTokens: number,
   model: string,
@@ -2949,17 +1948,18 @@ function emitUsage(
 }
 
 /**
- * Minimal context shape consumed by `applyCompactionResult`. Both
- * `AgentLoopConversationContext` and `Conversation` satisfy this via structural
- * typing, so the helper can back both the 5 agent-loop auto-compaction sites
- * and the single `forceCompact` user-initiated site.
+ * Minimal context shape consumed by `applyCompactionResult`, satisfied by
+ * `Conversation` via structural typing, so the helper can back both the 5
+ * agent-loop auto-compaction sites and the single `forceCompact`
+ * user-initiated site.
  */
 export interface CompactionApplyContext {
   readonly conversationId: string;
   messages: Message[];
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
-  pendingPostCompactReinject: boolean;
+  contextSummary: string | null;
+  slackContextCompactionWatermarkTs: string | null;
   readonly graphMemory: ConversationGraphMemory;
   readonly provider: Provider;
   usageStats: UsageStats;
@@ -3006,13 +2006,22 @@ export async function applyCompactionResult(
   } = {},
 ): Promise<void> {
   ctx.messages = result.messages;
-  ctx.contextCompactedMessageCount += result.compactedPersistedMessages;
+  // Compaction operates on the in-context history. Untrusted actor views
+  // render that history unsliced (boundary 0); trusted views start past the
+  // already-compacted prefix (the mirrored DB count). Advance from that
+  // in-context boundary rather than the raw mirror so the persisted count
+  // stays consistent with what the new summary represents and never
+  // double-counts an unsliced untrusted view.
+  const inContextCompactedCount = isUntrustedTrustClass(
+    ctx.trustContext?.trustClass,
+  )
+    ? 0
+    : ctx.contextCompactedMessageCount;
+  ctx.contextCompactedMessageCount =
+    inContextCompactedCount + result.compactedPersistedMessages;
+  ctx.contextSummary = result.summaryText;
   const compactedAt = Date.now();
   ctx.contextCompactedAt = compactedAt;
-  // Signal to the next agent loop turn that NOW.md / PKB / v2 static blocks
-  // were stripped from the tail and need fresh re-injection. Consumed and
-  // cleared at the top of the next `runAgentLoopImpl` run.
-  ctx.pendingPostCompactReinject = true;
   await ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
   updateConversationContextWindow(
     ctx.conversationId,
@@ -3026,6 +2035,8 @@ export async function applyCompactionResult(
       options.slackContextCompactionWatermarkTs,
       compactedAt,
     );
+    ctx.slackContextCompactionWatermarkTs =
+      options.slackContextCompactionWatermarkTs;
   }
   enqueueAutoAnalysisOnCompaction(
     ctx.conversationId,