@vellumai/assistant 0.8.6 → 0.8.7

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

@@ -17,7 +17,7 @@ import type {
   AgentLoop,
   AgentLoopExitReason,
   CheckpointDecision,
-  CheckpointInfo,
+  MidLoopCompaction,
 } from "../agent/loop.js";
 import { createAssistantMessage } from "../agent/message-types.js";
 import type {
@@ -26,6 +26,7 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import {
   contextWindowConfigFromEffective,
   type EffectiveContextWindow,
@@ -95,28 +96,24 @@ import {
 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.js";
-import { defaultHistoryRepairTerminal } from "../plugins/defaults/history-repair.js";
+import { defaultCompactionTerminal } from "../plugins/defaults/compaction/terminal.js";
+import { deepRepairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import {
   asDefaultGraphPayload,
   type DefaultMemoryRetrievalDeps,
   type GraphMemoryPayload,
   runDefaultMemoryRetrieval,
-} from "../plugins/defaults/memory-retrieval.js";
-import { defaultPersistenceTerminal } from "../plugins/defaults/persistence.js";
-import { defaultTitleGenerateTerminal } from "../plugins/defaults/title-generate.js";
-import { defaultTokenEstimateTerminal } from "../plugins/defaults/token-estimate.js";
+} from "../plugins/defaults/memory-retrieval/register.js";
+import { defaultPersistenceTerminal } from "../plugins/defaults/persistence/terminal.js";
+import { defaultTitleGenerateTerminal } from "../plugins/defaults/title-generate/terminal.js";
+import { defaultTokenEstimateTerminal } from "../plugins/defaults/token-estimate/terminal.js";
 import { DEFAULT_TIMEOUTS, runHook, runPipeline } from "../plugins/pipeline.js";
 import { getMiddlewaresFor } from "../plugins/registry.js";
 import type {
-  CircuitBreakerArgs,
-  CircuitBreakerResult,
   CompactionArgs,
   CompactionResult,
   EstimateArgs,
   EstimateResult,
-  HistoryRepairArgs,
-  HistoryRepairResult,
   MemoryArgs,
   MemoryResult,
   OverflowReduceArgs,
@@ -127,11 +124,6 @@ import type {
   TurnContext as PluginTurnContext,
 } from "../plugins/types.js";
 import { PluginExecutionError, PluginTimeoutError } from "../plugins/types.js";
-import {
-  hasProactiveArtifactCompleted,
-  runProactiveArtifactJob,
-  tryClaimProactiveArtifactTrigger,
-} from "../proactive-artifact/index.js";
 import type {
   ContentBlock,
   Message,
@@ -210,7 +202,6 @@ import {
 } from "./date-context.js";
 import { getDiskPressureStatus } from "./disk-pressure-guard.js";
 import { classifyDiskPressureTurnPolicy } from "./disk-pressure-policy.js";
-import { deepRepairHistory } from "./history-repair.js";
 import type {
   DynamicPageSurfaceData,
   ServerMessage,
@@ -276,154 +267,6 @@ 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.";
 }
 
-// ── Compaction circuit-breaker pipeline helpers ─────────────────────
-//
-// The circuit-breaker behavior (3 consecutive summary-LLM failures trips a
-// 1-hour cooldown) is now implemented by the `circuitBreaker` plugin
-// pipeline. The default plugin (`plugins/defaults/circuit-breaker.ts`)
-// replicates the legacy threshold/cooldown constants and event-emission
-// semantics exactly — it operates on the `consecutiveCompactionFailures` /
-// `compactionCircuitOpenUntil` fields the conversation still owns so the
-// dev-only playground routes (`POST /playground/reset-compaction-circuit`,
-// `POST /playground/inject-compaction-failures`) continue to read and
-// mutate those fields directly.
-//
-// The helpers below build the pipeline inputs and invoke the runner. They
-// are the sole entry points the rest of the daemon uses to query or update
-// the compaction circuit.
-
-/** Circuit-breaker key for a specific conversation's compaction pipeline. */
-function compactionCircuitKey(conversationId: string): string {
-  return `compaction:${conversationId}`;
-}
-
-/**
- * Build the minimal {@link TurnContext} the pipeline runner requires. Called
- * both from inside the agent loop (where turn identifiers are available) and
- * from non-turn invocations like `Conversation.forceCompact` (which falls
- * back to stable placeholders so the runner's log records still carry the
- * conversation identifier).
- */
-function buildCircuitTurnContext(ctx: {
-  readonly conversationId: string;
-  currentRequestId?: string;
-  currentTurnTrustContext?: TrustContext;
-  trustContext?: TrustContext;
-  turnCount: number;
-}): PluginTurnContext {
-  const trust: TrustContext =
-    ctx.currentTurnTrustContext ?? ctx.trustContext ?? FALLBACK_TURN_TRUST;
-  return {
-    requestId: ctx.currentRequestId ?? "circuit-breaker",
-    conversationId: ctx.conversationId,
-    turnIndex: ctx.turnCount,
-    trust,
-  };
-}
-
-/**
- * Run the `circuitBreaker` pipeline for the compaction circuit on this
- * conversation. When `outcome` is provided, state is updated (and transition
- * events emit via `onEvent`); when omitted the call is query-only.
- *
- * Returns the post-call decision from the pipeline. Callers gate auto-paths
- * on `!result.open` and admit forced paths regardless of the decision.
- */
-async function runCompactionCircuitPipeline(
-  ctx: {
-    readonly conversationId: string;
-    consecutiveCompactionFailures: number;
-    compactionCircuitOpenUntil: number | null;
-    currentRequestId?: string;
-    currentTurnTrustContext?: TrustContext;
-    trustContext?: TrustContext;
-    turnCount: number;
-  },
-  args: {
-    outcome?: "success" | "failure";
-    onEvent?: (msg: ServerMessage) => void;
-  },
-): Promise<CircuitBreakerResult> {
-  const turnContext = buildCircuitTurnContext(ctx);
-  return runPipeline<CircuitBreakerArgs, CircuitBreakerResult>(
-    "circuitBreaker",
-    getMiddlewaresFor("circuitBreaker"),
-    async (terminalArgs) => {
-      // No plugin in the chain produced a decision. This should be
-      // unreachable in production because the default plugin registers a
-      // `circuitBreaker` middleware that always returns a decision, but we
-      // defensively derive the state here so test setups that intentionally
-      // omit the default plugin still get a sensible response.
-      const openUntil = terminalArgs.state.compactionCircuitOpenUntil;
-      const now = Date.now();
-      if (openUntil !== null && now < openUntil) {
-        return { open: true, cooldownRemainingMs: openUntil - now };
-      }
-      return { open: false };
-    },
-    {
-      key: compactionCircuitKey(ctx.conversationId),
-      // Pass the ctx directly as the mutable state container. The
-      // `CircuitBreakerArgs.state` shape deliberately matches the subset of
-      // fields the conversation owns so plugins mutate the same object the
-      // playground routes read and write.
-      state: ctx,
-      ...(args.outcome !== undefined ? { outcome: args.outcome } : {}),
-      ...(args.onEvent ? { onEvent: args.onEvent } : {}),
-    },
-    turnContext,
-    DEFAULT_TIMEOUTS.circuitBreaker,
-  );
-}
-
-/**
- * Query-only: is the compaction circuit breaker currently open for this
- * conversation? Thin wrapper around {@link runCompactionCircuitPipeline}
- * with no outcome. Async because the pipeline runner is async, but the
- * default plugin resolves synchronously on its microtask.
- */
-async function isCompactionCircuitOpen(ctx: {
-  readonly conversationId: string;
-  consecutiveCompactionFailures: number;
-  compactionCircuitOpenUntil: number | null;
-  currentRequestId?: string;
-  currentTurnTrustContext?: TrustContext;
-  trustContext?: TrustContext;
-  turnCount: number;
-}): Promise<boolean> {
-  const decision = await runCompactionCircuitPipeline(ctx, {});
-  return decision.open;
-}
-
-/**
- * Update the compaction circuit breaker with the outcome of a `maybeCompact`
- * call and emit any transition event. A `summaryFailed` value of `undefined`
- * means the summary LLM never ran (early return) — callers must guard with
- * `summaryFailed !== undefined` before invoking this helper so early-return
- * paths don't silently reset the 3-strike counter.
- *
- * The default plugin handles threshold-based tripping and cooldown reset;
- * see `plugins/defaults/circuit-breaker.ts` for the canonical semantics.
- */
-export async function trackCompactionOutcome(
-  ctx: {
-    readonly conversationId: string;
-    consecutiveCompactionFailures: number;
-    compactionCircuitOpenUntil: number | null;
-    currentRequestId?: string;
-    currentTurnTrustContext?: TrustContext;
-    trustContext?: TrustContext;
-    turnCount: number;
-  },
-  summaryFailed: boolean,
-  onEvent: (msg: ServerMessage) => void,
-): Promise<void> {
-  await runCompactionCircuitPipeline(ctx, {
-    outcome: summaryFailed ? "failure" : "success",
-    onEvent,
-  });
-}
-
 // ── Plugin pipeline helpers ──────────────────────────────────────────
 //
 // Canonical {@link PluginTurnContext} builder threaded into every
@@ -484,6 +327,28 @@ function buildPluginTurnContext(
 
 // ── 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}.
+ */
+export interface AssistantSurface {
+  surfaceId: string;
+  surfaceType: SurfaceType;
+  title?: string;
+  data: SurfaceData;
+  actions?: Array<{
+    id: string;
+    label: string;
+    style?: string;
+    data?: Record<string, unknown>;
+  }>;
+  display?: string;
+  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[];
@@ -507,10 +372,6 @@ export interface AgentLoopConversationContext {
    * happened just before this turn).
    */
   pendingPostCompactReinject: boolean;
-  /** Tracks consecutive compaction failures (summary LLM call threw). */
-  consecutiveCompactionFailures: number;
-  /** Timestamp (ms since epoch) until which the circuit breaker is open. */
-  compactionCircuitOpenUntil: number | null;
 
   readonly graphMemory: ConversationGraphMemory;
 
@@ -533,20 +394,7 @@ export interface AgentLoopConversationContext {
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   surfaceActionRequestIds: Set<string>;
   approvedViaPromptThisTurn?: boolean;
-  currentTurnSurfaces: Array<{
-    surfaceId: string;
-    surfaceType: SurfaceType;
-    title?: string;
-    data: SurfaceData;
-    actions?: Array<{
-      id: string;
-      label: string;
-      style?: string;
-      data?: Record<string, unknown>;
-    }>;
-    display?: string;
-    persistent?: boolean;
-  }>;
+  currentTurnSurfaces: AssistantSurface[];
 
   workingDir: string;
   workspaceTopLevelContext: string | null;
@@ -624,9 +472,11 @@ export interface AgentLoopConversationContext {
       | "message_complete"
       | "generation_cancelled"
       | "error_terminal",
-    anchor?: "assistant_turn" | "user_turn" | "global",
-    requestId?: string,
-    statusText?: string,
+    options?: {
+      anchor?: "assistant_turn" | "user_turn" | "global";
+      requestId?: string;
+      statusText?: string;
+    },
   ): void;
   emitConfirmationStateChanged(
     params: ConfirmationStateChanged extends {
@@ -644,7 +494,6 @@ export interface AgentLoopConversationContext {
   onConfirmationOutcome?: (
     requestId: string,
     state: string,
-    toolName?: string,
     toolUseId?: string,
   ) => void;
 
@@ -859,6 +708,25 @@ export async function runAgentLoopImpl(
       preflightBudget: Math.floor(providerMaxTokens * (1 - safetyMargin)),
     };
   };
+  /**
+   * The agent loop's window into the orchestrator's current effective
+   * context window. The loop reads `maxInputTokens` for tool-result
+   * truncation and `overflowRecovery` for its mid-loop budget gate, applying
+   * the long-history safety-margin bump itself off its own running history.
+   * Resolved fresh on each access so a mid-turn profile change is reflected.
+   */
+  const resolveContextWindow = (): {
+    maxInputTokens: number;
+    overflowRecovery: { enabled: boolean; safetyMarginRatio: number };
+  } => {
+    refreshCurrentProfileState();
+    const { enabled, safetyMarginRatio } =
+      currentEffectiveContextWindow.overflowRecovery;
+    return {
+      maxInputTokens: currentEffectiveContextWindow.maxInputTokens,
+      overflowRecovery: { enabled, safetyMarginRatio },
+    };
+  };
 
   // Initial value for `createToolExecutor` to read into
   // `ToolContext.overrideProfile`. `resolveCurrentOverrideProfile` refreshes
@@ -968,7 +836,10 @@ export async function runAgentLoopImpl(
         { reason: diskPressureDecision.reason },
         "Blocked turn during disk pressure cleanup mode",
       );
-      ctx.emitActivityState("idle", "error_terminal", "global", reqId);
+      ctx.emitActivityState("idle", "error_terminal", {
+        anchor: "global",
+        requestId: reqId,
+      });
       ctx.traceEmitter.emit("request_error", message, {
         requestId: reqId,
         status: "error",
@@ -1220,14 +1091,12 @@ export async function runAgentLoopImpl(
     );
     // Skip auto-compaction while the circuit breaker is open. Force paths
     // and user-initiated /compact bypass this check.
-    const autoCompactAllowed = !(await isCompactionCircuitOpen(ctx));
+    const autoCompactAllowed =
+      !(await ctx.agentLoop.compactionCircuit.isOpen(ctx));
     if (compactCheck.needed && autoCompactAllowed) {
-      ctx.emitActivityState(
-        "thinking",
-        "context_compacting",
-        "assistant_turn",
-        reqId,
-      );
+      ctx.emitActivityState("thinking", "context_compacting", {
+        requestId: reqId,
+      });
     }
     const compactionOptions = {
       lastCompactedAt: ctx.contextCompactedAt ?? undefined,
@@ -1235,6 +1104,7 @@ export async function runAgentLoopImpl(
       conversationOriginChannel:
         getConversationOriginChannel(ctx.conversationId) ?? undefined,
       overrideProfile: resolveCurrentOverrideProfile() ?? null,
+      actorTrustClass: ctx.trustContext?.trustClass,
     };
     let compacted: Awaited<
       ReturnType<typeof ctx.contextWindowManager.maybeCompact>
@@ -1267,7 +1137,11 @@ export async function runAgentLoopImpl(
             { err, phase: "start-of-turn-compaction" },
             "Compaction pipeline timed out — skipping compaction this turn",
           );
-          await trackCompactionOutcome(ctx, true, onEvent);
+          await ctx.agentLoop.compactionCircuit.recordOutcome(
+            ctx,
+            true,
+            onEvent,
+          );
           compacted = null;
         } else {
           throw err;
@@ -1280,7 +1154,11 @@ export async function runAgentLoopImpl(
     // path) — treating those as "successful" compactions would silently reset
     // the 3-strike counter and break the invariant.
     if (compacted && compacted.summaryFailed !== undefined) {
-      await trackCompactionOutcome(ctx, compacted.summaryFailed, onEvent);
+      await ctx.agentLoop.compactionCircuit.recordOutcome(
+        ctx,
+        compacted.summaryFailed,
+        onEvent,
+      );
     }
     if (compacted?.compacted) {
       await applySuccessfulCompaction(
@@ -1295,12 +1173,7 @@ export async function runAgentLoopImpl(
 
     // Register confirmation outcome tracker so the agent loop can link
     // confirmation decisions to tool_use_ids for persistence.
-    ctx.onConfirmationOutcome = (
-      requestId,
-      confirmationState,
-      toolName,
-      toolUseId,
-    ) => {
+    ctx.onConfirmationOutcome = (requestId, confirmationState, toolUseId) => {
       if (confirmationState === "pending") {
         // Use the toolUseId passed from the prompter (which knows which tool
         // requested confirmation) instead of the ambient state.currentToolUseId,
@@ -1317,7 +1190,7 @@ export async function runAgentLoopImpl(
         const resolvedId =
           state.requestIdToToolUseId.get(requestId) ?? toolUseId;
         if (resolvedId) {
-          const name = state.toolUseIdToName.get(resolvedId) ?? toolName ?? "";
+          const name = state.toolUseIdToName.get(resolvedId) ?? "";
           // Build a friendly label from the tool name
           const label =
             TOOL_FRIENDLY_LABEL[name] ??
@@ -1760,8 +1633,21 @@ export async function runAgentLoopImpl(
     // to the reduced `ctx.messages`.
     let reducerCompacted = compactedThisTurn;
 
+    // memory-v3-live: route the turn's `<memory>` block to the v3 injector.
+    // When on, runtime assembly suppresses v2's `<memory>` injection (only
+    // when the v3 injector actually produced a block — otherwise v2 stays as a
+    // fallback) and 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. 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 = {
+      suppressV2MemoryForV3: memoryV3Live,
       diskPressureContext,
       activeSurface,
       activeDocuments,
@@ -1983,6 +1869,7 @@ export async function runAgentLoopImpl(
                 options: {
                   ...(opts ?? {}),
                   overrideProfile: resolveCurrentOverrideProfile() ?? null,
+                  actorTrustClass: ctx.trustContext?.trustClass,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -1996,7 +1883,11 @@ export async function runAgentLoopImpl(
                 { err, phase: "overflow-reducer-forced-compaction" },
                 "Compaction pipeline timed out — falling through to next reducer tier",
               );
-              await trackCompactionOutcome(ctx, true, onEvent);
+              await ctx.agentLoop.compactionCircuit.recordOutcome(
+                ctx,
+                true,
+                onEvent,
+              );
               return {
                 messages: msgs,
                 compacted: false,
@@ -2018,12 +1909,9 @@ export async function runAgentLoopImpl(
           }
         },
         emitActivityState: () => {
-          ctx.emitActivityState(
-            "thinking",
-            "context_compacting",
-            "assistant_turn",
-            reqId,
-          );
+          ctx.emitActivityState("thinking", "context_compacting", {
+            requestId: reqId,
+          });
         },
         onCompactionResult: async (result, compactedBasis) => {
           // Track circuit-breaker state whenever the reducer invoked
@@ -2036,7 +1924,11 @@ export async function runAgentLoopImpl(
           // truncation-only path, etc.) that shouldn't influence the
           // breaker.
           if (result.summaryFailed !== undefined) {
-            await trackCompactionOutcome(ctx, result.summaryFailed, onEvent);
+            await ctx.agentLoop.compactionCircuit.recordOutcome(
+              ctx,
+              result.summaryFailed,
+              onEvent,
+            );
           }
           if (result.compacted) {
             await applySuccessfulCompaction(result, compactedBasis);
@@ -2130,55 +2022,7 @@ export async function runAgentLoopImpl(
       }
     }
 
-    // Pre-run repair — routed through the `historyRepair` plugin pipeline so
-    // plugins can observe or override repair behavior. The default plugin's
-    // middleware is a passthrough; the actual repair runs in the terminal
-    // (`defaultHistoryRepairTerminal`).
     let preRepairMessages = runMessages;
-    let preRunRepair: HistoryRepairResult | null = null;
-    try {
-      preRunRepair = await runPipeline<HistoryRepairArgs, HistoryRepairResult>(
-        "historyRepair",
-        getMiddlewaresFor("historyRepair"),
-        async (args) => defaultHistoryRepairTerminal(args),
-        { history: runMessages, provider: ctx.provider.name },
-        buildPluginTurnContext(ctx, reqId),
-        DEFAULT_TIMEOUTS.historyRepair,
-      );
-    } catch (err) {
-      if (err instanceof PluginTimeoutError) {
-        // Pipeline exceeded its budget — likely a misbehaving third-party
-        // middleware. Degrade gracefully by proceeding with the un-repaired
-        // history rather than turn-fatal-erroring; un-repaired history is
-        // strictly better than no turn at all, and the provider call itself
-        // will still error visibly if the drift is unrecoverable.
-        rlog.warn(
-          { err, phase: "pre_run" },
-          "historyRepair pipeline timed out — proceeding with un-repaired history",
-        );
-      } else {
-        throw err;
-      }
-    }
-    if (preRunRepair !== null) {
-      // Always adopt the pipeline's output history — a user `historyRepair`
-      // middleware may rewrite `messages` (e.g. provider-specific
-      // normalization) without incrementing any of the built-in repair
-      // counters. Gating the assignment on `stats` would silently discard
-      // those edits and send the un-rewritten history to the provider.
-      runMessages = preRunRepair.messages;
-      if (
-        preRunRepair.stats.assistantToolResultsMigrated > 0 ||
-        preRunRepair.stats.missingToolResultsInserted > 0 ||
-        preRunRepair.stats.orphanToolResultsDowngraded > 0 ||
-        preRunRepair.stats.consecutiveSameRoleMerged > 0
-      ) {
-        rlog.warn(
-          { phase: "pre_run", ...preRunRepair.stats },
-          "Repaired runtime history before provider call",
-        );
-      }
-    }
 
     // Replace historical web_search_tool_result blocks with text summaries.
     // The opaque `encrypted_content` tokens Anthropic attaches to each result
@@ -2195,12 +2039,12 @@ export async function runAgentLoopImpl(
     }
 
     // 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.
+    // 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 `preRunHistoryLength` is captured so the boundary
     // between pre-existing and hook-emitted messages — consumed by the
@@ -2211,6 +2055,7 @@ export async function runAgentLoopImpl(
       conversationId: ctx.conversationId,
       originalMessages: ctx.messages,
       latestMessages: runMessages,
+      logger: rlog,
     };
     const finalUserPromptCtx = await runHook(
       HOOKS.USER_PROMPT_SUBMIT,
@@ -2234,41 +2079,16 @@ export async function runAgentLoopImpl(
       turnChannelContext: capturedTurnChannelContext,
       turnInterfaceContext: capturedTurnInterfaceContext,
     };
-    const eventHandler = (event: AgentEvent) =>
+    const eventHandler = (event: AgentEvent): Promise<void> =>
       dispatchAgentEvent(state, deps, event);
     emitTerminalExit = async (reason: AgentLoopExitReason): Promise<void> => {
       await eventHandler({ type: "agent_loop_exit", reason });
     };
 
-    const onCheckpoint = async (
-      checkpoint: CheckpointInfo,
-    ): Promise<CheckpointDecision> => {
-      state.currentTurnToolNames = [];
-
+    const onCheckpoint = async (): Promise<CheckpointDecision> => {
       if (ctx.canHandoffAtCheckpoint()) {
-        yieldedForHandoff = true;
-        pendingCheckpointYield = "handoff";
-        return "yield";
+        return "handoff";
       }
-
-      // Mid-loop token budget check: estimate current context size and
-      // yield if we're approaching the preflight budget. This lets the
-      // conversation-agent-loop run compaction before the provider rejects.
-      if (overflowRecovery.enabled) {
-        const midLoopThreshold =
-          resolveCurrentContextBudget().preflightBudget * 0.85;
-        const estimated = await runTokenEstimatePipeline(checkpoint.history);
-        if (estimated > midLoopThreshold) {
-          rlog.warn(
-            { phase: "mid-loop", estimated, threshold: midLoopThreshold },
-            "Token estimate approaching budget — yielding for compaction",
-          );
-          yieldedForBudget = true;
-          pendingCheckpointYield = "budget";
-          return "yield";
-        }
-      }
-
       return "continue";
     };
 
@@ -2284,19 +2104,120 @@ export async function runAgentLoopImpl(
     // and overwrites `turnIndex` with its own tool-use iteration counter.
     const loopTurnCtx = buildPluginTurnContext(ctx, reqId);
 
-    let updatedHistory = await ctx.agentLoop.run(
-      runMessages,
-      eventHandler,
-      abortController.signal,
-      reqId,
-      onCheckpoint,
-      turnCallSite,
-      loopTurnCtx,
-      turnOverrideProfile,
-      resolveCurrentMaxInputTokens(),
-      resolveCurrentOverrideProfile,
-      resolveCurrentMaxInputTokens,
-    );
+    // Hooks 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; these callbacks bridge the durable / injection
+    // state the loop is intentionally blind to. Durable persistence and
+    // re-injection stay orchestrator-supplied for now.
+    const midLoopCompaction: MidLoopCompaction = {
+      prepare: (history) => {
+        // Strip injected context so the compactor summarizes the raw
+        // persistent messages, and commit the stripped set to durable state.
+        const rawHistory = stripInjectionsForCompaction(history);
+        ctx.messages = rawHistory;
+        markHistoryStrippedBestEffort(ctx.conversationId, Date.now(), rlog);
+        return {
+          rawHistory,
+          options: {
+            lastCompactedAt: ctx.contextCompactedAt ?? undefined,
+            force: true,
+            targetInputTokensOverride:
+              resolveCurrentContextBudget().preflightBudget,
+            conversationOriginChannel:
+              getConversationOriginChannel(ctx.conversationId) ?? undefined,
+            overrideProfile: resolveCurrentOverrideProfile() ?? null,
+            actorTrustClass: ctx.trustContext?.trustClass,
+          },
+        };
+      },
+      applyResult: async (result, rawHistory) => {
+        await applySuccessfulCompaction(result, rawHistory);
+        reducerCompacted = true;
+        shouldInjectWorkspace = true;
+      },
+      reinject: async () => {
+        // stripInjectionsForCompaction() unconditionally removed the existing
+        // NOW.md block, so re-inject the current content regardless of whether
+        // compaction actually ran.
+        const injection = await applyRuntimeInjections(ctx.messages, {
+          ...injectionOpts,
+          pkbContext: currentPkbContent,
+          memoryV2Static: currentMemoryV2Static,
+          nowScratchpad: currentNowContent,
+          workspaceTopLevelContext: shouldInjectWorkspace
+            ? ctx.workspaceTopLevelContext
+            : null,
+          // 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: reducerCompacted
+            ? null
+            : injectionOpts.slackChronologicalMessages,
+          mode: currentInjectionMode,
+          turnContext: buildPluginTurnContext(ctx, reqId),
+        });
+        runMessages = injection.messages;
+        if (isTrustedActor && currentInjectionMode !== "minimal") {
+          ctx.graphMemory.retrackCachedNodes();
+        }
+        const midLoopCompactStrip =
+          stripHistoricalWebSearchResults(runMessages);
+        if (midLoopCompactStrip.stats.blocksStripped > 0) {
+          rlog.info(
+            { phase: "mid-loop-compact", ...midLoopCompactStrip.stats },
+            "Converted historical web_search_tool_result blocks to text summaries",
+          );
+          runMessages = midLoopCompactStrip.messages;
+        }
+        preRepairMessages = runMessages;
+        preRunHistoryLength = runMessages.length;
+        return runMessages;
+      },
+    };
+
+    /**
+     * 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.
+     */
+    const runAgentLoop = async (
+      msgs: Message[],
+      compaction?: MidLoopCompaction,
+    ): Promise<Message[]> => {
+      const { history, exitReason } = await ctx.agentLoop.run(
+        msgs,
+        eventHandler,
+        {
+          signal: abortController.signal,
+          requestId: reqId,
+          onCheckpoint,
+          callSite: turnCallSite,
+          turnContext: loopTurnCtx,
+          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,
+        },
+      );
+      if (exitReason === "handoff") {
+        yieldedForHandoff = true;
+        pendingCheckpointYield = "handoff";
+      } else if (exitReason === "budget") {
+        yieldedForBudget = true;
+        pendingCheckpointYield = "budget";
+      }
+      return history;
+    };
+
+    let updatedHistory = await runAgentLoop(runMessages, midLoopCompaction);
 
     rlog.info(
       { resultMessageCount: updatedHistory.length },
@@ -2308,167 +2229,16 @@ export async function runAgentLoopImpl(
       pendingCheckpointYield = null;
     }
 
-    // ── Proactive mid-loop compaction ───────────────────────────────
-    // When the agent loop yielded because the token budget check in
-    // onCheckpoint detected approaching limits, run compaction on the
-    // accumulated history and re-enter the agent loop. This is distinct
-    // from the reactive convergence loop below that fires after a
-    // provider rejection — here we compact *before* hitting the limit.
-    let midLoopCompactAttempts = 0;
-    while (
-      yieldedForBudget &&
-      midLoopCompactAttempts <
-        resolveCurrentContextBudget().overflowRecovery.maxAttempts &&
-      !state.contextTooLargeDetected &&
-      !abortController.signal.aborted
-    ) {
-      midLoopCompactAttempts++;
-      yieldedForBudget = false;
-      pendingCheckpointYield = null;
-
-      rlog.info(
-        { phase: "mid-loop-compact" },
-        "Running compaction after checkpoint yield",
-      );
-
-      // Strip injected context from updated history before compacting,
-      // so we compact the "raw" persistent messages.
-      const rawHistory = stripInjectionsForCompaction(updatedHistory);
-      ctx.messages = rawHistory;
-      markHistoryStrippedBestEffort(ctx.conversationId, Date.now(), rlog);
-
-      ctx.emitActivityState(
-        "thinking",
-        "context_compacting",
-        "assistant_turn",
-        reqId,
-        "Compacting context",
-      );
-      let midLoopCompact: Awaited<
-        ReturnType<typeof ctx.contextWindowManager.maybeCompact>
-      >;
-      try {
-        midLoopCompact = (await runPipeline<CompactionArgs, CompactionResult>(
-          "compaction",
-          getMiddlewaresFor("compaction"),
-          (args) =>
-            defaultCompactionTerminal(args, buildPluginTurnContext(ctx, reqId)),
-          {
-            messages: ctx.messages,
-            signal: abortController.signal,
-            options: {
-              lastCompactedAt: ctx.contextCompactedAt ?? undefined,
-              force: true,
-              targetInputTokensOverride:
-                resolveCurrentContextBudget().preflightBudget,
-              conversationOriginChannel:
-                getConversationOriginChannel(ctx.conversationId) ?? undefined,
-              overrideProfile: resolveCurrentOverrideProfile() ?? null,
-            },
-          },
-          buildPluginTurnContext(ctx, reqId),
-          DEFAULT_TIMEOUTS.compaction,
-        )) as Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>;
-      } catch (err) {
-        if (err instanceof PluginTimeoutError) {
-          // Mid-loop compaction timed out. Record the failure for the
-          // circuit breaker and escalate to the convergence loop's more
-          // aggressive reducer tiers (tool-result truncation, media
-          // stubbing, injection downgrade) by flipping the overflow flag
-          // and breaking out of the mid-loop retry. The existing
-          // "exhausted all attempts" block further down handles the
-          // escalation.
-          rlog.warn(
-            { err, phase: "mid-loop-compact" },
-            "Compaction pipeline timed out — escalating to convergence loop",
-          );
-          await trackCompactionOutcome(ctx, true, onEvent);
-          state.contextTooLargeDetected = true;
-          break;
-        }
-        throw err;
-      }
-      // `force: true` bypasses the cooldown/threshold gates but early returns
-      // for "no eligible messages" / "insufficient messages" still leave
-      // `summaryFailed` undefined. Only track when the summary LLM actually ran.
-      if (midLoopCompact.summaryFailed !== undefined) {
-        await trackCompactionOutcome(
-          ctx,
-          midLoopCompact.summaryFailed,
-          onEvent,
-        );
-      }
-      if (midLoopCompact.compacted) {
-        await applySuccessfulCompaction(midLoopCompact, rawHistory);
-        reducerCompacted = true;
-        shouldInjectWorkspace = true;
-      }
-
-      // Re-inject runtime context and re-enter the agent loop.
-      // stripInjectionsForCompaction() unconditionally removed the existing
-      // NOW.md block from ctx.messages above, so we must always re-inject
-      // the current content regardless of whether compaction actually ran.
-      const injection = await applyRuntimeInjections(ctx.messages, {
-        ...injectionOpts,
-        pkbContext: currentPkbContent,
-        memoryV2Static: currentMemoryV2Static,
-        nowScratchpad: currentNowContent,
-        workspaceTopLevelContext: shouldInjectWorkspace
-          ? ctx.workspaceTopLevelContext
-          : null,
-        // 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: reducerCompacted
-          ? null
-          : injectionOpts.slackChronologicalMessages,
-        mode: currentInjectionMode,
-        turnContext: buildPluginTurnContext(ctx, reqId),
-      });
-      runMessages = injection.messages;
-      if (isTrustedActor && currentInjectionMode !== "minimal") {
-        ctx.graphMemory.retrackCachedNodes();
-      }
-      const midLoopCompactStrip = stripHistoricalWebSearchResults(runMessages);
-      if (midLoopCompactStrip.stats.blocksStripped > 0) {
-        rlog.info(
-          { phase: "mid-loop-compact", ...midLoopCompactStrip.stats },
-          "Converted historical web_search_tool_result blocks to text summaries",
-        );
-        runMessages = midLoopCompactStrip.messages;
-      }
-      preRepairMessages = runMessages;
-      preRunHistoryLength = runMessages.length;
-
-      updatedHistory = await ctx.agentLoop.run(
-        runMessages,
-        eventHandler,
-        abortController.signal,
-        reqId,
-        onCheckpoint,
-        turnCallSite,
-        loopTurnCtx,
-        turnOverrideProfile,
-        resolveCurrentMaxInputTokens(),
-        resolveCurrentOverrideProfile,
-        resolveCurrentMaxInputTokens,
-      );
-    }
-
-    // If mid-loop compaction exhausted all attempts but the agent loop
-    // still yielded (yieldedForBudget is true), the turn is incomplete.
-    // Escalate to the convergence loop's more aggressive reducer tiers
-    // (tool-result truncation, media stubbing, injection downgrade)
-    // instead of silently treating an incomplete turn as done.
+    // The loop compacts in place when its budget gate trips and only yields
+    // `exitReason = "budget"` when that inline compaction timed out or
+    // exhausted its retry budget (the `reinject` hook has already restored
+    // runtime context for the productive case). Escalate to the convergence
+    // loop's more aggressive reducer tiers so a half-finished turn doesn't
+    // reach the user.
     if (yieldedForBudget && !abortController.signal.aborted) {
       rlog.warn(
-        {
-          phase: "mid-loop-compact",
-          midLoopCompactAttempts,
-          maxAttempts:
-            resolveCurrentContextBudget().overflowRecovery.maxAttempts,
-        },
-        "Mid-loop compaction exhausted all attempts — escalating to convergence loop",
+        { phase: "mid-loop-compact" },
+        "Inline compaction could not get under budget — escalating to convergence loop",
       );
       state.contextTooLargeDetected = true;
     }
@@ -2482,15 +2252,15 @@ export async function runAgentLoopImpl(
         { phase: "retry" },
         "Provider ordering error detected, attempting one-shot deep-repair retry",
       );
-      // Design note: deep-repair intentionally bypasses the `historyRepair`
-      // plugin pipeline. Deep-repair is a recovery-only path triggered by a
-      // provider ordering error — it must be deterministic and unaffected by
-      // user middleware that might have caused (or be unable to recover from)
-      // the original drift. Plugins can already observe / override the
-      // pre-run repair via the `historyRepair` pipeline above; widening that
-      // surface to deep-repair is intentionally deferred until there's a
-      // concrete plugin-level use case. Do not route this call through
-      // `runPipeline` without first revisiting that contract.
+      // Design note: deep-repair intentionally stays a direct call rather
+      // than running through the `user-prompt-submit` hook chain. Deep-repair
+      // is a recovery-only path triggered by a provider ordering error — it
+      // must be deterministic and unaffected by user hooks that might have
+      // caused (or be unable to recover from) the original drift. Plugins can
+      // already observe / transform the pre-run repair via the
+      // `user-prompt-submit` hook (the default history-repair plugin runs
+      // `repairHistory` there); widening that surface to deep-repair is
+      // intentionally deferred until there's a concrete plugin-level use case.
       const retryRepair = deepRepairHistory(runMessages);
       runMessages = retryRepair.messages;
       const retryStrip = stripHistoricalWebSearchResults(runMessages);
@@ -2500,19 +2270,7 @@ export async function runAgentLoopImpl(
       state.orderingErrorDetected = false;
       state.deferredOrderingError = null;
 
-      updatedHistory = await ctx.agentLoop.run(
-        runMessages,
-        eventHandler,
-        abortController.signal,
-        reqId,
-        onCheckpoint,
-        turnCallSite,
-        loopTurnCtx,
-        turnOverrideProfile,
-        resolveCurrentMaxInputTokens(),
-        resolveCurrentOverrideProfile,
-        resolveCurrentMaxInputTokens,
-      );
+      updatedHistory = await runAgentLoop(runMessages);
 
       if (state.orderingErrorDetected) {
         rlog.error(
@@ -2571,19 +2329,7 @@ export async function runAgentLoopImpl(
         };
       });
       runMessages = ctx.messages;
-      updatedHistory = await ctx.agentLoop.run(
-        runMessages,
-        eventHandler,
-        abortController.signal,
-        reqId,
-        onCheckpoint,
-        turnCallSite,
-        loopTurnCtx,
-        turnOverrideProfile,
-        resolveCurrentMaxInputTokens(),
-        resolveCurrentOverrideProfile,
-        resolveCurrentMaxInputTokens,
-      );
+      updatedHistory = await runAgentLoop(runMessages);
       if (state.imageTooLargeDetected) {
         rlog.error(
           { phase: "image-recovery" },
@@ -2703,7 +2449,7 @@ export async function runAgentLoopImpl(
               "Emergency mid-turn compaction succeeded — bypassing reducer tiers",
             );
             if (emergencyResult.summaryFailed !== undefined) {
-              await trackCompactionOutcome(
+              await ctx.agentLoop.compactionCircuit.recordOutcome(
                 ctx,
                 emergencyResult.summaryFailed,
                 onEvent,
@@ -2744,12 +2490,9 @@ export async function runAgentLoopImpl(
           "Context too large — applying next reducer tier",
         );
 
-        ctx.emitActivityState(
-          "thinking",
-          "context_compacting",
-          "assistant_turn",
-          reqId,
-        );
+        ctx.emitActivityState("thinking", "context_compacting", {
+          requestId: reqId,
+        });
         const convergenceCompactionBasis = ctx.messages;
         const step = await reduceContextOverflow(
           convergenceCompactionBasis,
@@ -2765,6 +2508,7 @@ export async function runAgentLoopImpl(
             ctx.contextWindowManager.maybeCompact(msgs, signal!, {
               ...(opts ?? {}),
               overrideProfile: resolveCurrentOverrideProfile() ?? null,
+              actorTrustClass: ctx.trustContext?.trustClass,
             }),
           abortController.signal,
         );
@@ -2781,7 +2525,7 @@ export async function runAgentLoopImpl(
           step.compactionResult &&
           step.compactionResult.summaryFailed !== undefined
         ) {
-          await trackCompactionOutcome(
+          await ctx.agentLoop.compactionCircuit.recordOutcome(
             ctx,
             step.compactionResult.summaryFailed,
             onEvent,
@@ -2831,19 +2575,7 @@ export async function runAgentLoopImpl(
         state.contextTooLargeDetected = false;
         yieldedForBudget = false;
 
-        updatedHistory = await ctx.agentLoop.run(
-          runMessages,
-          eventHandler,
-          abortController.signal,
-          reqId,
-          onCheckpoint,
-          turnCallSite,
-          loopTurnCtx,
-          turnOverrideProfile,
-          resolveCurrentMaxInputTokens(),
-          resolveCurrentOverrideProfile,
-          resolveCurrentMaxInputTokens,
-        );
+        updatedHistory = await runAgentLoop(runMessages);
 
         // If the rerun still yields at checkpoint, the turn is still
         // incomplete — continue reducing through the remaining tiers
@@ -2884,12 +2616,9 @@ export async function runAgentLoopImpl(
 
         if (action === "auto_compress_latest_turn") {
           // Auto-compress without asking — users opt out via the "drop" policy.
-          ctx.emitActivityState(
-            "thinking",
-            "context_compacting",
-            "assistant_turn",
-            reqId,
-          );
+          ctx.emitActivityState("thinking", "context_compacting", {
+            requestId: reqId,
+          });
           let emergencyCompact: Awaited<
             ReturnType<typeof ctx.contextWindowManager.maybeCompact>
           > | null = null;
@@ -2931,7 +2660,11 @@ export async function runAgentLoopImpl(
                 { err, phase: "emergency-compaction" },
                 "Emergency compaction pipeline timed out — continuing with overflow fallback",
               );
-              await trackCompactionOutcome(ctx, true, onEvent);
+              await ctx.agentLoop.compactionCircuit.recordOutcome(
+                ctx,
+                true,
+                onEvent,
+              );
               emergencyCompact = null;
             } else {
               throw err;
@@ -2943,7 +2676,7 @@ export async function runAgentLoopImpl(
             emergencyCompact &&
             emergencyCompact.summaryFailed !== undefined
           ) {
-            await trackCompactionOutcome(
+            await ctx.agentLoop.compactionCircuit.recordOutcome(
               ctx,
               emergencyCompact.summaryFailed,
               onEvent,
@@ -2987,19 +2720,7 @@ export async function runAgentLoopImpl(
           preRunHistoryLength = runMessages.length;
           state.contextTooLargeDetected = false;
 
-          updatedHistory = await ctx.agentLoop.run(
-            runMessages,
-            eventHandler,
-            abortController.signal,
-            reqId,
-            onCheckpoint,
-            turnCallSite,
-            loopTurnCtx,
-            turnOverrideProfile,
-            resolveCurrentMaxInputTokens(),
-            resolveCurrentOverrideProfile,
-            resolveCurrentMaxInputTokens,
-          );
+          updatedHistory = await runAgentLoop(runMessages);
         }
         // action === "fail_gracefully" falls through to the final error below
       }
@@ -3389,7 +3110,10 @@ export async function runAgentLoopImpl(
     // so the client can re-enable the UI without delay.
     if (abortController.signal.aborted) {
       syncLastAssistantMessageToDisk();
-      ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
+      ctx.emitActivityState("idle", "generation_cancelled", {
+        anchor: "global",
+        requestId: reqId,
+      });
       ctx.traceEmitter.emit(
         "generation_cancelled",
         "Generation cancelled by user",
@@ -3433,7 +3157,10 @@ export async function runAgentLoopImpl(
           await emitTerminalExit?.("aborted_after_checkpoint");
           pendingCheckpointYield = null;
         }
-        ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
+        ctx.emitActivityState("idle", "generation_cancelled", {
+          anchor: "global",
+          requestId: reqId,
+        });
         ctx.traceEmitter.emit(
           "generation_cancelled",
           "Generation cancelled by user",
@@ -3474,7 +3201,10 @@ export async function runAgentLoopImpl(
         });
         publishLoopMessagesChanged();
       } else {
-        ctx.emitActivityState("idle", "message_complete", "global", reqId);
+        ctx.emitActivityState("idle", "message_complete", {
+          anchor: "global",
+          requestId: reqId,
+        });
         ctx.traceEmitter.emit(
           "message_complete",
           "Message processing complete",
@@ -3497,42 +3227,6 @@ export async function runAgentLoopImpl(
             : {}),
         });
         publishLoopMessagesChanged();
-
-        // Proactive artifact: fire once when the processed turn was the 4th user message.
-        // Only trigger for real user-authored turns (not subagent/system messages).
-        {
-          const paConv = getConversation(ctx.conversationId);
-          if (
-            paConv &&
-            paConv.conversationType === "standard" &&
-            options?.isUserMessage
-          ) {
-            void (async () => {
-              try {
-                if (hasProactiveArtifactCompleted()) return;
-                const userMsg = getMessageById(
-                  userMessageId,
-                  ctx.conversationId,
-                );
-                if (!userMsg) return;
-                if (!tryClaimProactiveArtifactTrigger(userMsg.createdAt))
-                  return;
-                await runProactiveArtifactJob({
-                  conversationId: ctx.conversationId,
-                  userMessageCutoff: userMsg.createdAt,
-                  assistantMessageId: state.lastAssistantMessageId,
-                  suppressAppBuild: state.appBuildToolUsedThisRun,
-                  broadcastMessage,
-                });
-              } catch (err) {
-                log.warn(
-                  { err, conversationId: ctx.conversationId },
-                  "Proactive artifact trigger failed",
-                );
-              }
-            })();
-          }
-        }
       }
     }
 
@@ -3569,7 +3263,10 @@ export async function runAgentLoopImpl(
         await emitTerminalExit?.("aborted_after_checkpoint");
         pendingCheckpointYield = null;
       }
-      ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
+      ctx.emitActivityState("idle", "generation_cancelled", {
+        anchor: "global",
+        requestId: reqId,
+      });
       rlog.info("Generation cancelled by user");
       ctx.traceEmitter.emit(
         "generation_cancelled",
@@ -3585,7 +3282,10 @@ export async function runAgentLoopImpl(
       });
       publishLoopMessagesChanged();
     } else {
-      ctx.emitActivityState("idle", "error_terminal", "global", reqId);
+      ctx.emitActivityState("idle", "error_terminal", {
+        anchor: "global",
+        requestId: reqId,
+      });
       const message = err instanceof Error ? err.message : String(err);
       const errorClass = err instanceof Error ? err.constructor.name : "Error";
       rlog.error({ err }, "Conversation processing error");