@vellumai/assistant 0.8.8 → 0.8.9-staging.1

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

@@ -4,7 +4,7 @@
  * 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";
@@ -12,10 +12,8 @@ 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 +22,6 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import {
   contextWindowConfigFromEffective,
   type EffectiveContextWindow,
@@ -44,11 +41,9 @@ import {
 } 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 type { ContextWindowCompactOptions } from "../context/window-manager.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import {
   clearSentryConversationContext,
@@ -62,66 +57,53 @@ 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 { defaultCompact } from "../plugins/defaults/compaction/compact.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,
+  resolveActorTrust,
+} 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 { 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 +122,22 @@ 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 {
   applyRuntimeInjections,
-  buildActiveDocuments,
-  buildActiveSurfaceContext,
-  buildSubagentStatusBlock,
-  buildUnifiedTurnContextBlock,
-  buildWorkspaceTopLevelContext,
   getSlackCompactionWatermarkForPrefix,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
-  loadSlackActiveThreadFocusBlock,
   loadSlackChronologicalContext,
   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,13 +146,11 @@ 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 {
   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";
 
@@ -206,23 +173,14 @@ 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.";
 }
 
 // ── 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 +191,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;
@@ -310,180 +226,10 @@ export interface AssistantSurface {
   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.
-   */
-  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;
-}
-
 // ── runAgentLoop ─────────────────────────────────────────────────────
 
 export async function runAgentLoopImpl(
-  ctx: AgentLoopConversationContext,
+  ctx: Conversation,
   content: string,
   userMessageId: string,
   onEvent: (msg: ServerMessage) => void,
@@ -556,26 +302,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 +330,7 @@ export async function runAgentLoopImpl(
 
   const readCurrentOverrideProfile = (): string | undefined =>
     options?.overrideProfile ??
-    getConversationOverrideProfileFromRow(
-      getConversation(ctx.conversationId),
-    ) ??
+    resolveOverrideProfile(ctx) ??
     ctx.toolRoutedProfile;
 
   const effectiveContextWindow = resolveEffectiveContextWindow({
@@ -608,11 +348,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 +368,7 @@ export async function runAgentLoopImpl(
         }).contextWindow,
         currentEffectiveContextWindow,
       );
-      contextWindowManager.updateConfig?.(currentContextWindowConfig);
+      ctx.contextWindowManager.updateConfig(currentContextWindowConfig);
       appliedOverrideProfile = currentOverrideProfile;
       rlog.info(
         { overrideProfile: currentOverrideProfile ?? null },
@@ -751,11 +487,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 +514,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 +617,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 +626,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 +721,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 +728,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) => {
@@ -1165,18 +794,20 @@ export async function runAgentLoopImpl(
       }
     }
 
-    // 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;
+    // Resolve the guardian flag for this turn. It derives only from the
+    // resolved actor trust class — never from retrieval — so it settles before
+    // context assembly.
     const isGuardian =
       resolvedInboundActorContext?.trustClass === "guardian" ||
       !resolvedInboundActorContext;
 
+    // Unified `<turn_context>` actor input, included only for non-guardian
+    // turns. 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 = isGuardian ? null : resolvedInboundActorContext;
+
     // Surface long gaps between user messages so the model can acknowledge
     // the absence naturally. Gated at >12h to avoid noisy injection during
     // normal back-and-forth turns.
@@ -1196,6 +827,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,7 +848,7 @@ export async function runAgentLoopImpl(
       turnOverrideProfile ??
       config.llm.activeProfile ??
       resolveDefaultProfileKey("mainAgent", config.llm);
-    const lastNotified = turnStartConversation?.lastNotifiedInferenceProfile;
+    const lastNotified = ctx.lastNotifiedInferenceProfile;
     let modelProfileStr: string | null = null;
     if (effectiveProfileKey != null && effectiveProfileKey !== lastNotified) {
       const profileEntry = config.llm.profiles?.[effectiveProfileKey];
@@ -1221,16 +865,21 @@ export async function runAgentLoopImpl(
       state.pendingNotifiedInferenceProfile = effectiveProfileKey;
     }
 
-    // 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.
+    // Memory retrieval + runtime injection — fetches PKB / NOW.md / memory-graph
+    // outputs, persists the retrieval's own side effects (injected-block
+    // metadata, recall log, `memory_recalled` event), and assembles the turn's
+    // runtime-injection blocks onto the history (persisting those blocks too).
+    // Runs at the early "prompt submitted, before context assembly" moment so
+    // its injected output is what the agent loop receives. It is shaped as the
+    // `user-prompt-submit-temp` hook handler but invoked directly for now,
+    // separate from the canonical late `user-prompt-submit` hook (history
+    // repair, title) that fires just before the loop.
+    // The injection inputs (`mode`, `isNonInteractive`, `modelProfile`,
+    // `actorContext`) are resolved once at turn start and threaded in so
+    // post-compaction re-injection reuses the same snapshot rather than live
+    // state that can flip mid-turn.
     const isTrustedActor = resolveTrustClass(ctx.trustContext) === "guardian";
+    let currentInjectionMode: InjectionMode = "full";
     const memoryCtx: MemoryRetrievalHookContext = {
       graphMemory: ctx.graphMemory,
       config: getConfig(),
@@ -1243,443 +892,33 @@ export async function runAgentLoopImpl(
       // to completion after the turn has already been torn down.
       signal: abortController.signal,
       latestMessages: ctx.messages,
+      requestId: reqId,
+      mode: currentInjectionMode,
+      isNonInteractive,
+      modelProfile: modelProfileStr,
+      actorContext,
     };
     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.
+    // The hook owns its side effects (injected-block metadata, recall log,
+    // `memory_recalled` event, and the runtime-injection metadata persist) and
+    // records the dense/sparse PKB query pair on the graph handle for the
+    // PKB-reminder injector to read back; the loop reuses the fully 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;
+    // 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);
-    // 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
@@ -1750,75 +989,46 @@ 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,
+          contextWindowManager: ctx.contextWindowManager,
           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 +1042,7 @@ export async function runAgentLoopImpl(
       return history;
     };
 
-    let updatedHistory = await runAgentLoop(runMessages, midLoopCompaction);
+    let updatedHistory = await runAgentLoop(runMessages, true);
 
     rlog.info(
       { resultMessageCount: updatedHistory.length },
@@ -2064,14 +1274,12 @@ export async function runAgentLoopImpl(
             );
             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.
@@ -2119,8 +1327,11 @@ export async function runAgentLoopImpl(
           },
           reducerState,
           (msgs, signal, opts) =>
-            ctx.contextWindowManager.maybeCompact(msgs, signal!, {
-              ...(opts ?? {}),
+            defaultCompact({
+              manager: ctx.contextWindowManager,
+              messages: msgs,
+              signal,
+              ...((opts ?? {}) as ContextWindowCompactOptions),
               overrideProfile: resolveCurrentOverrideProfile() ?? null,
               actorTrustClass: resolveTurnActorTrustClass(ctx),
             }),
@@ -2140,7 +1351,6 @@ export async function runAgentLoopImpl(
           step.compactionResult.summaryFailed !== undefined
         ) {
           await ctx.agentLoop.compactionCircuit.recordOutcome(
-            ctx,
             step.compactionResult.summaryFailed,
             onEvent,
           );
@@ -2151,8 +1361,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,16 +1369,12 @@ 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") {
@@ -2219,7 +1423,7 @@ export async function runAgentLoopImpl(
       // through to the final graceful-error fallback below.
       if (state.contextTooLargeDetected) {
         const action = resolveOverflowAction({
-          overflowRecovery,
+          overflowRecovery: convergenceBudget.overflowRecovery,
           isInteractive: isInteractiveResolved,
         });
 
@@ -2228,71 +1432,24 @@ export async function runAgentLoopImpl(
           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),
-                ),
-              {
-                messages: ctx.messages,
-                signal: abortController.signal,
-                options: {
-                  force: true,
-                  minKeepRecentUserTurns: 0,
-                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
-                },
-              },
-              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;
-            }
-          }
+          const emergencyCompact = await defaultCompact({
+            manager: ctx.contextWindowManager,
+            messages: ctx.messages,
+            signal: abortController.signal,
+            force: true,
+            minKeepRecentUserTurns: 0,
+            overrideProfile: resolveCurrentOverrideProfile() ?? null,
+          });
           // 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
-          ) {
+          if (emergencyCompact.summaryFailed !== undefined) {
             await ctx.agentLoop.compactionCircuit.recordOutcome(
-              ctx,
               emergencyCompact.summaryFailed,
               onEvent,
             );
           }
-          if (emergencyCompact?.compacted) {
+          if (emergencyCompact.compacted) {
             await applySuccessfulCompaction(emergencyCompact, ctx.messages);
-            state.reducerCompacted = true;
-            state.shouldInjectWorkspace = true;
           }
 
           // Only re-inject the memory-static block when ctx.messages was
@@ -2301,16 +1458,12 @@ export async function runAgentLoopImpl(
           // 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") {
@@ -2906,10 +2059,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 +2099,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 +2157,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 +2186,8 @@ export async function applyCompactionResult(
       options.slackContextCompactionWatermarkTs,
       compactedAt,
     );
+    ctx.slackContextCompactionWatermarkTs =
+      options.slackContextCompactionWatermarkTs;
   }
   enqueueAutoAnalysisOnCompaction(
     ctx.conversationId,