@vellumai/assistant 0.6.4 → 0.6.6

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

@@ -7,6 +7,8 @@
  * runAgentLoop method here via the AgentLoopConversationContext interface.
  */
 
+import { join } from "node:path";
+
 import { v4 as uuid } from "uuid";
 
 import type {
@@ -24,15 +26,19 @@ import type {
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
 } from "../context/post-turn-tool-result-truncation.js";
-import { estimatePromptTokens } from "../context/token-estimator.js";
+import {
+  estimatePromptTokens,
+  getCalibrationProviderKey,
+} from "../context/token-estimator.js";
 import type { ContextWindowManager } from "../context/window-manager.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
+import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
-import { getHookManager } from "../hooks/manager.js";
 import {
   clearSentryConversationContext,
   setSentryConversationContext,
@@ -41,8 +47,7 @@ import { commitAppTurnChanges } from "../memory/app-git-service.js";
 import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
 import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import {
-  addMessage,
-  deleteMessageById,
+  clearStrippedInjectionMetadataForConversation,
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
@@ -50,27 +55,60 @@ import {
   getMessageById,
   provenanceFromTrustContext,
   updateConversationContextWindow,
-  updateConversationTitle,
-  updateMessageMetadata,
 } from "../memory/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import {
   isReplaceableTitle,
-  queueGenerateConversationTitle,
   queueRegenerateConversationTitle,
-  UNTITLED_FALLBACK,
 } from "../memory/conversation-title-service.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
+import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
-import type { ContentBlock, Message } from "../providers/types.js";
+import { defaultCompactionTerminal } from "../plugins/defaults/compaction.js";
+import { defaultHistoryRepairTerminal } from "../plugins/defaults/history-repair.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";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import { getMiddlewaresFor } from "../plugins/registry.js";
+import type {
+  CircuitBreakerArgs,
+  CircuitBreakerResult,
+  CompactionArgs,
+  CompactionResult,
+  EstimateArgs,
+  EstimateResult,
+  HistoryRepairArgs,
+  HistoryRepairResult,
+  MemoryArgs,
+  MemoryResult,
+  OverflowReduceArgs,
+  OverflowReduceResult,
+  PersistArgs,
+  PersistResult,
+  TurnContext as PluginTurnContext,
+} from "../plugins/types.js";
+import { PluginExecutionError, PluginTimeoutError } from "../plugins/types.js";
+import type {
+  ContentBlock,
+  Message,
+  ToolDefinition,
+} from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { UsageActor } from "../usage/actors.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { timeAgo } from "../util/time.js";
 import { truncate } from "../util/truncate.js";
 import { getWorkspaceGitService } from "../workspace/git-service.js";
@@ -79,7 +117,6 @@ import {
   type AssistantAttachmentDraft,
   cleanAssistantContent,
 } from "./assistant-attachments.js";
-import { requestCompressionApproval } from "./context-overflow-approval.js";
 import { resolveOverflowAction } from "./context-overflow-policy.js";
 import {
   createInitialReducerState,
@@ -115,10 +152,11 @@ import {
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
+  getPkbAutoInjectList,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
-  readNowScratchpad,
-  readPkbContext,
+  loadSlackActiveThreadFocusBlock,
+  loadSlackChronologicalMessages,
   stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
@@ -126,7 +164,7 @@ import { markSurfaceCompleted } from "./conversation-surfaces.js";
 import { resolveTrustClass } from "./conversation-tool-setup.js";
 import { recordUsage } from "./conversation-usage.js";
 import { formatTurnTimestamp } from "./date-context.js";
-import { deepRepairHistory, repairHistory } from "./history-repair.js";
+import { deepRepairHistory } from "./history-repair.js";
 import type {
   DynamicPageSurfaceData,
   ServerMessage,
@@ -135,44 +173,12 @@ import type {
   UsageStats,
 } from "./message-protocol.js";
 import type { MemoryRecalled } from "./message-types/memory.js";
+import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import type { TraceEmitter } from "./trace-emitter.js";
+import { stripHistoricalWebSearchResults } from "./web-search-history.js";
 
 const log = getLogger("conversation-agent-loop");
 
-/**
- * Parse the actual token count reported by the provider in a context-too-large
- * error message. Providers typically include the prompt size, e.g.:
- *   "prompt is too long: 242201 tokens > 200000 maximum"
- *   "too many input tokens: 242201 > 200000"
- *
- * Returns the actual token count or null if it cannot be parsed.
- */
-export function parseActualTokensFromError(
-  errorMessage: string | null,
-): number | null {
-  if (!errorMessage) return null;
-
-  // Match patterns like "242201 tokens > 200000" or "242201 > 200000 maximum"
-  const match = errorMessage.match(
-    /(\d[\d,]*)\s*tokens?\s*[>≥]|:\s*(\d[\d,]*)\s*[>≥]/i,
-  );
-  if (match) {
-    const raw = (match[1] || match[2]).replace(/,/g, "");
-    const parsed = parseInt(raw, 10);
-    if (!isNaN(parsed) && parsed > 0) return parsed;
-  }
-
-  // Fallback: match "too many input tokens: N > M"
-  const fallback = errorMessage.match(/(\d[\d,]*)\s*[>≥]\s*\d/);
-  if (fallback) {
-    const raw = fallback[1].replace(/,/g, "");
-    const parsed = parseInt(raw, 10);
-    if (!isNaN(parsed) && parsed > 0) return parsed;
-  }
-
-  return null;
-}
-
 /** Title-cased friendly labels for tool names, used in confirmation chips. */
 const TOOL_FRIENDLY_LABEL: Record<string, string> = {
   bash: "Run Command",
@@ -181,12 +187,6 @@ const TOOL_FRIENDLY_LABEL: Record<string, string> = {
   file_read: "Read File",
   file_write: "Write File",
   file_edit: "Edit File",
-  browser_navigate: "Browser",
-  browser_click: "Browser",
-  browser_type: "Browser",
-  browser_screenshot: "Browser",
-  browser_scroll: "Browser",
-  browser_wait: "Browser",
   app_create: "Create App",
   app_refresh: "Refresh App",
   skill_load: "Load Skill",
@@ -197,6 +197,212 @@ type GitServiceInitializer = {
   ensureInitialized(): Promise<void>;
 };
 
+// ── 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.
+ */
+export 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
+// `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
+ * 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
+ * to a custom plugin reading `ctx.trust`.
+ */
+export const FALLBACK_TURN_TRUST: TrustContext = {
+  sourceChannel: "vellum",
+  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`.
+ */
+export 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,
+  };
+}
+
 // ── Context Interface ────────────────────────────────────────────────
 
 export interface AgentLoopConversationContext {
@@ -213,6 +419,10 @@ export interface AgentLoopConversationContext {
   readonly contextWindowManager: ContextWindowManager;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  /** 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 memoryPolicy: { scopeId: string; includeDefaultFallback: boolean };
   readonly graphMemory: ConversationGraphMemory;
@@ -235,6 +445,7 @@ export interface AgentLoopConversationContext {
   >;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   surfaceActionRequestIds: Set<string>;
+  approvedViaPromptThisTurn?: boolean;
   currentTurnSurfaces: Array<{
     surfaceId: string;
     surfaceType: SurfaceType;
@@ -352,10 +563,16 @@ export async function runAgentLoopImpl(
   userMessageId: string,
   onEvent: (msg: ServerMessage) => void,
   options?: {
-    skipPreMessageRollback?: boolean;
     isInteractive?: boolean;
     isUserMessage?: boolean;
     titleText?: string;
+    /**
+     * LLM call-site identifier threaded into the per-call provider config.
+     * Adapter callers (heartbeat, filing, scheduler, etc.) pass their own
+     * call-site id so the resolver picks `llm.callSites.<id>`. When unset,
+     * the agent loop defaults to `'mainAgent'` for user-initiated turns.
+     */
+    callSite?: LLMCallSite;
   },
 ): Promise<void> {
   if (!ctx.abortController) {
@@ -379,6 +596,13 @@ export async function runAgentLoopImpl(
   });
   let yieldedForHandoff = false;
 
+  // Default user-initiated turns to the `mainAgent` call site. Other
+  // invocation contexts (heartbeat, filing, analyze, etc.) pass their own
+  // `callSite`. The provider layer resolves provider/model/maxTokens via
+  // `resolveCallSiteConfig`, picking up any user overrides under
+  // `llm.callSites.mainAgent` (falling back to `llm.default` when absent).
+  const turnCallSite: LLMCallSite = options?.callSite ?? "mainAgent";
+
   // Capture the turn channel context *before* any awaits so a second
   // message from a different channel can't overwrite it mid-flight.
   // When context is unavailable (e.g. regenerate after daemon restart),
@@ -462,40 +686,10 @@ export async function runAgentLoopImpl(
       }
     }
 
-    const preMessageResult = await getHookManager().trigger("pre-message", {
-      conversationId: ctx.conversationId,
-      messagePreview: truncate(content, 200, ""),
-    });
-
-    if (preMessageResult.blocked) {
-      if (!options?.skipPreMessageRollback) {
-        ctx.messages.pop();
-        deleteMessageById(userMessageId);
-      }
-      // Replace loading placeholder so the conversation isn't stuck as "Generating title..."
-      const currentConv = getConversation(ctx.conversationId);
-      if (
-        isReplaceableTitle(currentConv?.title ?? null) &&
-        currentConv?.title !== UNTITLED_FALLBACK
-      ) {
-        updateConversationTitle(ctx.conversationId, UNTITLED_FALLBACK);
-        onEvent({
-          type: "conversation_title_updated",
-          conversationId: ctx.conversationId,
-          title: UNTITLED_FALLBACK,
-        });
-      }
-      onEvent({
-        type: "error",
-        message: `Message blocked by hook "${preMessageResult.blockedBy}"`,
-      });
-      return;
-    }
-
     // Generate title early — the user message alone is sufficient context.
-    // Firing after hook gating but before the main LLM call removes the
-    // delay of waiting for the full assistant response. The second-pass
-    // regeneration at turn 3 will refine the title with more context.
+    // Firing before the main LLM call removes the delay of waiting for the
+    // full assistant response. The second-pass regeneration at turn 3 will
+    // refine the title with more context.
     // No abort signal — title generation should complete even if the user
     // cancels the response, since the user message is already persisted.
     // Deferred via setTimeout so the main agent loop LLM call enqueues
@@ -503,18 +697,38 @@ export async function runAgentLoopImpl(
     if (
       isReplaceableTitle(getConversation(ctx.conversationId)?.title ?? null)
     ) {
+      // TurnContext routed through the canonical builder so the pipeline's
+      // log record reports the same `conversationId`/`turnIndex` shape as
+      // every other slot in this turn. Title generation does not depend on
+      // the context-window manager attached by the builder, but sharing the
+      // builder keeps the invariant enforced in one place.
+      const titlePipelineCtx = buildPluginTurnContext(ctx, reqId);
+      const titleArgs = {
+        conversationId: ctx.conversationId,
+        provider: ctx.provider,
+        userMessage: options?.titleText ?? content,
+        onTitleUpdated: (title: string) => {
+          onEvent({
+            type: "conversation_title_updated",
+            conversationId: ctx.conversationId,
+            title,
+          });
+        },
+      };
       setTimeout(() => {
-        queueGenerateConversationTitle({
-          conversationId: ctx.conversationId,
-          provider: ctx.provider,
-          userMessage: options?.titleText ?? content,
-          onTitleUpdated: (title) => {
-            onEvent({
-              type: "conversation_title_updated",
-              conversationId: ctx.conversationId,
-              title,
-            });
-          },
+        runPipeline(
+          "titleGenerate",
+          getMiddlewaresFor("titleGenerate"),
+          defaultTitleGenerateTerminal,
+          titleArgs,
+          titlePipelineCtx,
+          DEFAULT_TIMEOUTS.titleGenerate,
+        ).catch((err) => {
+          // Fire-and-forget — keep previous non-propagating semantics.
+          // queueGenerateConversationTitle already swallows internal
+          // errors; this catch covers pipeline-layer errors (timeouts,
+          // middleware throws) without surfacing them to the agent loop.
+          rlog.warn({ err }, "titleGenerate pipeline failed (non-fatal)");
         });
       }, 0);
     }
@@ -524,7 +738,10 @@ export async function runAgentLoopImpl(
     let compactedThisTurn = false;
 
     const compactCheck = ctx.contextWindowManager.shouldCompact(ctx.messages);
-    if (compactCheck.needed) {
+    // Skip auto-compaction while the circuit breaker is open. Force paths
+    // and user-initiated /compact bypass this check.
+    const autoCompactAllowed = !(await isCompactionCircuitOpen(ctx));
+    if (compactCheck.needed && autoCompactAllowed) {
       ctx.emitActivityState(
         "thinking",
         "context_compacting",
@@ -532,57 +749,59 @@ export async function runAgentLoopImpl(
         reqId,
       );
     }
-    const compacted = await ctx.contextWindowManager.maybeCompact(
-      ctx.messages,
-      abortController.signal,
-      {
-        lastCompactedAt: ctx.contextCompactedAt ?? undefined,
-        precomputedEstimate: compactCheck.estimatedTokens,
-      },
-    );
-    if (compacted.compacted) {
-      ctx.messages = compacted.messages;
-      ctx.contextCompactedMessageCount += compacted.compactedPersistedMessages;
-      ctx.contextCompactedAt = Date.now();
-      // Notify memory graph that compaction happened — triggers full context
-      // reload on the next turn to replenish lost memory context.
-      ctx.graphMemory.onCompacted(compacted.compactedPersistedMessages);
-      updateConversationContextWindow(
-        ctx.conversationId,
-        compacted.summaryText,
-        ctx.contextCompactedMessageCount,
-      );
-      // Fire auto-analysis on compaction so the reflective agent can
-      // crystallize anything worth remembering before the context window
-      // narrows further.
-      enqueueAutoAnalysisOnCompaction(
-        ctx.conversationId,
-        ctx.trustContext?.trustClass,
-      );
-      onEvent({
-        type: "context_compacted",
-        previousEstimatedInputTokens: compacted.previousEstimatedInputTokens,
-        estimatedInputTokens: compacted.estimatedInputTokens,
-        maxInputTokens: compacted.maxInputTokens,
-        thresholdTokens: compacted.thresholdTokens,
-        compactedMessages: compacted.compactedMessages,
-        summaryCalls: compacted.summaryCalls,
-        summaryInputTokens: compacted.summaryInputTokens,
-        summaryOutputTokens: compacted.summaryOutputTokens,
-        summaryModel: compacted.summaryModel,
-      });
-      emitUsage(
-        ctx,
-        compacted.summaryInputTokens,
-        compacted.summaryOutputTokens,
-        compacted.summaryModel,
-        onEvent,
-        "context_compactor",
-        reqId,
-        compacted.summaryCacheCreationInputTokens ?? 0,
-        compacted.summaryCacheReadInputTokens ?? 0,
-        collapseRawResponses(compacted.summaryRawResponses),
-      );
+    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: ctx.messages,
+            signal: abortController.signal,
+            options: {
+              lastCompactedAt: ctx.contextCompactedAt ?? undefined,
+              precomputedEstimate: compactCheck.estimatedTokens,
+              conversationOriginChannel:
+                getConversationOriginChannel(ctx.conversationId) ?? undefined,
+            },
+          },
+          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 trackCompactionOutcome(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, cooldown active, 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 trackCompactionOutcome(ctx, compacted.summaryFailed, onEvent);
+    }
+    if (compacted?.compacted) {
+      applyCompactionResult(ctx, compacted, onEvent, reqId);
       shouldInjectWorkspace = true;
       if (compacted.compactedPersistedMessages > 0) {
         compactedThisTurn = true;
@@ -630,26 +849,98 @@ export async function runAgentLoopImpl(
 
     let runMessages = ctx.messages;
 
-    // Memory graph retrieval — dispatches to context-load / per-turn based on
-    // conversation state.
+    // Memory retrieval pipeline — fetches PKB, NOW.md, and memory-graph
+    // outputs through a single `memoryRetrieval` pipeline. Plugins may
+    // replace the terminal behavior by registering a middleware that
+    // short-circuits with its own `MemoryResult`; the default terminal
+    // below runs `runDefaultMemoryRetrieval` which reproduces the prior
+    // in-lined behavior (PKB/NOW reads + gated graph call).
     const isTrustedActor = resolveTrustClass(ctx.trustContext) === "guardian";
-    if (isTrustedActor) {
-      const graphResult = await ctx.graphMemory.prepareMemory(
-        ctx.messages,
-        getConfig(),
-        abortController.signal,
-        onEvent,
-      );
+    // Canonical builder — pulls trust from per-turn snapshot, then
+    // conversation-level, then the synthetic fallback. Memory retrieval
+    // does not need the context-window handle the builder attaches, but
+    // keeping every call site on one helper is load-bearing for log
+    // coherence across pipeline slots.
+    const memoryPluginTurnCtx = buildPluginTurnContext(ctx, reqId);
+    const memoryArgs: MemoryArgs = {
+      conversationId: ctx.conversationId,
+      trustContext: ctx.trustContext,
+      turnIndex: ctx.turnCount,
+      // Pass the abort signal via `args` (not `deps`) so the pipeline
+      // runner's `linkAbortSignal` can swap it for a signal linked to the
+      // pipeline's internal controller — on a plugin-set timeout or
+      // external cancel, the linked signal aborts and `prepareMemory`
+      // stops mutating graph state / emitting events after the pipeline
+      // has already errored.
+      signal: abortController.signal,
+    };
+    const memoryDeps: DefaultMemoryRetrievalDeps = {
+      messages: ctx.messages,
+      graphMemory: ctx.graphMemory,
+      config: getConfig(),
+      onEvent,
+      isTrustedActor,
+    };
+    const memoryResult: MemoryResult = await runPipeline(
+      "memoryRetrieval",
+      getMiddlewaresFor("memoryRetrieval"),
+      (args) => runDefaultMemoryRetrieval(args, memoryDeps),
+      memoryArgs,
+      memoryPluginTurnCtx,
+      DEFAULT_TIMEOUTS.memoryRetrieval,
+    );
+
+    // Consume the memory-graph block when the default retriever emitted
+    // one. Custom plugins that substitute their own blocks without the
+    // default discriminator are expected to handle their own side effects
+    // (event emission, metric persistence) inside their middleware; this
+    // block short-circuits to the original no-op behavior in that case.
+    const defaultGraphPayload: GraphMemoryPayload | null =
+      asDefaultGraphPayload(memoryResult.memoryGraphBlocks);
+    let pkbQueryVector: number[] | undefined;
+    let pkbSparseVector:
+      | import("../memory/qdrant-client.js").QdrantSparseVector
+      | undefined;
+    if (defaultGraphPayload) {
+      const graphResult = defaultGraphPayload.result;
       runMessages = graphResult.runMessages;
+      // Select dense+sparse as a matched pair so RRF fusion combines two
+      // signals aligned to the same query text:
+      //   1. Context-load with a user query: user-query dense + user-query
+      //      sparse — the cleanest pairing.
+      //   2. Otherwise (context-load without a user query, or per-turn):
+      //      whatever `queryVector` / `sparseVector` the retriever produced,
+      //      which are themselves co-aligned (both summary-derived in
+      //      context-load, both user-last-message-derived in per-turn).
+      // Never pair a user-query dense with a summary-aligned sparse.
+      if (graphResult.userQueryVector) {
+        pkbQueryVector = graphResult.userQueryVector;
+        pkbSparseVector = graphResult.userQuerySparseVector;
+      } else {
+        pkbQueryVector = graphResult.queryVector;
+        pkbSparseVector = graphResult.sparseVector;
+      }
 
       // Persist the injected block text in message metadata so it survives
       // conversation reloads (eviction, restart, fork). loadFromDb re-injects
-      // from metadata.
+      // from metadata. Routed through the `persistence` pipeline so plugins
+      // can observe or override metadata updates alongside add/delete.
       if (graphResult.injectedBlockText) {
         try {
-          updateMessageMetadata(userMessageId, {
-            memoryInjectedBlock: graphResult.injectedBlockText,
-          });
+          await runPipeline<PersistArgs, PersistResult>(
+            "persistence",
+            getMiddlewaresFor("persistence"),
+            defaultPersistenceTerminal,
+            {
+              op: "update",
+              messageId: userMessageId,
+              updates: {
+                memoryInjectedBlock: graphResult.injectedBlockText,
+              },
+            },
+            buildPluginTurnContext(ctx, reqId),
+            DEFAULT_TIMEOUTS.persistence,
+          );
         } catch (err) {
           rlog.warn(
             { err },
@@ -831,14 +1122,31 @@ export async function runAgentLoopImpl(
     // Inject NOW.md and PKB content only on the first turn (or after
     // compaction re-strips them).  Old injections persist in history and
     // are never stripped on normal turns — this preserves the cached prefix.
-    const currentNowContent = readNowScratchpad();
+    // PKB/NOW content is sourced from the `memoryRetrieval` pipeline above
+    // so plugins can override either source without touching the agent loop.
+    const currentNowContent = memoryResult.nowContent;
     const shouldInjectNowAndPkb = isFirstMessage || compactedThisTurn;
     const nowScratchpad = shouldInjectNowAndPkb ? currentNowContent : null;
 
-    const currentPkbContent = readPkbContext();
+    const currentPkbContent = memoryResult.pkbContent;
     const pkbContext = shouldInjectNowAndPkb ? currentPkbContent : null;
     const pkbActive = currentPkbContent !== null;
 
+    // PKB relevance-hint inputs. Resolved once per turn and reused across
+    // re-injections so post-compaction rebuilds pick up fresh hints against
+    // the updated conversation history.
+    const pkbRoot = pkbActive ? join(getWorkspaceDir(), "pkb") : undefined;
+    const pkbAutoInjectList = pkbRoot
+      ? getPkbAutoInjectList(pkbRoot)
+      : undefined;
+    // Pass `ctx` directly — `PkbContextConversation` is structural and
+    // `getInContextPkbPaths` re-reads `conversation.messages` on each call,
+    // so post-compaction re-injects see the updated history.
+    const pkbConversation = pkbActive ? ctx : undefined;
+    // PKB points live under a single workspace sentinel scope, not the
+    // conversation's memoryPolicy.scopeId. See `PKB_WORKSPACE_SCOPE` for why.
+    const pkbScopeId = pkbActive ? PKB_WORKSPACE_SCOPE : undefined;
+
     // 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
@@ -847,6 +1155,43 @@ export async function runAgentLoopImpl(
           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 isSlackConversation = ctx.channelCapabilities?.channel === "slack";
+    const slackChronologicalMessages = isSlackConversation
+      ? loadSlackChronologicalMessages(
+          ctx.conversationId,
+          ctx.channelCapabilities!,
+          { trustClass: ctx.trustContext?.trustClass },
+        )
+      : 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 },
+        )
+      : null;
+
+    // Guards the chronological-transcript override on re-injection after
+    // the reducer compacts `ctx.messages`. The captured transcript is the
+    // full persisted history; blindly replaying it on every re-inject would
+    // overwrite the reducer's compacted messages and undo compaction. Flip
+    // to `true` after any compaction so subsequent re-injections fall back
+    // to the reduced `ctx.messages`.
+    let reducerCompacted = compactedThisTurn;
+
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
       activeSurface,
@@ -858,27 +1203,97 @@ export async function runAgentLoopImpl(
       unifiedTurnContext: unifiedTurnContextStr,
       pkbContext,
       pkbActive,
+      pkbQueryVector,
+      pkbSparseVector,
+      pkbScopeId,
+      pkbConversation,
+      pkbAutoInjectList,
+      pkbRoot,
+      pkbWorkingDir: pkbActive ? ctx.workingDir : undefined,
       nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
       isNonInteractive: !isInteractiveResolved,
       subagentStatusBlock,
+      slackChronologicalMessages,
+      slackActiveThreadFocusBlock,
     } as const;
 
     let currentInjectionMode: InjectionMode = "full";
 
-    runMessages = applyRuntimeInjections(runMessages, {
+    // 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: 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
+    ) {
+      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;
+        }
+        await runPipeline<PersistArgs, PersistResult>(
+          "persistence",
+          getMiddlewaresFor("persistence"),
+          defaultPersistenceTerminal,
+          {
+            op: "update",
+            messageId: userMessageId,
+            updates: metadataUpdates,
+          },
+          buildPluginTurnContext(ctx, reqId),
+          DEFAULT_TIMEOUTS.persistence,
+        );
+      } 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 config = getConfig();
-    const overflowRecovery = config.contextWindow.overflowRecovery;
-    const providerMaxTokens = config.contextWindow.maxInputTokens;
+    const overflowRecovery = config.llm.default.contextWindow.overflowRecovery;
+    const providerMaxTokens = config.llm.default.contextWindow.maxInputTokens;
     // Widen safety margin for large conversations where estimation error
     // compounds across many messages with tool results.
     const baseSafetyMargin = overflowRecovery.safetyMarginRatio;
@@ -889,11 +1304,51 @@ export async function runAgentLoopImpl(
     let reducerState: ReducerState | undefined;
 
     const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
-    const preflightTokens = estimatePromptTokens(
-      runMessages,
-      ctx.systemPrompt,
-      { providerName: ctx.provider.name, toolTokenBudget },
-    );
+    // Canonical calibration key — passed to the `tokenEstimate` pipeline for
+    // every preflight/mid-loop 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);
+
+    // Shared `TurnContext` for every `tokenEstimate` pipeline invocation in
+    // this turn. The pipeline is the extension point for plugins that want
+    // to substitute an alternate estimator (e.g. provider-native tokenization)
+    // without touching orchestrator code.
+    //
+    // Routed through the canonical builder — `turnIndex` is `ctx.turnCount`,
+    // trust cascades through per-turn/conversation-level/fallback, and the
+    // context-window handle rides along so any middleware that wants to
+    // reuse the manager (e.g. to compute compaction-aware estimates) can.
+    const pipelineTurnCtx = buildPluginTurnContext(ctx, reqId);
+
+    const runTokenEstimatePipeline = (
+      history: Message[],
+    ): Promise<EstimateResult> =>
+      runPipeline<EstimateArgs, EstimateResult>(
+        "tokenEstimate",
+        getMiddlewaresFor("tokenEstimate"),
+        defaultTokenEstimateTerminal,
+        {
+          // Shallow-frozen copies so a misbehaving middleware that mutates
+          // `args.history` or `args.tools` in place (e.g. trims the array
+          // before calling next) can't silently strip prompt context from
+          // the orchestrator's live `runMessages` / resolved-tools arrays.
+          // TypeScript `readonly` on `EstimateArgs` does not prevent
+          // `push`/`splice` at runtime; the frozen wrapper throws in strict
+          // mode and isolates any mutation attempts from the call-site state.
+          history: Object.freeze([...history]) as Message[],
+          systemPrompt: ctx.systemPrompt,
+          tools: Object.freeze([
+            ...ctx.agentLoop.getResolvedTools(history),
+          ]) as ToolDefinition[],
+          providerName: estimationProviderName,
+        },
+        pipelineTurnCtx,
+        DEFAULT_TIMEOUTS.tokenEstimate,
+      );
+
+    const preflightTokens = await runTokenEstimatePipeline(runMessages);
 
     if (overflowRecovery.enabled && preflightTokens > preflightBudget) {
       rlog.warn(
@@ -905,127 +1360,198 @@ export async function runAgentLoopImpl(
         "Preflight budget exceeded — running overflow reducer before provider call",
       );
 
-      reducerState = createInitialReducerState();
-      let preflightAttempts = 0;
-
-      while (
-        preflightAttempts < overflowRecovery.maxAttempts &&
-        !reducerState.exhausted
-      ) {
-        preflightAttempts++;
-        ctx.emitActivityState(
-          "thinking",
-          "context_compacting",
-          "assistant_turn",
-          reqId,
-        );
-        const step = await reduceContextOverflow(
-          ctx.messages,
-          {
-            providerName: ctx.provider.name,
-            systemPrompt: ctx.systemPrompt,
-            contextWindow: config.contextWindow,
-            targetTokens: preflightBudget,
-            toolTokenBudget,
-          },
-          reducerState,
-          (msgs, signal, opts) =>
-            ctx.contextWindowManager.maybeCompact(msgs, signal!, opts),
-          abortController.signal,
-        );
-
-        reducerState = step.state;
-        ctx.messages = step.messages;
-        currentInjectionMode = step.state.injectionMode;
-
-        if (step.compactionResult?.compacted) {
-          ctx.contextCompactedMessageCount +=
-            step.compactionResult.compactedPersistedMessages;
-          ctx.contextCompactedAt = Date.now();
-          updateConversationContextWindow(
-            ctx.conversationId,
-            step.compactionResult.summaryText,
-            ctx.contextCompactedMessageCount,
-          );
-          // Fire auto-analysis on compaction — see forceCompact() for rationale.
-          enqueueAutoAnalysisOnCompaction(
-            ctx.conversationId,
-            ctx.trustContext?.trustClass,
-          );
-          onEvent({
-            type: "context_compacted",
-            previousEstimatedInputTokens:
-              step.compactionResult.previousEstimatedInputTokens,
-            estimatedInputTokens: step.compactionResult.estimatedInputTokens,
-            maxInputTokens: step.compactionResult.maxInputTokens,
-            thresholdTokens: step.compactionResult.thresholdTokens,
-            compactedMessages: step.compactionResult.compactedMessages,
-            summaryCalls: step.compactionResult.summaryCalls,
-            summaryInputTokens: step.compactionResult.summaryInputTokens,
-            summaryOutputTokens: step.compactionResult.summaryOutputTokens,
-            summaryModel: step.compactionResult.summaryModel,
-          });
-          emitUsage(
-            ctx,
-            step.compactionResult.summaryInputTokens,
-            step.compactionResult.summaryOutputTokens,
-            step.compactionResult.summaryModel,
-            onEvent,
-            "context_compactor",
+      // 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 overflowArgs: OverflowReduceArgs = {
+        messages: ctx.messages,
+        runMessages,
+        systemPrompt: ctx.systemPrompt,
+        providerName: estimationProviderName,
+        contextWindow: config.llm.default.contextWindow,
+        preflightBudget,
+        toolTokenBudget,
+        maxAttempts: 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.
+          (await runPipeline<CompactionArgs, CompactionResult>(
+            "compaction",
+            getMiddlewaresFor("compaction"),
+            (args) =>
+              defaultCompactionTerminal(
+                args,
+                buildPluginTurnContext(ctx, reqId),
+              ),
+            {
+              messages: msgs,
+              signal,
+              options: opts,
+            },
+            buildPluginTurnContext(ctx, reqId),
+            DEFAULT_TIMEOUTS.compaction,
+          )) as Awaited<
+            ReturnType<typeof ctx.contextWindowManager.maybeCompact>
+          >,
+        emitActivityState: () => {
+          ctx.emitActivityState(
+            "thinking",
+            "context_compacting",
+            "assistant_turn",
             reqId,
-            step.compactionResult.summaryCacheCreationInputTokens ?? 0,
-            step.compactionResult.summaryCacheReadInputTokens ?? 0,
-            collapseRawResponses(step.compactionResult.summaryRawResponses),
-          );
-          ctx.graphMemory.onCompacted(
-            step.compactionResult.compactedPersistedMessages,
           );
-          shouldInjectWorkspace = true;
-        }
-
-        // Re-inject with potentially downgraded injection mode.
-        // When compaction ran it strips existing NOW.md / PKB blocks, so we
-        // must re-inject the current content. Otherwise rely on the deduplicated
-        // value from injectionOpts to avoid duplicate injection.
-        runMessages = applyRuntimeInjections(ctx.messages, {
-          ...injectionOpts,
-          ...(step.compactionResult?.compacted && {
-            pkbContext: currentPkbContent,
-          }),
-          ...(step.compactionResult?.compacted && {
-            nowScratchpad: currentNowContent,
+        },
+        onCompactionResult: async (result) => {
+          // 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 trackCompactionOutcome(ctx, result.summaryFailed, onEvent);
+          }
+          if (result.compacted) {
+            applyCompactionResult(ctx, result, onEvent, reqId);
+            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 existing NOW.md /
+          // PKB blocks — so we re-inject current content. A later iteration
+          // that only truncates or downgrades must NOT re-force PKB/NOW,
+          // or each round would grow the token count. Matches the
+          // pre-PR-23 per-iteration `step.compactionResult?.compacted` gate.
+          const injection = await applyRuntimeInjections(reducedMessages, {
+            ...injectionOpts,
+            ...(stepCompacted && { pkbContext: currentPkbContent }),
+            ...(stepCompacted && { nowScratchpad: currentNowContent }),
+            workspaceTopLevelContext: shouldInjectWorkspace
+              ? ctx.workspaceTopLevelContext
+              : null,
+            // 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,
           }),
-          workspaceTopLevelContext: shouldInjectWorkspace
-            ? ctx.workspaceTopLevelContext
-            : null,
-          mode: currentInjectionMode,
-        });
-        if (isTrustedActor && currentInjectionMode !== "minimal") {
-          const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-          runMessages = memResult.runMessages;
-        }
+      };
 
-        // Re-estimate with injections included — step.estimatedTokens was
-        // computed on bare history (ctx.messages) and doesn't account for
-        // tokens added by runtime injections.
-        const postInjectionTokens = estimatePromptTokens(
-          runMessages,
-          ctx.systemPrompt,
-          { providerName: ctx.provider.name, 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,
+      );
 
-        if (postInjectionTokens <= preflightBudget) break;
+      ctx.messages = overflowResult.messages;
+      runMessages = overflowResult.runMessages;
+      currentInjectionMode = overflowResult.injectionMode;
+      reducerState = overflowResult.reducerState;
+      if (overflowResult.reducerCompacted) {
+        reducerCompacted = true;
       }
     }
 
-    // Pre-run repair
+    // 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;
-    const preRunRepair = repairHistory(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.stats.assistantToolResultsMigrated > 0 ||
-      preRunRepair.stats.missingToolResultsInserted > 0 ||
-      preRunRepair.stats.orphanToolResultsDowngraded > 0 ||
-      preRunRepair.stats.consecutiveSameRoleMerged > 0
+      preRunRepair !== null &&
+      (preRunRepair.stats.assistantToolResultsMigrated > 0 ||
+        preRunRepair.stats.missingToolResultsInserted > 0 ||
+        preRunRepair.stats.orphanToolResultsDowngraded > 0 ||
+        preRunRepair.stats.consecutiveSameRoleMerged > 0)
     ) {
       rlog.warn(
         { phase: "pre_run", ...preRunRepair.stats },
@@ -1034,6 +1560,20 @@ export async function runAgentLoopImpl(
       runMessages = preRunRepair.messages;
     }
 
+    // Replace historical web_search_tool_result blocks with text summaries.
+    // The opaque `encrypted_content` tokens Anthropic attaches to each result
+    // expire / are route-scoped; replaying a stale token is rejected with
+    // `Invalid encrypted_content in search_result block`. Titles + URLs
+    // preserve enough context for the model on follow-up turns.
+    const webSearchStrip = stripHistoricalWebSearchResults(runMessages);
+    if (webSearchStrip.stats.blocksStripped > 0) {
+      rlog.info(
+        { phase: "pre_run", ...webSearchStrip.stats },
+        "Converted historical web_search_tool_result blocks to text summaries",
+      );
+      runMessages = webSearchStrip.messages;
+    }
+
     let preRunHistoryLength = runMessages.length;
 
     const shouldGenerateTitle = isReplaceableTitle(
@@ -1055,18 +1595,14 @@ export async function runAgentLoopImpl(
 
     let yieldedForBudget = false;
 
-    const onCheckpoint = (checkpoint: CheckpointInfo): CheckpointDecision => {
-      const turnTools = state.currentTurnToolNames;
+    const onCheckpoint = async (
+      checkpoint: CheckpointInfo,
+    ): Promise<CheckpointDecision> => {
       state.currentTurnToolNames = [];
 
       if (ctx.canHandoffAtCheckpoint()) {
-        const inBrowserFlow =
-          turnTools.length > 0 &&
-          turnTools.every((n) => n.startsWith("browser_"));
-        if (!inBrowserFlow) {
-          yieldedForHandoff = true;
-          return "yield";
-        }
+        yieldedForHandoff = true;
+        return "yield";
       }
 
       // Mid-loop token budget check: estimate current context size and
@@ -1074,11 +1610,7 @@ export async function runAgentLoopImpl(
       // conversation-agent-loop run compaction before the provider rejects.
       if (overflowRecovery.enabled) {
         const midLoopThreshold = preflightBudget * 0.85;
-        const estimated = estimatePromptTokens(
-          checkpoint.history,
-          ctx.systemPrompt,
-          { providerName: ctx.provider.name, toolTokenBudget },
-        );
+        const estimated = await runTokenEstimatePipeline(checkpoint.history);
         if (estimated > midLoopThreshold) {
           rlog.warn(
             { phase: "mid-loop", estimated, threshold: midLoopThreshold },
@@ -1094,7 +1626,15 @@ export async function runAgentLoopImpl(
 
     turnStarted = true;
 
-    let denyCompressionMessage: Message | null = null;
+    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 (llmCall, emptyResponse,
+    // toolError, toolResultTruncate, toolExecute) 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);
 
     let updatedHistory = await ctx.agentLoop.run(
       runMessages,
@@ -1102,6 +1642,13 @@ export async function runAgentLoopImpl(
       abortController.signal,
       reqId,
       onCheckpoint,
+      turnCallSite,
+      loopTurnCtx,
+    );
+
+    rlog.info(
+      { resultMessageCount: updatedHistory.length },
+      "Agent loop run completed",
     );
 
     // ── Proactive mid-loop compaction ───────────────────────────────
@@ -1129,6 +1676,14 @@ export async function runAgentLoopImpl(
       // so we compact the "raw" persistent messages.
       const rawHistory = stripInjectionsForCompaction(updatedHistory);
       ctx.messages = rawHistory;
+      try {
+        clearStrippedInjectionMetadataForConversation(ctx.conversationId);
+      } catch (err) {
+        rlog.warn(
+          { err },
+          "Failed to clear stripped-injection metadata after compaction strip (non-fatal)",
+        );
+      }
 
       ctx.emitActivityState(
         "thinking",
@@ -1137,56 +1692,61 @@ export async function runAgentLoopImpl(
         reqId,
         "Compacting context",
       );
-      const midLoopCompact = await ctx.contextWindowManager.maybeCompact(
-        ctx.messages,
-        abortController.signal,
-        {
-          lastCompactedAt: ctx.contextCompactedAt ?? undefined,
-          force: true,
-          targetInputTokensOverride: preflightBudget,
-        },
-      );
-      if (midLoopCompact.compacted) {
-        ctx.messages = midLoopCompact.messages;
-        ctx.contextCompactedMessageCount +=
-          midLoopCompact.compactedPersistedMessages;
-        ctx.contextCompactedAt = Date.now();
-        updateConversationContextWindow(
-          ctx.conversationId,
-          midLoopCompact.summaryText,
-          ctx.contextCompactedMessageCount,
-        );
-        // Fire auto-analysis on compaction — see forceCompact() for rationale.
-        enqueueAutoAnalysisOnCompaction(
-          ctx.conversationId,
-          ctx.trustContext?.trustClass,
-        );
-        onEvent({
-          type: "context_compacted",
-          previousEstimatedInputTokens:
-            midLoopCompact.previousEstimatedInputTokens,
-          estimatedInputTokens: midLoopCompact.estimatedInputTokens,
-          maxInputTokens: midLoopCompact.maxInputTokens,
-          thresholdTokens: midLoopCompact.thresholdTokens,
-          compactedMessages: midLoopCompact.compactedMessages,
-          summaryCalls: midLoopCompact.summaryCalls,
-          summaryInputTokens: midLoopCompact.summaryInputTokens,
-          summaryOutputTokens: midLoopCompact.summaryOutputTokens,
-          summaryModel: midLoopCompact.summaryModel,
-        });
-        emitUsage(
+      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: preflightBudget,
+              conversationOriginChannel:
+                getConversationOriginChannel(ctx.conversationId) ?? undefined,
+            },
+          },
+          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.summaryInputTokens,
-          midLoopCompact.summaryOutputTokens,
-          midLoopCompact.summaryModel,
+          midLoopCompact.summaryFailed,
           onEvent,
-          "context_compactor",
-          reqId,
-          midLoopCompact.summaryCacheCreationInputTokens ?? 0,
-          midLoopCompact.summaryCacheReadInputTokens ?? 0,
-          collapseRawResponses(midLoopCompact.summaryRawResponses),
         );
-        ctx.graphMemory.onCompacted(midLoopCompact.compactedPersistedMessages);
+      }
+      if (midLoopCompact.compacted) {
+        applyCompactionResult(ctx, midLoopCompact, onEvent, reqId);
+        reducerCompacted = true;
         shouldInjectWorkspace = true;
       }
 
@@ -1194,18 +1754,34 @@ export async function runAgentLoopImpl(
       // 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.
-      runMessages = applyRuntimeInjections(ctx.messages, {
+      const injection = await applyRuntimeInjections(ctx.messages, {
         ...injectionOpts,
         pkbContext: currentPkbContent,
         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;
 
@@ -1215,6 +1791,8 @@ export async function runAgentLoopImpl(
         abortController.signal,
         reqId,
         onCheckpoint,
+        turnCallSite,
+        loopTurnCtx,
       );
     }
 
@@ -1244,9 +1822,20 @@ 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.
       const retryRepair = deepRepairHistory(runMessages);
       runMessages = retryRepair.messages;
-      preRepairMessages = retryRepair.messages;
+      const retryStrip = stripHistoricalWebSearchResults(runMessages);
+      runMessages = retryStrip.messages;
+      preRepairMessages = runMessages;
       preRunHistoryLength = runMessages.length;
       state.orderingErrorDetected = false;
       state.deferredOrderingError = null;
@@ -1257,6 +1846,8 @@ export async function runAgentLoopImpl(
         abortController.signal,
         reqId,
         onCheckpoint,
+        turnCallSite,
+        loopTurnCtx,
       );
 
       if (state.orderingErrorDetected) {
@@ -1270,8 +1861,7 @@ export async function runAgentLoopImpl(
     // ── Bounded context overflow convergence loop ──────────────────
     // When the provider rejects with context-too-large, iterate through
     // reducer tiers (forced compaction, tool-result truncation, media
-    // stubbing, injection downgrade) with optional approval gating for
-    // interactive latest-turn compression.
+    // stubbing, injection downgrade).
     //
     // When progress was made (agent added messages before hitting the
     // limit), incorporate those new messages into ctx.messages so the
@@ -1286,6 +1876,14 @@ export async function runAgentLoopImpl(
 
       if (updatedHistory.length > preRunHistoryLength) {
         ctx.messages = stripInjectionsForCompaction(updatedHistory);
+        try {
+          clearStrippedInjectionMetadataForConversation(ctx.conversationId);
+        } catch (err) {
+          rlog.warn(
+            { err },
+            "Failed to clear stripped-injection metadata after compaction strip (non-fatal)",
+          );
+        }
         convergenceStripped = true;
         preRepairMessages = updatedHistory;
         preRunHistoryLength = updatedHistory.length;
@@ -1298,14 +1896,19 @@ export async function runAgentLoopImpl(
       // message (e.g. "242201 tokens > 200000"), use it to correct the
       // compaction target. The estimator may significantly underestimate
       // (e.g. estimated 185k but actual was 242k), so using the
-      // uncorrected preflightBudget would still be too high.
+      // uncorrected preflightBudget would still be too high. Passes the raw
+      // error so ContextOverflowError.actualTokens can short-circuit the
+      // string-regex path for proxy-rewrapped untyped errors.
       const actualTokens = parseActualTokensFromError(
-        state.contextTooLargeErrorMessage,
+        state.contextTooLargeError,
       );
       const estimatedTokensAtOverflow = estimatePromptTokens(
         ctx.messages,
         ctx.systemPrompt,
-        { providerName: ctx.provider.name, toolTokenBudget },
+        {
+          providerName: estimationProviderName,
+          toolTokenBudget,
+        },
       );
       let correctedTarget = preflightBudget;
       if (actualTokens && estimatedTokensAtOverflow > 0) {
@@ -1353,9 +1956,9 @@ export async function runAgentLoopImpl(
         const step = await reduceContextOverflow(
           ctx.messages,
           {
-            providerName: ctx.provider.name,
+            providerName: estimationProviderName,
             systemPrompt: ctx.systemPrompt,
-            contextWindow: config.contextWindow,
+            contextWindow: config.llm.default.contextWindow,
             targetTokens: correctedTarget,
             toolTokenBudget,
           },
@@ -1369,66 +1972,55 @@ export async function runAgentLoopImpl(
         ctx.messages = step.messages;
         currentInjectionMode = step.state.injectionMode;
 
-        if (step.compactionResult?.compacted) {
-          ctx.contextCompactedMessageCount +=
-            step.compactionResult.compactedPersistedMessages;
-          ctx.contextCompactedAt = Date.now();
-          updateConversationContextWindow(
-            ctx.conversationId,
-            step.compactionResult.summaryText,
-            ctx.contextCompactedMessageCount,
-          );
-          // Fire auto-analysis on compaction — see forceCompact() for rationale.
-          enqueueAutoAnalysisOnCompaction(
-            ctx.conversationId,
-            ctx.trustContext?.trustClass,
-          );
-          onEvent({
-            type: "context_compacted",
-            previousEstimatedInputTokens:
-              step.compactionResult.previousEstimatedInputTokens,
-            estimatedInputTokens: step.compactionResult.estimatedInputTokens,
-            maxInputTokens: step.compactionResult.maxInputTokens,
-            thresholdTokens: step.compactionResult.thresholdTokens,
-            compactedMessages: step.compactionResult.compactedMessages,
-            summaryCalls: step.compactionResult.summaryCalls,
-            summaryInputTokens: step.compactionResult.summaryInputTokens,
-            summaryOutputTokens: step.compactionResult.summaryOutputTokens,
-            summaryModel: step.compactionResult.summaryModel,
-          });
-          emitUsage(
+        // See the preflight reducer call above for rationale. Only track when
+        // the summary LLM actually ran — `summaryFailed === undefined`
+        // indicates the reducer's forced compaction took an early-return path
+        // without calling the summary LLM.
+        if (
+          step.compactionResult &&
+          step.compactionResult.summaryFailed !== undefined
+        ) {
+          await trackCompactionOutcome(
             ctx,
-            step.compactionResult.summaryInputTokens,
-            step.compactionResult.summaryOutputTokens,
-            step.compactionResult.summaryModel,
+            step.compactionResult.summaryFailed,
             onEvent,
-            "context_compactor",
-            reqId,
-            step.compactionResult.summaryCacheCreationInputTokens ?? 0,
-            step.compactionResult.summaryCacheReadInputTokens ?? 0,
-            collapseRawResponses(step.compactionResult.summaryRawResponses),
-          );
-          ctx.graphMemory.onCompacted(
-            step.compactionResult.compactedPersistedMessages,
           );
+        }
+
+        if (step.compactionResult?.compacted) {
+          applyCompactionResult(ctx, step.compactionResult, onEvent, reqId);
           shouldInjectWorkspace = true;
+          reducerCompacted = true;
         }
 
         // Only re-inject NOW.md when ctx.messages was actually stripped;
         // otherwise the existing NOW.md block is still present and
         // re-injecting would duplicate it.
-        runMessages = applyRuntimeInjections(ctx.messages, {
+        const injection = await applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
           pkbContext: currentPkbContent,
           nowScratchpad: convergenceStripped ? currentNowContent : null,
           workspaceTopLevelContext: shouldInjectWorkspace
             ? ctx.workspaceTopLevelContext
             : null,
+          slackChronologicalMessages: reducerCompacted
+            ? null
+            : injectionOpts.slackChronologicalMessages,
           mode: currentInjectionMode,
+          turnContext: buildPluginTurnContext(ctx, reqId),
         });
+        runMessages = injection.messages;
         if (isTrustedActor && currentInjectionMode !== "minimal") {
           ctx.graphMemory.retrackCachedNodes();
         }
+        const convergenceStrip = stripHistoricalWebSearchResults(runMessages);
+        if (convergenceStrip.stats.blocksStripped > 0) {
+          rlog.info(
+            { phase: "convergence", ...convergenceStrip.stats },
+            "Converted historical web_search_tool_result blocks to text summaries",
+          );
+          runMessages = convergenceStrip.messages;
+        }
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
         state.contextTooLargeDetected = false;
@@ -1440,6 +2032,8 @@ export async function runAgentLoopImpl(
           abortController.signal,
           reqId,
           onCheckpoint,
+          turnCallSite,
+          loopTurnCtx,
         );
 
         // If the rerun still yields at checkpoint, the turn is still
@@ -1461,6 +2055,14 @@ export async function runAgentLoopImpl(
           // pre-rerun messages.
           if (updatedHistory.length > preRunHistoryLength) {
             ctx.messages = stripInjectionsForCompaction(updatedHistory);
+            try {
+              clearStrippedInjectionMetadataForConversation(ctx.conversationId);
+            } catch (err) {
+              rlog.warn(
+                { err },
+                "Failed to clear stripped-injection metadata after compaction strip (non-fatal)",
+              );
+            }
             convergenceStripped = true;
             preRepairMessages = updatedHistory;
             preRunHistoryLength = updatedHistory.length;
@@ -1470,215 +2072,113 @@ export async function runAgentLoopImpl(
 
       // All reducer tiers exhausted but provider still rejects —
       // consult the overflow policy for latest-turn compression.
-      // Emergency compaction is deferred to the policy-gated paths below
-      // so that `request_user_approval` sessions collect consent first.
+      // The policy either auto-compresses the latest turn or falls
+      // through to the final graceful-error fallback below.
       if (state.contextTooLargeDetected) {
         const action = resolveOverflowAction({
           overflowRecovery,
           isInteractive: isInteractiveResolved,
         });
 
-        if (action === "request_user_approval") {
-          const approval = await requestCompressionApproval(ctx.prompter, {
-            signal: abortController.signal,
-          });
-
-          if (approval.approved) {
-            // User approved — force emergency compaction with aggressive settings
-            const emergencyCompact =
-              await ctx.contextWindowManager.maybeCompact(
-                ctx.messages,
-                abortController.signal,
-                {
+        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,
+          );
+          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: {
                   lastCompactedAt: ctx.contextCompactedAt ?? undefined,
                   force: true,
                   minKeepRecentUserTurns: 0,
                   targetInputTokensOverride: correctedTarget,
                 },
+              },
+              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",
               );
-            if (emergencyCompact.compacted) {
-              ctx.messages = emergencyCompact.messages;
-              ctx.contextCompactedMessageCount +=
-                emergencyCompact.compactedPersistedMessages;
-              ctx.contextCompactedAt = Date.now();
-              updateConversationContextWindow(
-                ctx.conversationId,
-                emergencyCompact.summaryText,
-                ctx.contextCompactedMessageCount,
-              );
-              // Fire auto-analysis on compaction — see forceCompact() for rationale.
-              enqueueAutoAnalysisOnCompaction(
-                ctx.conversationId,
-                ctx.trustContext?.trustClass,
-              );
-              onEvent({
-                type: "context_compacted",
-                previousEstimatedInputTokens:
-                  emergencyCompact.previousEstimatedInputTokens,
-                estimatedInputTokens: emergencyCompact.estimatedInputTokens,
-                maxInputTokens: emergencyCompact.maxInputTokens,
-                thresholdTokens: emergencyCompact.thresholdTokens,
-                compactedMessages: emergencyCompact.compactedMessages,
-                summaryCalls: emergencyCompact.summaryCalls,
-                summaryInputTokens: emergencyCompact.summaryInputTokens,
-                summaryOutputTokens: emergencyCompact.summaryOutputTokens,
-                summaryModel: emergencyCompact.summaryModel,
-              });
-              emitUsage(
-                ctx,
-                emergencyCompact.summaryInputTokens,
-                emergencyCompact.summaryOutputTokens,
-                emergencyCompact.summaryModel,
-                onEvent,
-                "context_compactor",
-                reqId,
-                emergencyCompact.summaryCacheCreationInputTokens ?? 0,
-                emergencyCompact.summaryCacheReadInputTokens ?? 0,
-                collapseRawResponses(emergencyCompact.summaryRawResponses),
-              );
-              ctx.graphMemory.onCompacted(
-                emergencyCompact.compactedPersistedMessages,
-              );
-              shouldInjectWorkspace = true;
+              await trackCompactionOutcome(ctx, true, onEvent);
+              emergencyCompact = null;
+            } else {
+              throw err;
             }
-
-            // Only re-inject NOW.md when ctx.messages was actually stripped;
-            // otherwise the existing block is still present.
-            runMessages = applyRuntimeInjections(ctx.messages, {
-              ...injectionOpts,
-              pkbContext: currentPkbContent,
-              nowScratchpad: convergenceStripped ? currentNowContent : null,
-              workspaceTopLevelContext: shouldInjectWorkspace
-                ? ctx.workspaceTopLevelContext
-                : null,
-              mode: currentInjectionMode,
-            });
-            if (isTrustedActor && currentInjectionMode !== "minimal") {
-              ctx.graphMemory.retrackCachedNodes();
-            }
-            preRepairMessages = runMessages;
-            preRunHistoryLength = runMessages.length;
-            state.contextTooLargeDetected = false;
-
-            updatedHistory = await ctx.agentLoop.run(
-              runMessages,
-              eventHandler,
-              abortController.signal,
-              reqId,
-              onCheckpoint,
-            );
-          } else {
-            // User denied compression — emit a graceful assistant explanation
-            // instead of a conversation_error, and end the turn cleanly.
-            state.contextTooLargeDetected = false;
-            const denyText =
-              "The conversation has grown too long for the model to process, " +
-              "and compression was declined. Please start a new conversation " +
-              "or manually shorten the conversation to continue.";
-            const loopChannelMeta = {
-              ...provenanceFromTrustContext(ctx.trustContext),
-              userMessageChannel: capturedTurnChannelContext.userMessageChannel,
-              assistantMessageChannel:
-                capturedTurnChannelContext.assistantMessageChannel,
-              userMessageInterface:
-                capturedTurnInterfaceContext.userMessageInterface,
-              assistantMessageInterface:
-                capturedTurnInterfaceContext.assistantMessageInterface,
-            };
-            const denyMessage = createAssistantMessage(denyText);
-            await addMessage(
-              ctx.conversationId,
-              "assistant",
-              JSON.stringify(denyMessage.content),
-              loopChannelMeta,
-            );
-            denyCompressionMessage = denyMessage;
-            onEvent({
-              type: "assistant_text_delta",
-              text: denyText,
-              conversationId: ctx.conversationId,
-            });
-            // Prevent the final error fallback from firing
-            state.providerErrorUserMessage = null;
           }
-        } else if (action === "auto_compress_latest_turn") {
-          // Non-interactive — auto-compress without asking
-          ctx.emitActivityState(
-            "thinking",
-            "context_compacting",
-            "assistant_turn",
-            reqId,
-          );
-          const emergencyCompact = await ctx.contextWindowManager.maybeCompact(
-            ctx.messages,
-            abortController.signal,
-            {
-              lastCompactedAt: ctx.contextCompactedAt ?? undefined,
-              force: true,
-              minKeepRecentUserTurns: 0,
-              targetInputTokensOverride: correctedTarget,
-            },
-          );
-          if (emergencyCompact.compacted) {
-            ctx.messages = emergencyCompact.messages;
-            ctx.contextCompactedMessageCount +=
-              emergencyCompact.compactedPersistedMessages;
-            ctx.contextCompactedAt = Date.now();
-            updateConversationContextWindow(
-              ctx.conversationId,
-              emergencyCompact.summaryText,
-              ctx.contextCompactedMessageCount,
-            );
-            // Fire auto-analysis on compaction — see forceCompact() for rationale.
-            enqueueAutoAnalysisOnCompaction(
-              ctx.conversationId,
-              ctx.trustContext?.trustClass,
-            );
-            onEvent({
-              type: "context_compacted",
-              previousEstimatedInputTokens:
-                emergencyCompact.previousEstimatedInputTokens,
-              estimatedInputTokens: emergencyCompact.estimatedInputTokens,
-              maxInputTokens: emergencyCompact.maxInputTokens,
-              thresholdTokens: emergencyCompact.thresholdTokens,
-              compactedMessages: emergencyCompact.compactedMessages,
-              summaryCalls: emergencyCompact.summaryCalls,
-              summaryInputTokens: emergencyCompact.summaryInputTokens,
-              summaryOutputTokens: emergencyCompact.summaryOutputTokens,
-              summaryModel: emergencyCompact.summaryModel,
-            });
-            emitUsage(
+          // Only track when the summary LLM actually ran; `force: true`
+          // bypasses the cooldown but not the early-return paths.
+          if (
+            emergencyCompact &&
+            emergencyCompact.summaryFailed !== undefined
+          ) {
+            await trackCompactionOutcome(
               ctx,
-              emergencyCompact.summaryInputTokens,
-              emergencyCompact.summaryOutputTokens,
-              emergencyCompact.summaryModel,
+              emergencyCompact.summaryFailed,
               onEvent,
-              "context_compactor",
-              reqId,
-              emergencyCompact.summaryCacheCreationInputTokens ?? 0,
-              emergencyCompact.summaryCacheReadInputTokens ?? 0,
-              collapseRawResponses(emergencyCompact.summaryRawResponses),
-            );
-            ctx.graphMemory.onCompacted(
-              emergencyCompact.compactedPersistedMessages,
             );
+          }
+          if (emergencyCompact?.compacted) {
+            applyCompactionResult(ctx, emergencyCompact, onEvent, reqId);
+            reducerCompacted = true;
             shouldInjectWorkspace = true;
           }
 
           // Only re-inject NOW.md when ctx.messages was actually stripped;
           // otherwise the existing block is still present.
-          runMessages = applyRuntimeInjections(ctx.messages, {
+          const injection = await applyRuntimeInjections(ctx.messages, {
             ...injectionOpts,
             pkbContext: currentPkbContent,
             nowScratchpad: convergenceStripped ? currentNowContent : null,
             workspaceTopLevelContext: shouldInjectWorkspace
               ? ctx.workspaceTopLevelContext
               : null,
+            slackChronologicalMessages: reducerCompacted
+              ? null
+              : injectionOpts.slackChronologicalMessages,
             mode: currentInjectionMode,
+            turnContext: buildPluginTurnContext(ctx, reqId),
           });
+          runMessages = injection.messages;
           if (isTrustedActor && currentInjectionMode !== "minimal") {
             ctx.graphMemory.retrackCachedNodes();
           }
+          const fallbackStrip = stripHistoricalWebSearchResults(runMessages);
+          if (fallbackStrip.stats.blocksStripped > 0) {
+            rlog.info(
+              { phase: "fail_gracefully_compact", ...fallbackStrip.stats },
+              "Converted historical web_search_tool_result blocks to text summaries",
+            );
+            runMessages = fallbackStrip.messages;
+          }
           preRepairMessages = runMessages;
           preRunHistoryLength = runMessages.length;
           state.contextTooLargeDetected = false;
@@ -1689,6 +2189,8 @@ export async function runAgentLoopImpl(
             abortController.signal,
             reqId,
             onCheckpoint,
+            turnCallSite,
+            loopTurnCtx,
           );
         }
         // action === "fail_gracefully" falls through to the final error below
@@ -1753,11 +2255,19 @@ export async function runAgentLoopImpl(
         assistantMessageInterface:
           capturedTurnInterfaceContext.assistantMessageInterface,
       };
-      await addMessage(
-        ctx.conversationId,
-        "user",
-        JSON.stringify(toolResultBlocks),
-        toolResultMetadata,
+      await runPipeline<PersistArgs, PersistResult>(
+        "persistence",
+        getMiddlewaresFor("persistence"),
+        defaultPersistenceTerminal,
+        {
+          op: "add",
+          conversationId: ctx.conversationId,
+          role: "user",
+          content: JSON.stringify(toolResultBlocks),
+          metadata: toolResultMetadata,
+        },
+        buildPluginTurnContext(ctx, reqId),
+        DEFAULT_TIMEOUTS.persistence,
       );
       state.pendingToolResults.clear();
     }
@@ -1770,10 +2280,6 @@ export async function runAgentLoopImpl(
       return { ...msg, content: cleanedBlocks };
     });
 
-    if (denyCompressionMessage) {
-      newMessages.push(denyCompressionMessage);
-    }
-
     const hasAssistantResponse = newMessages.some(
       (msg) => msg.role === "assistant",
     );
@@ -1795,11 +2301,19 @@ export async function runAgentLoopImpl(
       const errorAssistantMessage = createAssistantMessage(
         state.providerErrorUserMessage,
       );
-      await addMessage(
-        ctx.conversationId,
-        "assistant",
-        JSON.stringify(errorAssistantMessage.content),
-        errChannelMeta,
+      await runPipeline<PersistArgs, PersistResult>(
+        "persistence",
+        getMiddlewaresFor("persistence"),
+        defaultPersistenceTerminal,
+        {
+          op: "add",
+          conversationId: ctx.conversationId,
+          role: "assistant",
+          content: JSON.stringify(errorAssistantMessage.content),
+          metadata: errChannelMeta,
+        },
+        buildPluginTurnContext(ctx, reqId),
+        DEFAULT_TIMEOUTS.persistence,
       );
       newMessages.push(errorAssistantMessage);
       // Do NOT send assistant_text_delta here — handleProviderError already
@@ -1863,14 +2377,10 @@ export async function runAgentLoopImpl(
       state.exchangeLlmCallCount,
       {
         tokens: state.lastCallInputTokens,
-        maxTokens: config.contextWindow.maxInputTokens,
+        maxTokens: config.llm.default.contextWindow.maxInputTokens,
       },
     );
 
-    void getHookManager().trigger("post-message", {
-      conversationId: ctx.conversationId,
-    });
-
     const syncLastAssistantMessageToDisk = (): void => {
       if (!state.lastAssistantMessageId) return;
       const convForDisk = getConversation(ctx.conversationId);
@@ -1987,13 +2497,65 @@ export async function runAgentLoopImpl(
             ? { messageId: state.lastAssistantMessageId }
             : {}),
         });
+
+        // Emit a home-feed event for background/scheduled conversation completions.
+        // Scoped to message_complete only (not cancelled/handoff), wrapped in
+        // try-catch so malformed message content can never propagate errors.
+        try {
+          const conv = getConversation(ctx.conversationId);
+          if (
+            conv &&
+            (conv.conversationType === "background" ||
+              conv.conversationType === "scheduled")
+          ) {
+            const lastMsg = state.lastAssistantMessageId
+              ? getMessageById(state.lastAssistantMessageId, ctx.conversationId)
+              : undefined;
+            let summary: string;
+            if (lastMsg) {
+              const parsed: unknown = JSON.parse(lastMsg.content);
+              if (typeof parsed === "string") {
+                summary = parsed.slice(0, 200);
+              } else if (Array.isArray(parsed)) {
+                const textBlock = parsed.find(
+                  (b: { type?: string }) => b.type === "text",
+                );
+                summary =
+                  typeof textBlock?.text === "string"
+                    ? textBlock.text.slice(0, 200)
+                    : (conv.title ?? "Background task completed.");
+              } else {
+                summary = conv.title ?? "Background task completed.";
+              }
+            } else {
+              summary = conv.title ?? "Background task completed.";
+            }
+            void emitFeedEvent({
+              source: "assistant",
+              title: conv.title ?? "Background Task",
+              summary,
+              dedupKey: `bg-conv:${ctx.conversationId}`,
+            }).catch((err) => {
+              log.warn(
+                { err, conversationId: ctx.conversationId },
+                "Failed to emit background conversation feed event",
+              );
+            });
+          }
+        } catch (feedErr) {
+          log.warn(
+            { err: feedErr, conversationId: ctx.conversationId },
+            "Failed to build home-feed event for background conversation",
+          );
+        }
       }
     }
 
     // Second title pass: after 3 completed turns, re-generate the title
     // using the last 3 messages for better context. Only fires when the
-    // current title was auto-generated (isAutoTitle = 1).
-    if (ctx.turnCount === 2) {
+    // current title was auto-generated (isAutoTitle = 1) and the user
+    // has not opted out via `conversations.skipAutoRetitling`.
+    if (ctx.turnCount === 2 && !getConfig().conversations.skipAutoRetitling) {
       // turnCount is 0-indexed, incremented in finally; 2 = about to become 3rd turn
       queueRegenerateConversationTitle({
         conversationId: ctx.conversationId,
@@ -2046,12 +2608,6 @@ export async function runAgentLoopImpl(
       });
       onEvent({ type: "error", message: classified.userMessage });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
-      void getHookManager().trigger("on-error", {
-        error: err instanceof Error ? err.name : "Error",
-        message,
-        stack: err instanceof Error ? err.stack : undefined,
-        conversationId: ctx.conversationId,
-      });
     }
   } finally {
     if (turnStarted) {
@@ -2095,6 +2651,7 @@ export async function runAgentLoopImpl(
     ctx.processing = false;
     ctx.onConfirmationOutcome = undefined;
     ctx.surfaceActionRequestIds.delete(ctx.currentRequestId ?? "");
+    ctx.approvedViaPromptThisTurn = false;
     ctx.currentRequestId = undefined;
     ctx.currentActiveSurfaceId = undefined;
     ctx.allowedToolNames = undefined;
@@ -2160,7 +2717,133 @@ function emitUsage(
   );
 }
 
-function collapseRawResponses(rawResponses?: unknown[]): unknown | undefined {
+/**
+ * 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.
+ */
+export interface CompactionApplyContext {
+  readonly conversationId: string;
+  messages: Message[];
+  contextCompactedMessageCount: number;
+  contextCompactedAt: number | null;
+  readonly graphMemory: ConversationGraphMemory;
+  readonly provider: Provider;
+  usageStats: UsageStats;
+  trustContext?: TrustContext;
+}
+
+/**
+ * Applies a successful `ContextWindowResult` to a conversation: updates the
+ * in-memory message buffer and compaction counters, notifies the graph memory
+ * and conversation-summary store, enqueues auto-analysis, emits the
+ * `context_compacted` event, and records a `context_compactor` usage event.
+ *
+ * The emitted `usage_update` intentionally omits `contextWindow` — the
+ * `context_compacted` event already carries the fresh
+ * `estimatedInputTokens` / `maxInputTokens` and is the single source of
+ * truth for the UI indicator after compaction. Emitting both caused a
+ * redundant SwiftUI invalidation on every compaction.
+ */
+export function applyCompactionResult(
+  ctx: CompactionApplyContext,
+  result: {
+    messages: Message[];
+    compactedPersistedMessages: number;
+    previousEstimatedInputTokens: number;
+    estimatedInputTokens: number;
+    maxInputTokens: number;
+    thresholdTokens: number;
+    compactedMessages: number;
+    summaryCalls: number;
+    summaryInputTokens: number;
+    summaryOutputTokens: number;
+    summaryModel: string;
+    summaryText: string;
+    summaryCacheCreationInputTokens?: number;
+    summaryCacheReadInputTokens?: number;
+    summaryRawResponses?: unknown[];
+  },
+  onEvent: (msg: ServerMessage) => void,
+  reqId: string | null,
+): void {
+  ctx.messages = result.messages;
+  ctx.contextCompactedMessageCount += result.compactedPersistedMessages;
+  ctx.contextCompactedAt = Date.now();
+  ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
+  updateConversationContextWindow(
+    ctx.conversationId,
+    result.summaryText,
+    ctx.contextCompactedMessageCount,
+  );
+  enqueueAutoAnalysisOnCompaction(
+    ctx.conversationId,
+    ctx.trustContext?.trustClass,
+  );
+  const summarySignals = computeSummaryQualitySignals(result.summaryText);
+  onEvent({
+    type: "context_compacted",
+    conversationId: ctx.conversationId,
+    previousEstimatedInputTokens: result.previousEstimatedInputTokens,
+    estimatedInputTokens: result.estimatedInputTokens,
+    maxInputTokens: result.maxInputTokens,
+    thresholdTokens: result.thresholdTokens,
+    compactedMessages: result.compactedMessages,
+    summaryCalls: result.summaryCalls,
+    summaryInputTokens: result.summaryInputTokens,
+    summaryOutputTokens: result.summaryOutputTokens,
+    summaryModel: result.summaryModel,
+    summaryCharCount: summarySignals.charCount,
+    summaryHeaderCount: summarySignals.headerCount,
+    summaryHadMemoryEcho: summarySignals.hadMemoryEcho,
+  });
+  emitUsage(
+    ctx,
+    result.summaryInputTokens,
+    result.summaryOutputTokens,
+    result.summaryModel,
+    onEvent,
+    "context_compactor",
+    reqId,
+    result.summaryCacheCreationInputTokens ?? 0,
+    result.summaryCacheReadInputTokens ?? 0,
+    collapseRawResponses(result.summaryRawResponses),
+    undefined /* providerName */,
+    1 /* llmCallCount */,
+  );
+}
+
+export function collapseRawResponses(
+  rawResponses?: unknown[],
+): unknown | undefined {
   if (!rawResponses || rawResponses.length === 0) return undefined;
   return rawResponses.length === 1 ? rawResponses[0] : rawResponses;
 }
+
+/**
+ * Matches any runtime-injection tag that should never appear inside a
+ * generated summary. If the regex hits, either the compaction strip logic
+ * failed to drop an injected block from the summarizer input, or the
+ * summarizer invented tag-like text on its own — both are quality bugs
+ * worth surfacing via telemetry.
+ */
+const SUMMARY_MEMORY_ECHO_PATTERN =
+  /<(?:memory|memory_context|memory_image|turn_context|workspace|workspace_top_level|knowledge_base|pkb|system_reminder|now_scratchpad|NOW\.md|active_thread|active_subagents|active_workspace|active_dynamic_page|channel_capabilities|transport_hints|system_notice|non_interactive_context|temporal_context|guardian_context|inbound_actor_context|channel_turn_context|interface_turn_context|channel_command_context|voice_call_control)\b/i;
+
+/**
+ * Compute light-weight quality signals for a compaction summary. Emitted
+ * on every `context_compacted` event so regressions (short outputs,
+ * header collapse, memory-injection leakage) are visible without having
+ * to read the summary text from the DB.
+ */
+export function computeSummaryQualitySignals(summaryText: string): {
+  charCount: number;
+  headerCount: number;
+  hadMemoryEcho: boolean;
+} {
+  const charCount = summaryText.length;
+  const headerCount = (summaryText.match(/^## /gm) ?? []).length;
+  const hadMemoryEcho = SUMMARY_MEMORY_ECHO_PATTERN.test(summaryText);
+  return { charCount, headerCount, hadMemoryEcho };
+}