@vellumai/assistant 0.6.6 → 0.7.1

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

@@ -25,8 +25,13 @@ import type {
   TurnInterfaceContext,
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  contextWindowConfigFromEffective,
+  resolveEffectiveContextWindow,
+} from "../config/llm-context-resolution.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import type { ContextWindowConfig } from "../config/types.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
@@ -39,6 +44,7 @@ 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 { rewriteFeedTitle } from "../home/rewrite-feed-title.js";
 import {
   clearSentryConversationContext,
   setSentryConversationContext,
@@ -51,10 +57,12 @@ import {
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
+  getConversationOverrideProfileFromRow,
   getLastUserTimestampBefore,
   getMessageById,
   provenanceFromTrustContext,
   updateConversationContextWindow,
+  updateConversationSlackContextWatermark,
 } from "../memory/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
@@ -65,6 +73,8 @@ import {
 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 { QdrantSparseVector } from "../memory/qdrant-client.js";
+import { readMemoryV2StaticContent } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { defaultCompactionTerminal } from "../plugins/defaults/compaction.js";
 import { defaultHistoryRepairTerminal } from "../plugins/defaults/history-repair.js";
@@ -145,7 +155,6 @@ import type {
   ChannelCapabilities,
   InboundActorContext,
   InjectionMode,
-  TrustContext,
 } from "./conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
@@ -153,10 +162,12 @@ import {
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
   getPkbAutoInjectList,
+  getSlackCompactionWatermarkForPrefix,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
   loadSlackActiveThreadFocusBlock,
-  loadSlackChronologicalMessages,
+  loadSlackChronologicalContext,
+  type SlackChronologicalContext,
   stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
@@ -173,8 +184,10 @@ import type {
   UsageStats,
 } from "./message-protocol.js";
 import type { MemoryRecalled } from "./message-types/memory.js";
+import type { ConfirmationStateChanged } from "./message-types/messages.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
 import type { TraceEmitter } from "./trace-emitter.js";
+import type { TrustContext } from "./trust-context.js";
 import { stripHistoricalWebSearchResults } from "./web-search-history.js";
 
 const log = getLogger("conversation-agent-loop");
@@ -303,7 +316,7 @@ async function 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: {
+async function isCompactionCircuitOpen(ctx: {
   readonly conversationId: string;
   consecutiveCompactionFailures: number;
   compactionCircuitOpenUntil: number | null;
@@ -359,7 +372,7 @@ export async function trackCompactionOutcome(
  * `guardian` so a missing snapshot cannot accidentally grant elevated trust
  * to a custom plugin reading `ctx.trust`.
  */
-export const FALLBACK_TURN_TRUST: TrustContext = {
+const FALLBACK_TURN_TRUST: TrustContext = {
   sourceChannel: "vellum",
   trustClass: "unknown",
 };
@@ -388,7 +401,7 @@ export const FALLBACK_TURN_TRUST: TrustContext = {
  *   don't need it can ignore it; the default compaction plugin reads it
  *   via the typed optional field on `TurnContext`.
  */
-export function buildPluginTurnContext(
+function buildPluginTurnContext(
   ctx: AgentLoopConversationContext,
   requestId: string,
 ): PluginTurnContext {
@@ -464,6 +477,15 @@ export interface AgentLoopConversationContext {
   currentTurnTrustContext?: TrustContext;
   /** Per-turn snapshot of channelCapabilities, frozen at message-processing start. */
   currentTurnChannelCapabilities?: ChannelCapabilities;
+  /**
+   * Per-turn snapshot of the resolved inference-profile override. Read by
+   * `createToolExecutor` so `ToolContext.overrideProfile` carries the same
+   * profile the agent loop is sending to the provider. Without this, a tool
+   * that spawns nested subagents (e.g. `subagent_spawn`) cannot recover the
+   * override from a row read because the in-flight subagent's own row never
+   * had `inferenceProfile` set.
+   */
+  currentTurnOverrideProfile?: string;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   trustContext?: TrustContext;
   /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
@@ -471,6 +493,7 @@ export interface AgentLoopConversationContext {
   assistantId?: string;
   voiceCallControlPrompt?: string;
   transportHints?: string[];
+  slackRuntimeContextNotice?: string;
 
   readonly coreToolNames: Set<string>;
   allowedToolNames?: Set<string>;
@@ -520,13 +543,10 @@ export interface AgentLoopConversationContext {
     statusText?: string,
   ): void;
   emitConfirmationStateChanged(
-    params: import("./message-types/messages.js").ConfirmationStateChanged extends {
+    params: ConfirmationStateChanged extends {
       type: infer _;
     }
-      ? Omit<
-          import("./message-types/messages.js").ConfirmationStateChanged,
-          "type"
-        >
+      ? Omit<ConfirmationStateChanged, "type">
       : never,
   ): void;
 
@@ -573,6 +593,16 @@ export async function runAgentLoopImpl(
      * the agent loop defaults to `'mainAgent'` for user-initiated turns.
      */
     callSite?: LLMCallSite;
+    /**
+     * Optional ad-hoc inference-profile override applied to every LLM call
+     * the loop issues. When set, the agent loop sets
+     * `SendMessageOptions.config.overrideProfile` on each provider call so
+     * the resolver layers `llm.profiles[<name>]` between the workspace's
+     * `activeProfile` and the call-site's named profile. Used by
+     * per-conversation pinned profiles (and inherited by subagents the loop
+     * spawns).
+     */
+    overrideProfile?: string;
   },
 ): Promise<void> {
   if (!ctx.abortController) {
@@ -603,6 +633,44 @@ export async function runAgentLoopImpl(
   // `llm.callSites.mainAgent` (falling back to `llm.default` when absent).
   const turnCallSite: LLMCallSite = options?.callSite ?? "mainAgent";
 
+  // Read the conversation row once for both the override-profile derivation
+  // below and the title-replaceability check at turn start. Later reads in
+  // this function (post-turn truncation, disk sync, home-feed emission)
+  // intentionally re-read because state can change during the turn.
+  const turnStartConversation = getConversation(ctx.conversationId);
+
+  // Optional per-turn inference-profile override. Plumbed through to every
+  // LLM call the loop emits and inherited by any subagents spawned during
+  // this turn. Caller-supplied `options.overrideProfile` (e.g.
+  // SubagentManager forwarding the parent's pinned profile into the
+  // spawned subagent's background conversation) wins over the row read
+  // so the agent loop's own background-skip rule doesn't zero out an
+  // explicitly inherited override.
+  const turnOverrideProfile =
+    options?.overrideProfile ??
+    getConversationOverrideProfileFromRow(turnStartConversation);
+
+  const config = getConfig();
+  const effectiveContextWindow = resolveEffectiveContextWindow({
+    llm: config.llm,
+    callSite: turnCallSite,
+    overrideProfile: turnOverrideProfile ?? undefined,
+  });
+  const turnContextWindowConfig = contextWindowConfigFromEffective(
+    config.llm.default.contextWindow,
+    effectiveContextWindow,
+  );
+  (
+    ctx.contextWindowManager as ContextWindowManager & {
+      updateConfig?: (config: ContextWindowConfig) => void;
+    }
+  ).updateConfig?.(turnContextWindowConfig);
+
+  // Snapshot for `createToolExecutor` to read into `ToolContext.overrideProfile`
+  // — see field doc on `AgentLoopConversationContext` for why the tool needs
+  // it (nested subagent spawns can't recover the override from a row read).
+  ctx.currentTurnOverrideProfile = turnOverrideProfile;
+
   // 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),
@@ -633,8 +701,8 @@ export async function runAgentLoopImpl(
         assistantMessageInterface: origin,
       };
     return {
-      userMessageInterface: "vellum" as InterfaceId,
-      assistantMessageInterface: "vellum" as InterfaceId,
+      userMessageInterface: "web" as InterfaceId,
+      assistantMessageInterface: "web" as InterfaceId,
     };
   })();
 
@@ -694,9 +762,7 @@ export async function runAgentLoopImpl(
     // cancels the response, since the user message is already persisted.
     // Deferred via setTimeout so the main agent loop LLM call enqueues
     // first, avoiding rate-limit slot contention on strict configs.
-    if (
-      isReplaceableTitle(getConversation(ctx.conversationId)?.title ?? null)
-    ) {
+    if (isReplaceableTitle(turnStartConversation?.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
@@ -736,8 +802,138 @@ export async function runAgentLoopImpl(
     const isFirstMessage = ctx.messages.length === 1;
     let shouldInjectWorkspace = isFirstMessage;
     let compactedThisTurn = false;
+    let slackCompactedThisTurn = false;
+    const isSlackConversation = ctx.channelCapabilities?.channel === "slack";
+    let currentSlackContextSummary =
+      turnStartConversation?.contextSummary ?? null;
+    let currentSlackContextCompactedMessageCount =
+      turnStartConversation?.contextCompactedMessageCount ?? 0;
+    let currentSlackContextCompactionWatermarkTs =
+      turnStartConversation?.slackContextCompactionWatermarkTs ?? null;
+    const loadCurrentSlackChronologicalContext =
+      (): SlackChronologicalContext | null => {
+        if (!isSlackConversation) return null;
+        return loadSlackChronologicalContext(
+          ctx.conversationId,
+          ctx.channelCapabilities!,
+          {
+            trustClass: ctx.trustContext?.trustClass,
+            contextSummary: currentSlackContextSummary,
+            contextCompactedMessageCount:
+              currentSlackContextCompactedMessageCount,
+            slackContextCompactionWatermarkTs:
+              currentSlackContextCompactionWatermarkTs,
+          },
+        );
+      };
+    let slackChronologicalContext: SlackChronologicalContext | null =
+      loadCurrentSlackChronologicalContext();
+    const messagesForStartOfTurnCompaction =
+      slackChronologicalContext?.messages ?? ctx.messages;
+    const getSlackProvenanceContextForCompactionBasis = (
+      messages: Message[],
+      compactedMessages: number,
+    ): SlackChronologicalContext | null => {
+      if (!isSlackConversation || compactedMessages <= 0) return null;
+      const context = slackChronologicalContext;
+      if (!context) return null;
+      if (messages !== context.messages) return null;
+      const end = context.compactableStartIndex + compactedMessages;
+      if (
+        end <= context.compactableStartIndex ||
+        end > context.renderedMessages.length ||
+        context.renderedMessages.length !== context.messages.length
+      ) {
+        return null;
+      }
+      return context;
+    };
+    const projectSlackProvenanceAfterCompaction = (
+      context: SlackChronologicalContext | null,
+      compactedBasis: Message[] | undefined,
+      result: Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>,
+    ): SlackChronologicalContext | null => {
+      if (
+        !isSlackConversation ||
+        !context ||
+        !compactedBasis ||
+        compactedBasis !== context.messages ||
+        result.compactedMessages <= 0 ||
+        result.messages.length === 0 ||
+        context.renderedMessages.length !== context.messages.length
+      ) {
+        return null;
+      }
+
+      const keptStart =
+        context.compactableStartIndex + result.compactedMessages;
+      if (keptStart > context.renderedMessages.length) {
+        return null;
+      }
 
-    const compactCheck = ctx.contextWindowManager.shouldCompact(ctx.messages);
+      const retainedRenderedMessages =
+        context.renderedMessages.slice(keptStart);
+      const retainedResultMessages = result.messages.slice(1);
+      if (retainedResultMessages.length !== retainedRenderedMessages.length) {
+        return null;
+      }
+      for (let index = 0; index < retainedResultMessages.length; index++) {
+        if (
+          retainedResultMessages[index] !==
+          retainedRenderedMessages[index]!.message
+        ) {
+          return null;
+        }
+      }
+
+      return {
+        renderedMessages: [
+          {
+            message: result.messages[0]!,
+            sourceChannelTs: null,
+          },
+          ...retainedRenderedMessages,
+        ],
+        messages: result.messages,
+        compactableStartIndex: 1,
+      };
+    };
+    const applySuccessfulCompaction = (
+      result: Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>,
+      compactedBasis?: Message[],
+    ) => {
+      const provenanceContext = compactedBasis
+        ? getSlackProvenanceContextForCompactionBasis(
+            compactedBasis,
+            result.compactedMessages,
+          )
+        : null;
+      const slackWatermarkTs = getSlackCompactionWatermarkForPrefix(
+        provenanceContext,
+        result.compactedMessages,
+      );
+      applyCompactionResult(ctx, result, onEvent, reqId, {
+        slackContextCompactionWatermarkTs: slackWatermarkTs,
+      });
+      currentSlackContextSummary = result.summaryText;
+      currentSlackContextCompactedMessageCount =
+        ctx.contextCompactedMessageCount;
+      if (slackWatermarkTs) {
+        currentSlackContextCompactionWatermarkTs = slackWatermarkTs;
+      }
+      if (isSlackConversation) {
+        slackCompactedThisTurn = true;
+      }
+      slackChronologicalContext = projectSlackProvenanceAfterCompaction(
+        provenanceContext,
+        compactedBasis,
+        result,
+      );
+    };
+
+    const compactCheck = ctx.contextWindowManager.shouldCompact(
+      messagesForStartOfTurnCompaction,
+    );
     // Skip auto-compaction while the circuit breaker is open. Force paths
     // and user-initiated /compact bypass this check.
     const autoCompactAllowed = !(await isCompactionCircuitOpen(ctx));
@@ -749,6 +945,13 @@ export async function runAgentLoopImpl(
         reqId,
       );
     }
+    const compactionOptions = {
+      lastCompactedAt: ctx.contextCompactedAt ?? undefined,
+      precomputedEstimate: compactCheck.estimatedTokens,
+      conversationOriginChannel:
+        getConversationOriginChannel(ctx.conversationId) ?? undefined,
+      overrideProfile: turnOverrideProfile ?? null,
+    };
     let compacted: Awaited<
       ReturnType<typeof ctx.contextWindowManager.maybeCompact>
     > | null = null;
@@ -760,14 +963,9 @@ export async function runAgentLoopImpl(
           (args) =>
             defaultCompactionTerminal(args, buildPluginTurnContext(ctx, reqId)),
           {
-            messages: ctx.messages,
+            messages: messagesForStartOfTurnCompaction,
             signal: abortController.signal,
-            options: {
-              lastCompactedAt: ctx.contextCompactedAt ?? undefined,
-              precomputedEstimate: compactCheck.estimatedTokens,
-              conversationOriginChannel:
-                getConversationOriginChannel(ctx.conversationId) ?? undefined,
-            },
+            options: compactionOptions,
           },
           buildPluginTurnContext(ctx, reqId),
           DEFAULT_TIMEOUTS.compaction,
@@ -801,7 +999,7 @@ export async function runAgentLoopImpl(
       await trackCompactionOutcome(ctx, compacted.summaryFailed, onEvent);
     }
     if (compacted?.compacted) {
-      applyCompactionResult(ctx, compacted, onEvent, reqId);
+      applySuccessfulCompaction(compacted, messagesForStartOfTurnCompaction);
       shouldInjectWorkspace = true;
       if (compacted.compactedPersistedMessages > 0) {
         compactedThisTurn = true;
@@ -898,9 +1096,7 @@ export async function runAgentLoopImpl(
     const defaultGraphPayload: GraphMemoryPayload | null =
       asDefaultGraphPayload(memoryResult.memoryGraphBlocks);
     let pkbQueryVector: number[] | undefined;
-    let pkbSparseVector:
-      | import("../memory/qdrant-client.js").QdrantSparseVector
-      | undefined;
+    let pkbSparseVector: QdrantSparseVector | undefined;
     if (defaultGraphPayload) {
       const graphResult = defaultGraphPayload.result;
       runMessages = graphResult.runMessages;
@@ -1132,6 +1328,15 @@ export async function runAgentLoopImpl(
     const pkbContext = shouldInjectNowAndPkb ? currentPkbContent : null;
     const pkbActive = currentPkbContent !== null;
 
+    // V2 static memory block (essentials/threads/recent/buffer). Same
+    // first-turn / post-compaction cadence as PKB — `readMemoryV2StaticContent`
+    // self-gates on the v2 flag + config, returning null when v2 is off.
+    // Skip the file reads entirely on non-injection turns.
+    const currentMemoryV2Static = shouldInjectNowAndPkb
+      ? readMemoryV2StaticContent()
+      : null;
+    const memoryV2Static = currentMemoryV2Static;
+
     // 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.
@@ -1160,14 +1365,25 @@ export async function runAgentLoopImpl(
     // 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;
+    const slackConversationForInjection = isSlackConversation
+      ? (getConversation(ctx.conversationId) ?? turnStartConversation)
+      : turnStartConversation;
+    if (isSlackConversation && !slackCompactedThisTurn) {
+      slackChronologicalContext ??= loadSlackChronologicalContext(
+        ctx.conversationId,
+        ctx.channelCapabilities!,
+        {
+          trustClass: ctx.trustContext?.trustClass,
+          contextSummary: slackConversationForInjection?.contextSummary,
+          contextCompactedMessageCount:
+            slackConversationForInjection?.contextCompactedMessageCount,
+          slackContextCompactionWatermarkTs:
+            slackConversationForInjection?.slackContextCompactionWatermarkTs,
+        },
+      );
+    }
+    const slackChronologicalMessages =
+      slackChronologicalContext?.messages ?? null;
 
     // Active-thread focus block: when the inbound user message belongs to
     // a Slack thread, append a non-persisted `<active_thread>` tail block
@@ -1180,7 +1396,13 @@ export async function runAgentLoopImpl(
       ? loadSlackActiveThreadFocusBlock(
           ctx.conversationId,
           ctx.channelCapabilities!,
-          { trustClass: ctx.trustContext?.trustClass },
+          {
+            trustClass: ctx.trustContext?.trustClass,
+            contextCompactedMessageCount:
+              slackConversationForInjection?.contextCompactedMessageCount,
+            slackContextCompactionWatermarkTs:
+              slackConversationForInjection?.slackContextCompactionWatermarkTs,
+          },
         )
       : null;
 
@@ -1210,9 +1432,11 @@ export async function runAgentLoopImpl(
       pkbAutoInjectList,
       pkbRoot,
       pkbWorkingDir: pkbActive ? ctx.workingDir : undefined,
+      memoryV2Static,
       nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
+      slackRuntimeContextNotice: ctx.slackRuntimeContextNotice ?? null,
       isNonInteractive: !isInteractiveResolved,
       subagentStatusBlock,
       slackChronologicalMessages,
@@ -1291,9 +1515,8 @@ export async function runAgentLoopImpl(
     // 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.llm.default.contextWindow.overflowRecovery;
-    const providerMaxTokens = config.llm.default.contextWindow.maxInputTokens;
+    const overflowRecovery = effectiveContextWindow.overflowRecovery;
+    const providerMaxTokens = effectiveContextWindow.maxInputTokens;
     // Widen safety margin for large conversations where estimation error
     // compounds across many messages with tool results.
     const baseSafetyMargin = overflowRecovery.safetyMarginRatio;
@@ -1370,40 +1593,81 @@ export async function runAgentLoopImpl(
       // injection reassembly, token re-estimation). Registered plugins that
       // wrap the `overflowReduce` slot see each iteration through their own
       // middleware `next` callback.
+      const messagesForPreflightOverflowReduction =
+        slackChronologicalContext?.messages ?? ctx.messages;
       const overflowArgs: OverflowReduceArgs = {
-        messages: ctx.messages,
+        messages: messagesForPreflightOverflowReduction,
         runMessages,
         systemPrompt: ctx.systemPrompt,
         providerName: estimationProviderName,
-        contextWindow: config.llm.default.contextWindow,
+        contextWindow: turnContextWindowConfig,
         preflightBudget,
         toolTokenBudget,
         maxAttempts: overflowRecovery.maxAttempts,
         abortSignal: abortController.signal,
-        compactFn: async (msgs, signal, opts) =>
+        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>
-          >,
+          //
+          // Pipeline timeouts must be caught locally — a `PluginTimeoutError`
+          // bubbling out of here would abort the overflow-reducer tier loop
+          // entirely, skipping fallback tiers (tool-result truncation, media
+          // stubbing, injection downgrade) and bypassing circuit-breaker
+          // bookkeeping. On timeout, record the failure and return a
+          // `compacted: false` result so the reducer falls through to the
+          // next tier.
+          try {
+            return (await runPipeline<CompactionArgs, CompactionResult>(
+              "compaction",
+              getMiddlewaresFor("compaction"),
+              (args) =>
+                defaultCompactionTerminal(
+                  args,
+                  buildPluginTurnContext(ctx, reqId),
+                ),
+              {
+                messages: msgs,
+                signal,
+                options: {
+                  ...(opts ?? {}),
+                  overrideProfile: turnOverrideProfile ?? null,
+                },
+              },
+              buildPluginTurnContext(ctx, reqId),
+              DEFAULT_TIMEOUTS.compaction,
+            )) as Awaited<
+              ReturnType<typeof ctx.contextWindowManager.maybeCompact>
+            >;
+          } catch (err) {
+            if (err instanceof PluginTimeoutError) {
+              rlog.warn(
+                { err, phase: "overflow-reducer-forced-compaction" },
+                "Compaction pipeline timed out — falling through to next reducer tier",
+              );
+              await trackCompactionOutcome(ctx, true, onEvent);
+              return {
+                messages: msgs,
+                compacted: false,
+                previousEstimatedInputTokens: 0,
+                estimatedInputTokens: 0,
+                maxInputTokens: 0,
+                thresholdTokens: 0,
+                compactedMessages: 0,
+                compactedPersistedMessages: 0,
+                summaryCalls: 0,
+                summaryInputTokens: 0,
+                summaryOutputTokens: 0,
+                summaryModel: "",
+                summaryText: "",
+                reason: "compaction pipeline timed out",
+              };
+            }
+            throw err;
+          }
+        },
         emitActivityState: () => {
           ctx.emitActivityState(
             "thinking",
@@ -1412,7 +1676,7 @@ export async function runAgentLoopImpl(
             reqId,
           );
         },
-        onCompactionResult: async (result) => {
+        onCompactionResult: async (result, compactedBasis) => {
           // Track circuit-breaker state whenever the reducer invoked
           // compaction. The reducer's forced_compaction tier uses
           // force:true, so it bypasses the open-circuit check, but we
@@ -1426,7 +1690,7 @@ export async function runAgentLoopImpl(
             await trackCompactionOutcome(ctx, result.summaryFailed, onEvent);
           }
           if (result.compacted) {
-            applyCompactionResult(ctx, result, onEvent, reqId);
+            applySuccessfulCompaction(result, compactedBasis);
             shouldInjectWorkspace = true;
           }
         },
@@ -1449,11 +1713,12 @@ export async function runAgentLoopImpl(
           // 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.
+          // or each round would grow the token count.
+          // Gate: only the iteration that actually compacted re-injects.
           const injection = await applyRuntimeInjections(reducedMessages, {
             ...injectionOpts,
             ...(stepCompacted && { pkbContext: currentPkbContent }),
+            ...(stepCompacted && { memoryV2Static: currentMemoryV2Static }),
             ...(stepCompacted && { nowScratchpad: currentNowContent }),
             workspaceTopLevelContext: shouldInjectWorkspace
               ? ctx.workspaceTopLevelContext
@@ -1546,18 +1811,24 @@ export async function runAgentLoopImpl(
         throw err;
       }
     }
-    if (
-      preRunRepair !== null &&
-      (preRunRepair.stats.assistantToolResultsMigrated > 0 ||
+    if (preRunRepair !== null) {
+      // Always adopt the pipeline's output history — a user `historyRepair`
+      // middleware may rewrite `messages` (e.g. provider-specific
+      // normalization) without incrementing any of the built-in repair
+      // counters. Gating the assignment on `stats` would silently discard
+      // those edits and send the un-rewritten history to the provider.
+      runMessages = preRunRepair.messages;
+      if (
+        preRunRepair.stats.assistantToolResultsMigrated > 0 ||
         preRunRepair.stats.missingToolResultsInserted > 0 ||
         preRunRepair.stats.orphanToolResultsDowngraded > 0 ||
-        preRunRepair.stats.consecutiveSameRoleMerged > 0)
-    ) {
-      rlog.warn(
-        { phase: "pre_run", ...preRunRepair.stats },
-        "Repaired runtime history before provider call",
-      );
-      runMessages = preRunRepair.messages;
+        preRunRepair.stats.consecutiveSameRoleMerged > 0
+      ) {
+        rlog.warn(
+          { phase: "pre_run", ...preRunRepair.stats },
+          "Repaired runtime history before provider call",
+        );
+      }
     }
 
     // Replace historical web_search_tool_result blocks with text summaries.
@@ -1644,6 +1915,8 @@ export async function runAgentLoopImpl(
       onCheckpoint,
       turnCallSite,
       loopTurnCtx,
+      turnOverrideProfile,
+      effectiveContextWindow.maxInputTokens,
     );
 
     rlog.info(
@@ -1710,6 +1983,7 @@ export async function runAgentLoopImpl(
               targetInputTokensOverride: preflightBudget,
               conversationOriginChannel:
                 getConversationOriginChannel(ctx.conversationId) ?? undefined,
+              overrideProfile: turnOverrideProfile ?? null,
             },
           },
           buildPluginTurnContext(ctx, reqId),
@@ -1745,7 +2019,7 @@ export async function runAgentLoopImpl(
         );
       }
       if (midLoopCompact.compacted) {
-        applyCompactionResult(ctx, midLoopCompact, onEvent, reqId);
+        applySuccessfulCompaction(midLoopCompact, rawHistory);
         reducerCompacted = true;
         shouldInjectWorkspace = true;
       }
@@ -1757,6 +2031,7 @@ export async function runAgentLoopImpl(
       const injection = await applyRuntimeInjections(ctx.messages, {
         ...injectionOpts,
         pkbContext: currentPkbContent,
+        memoryV2Static: currentMemoryV2Static,
         nowScratchpad: currentNowContent,
         workspaceTopLevelContext: shouldInjectWorkspace
           ? ctx.workspaceTopLevelContext
@@ -1793,6 +2068,8 @@ export async function runAgentLoopImpl(
         onCheckpoint,
         turnCallSite,
         loopTurnCtx,
+        turnOverrideProfile,
+        effectiveContextWindow.maxInputTokens,
       );
     }
 
@@ -1848,6 +2125,8 @@ export async function runAgentLoopImpl(
         onCheckpoint,
         turnCallSite,
         loopTurnCtx,
+        turnOverrideProfile,
+        effectiveContextWindow.maxInputTokens,
       );
 
       if (state.orderingErrorDetected) {
@@ -1953,18 +2232,22 @@ export async function runAgentLoopImpl(
           "assistant_turn",
           reqId,
         );
+        const convergenceCompactionBasis = ctx.messages;
         const step = await reduceContextOverflow(
-          ctx.messages,
+          convergenceCompactionBasis,
           {
             providerName: estimationProviderName,
             systemPrompt: ctx.systemPrompt,
-            contextWindow: config.llm.default.contextWindow,
+            contextWindow: turnContextWindowConfig,
             targetTokens: correctedTarget,
             toolTokenBudget,
           },
           reducerState,
           (msgs, signal, opts) =>
-            ctx.contextWindowManager.maybeCompact(msgs, signal!, opts),
+            ctx.contextWindowManager.maybeCompact(msgs, signal!, {
+              ...(opts ?? {}),
+              overrideProfile: turnOverrideProfile ?? null,
+            }),
           abortController.signal,
         );
 
@@ -1988,7 +2271,10 @@ export async function runAgentLoopImpl(
         }
 
         if (step.compactionResult?.compacted) {
-          applyCompactionResult(ctx, step.compactionResult, onEvent, reqId);
+          applySuccessfulCompaction(
+            step.compactionResult,
+            convergenceCompactionBasis,
+          );
           shouldInjectWorkspace = true;
           reducerCompacted = true;
         }
@@ -1999,6 +2285,7 @@ export async function runAgentLoopImpl(
         const injection = await applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
           pkbContext: currentPkbContent,
+          memoryV2Static: convergenceStripped ? currentMemoryV2Static : null,
           nowScratchpad: convergenceStripped ? currentNowContent : null,
           workspaceTopLevelContext: shouldInjectWorkspace
             ? ctx.workspaceTopLevelContext
@@ -2034,6 +2321,8 @@ export async function runAgentLoopImpl(
           onCheckpoint,
           turnCallSite,
           loopTurnCtx,
+          turnOverrideProfile,
+          effectiveContextWindow.maxInputTokens,
         );
 
         // If the rerun still yields at checkpoint, the turn is still
@@ -2111,6 +2400,7 @@ export async function runAgentLoopImpl(
                   force: true,
                   minKeepRecentUserTurns: 0,
                   targetInputTokensOverride: correctedTarget,
+                  overrideProfile: turnOverrideProfile ?? null,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -2147,7 +2437,7 @@ export async function runAgentLoopImpl(
             );
           }
           if (emergencyCompact?.compacted) {
-            applyCompactionResult(ctx, emergencyCompact, onEvent, reqId);
+            applySuccessfulCompaction(emergencyCompact, ctx.messages);
             reducerCompacted = true;
             shouldInjectWorkspace = true;
           }
@@ -2157,6 +2447,7 @@ export async function runAgentLoopImpl(
           const injection = await applyRuntimeInjections(ctx.messages, {
             ...injectionOpts,
             pkbContext: currentPkbContent,
+            memoryV2Static: convergenceStripped ? currentMemoryV2Static : null,
             nowScratchpad: convergenceStripped ? currentNowContent : null,
             workspaceTopLevelContext: shouldInjectWorkspace
               ? ctx.workspaceTopLevelContext
@@ -2191,6 +2482,8 @@ export async function runAgentLoopImpl(
             onCheckpoint,
             turnCallSite,
             loopTurnCtx,
+            turnOverrideProfile,
+            effectiveContextWindow.maxInputTokens,
           );
         }
         // action === "fail_gracefully" falls through to the final error below
@@ -2377,7 +2670,11 @@ export async function runAgentLoopImpl(
       state.exchangeLlmCallCount,
       {
         tokens: state.lastCallInputTokens,
-        maxTokens: config.llm.default.contextWindow.maxInputTokens,
+        maxTokens: effectiveContextWindow.maxInputTokens,
+      },
+      {
+        callSite: turnCallSite,
+        overrideProfile: turnOverrideProfile ?? null,
       },
     );
 
@@ -2530,17 +2827,44 @@ export async function runAgentLoopImpl(
             } else {
               summary = conv.title ?? "Background task completed.";
             }
+            const feedTitle =
+              conv.title && !isReplaceableTitle(conv.title)
+                ? conv.title
+                : "Background task";
+            const dedupKey = `bg-conv:${ctx.conversationId}`;
             void emitFeedEvent({
               source: "assistant",
-              title: conv.title ?? "Background Task",
+              title: feedTitle,
               summary,
-              dedupKey: `bg-conv:${ctx.conversationId}`,
+              dedupKey,
+              conversationId: ctx.conversationId,
             }).catch((err) => {
               log.warn(
                 { err, conversationId: ctx.conversationId },
                 "Failed to emit background conversation feed event",
               );
             });
+
+            if (isReplaceableTitle(conv.title ?? null)) {
+              void rewriteFeedTitle(feedTitle)
+                .then((prose) => {
+                  if (prose && prose !== feedTitle) {
+                    return emitFeedEvent({
+                      source: "assistant",
+                      title: prose,
+                      summary,
+                      dedupKey,
+                      conversationId: ctx.conversationId,
+                    });
+                  }
+                })
+                .catch((err) => {
+                  log.warn(
+                    { err, conversationId: ctx.conversationId },
+                    "Failed to update feed event with prose title rewrite",
+                  );
+                });
+            }
           }
         } catch (feedErr) {
           log.warn(
@@ -2606,7 +2930,12 @@ export async function runAgentLoopImpl(
           errorCode: classified.code,
         },
       });
-      onEvent({ type: "error", message: classified.userMessage });
+      onEvent({
+        type: "error",
+        conversationId: ctx.conversationId,
+        code: classified.code,
+        message: classified.userMessage,
+      });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
     }
   } finally {
@@ -2656,6 +2985,8 @@ export async function runAgentLoopImpl(
     ctx.currentActiveSurfaceId = undefined;
     ctx.allowedToolNames = undefined;
     ctx.preactivatedSkillIds = undefined;
+    ctx.currentTurnOverrideProfile = undefined;
+    ctx.slackRuntimeContextNotice = undefined;
     // 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;
@@ -2696,6 +3027,10 @@ function emitUsage(
   providerName?: string,
   llmCallCount = 1,
   contextWindow?: { tokens: number; maxTokens: number },
+  attribution?: {
+    callSite: LLMCallSite | null;
+    overrideProfile?: string | null;
+  },
 ): void {
   recordUsage(
     {
@@ -2714,6 +3049,7 @@ function emitUsage(
     rawResponse,
     llmCallCount,
     contextWindow,
+    attribution,
   );
 }
 
@@ -2764,19 +3100,32 @@ export function applyCompactionResult(
     summaryCacheCreationInputTokens?: number;
     summaryCacheReadInputTokens?: number;
     summaryRawResponses?: unknown[];
+    summaryCallSite?: LLMCallSite;
+    summaryOverrideProfile?: string | null;
   },
   onEvent: (msg: ServerMessage) => void,
   reqId: string | null,
+  options: {
+    slackContextCompactionWatermarkTs?: string | null;
+  } = {},
 ): void {
   ctx.messages = result.messages;
   ctx.contextCompactedMessageCount += result.compactedPersistedMessages;
-  ctx.contextCompactedAt = Date.now();
+  const compactedAt = Date.now();
+  ctx.contextCompactedAt = compactedAt;
   ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
   updateConversationContextWindow(
     ctx.conversationId,
     result.summaryText,
     ctx.contextCompactedMessageCount,
   );
+  if (options.slackContextCompactionWatermarkTs) {
+    updateConversationSlackContextWatermark(
+      ctx.conversationId,
+      options.slackContextCompactionWatermarkTs,
+      compactedAt,
+    );
+  }
   enqueueAutoAnalysisOnCompaction(
     ctx.conversationId,
     ctx.trustContext?.trustClass,
@@ -2811,12 +3160,15 @@ export function applyCompactionResult(
     collapseRawResponses(result.summaryRawResponses),
     undefined /* providerName */,
     1 /* llmCallCount */,
+    undefined /* contextWindow */,
+    {
+      callSite: result.summaryCallSite ?? null,
+      overrideProfile: result.summaryOverrideProfile ?? null,
+    },
   );
 }
 
-export function collapseRawResponses(
-  rawResponses?: unknown[],
-): unknown | undefined {
+function collapseRawResponses(rawResponses?: unknown[]): unknown | undefined {
   if (!rawResponses || rawResponses.length === 0) return undefined;
   return rawResponses.length === 1 ? rawResponses[0] : rawResponses;
 }