@vellumai/assistant 0.6.3 → 0.6.5

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,10 +26,18 @@ import type {
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import { derefToolResultReReads,postTurnTruncateToolResults } from "../context/post-turn-tool-result-truncation.js";
-import { estimatePromptTokens } from "../context/token-estimator.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import {
+  derefToolResultReReads,
+  postTurnTruncateToolResults,
+} from "../context/post-turn-tool-result-truncation.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 { writeRelationshipState } from "../home/relationship-state-writer.js";
 import { getHookManager } from "../hooks/manager.js";
 import {
   clearSentryConversationContext,
@@ -35,12 +45,16 @@ import {
 } from "../instrument.js";
 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,
+  clearPkbSystemReminderMetadataForConversation,
   deleteMessageById,
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
+  getLastUserTimestampBefore,
+  getMessageById,
   provenanceFromTrustContext,
   updateConversationContextWindow,
   updateConversationTitle,
@@ -56,6 +70,7 @@ import {
 } 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 type { Provider } from "../providers/types.js";
@@ -64,6 +79,8 @@ 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";
 import { commitTurnChanges } from "../workspace/turn-commit.js";
@@ -107,8 +124,11 @@ import {
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
+  getPkbAutoInjectList,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
+  loadSlackActiveThreadFocusBlock,
+  loadSlackChronologicalMessages,
   readNowScratchpad,
   readPkbContext,
   stripInjectionsForCompaction,
@@ -127,44 +147,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",
@@ -173,12 +161,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",
@@ -189,6 +171,79 @@ type GitServiceInitializer = {
   ensureInitialized(): Promise<void>;
 };
 
+// ── Compaction circuit-breaker constants ────────────────────────────
+//
+// The circuit opens after `COMPACTION_CIRCUIT_FAILURE_THRESHOLD` consecutive
+// summary-LLM failures and stays open for `COMPACTION_CIRCUIT_COOLDOWN_MS`
+// before auto-compaction is allowed to retry. User-initiated compaction
+// (`force: true`) bypasses the breaker regardless of its state.
+const COMPACTION_CIRCUIT_FAILURE_THRESHOLD = 3;
+const COMPACTION_CIRCUIT_COOLDOWN_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Check whether the compaction circuit breaker is currently open for the
+ * given context. The breaker auto-closes once `compactionCircuitOpenUntil`
+ * has elapsed.
+ */
+export function isCompactionCircuitOpen(ctx: {
+  compactionCircuitOpenUntil: number | null;
+}): boolean {
+  return (
+    ctx.compactionCircuitOpenUntil !== null &&
+    Date.now() < ctx.compactionCircuitOpenUntil
+  );
+}
+
+/**
+ * Track the outcome of a `maybeCompact()` call against the circuit breaker.
+ *
+ * - When the summary LLM call failed (local fallback covered the result),
+ *   increment the consecutive-failure counter. If the counter reaches the
+ *   threshold, open the circuit for the cooldown window and emit
+ *   `compaction_circuit_open` so clients can surface a notice.
+ * - When the call did not fail, reset the counter and clear any open circuit.
+ *
+ * This is called by every `maybeCompact()` site (including forced ones),
+ * because a run of three failures is a provider-health signal regardless of
+ * whether the caller bypassed the breaker.
+ */
+export function trackCompactionOutcome(
+  ctx: {
+    consecutiveCompactionFailures: number;
+    compactionCircuitOpenUntil: number | null;
+  },
+  summaryFailed: boolean | undefined,
+  onEvent: (msg: ServerMessage) => void,
+): void {
+  if (summaryFailed) {
+    ctx.consecutiveCompactionFailures += 1;
+    // Treat a stale/expired open-until timestamp the same as null so a new
+    // 3-strike window can re-open the circuit after the prior cooldown
+    // elapses. Without this the second trip would no-op because
+    // `compactionCircuitOpenUntil` remains set to a past timestamp even
+    // though `isCompactionCircuitOpen()` correctly reports closed.
+    const circuitDormant =
+      ctx.compactionCircuitOpenUntil === null ||
+      Date.now() >= ctx.compactionCircuitOpenUntil;
+    if (
+      ctx.consecutiveCompactionFailures >=
+        COMPACTION_CIRCUIT_FAILURE_THRESHOLD &&
+      circuitDormant
+    ) {
+      const openUntil = Date.now() + COMPACTION_CIRCUIT_COOLDOWN_MS;
+      ctx.compactionCircuitOpenUntil = openUntil;
+      onEvent({
+        type: "compaction_circuit_open",
+        reason: "3_consecutive_failures",
+        openUntil,
+      });
+    }
+  } else {
+    ctx.consecutiveCompactionFailures = 0;
+    ctx.compactionCircuitOpenUntil = null;
+  }
+}
+
 // ── Context Interface ────────────────────────────────────────────────
 
 export interface AgentLoopConversationContext {
@@ -205,6 +260,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;
@@ -227,6 +286,7 @@ export interface AgentLoopConversationContext {
   >;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   surfaceActionRequestIds: Set<string>;
+  approvedViaPromptThisTurn?: boolean;
   currentTurnSurfaces: Array<{
     surfaceId: string;
     surfaceType: SurfaceType;
@@ -234,6 +294,7 @@ export interface AgentLoopConversationContext {
     data: SurfaceData;
     actions?: Array<{ id: string; label: string; style?: string }>;
     display?: string;
+    persistent?: boolean;
   }>;
 
   workingDir: string;
@@ -246,6 +307,8 @@ export interface AgentLoopConversationContext {
   currentTurnChannelCapabilities?: ChannelCapabilities;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   trustContext?: TrustContext;
+  /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
+  taskRunId?: string;
   assistantId?: string;
   voiceCallControlPrompt?: string;
   transportHints?: string[];
@@ -345,6 +408,13 @@ export async function runAgentLoopImpl(
     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) {
@@ -368,6 +438,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),
@@ -513,7 +590,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 = !isCompactionCircuitOpen(ctx);
+    if (compactCheck.needed && autoCompactAllowed) {
       ctx.emitActivityState(
         "thinking",
         "context_compacting",
@@ -521,15 +601,27 @@ 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) {
+    const compacted = autoCompactAllowed
+      ? await ctx.contextWindowManager.maybeCompact(
+          ctx.messages,
+          abortController.signal,
+          {
+            lastCompactedAt: ctx.contextCompactedAt ?? undefined,
+            precomputedEstimate: compactCheck.estimatedTokens,
+            conversationOriginChannel:
+              getConversationOriginChannel(ctx.conversationId) ?? undefined,
+          },
+        )
+      : null;
+    // 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) {
+      trackCompactionOutcome(ctx, compacted.summaryFailed, onEvent);
+    }
+    if (compacted?.compacted) {
       ctx.messages = compacted.messages;
       ctx.contextCompactedMessageCount += compacted.compactedPersistedMessages;
       ctx.contextCompactedAt = Date.now();
@@ -541,6 +633,13 @@ export async function runAgentLoopImpl(
         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,
@@ -613,7 +712,12 @@ export async function runAgentLoopImpl(
     let runMessages = ctx.messages;
 
     // Memory graph retrieval — dispatches to context-load / per-turn based on
-    // conversation state.
+    // conversation state. Keep the query vector around so the PKB reminder
+    // can reuse it for relevance-hint search (see `applyRuntimeInjections`).
+    let pkbQueryVector: number[] | undefined;
+    let pkbSparseVector:
+      | import("../memory/qdrant-client.js").QdrantSparseVector
+      | undefined;
     const isTrustedActor = resolveTrustClass(ctx.trustContext) === "guardian";
     if (isTrustedActor) {
       const graphResult = await ctx.graphMemory.prepareMemory(
@@ -623,6 +727,22 @@ export async function runAgentLoopImpl(
         onEvent,
       );
       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
@@ -773,14 +893,35 @@ export async function runAgentLoopImpl(
     const isGuardian =
       resolvedInboundActorContext?.trustClass === "guardian" ||
       !resolvedInboundActorContext;
+
+    // Surface long gaps between user messages so the model can acknowledge
+    // the absence naturally. Gated at >12h to avoid noisy injection during
+    // normal back-and-forth turns.
+    const TWELVE_HOURS_MS = 12 * 60 * 60 * 1000;
+    let timeSinceLastMessage: string | null = null;
+    const currentUserMessage = getMessageById(userMessageId);
+    if (currentUserMessage) {
+      const prevUserTs = getLastUserTimestampBefore(
+        ctx.conversationId,
+        currentUserMessage.createdAt,
+      );
+      if (
+        prevUserTs > 0 &&
+        currentUserMessage.createdAt - prevUserTs > TWELVE_HOURS_MS
+      ) {
+        timeSinceLastMessage = timeAgo(prevUserTs);
+      }
+    }
+
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
-        ? { timestamp, interfaceName, channelName }
+        ? { timestamp, interfaceName, channelName, timeSinceLastMessage }
         : {
             timestamp,
             interfaceName,
             channelName,
             actorContext: resolvedInboundActorContext,
+            timeSinceLastMessage,
           },
     );
 
@@ -800,6 +941,21 @@ export async function runAgentLoopImpl(
     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
@@ -808,6 +964,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,
@@ -819,27 +1012,66 @@ 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, {
+    const injection = await applyRuntimeInjections(runMessages, {
       ...injectionOpts,
+      slackChronologicalMessages: reducerCompacted
+        ? null
+        : injectionOpts.slackChronologicalMessages,
       mode: currentInjectionMode,
     });
+    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`. Both blocks are written in a single call to avoid
+    // doubling SQLite SELECT+UPDATE work on every turn.
+    if (
+      injection.blocks.unifiedTurnContext ||
+      injection.blocks.pkbSystemReminder
+    ) {
+      try {
+        const metadataUpdates: Record<string, unknown> = {};
+        if (injection.blocks.unifiedTurnContext) {
+          metadataUpdates.turnContextBlock =
+            injection.blocks.unifiedTurnContext;
+        }
+        if (injection.blocks.pkbSystemReminder) {
+          metadataUpdates.pkbSystemReminderBlock =
+            injection.blocks.pkbSystemReminder;
+        }
+        updateMessageMetadata(userMessageId, metadataUpdates);
+      } catch (err) {
+        rlog.warn({ err }, "Failed to persist injection metadata (non-fatal)");
+      }
+    }
 
     // ── Preflight budget evaluation ──────────────────────────────
     // After runtime injections are applied, estimate the prompt token count
     // and proactively invoke the reducer if already above budget. This avoids
     // a wasted provider round-trip that would just fail with context_too_large.
     const 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;
@@ -850,10 +1082,17 @@ export async function runAgentLoopImpl(
     let reducerState: ReducerState | undefined;
 
     const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
+    // Canonical calibration key used at every `estimatePromptTokens` site in
+    // this function. Matches the key recorded by `handleUsage` for wrapper
+    // providers (OpenRouter routing to Anthropic → key is `"anthropic"`).
+    const estimationProviderName = getCalibrationProviderKey(ctx.provider);
     const preflightTokens = estimatePromptTokens(
       runMessages,
       ctx.systemPrompt,
-      { providerName: ctx.provider.name, toolTokenBudget },
+      {
+        providerName: estimationProviderName,
+        toolTokenBudget,
+      },
     );
 
     if (overflowRecovery.enabled && preflightTokens > preflightBudget) {
@@ -883,9 +1122,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: preflightBudget,
             toolTokenBudget,
           },
@@ -899,6 +1138,24 @@ export async function runAgentLoopImpl(
         ctx.messages = step.messages;
         currentInjectionMode = step.state.injectionMode;
 
+        // 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 (
+          step.compactionResult &&
+          step.compactionResult.summaryFailed !== undefined
+        ) {
+          trackCompactionOutcome(
+            ctx,
+            step.compactionResult.summaryFailed,
+            onEvent,
+          );
+        }
+
         if (step.compactionResult?.compacted) {
           ctx.contextCompactedMessageCount +=
             step.compactionResult.compactedPersistedMessages;
@@ -908,6 +1165,11 @@ export async function runAgentLoopImpl(
             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:
@@ -937,21 +1199,34 @@ export async function runAgentLoopImpl(
             step.compactionResult.compactedPersistedMessages,
           );
           shouldInjectWorkspace = true;
+          reducerCompacted = 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, {
+        const injection = await applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
-          ...(step.compactionResult?.compacted && { pkbContext: currentPkbContent }),
-          ...(step.compactionResult?.compacted && { nowScratchpad: currentNowContent }),
+          ...(step.compactionResult?.compacted && {
+            pkbContext: currentPkbContent,
+          }),
+          ...(step.compactionResult?.compacted && {
+            nowScratchpad: currentNowContent,
+          }),
           workspaceTopLevelContext: shouldInjectWorkspace
             ? ctx.workspaceTopLevelContext
             : null,
+          // Once the reducer 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.
+          slackChronologicalMessages: reducerCompacted
+            ? null
+            : injectionOpts.slackChronologicalMessages,
           mode: currentInjectionMode,
         });
+        runMessages = injection.messages;
         if (isTrustedActor && currentInjectionMode !== "minimal") {
           const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
           runMessages = memResult.runMessages;
@@ -963,7 +1238,10 @@ export async function runAgentLoopImpl(
         const postInjectionTokens = estimatePromptTokens(
           runMessages,
           ctx.systemPrompt,
-          { providerName: ctx.provider.name, toolTokenBudget },
+          {
+            providerName: estimationProviderName,
+            toolTokenBudget,
+          },
         );
 
         if (postInjectionTokens <= preflightBudget) break;
@@ -986,6 +1264,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(
@@ -1008,17 +1300,11 @@ export async function runAgentLoopImpl(
     let yieldedForBudget = false;
 
     const onCheckpoint = (checkpoint: CheckpointInfo): CheckpointDecision => {
-      const turnTools = state.currentTurnToolNames;
       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
@@ -1029,7 +1315,10 @@ export async function runAgentLoopImpl(
         const estimated = estimatePromptTokens(
           checkpoint.history,
           ctx.systemPrompt,
-          { providerName: ctx.provider.name, toolTokenBudget },
+          {
+            providerName: estimationProviderName,
+            toolTokenBudget,
+          },
         );
         if (estimated > midLoopThreshold) {
           rlog.warn(
@@ -1048,12 +1337,20 @@ export async function runAgentLoopImpl(
 
     let denyCompressionMessage: Message | null = null;
 
+    rlog.info({ callSite: turnCallSite }, "Starting agent loop run");
+
     let updatedHistory = await ctx.agentLoop.run(
       runMessages,
       eventHandler,
       abortController.signal,
       reqId,
       onCheckpoint,
+      turnCallSite,
+    );
+
+    rlog.info(
+      { resultMessageCount: updatedHistory.length },
+      "Agent loop run completed",
     );
 
     // ── Proactive mid-loop compaction ───────────────────────────────
@@ -1081,6 +1378,14 @@ export async function runAgentLoopImpl(
       // so we compact the "raw" persistent messages.
       const rawHistory = stripInjectionsForCompaction(updatedHistory);
       ctx.messages = rawHistory;
+      try {
+        clearPkbSystemReminderMetadataForConversation(ctx.conversationId);
+      } catch (err) {
+        rlog.warn(
+          { err },
+          "Failed to clear pkbSystemReminderBlock metadata after compaction strip (non-fatal)",
+        );
+      }
 
       ctx.emitActivityState(
         "thinking",
@@ -1096,10 +1401,19 @@ export async function runAgentLoopImpl(
           lastCompactedAt: ctx.contextCompactedAt ?? undefined,
           force: true,
           targetInputTokensOverride: preflightBudget,
+          conversationOriginChannel:
+            getConversationOriginChannel(ctx.conversationId) ?? undefined,
         },
       );
+      // `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) {
+        trackCompactionOutcome(ctx, midLoopCompact.summaryFailed, onEvent);
+      }
       if (midLoopCompact.compacted) {
         ctx.messages = midLoopCompact.messages;
+        reducerCompacted = true;
         ctx.contextCompactedMessageCount +=
           midLoopCompact.compactedPersistedMessages;
         ctx.contextCompactedAt = Date.now();
@@ -1108,6 +1422,11 @@ export async function runAgentLoopImpl(
           midLoopCompact.summaryText,
           ctx.contextCompactedMessageCount,
         );
+        // Fire auto-analysis on compaction — see forceCompact() for rationale.
+        enqueueAutoAnalysisOnCompaction(
+          ctx.conversationId,
+          ctx.trustContext?.trustClass,
+        );
         onEvent({
           type: "context_compacted",
           previousEstimatedInputTokens:
@@ -1141,18 +1460,32 @@ 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,
       });
+      runMessages = injection.messages;
       if (isTrustedActor && currentInjectionMode !== "minimal") {
-        const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-        runMessages = memResult.runMessages;
+        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;
@@ -1163,6 +1496,7 @@ export async function runAgentLoopImpl(
         abortController.signal,
         reqId,
         onCheckpoint,
+        turnCallSite,
       );
     }
 
@@ -1194,7 +1528,9 @@ export async function runAgentLoopImpl(
       );
       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;
@@ -1205,6 +1541,7 @@ export async function runAgentLoopImpl(
         abortController.signal,
         reqId,
         onCheckpoint,
+        turnCallSite,
       );
 
       if (state.orderingErrorDetected) {
@@ -1234,6 +1571,14 @@ export async function runAgentLoopImpl(
 
       if (updatedHistory.length > preRunHistoryLength) {
         ctx.messages = stripInjectionsForCompaction(updatedHistory);
+        try {
+          clearPkbSystemReminderMetadataForConversation(ctx.conversationId);
+        } catch (err) {
+          rlog.warn(
+            { err },
+            "Failed to clear pkbSystemReminderBlock metadata after compaction strip (non-fatal)",
+          );
+        }
         convergenceStripped = true;
         preRepairMessages = updatedHistory;
         preRunHistoryLength = updatedHistory.length;
@@ -1246,14 +1591,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) {
@@ -1301,9 +1651,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,
           },
@@ -1317,6 +1667,21 @@ export async function runAgentLoopImpl(
         ctx.messages = step.messages;
         currentInjectionMode = step.state.injectionMode;
 
+        // See the preflight reducer call above for rationale. Only track when
+        // the summary LLM actually ran — `summaryFailed === undefined`
+        // indicates the reducer's forced compaction took an early-return path
+        // without calling the summary LLM.
+        if (
+          step.compactionResult &&
+          step.compactionResult.summaryFailed !== undefined
+        ) {
+          trackCompactionOutcome(
+            ctx,
+            step.compactionResult.summaryFailed,
+            onEvent,
+          );
+        }
+
         if (step.compactionResult?.compacted) {
           ctx.contextCompactedMessageCount +=
             step.compactionResult.compactedPersistedMessages;
@@ -1326,6 +1691,11 @@ export async function runAgentLoopImpl(
             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:
@@ -1355,23 +1725,35 @@ export async function runAgentLoopImpl(
             step.compactionResult.compactedPersistedMessages,
           );
           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,
         });
+        runMessages = injection.messages;
         if (isTrustedActor && currentInjectionMode !== "minimal") {
-          const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-          runMessages = memResult.runMessages;
+          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;
@@ -1384,6 +1766,7 @@ export async function runAgentLoopImpl(
           abortController.signal,
           reqId,
           onCheckpoint,
+          turnCallSite,
         );
 
         // If the rerun still yields at checkpoint, the turn is still
@@ -1405,6 +1788,14 @@ export async function runAgentLoopImpl(
           // pre-rerun messages.
           if (updatedHistory.length > preRunHistoryLength) {
             ctx.messages = stripInjectionsForCompaction(updatedHistory);
+            try {
+              clearPkbSystemReminderMetadataForConversation(ctx.conversationId);
+            } catch (err) {
+              rlog.warn(
+                { err },
+                "Failed to clear pkbSystemReminderBlock metadata after compaction strip (non-fatal)",
+              );
+            }
             convergenceStripped = true;
             preRepairMessages = updatedHistory;
             preRunHistoryLength = updatedHistory.length;
@@ -1440,8 +1831,18 @@ export async function runAgentLoopImpl(
                   targetInputTokensOverride: correctedTarget,
                 },
               );
+            // Only track when the summary LLM actually ran; `force: true`
+            // bypasses the cooldown but not the early-return paths.
+            if (emergencyCompact.summaryFailed !== undefined) {
+              trackCompactionOutcome(
+                ctx,
+                emergencyCompact.summaryFailed,
+                onEvent,
+              );
+            }
             if (emergencyCompact.compacted) {
               ctx.messages = emergencyCompact.messages;
+              reducerCompacted = true;
               ctx.contextCompactedMessageCount +=
                 emergencyCompact.compactedPersistedMessages;
               ctx.contextCompactedAt = Date.now();
@@ -1450,6 +1851,11 @@ export async function runAgentLoopImpl(
                 emergencyCompact.summaryText,
                 ctx.contextCompactedMessageCount,
               );
+              // Fire auto-analysis on compaction — see forceCompact() for rationale.
+              enqueueAutoAnalysisOnCompaction(
+                ctx.conversationId,
+                ctx.trustContext?.trustClass,
+              );
               onEvent({
                 type: "context_compacted",
                 previousEstimatedInputTokens:
@@ -1483,19 +1889,29 @@ export async function runAgentLoopImpl(
 
             // 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,
             });
+            runMessages = injection.messages;
             if (isTrustedActor && currentInjectionMode !== "minimal") {
-              const memResult =
-                ctx.graphMemory.reinjectCachedMemory(runMessages);
-              runMessages = memResult.runMessages;
+              ctx.graphMemory.retrackCachedNodes();
+            }
+            const emergencyStrip = stripHistoricalWebSearchResults(runMessages);
+            if (emergencyStrip.stats.blocksStripped > 0) {
+              rlog.info(
+                { phase: "emergency_compact", ...emergencyStrip.stats },
+                "Converted historical web_search_tool_result blocks to text summaries",
+              );
+              runMessages = emergencyStrip.messages;
             }
             preRepairMessages = runMessages;
             preRunHistoryLength = runMessages.length;
@@ -1507,6 +1923,7 @@ export async function runAgentLoopImpl(
               abortController.signal,
               reqId,
               onCheckpoint,
+              turnCallSite,
             );
           } else {
             // User denied compression — emit a graceful assistant explanation
@@ -1560,8 +1977,18 @@ export async function runAgentLoopImpl(
               targetInputTokensOverride: correctedTarget,
             },
           );
+          // Only track when the summary LLM actually ran; `force: true`
+          // bypasses the cooldown but not the early-return paths.
+          if (emergencyCompact.summaryFailed !== undefined) {
+            trackCompactionOutcome(
+              ctx,
+              emergencyCompact.summaryFailed,
+              onEvent,
+            );
+          }
           if (emergencyCompact.compacted) {
             ctx.messages = emergencyCompact.messages;
+            reducerCompacted = true;
             ctx.contextCompactedMessageCount +=
               emergencyCompact.compactedPersistedMessages;
             ctx.contextCompactedAt = Date.now();
@@ -1570,6 +1997,11 @@ export async function runAgentLoopImpl(
               emergencyCompact.summaryText,
               ctx.contextCompactedMessageCount,
             );
+            // Fire auto-analysis on compaction — see forceCompact() for rationale.
+            enqueueAutoAnalysisOnCompaction(
+              ctx.conversationId,
+              ctx.trustContext?.trustClass,
+            );
             onEvent({
               type: "context_compacted",
               previousEstimatedInputTokens:
@@ -1603,18 +2035,29 @@ export async function runAgentLoopImpl(
 
           // 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,
           });
+          runMessages = injection.messages;
           if (isTrustedActor && currentInjectionMode !== "minimal") {
-            const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-            runMessages = memResult.runMessages;
+            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;
@@ -1626,6 +2069,7 @@ export async function runAgentLoopImpl(
             abortController.signal,
             reqId,
             onCheckpoint,
+            turnCallSite,
           );
         }
         // action === "fail_gracefully" falls through to the final error below
@@ -1753,9 +2197,16 @@ export async function runAgentLoopImpl(
       try {
         const conv = getConversation(ctx.conversationId);
         if (conv) {
-          const convDir = getResolvedConversationDirPath(ctx.conversationId, conv.createdAt);
-          const { messages: derefMessages, dereferencedCount } = derefToolResultReReads(restoredHistory);
-          const { messages: truncatedMessages, truncatedCount } = postTurnTruncateToolResults(derefMessages, { conversationDir: convDir });
+          const convDir = getResolvedConversationDirPath(
+            ctx.conversationId,
+            conv.createdAt,
+          );
+          const { messages: derefMessages, dereferencedCount } =
+            derefToolResultReReads(restoredHistory);
+          const { messages: truncatedMessages, truncatedCount } =
+            postTurnTruncateToolResults(derefMessages, {
+              conversationDir: convDir,
+            });
           if (truncatedCount > 0 || dereferencedCount > 0) {
             rlog.info(
               { truncatedCount, dereferencedCount },
@@ -1765,16 +2216,13 @@ export async function runAgentLoopImpl(
           restoredHistory = truncatedMessages;
         }
       } catch (err) {
-        rlog.warn({ err }, "Post-turn tool result truncation failed (non-fatal)");
+        rlog.warn(
+          { err },
+          "Post-turn tool result truncation failed (non-fatal)",
+        );
       }
     }
 
-    const postLoopContextEstimate = estimatePromptTokens(
-      restoredHistory,
-      ctx.systemPrompt,
-      { providerName: ctx.provider.name, toolTokenBudget },
-    );
-
     // Persist injections in history: runtime-injected context stays on
     // historical user messages so the conversation prefix is stable for
     // Anthropic's prefix caching.  Stripping only happens during
@@ -1795,8 +2243,8 @@ export async function runAgentLoopImpl(
       state.exchangeProviderName,
       state.exchangeLlmCallCount,
       {
-        tokens: postLoopContextEstimate,
-        maxTokens: config.contextWindow.maxInputTokens,
+        tokens: state.lastCallInputTokens,
+        maxTokens: config.llm.default.contextWindow.maxInputTokens,
       },
     );
 
@@ -2014,6 +2462,12 @@ export async function runAgentLoopImpl(
 
       // Commit app changes (fire-and-forget — apps repo is separate from workspace)
       void commitAppTurnChanges(ctx.conversationId, ctx.turnCount);
+
+      // Recompute relationship-state.json at turn boundary (fire-and-forget).
+      // The writer swallows its own errors, but we still guard with catch()
+      // here so a regression in the writer can never bubble out of the
+      // agent loop and reject an otherwise-complete turn.
+      void writeRelationshipState().catch(() => {});
     }
 
     ctx.profiler.emitSummary(ctx.traceEmitter, reqId);
@@ -2022,6 +2476,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;
@@ -2029,6 +2484,10 @@ export async function runAgentLoopImpl(
     // Channel command intents (e.g. Telegram /start) are single-turn metadata.
     // Clear at turn end so they never leak into subsequent unrelated messages.
     ctx.commandIntent = undefined;
+    // taskRunId scopes ephemeral task-run permissions to a single turn. Clear
+    // before drainQueue so queued/drained turns on a reused conversation can't
+    // inherit stale in-task-run scope from the turn that just finished.
+    ctx.taskRunId = undefined;
 
     // Consolidation deferred to compaction: keeping assistant + tool_result
     // messages unconsolidated preserves the exact message structure sent to