@vellumai/assistant 0.7.0 → 0.7.2

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

@@ -24,9 +24,13 @@ import type {
   TurnChannelContext,
   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,
@@ -57,6 +61,7 @@ import {
   getMessageById,
   provenanceFromTrustContext,
   updateConversationContextWindow,
+  updateConversationSlackContextWatermark,
 } from "../memory/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
@@ -68,6 +73,7 @@ import type { ConversationGraphMemory } from "../memory/graph/conversation-graph
 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";
@@ -108,6 +114,7 @@ import type {
 import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { redactSecrets } from "../security/secret-scanner.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { UsageActor } from "../usage/actors.js";
 import { getLogger } from "../util/logger.js";
@@ -120,6 +127,7 @@ import {
   type AssistantAttachmentDraft,
   cleanAssistantContent,
 } from "./assistant-attachments.js";
+import { cleanupBootstrapAfterTurnThreshold } from "./bootstrap-turn-cleanup.js";
 import { resolveOverflowAction } from "./context-overflow-policy.js";
 import {
   createInitialReducerState,
@@ -155,10 +163,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";
@@ -484,6 +494,7 @@ export interface AgentLoopConversationContext {
   assistantId?: string;
   voiceCallControlPrompt?: string;
   transportHints?: string[];
+  slackRuntimeContextNotice?: string;
 
   readonly coreToolNames: Set<string>;
   allowedToolNames?: Set<string>;
@@ -640,6 +651,22 @@ export async function runAgentLoopImpl(
     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).
@@ -776,8 +803,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));
@@ -789,6 +946,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;
@@ -800,14 +964,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,
@@ -841,7 +1000,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;
@@ -1170,6 +1329,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.
@@ -1198,14 +1366,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
@@ -1218,7 +1397,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;
 
@@ -1248,9 +1433,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,
@@ -1329,9 +1516,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;
@@ -1408,12 +1594,14 @@ 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,
@@ -1444,7 +1632,10 @@ export async function runAgentLoopImpl(
               {
                 messages: msgs,
                 signal,
-                options: opts,
+                options: {
+                  ...(opts ?? {}),
+                  overrideProfile: turnOverrideProfile ?? null,
+                },
               },
               buildPluginTurnContext(ctx, reqId),
               DEFAULT_TIMEOUTS.compaction,
@@ -1486,7 +1677,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
@@ -1500,7 +1691,7 @@ export async function runAgentLoopImpl(
             await trackCompactionOutcome(ctx, result.summaryFailed, onEvent);
           }
           if (result.compacted) {
-            applyCompactionResult(ctx, result, onEvent, reqId);
+            applySuccessfulCompaction(result, compactedBasis);
             shouldInjectWorkspace = true;
           }
         },
@@ -1528,6 +1719,7 @@ export async function runAgentLoopImpl(
           const injection = await applyRuntimeInjections(reducedMessages, {
             ...injectionOpts,
             ...(stepCompacted && { pkbContext: currentPkbContent }),
+            ...(stepCompacted && { memoryV2Static: currentMemoryV2Static }),
             ...(stepCompacted && { nowScratchpad: currentNowContent }),
             workspaceTopLevelContext: shouldInjectWorkspace
               ? ctx.workspaceTopLevelContext
@@ -1725,6 +1917,7 @@ export async function runAgentLoopImpl(
       turnCallSite,
       loopTurnCtx,
       turnOverrideProfile,
+      effectiveContextWindow.maxInputTokens,
     );
 
     rlog.info(
@@ -1791,6 +1984,7 @@ export async function runAgentLoopImpl(
               targetInputTokensOverride: preflightBudget,
               conversationOriginChannel:
                 getConversationOriginChannel(ctx.conversationId) ?? undefined,
+              overrideProfile: turnOverrideProfile ?? null,
             },
           },
           buildPluginTurnContext(ctx, reqId),
@@ -1826,7 +2020,7 @@ export async function runAgentLoopImpl(
         );
       }
       if (midLoopCompact.compacted) {
-        applyCompactionResult(ctx, midLoopCompact, onEvent, reqId);
+        applySuccessfulCompaction(midLoopCompact, rawHistory);
         reducerCompacted = true;
         shouldInjectWorkspace = true;
       }
@@ -1838,6 +2032,7 @@ export async function runAgentLoopImpl(
       const injection = await applyRuntimeInjections(ctx.messages, {
         ...injectionOpts,
         pkbContext: currentPkbContent,
+        memoryV2Static: currentMemoryV2Static,
         nowScratchpad: currentNowContent,
         workspaceTopLevelContext: shouldInjectWorkspace
           ? ctx.workspaceTopLevelContext
@@ -1875,6 +2070,7 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
+        effectiveContextWindow.maxInputTokens,
       );
     }
 
@@ -1931,6 +2127,7 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
+        effectiveContextWindow.maxInputTokens,
       );
 
       if (state.orderingErrorDetected) {
@@ -2036,18 +2233,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,
         );
 
@@ -2071,7 +2272,10 @@ export async function runAgentLoopImpl(
         }
 
         if (step.compactionResult?.compacted) {
-          applyCompactionResult(ctx, step.compactionResult, onEvent, reqId);
+          applySuccessfulCompaction(
+            step.compactionResult,
+            convergenceCompactionBasis,
+          );
           shouldInjectWorkspace = true;
           reducerCompacted = true;
         }
@@ -2082,6 +2286,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
@@ -2118,6 +2323,7 @@ export async function runAgentLoopImpl(
           turnCallSite,
           loopTurnCtx,
           turnOverrideProfile,
+          effectiveContextWindow.maxInputTokens,
         );
 
         // If the rerun still yields at checkpoint, the turn is still
@@ -2195,6 +2401,7 @@ export async function runAgentLoopImpl(
                   force: true,
                   minKeepRecentUserTurns: 0,
                   targetInputTokensOverride: correctedTarget,
+                  overrideProfile: turnOverrideProfile ?? null,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -2231,7 +2438,7 @@ export async function runAgentLoopImpl(
             );
           }
           if (emergencyCompact?.compacted) {
-            applyCompactionResult(ctx, emergencyCompact, onEvent, reqId);
+            applySuccessfulCompaction(emergencyCompact, ctx.messages);
             reducerCompacted = true;
             shouldInjectWorkspace = true;
           }
@@ -2241,6 +2448,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
@@ -2276,6 +2484,7 @@ export async function runAgentLoopImpl(
             turnCallSite,
             loopTurnCtx,
             turnOverrideProfile,
+            effectiveContextWindow.maxInputTokens,
           );
         }
         // action === "fail_gracefully" falls through to the final error below
@@ -2325,10 +2534,16 @@ export async function runAgentLoopImpl(
       ).map(([toolUseId, result]) => ({
         type: "tool_result",
         tool_use_id: toolUseId,
-        content: result.content,
+        content: redactSecrets(result.content),
         is_error: result.isError,
         ...(result.contentBlocks
-          ? { contentBlocks: result.contentBlocks }
+          ? {
+              contentBlocks: result.contentBlocks.map((block) =>
+                block.type === "text"
+                  ? { ...block, text: redactSecrets(block.text) }
+                  : block,
+              ),
+            }
           : {}),
       }));
       const toolResultMetadata = {
@@ -2411,34 +2626,29 @@ export async function runAgentLoopImpl(
 
     // Post-turn tool result truncation: save large results to disk and
     // replace in-context content with a prefix/suffix stub + file pointer.
-    if (isAssistantFeatureFlagEnabled("tool-result-truncation", config)) {
-      try {
-        const conv = getConversation(ctx.conversationId);
-        if (conv) {
-          const convDir = getResolvedConversationDirPath(
-            ctx.conversationId,
-            conv.createdAt,
+    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,
+          });
+        if (truncatedCount > 0 || dereferencedCount > 0) {
+          rlog.info(
+            { truncatedCount, dereferencedCount },
+            "Post-turn tool result truncation applied",
           );
-          const { messages: derefMessages, dereferencedCount } =
-            derefToolResultReReads(restoredHistory);
-          const { messages: truncatedMessages, truncatedCount } =
-            postTurnTruncateToolResults(derefMessages, {
-              conversationDir: convDir,
-            });
-          if (truncatedCount > 0 || dereferencedCount > 0) {
-            rlog.info(
-              { truncatedCount, dereferencedCount },
-              "Post-turn tool result truncation applied",
-            );
-          }
-          restoredHistory = truncatedMessages;
         }
-      } catch (err) {
-        rlog.warn(
-          { err },
-          "Post-turn tool result truncation failed (non-fatal)",
-        );
+        restoredHistory = truncatedMessages;
       }
+    } catch (err) {
+      rlog.warn({ err }, "Post-turn tool result truncation failed (non-fatal)");
     }
 
     // Persist injections in history: runtime-injected context stays on
@@ -2462,7 +2672,11 @@ export async function runAgentLoopImpl(
       state.exchangeLlmCallCount,
       {
         tokens: state.lastCallInputTokens,
-        maxTokens: config.llm.default.contextWindow.maxInputTokens,
+        maxTokens: effectiveContextWindow.maxInputTokens,
+      },
+      {
+        callSite: turnCallSite,
+        overrideProfile: turnOverrideProfile ?? null,
       },
     );
 
@@ -2718,11 +2932,18 @@ 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 {
     if (turnStarted) {
+      cleanupBootstrapAfterTurnThreshold(ctx.conversationId);
+
       ctx.turnCount++;
       const config = getConfig();
       const maxWait = config.workspaceGit?.turnCommitMaxWaitMs ?? 4000;
@@ -2769,6 +2990,7 @@ export async function runAgentLoopImpl(
     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;
@@ -2809,6 +3031,10 @@ function emitUsage(
   providerName?: string,
   llmCallCount = 1,
   contextWindow?: { tokens: number; maxTokens: number },
+  attribution?: {
+    callSite: LLMCallSite | null;
+    overrideProfile?: string | null;
+  },
 ): void {
   recordUsage(
     {
@@ -2827,6 +3053,7 @@ function emitUsage(
     rawResponse,
     llmCallCount,
     contextWindow,
+    attribution,
   );
 }
 
@@ -2877,19 +3104,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,
@@ -2924,6 +3164,11 @@ export function applyCompactionResult(
     collapseRawResponses(result.summaryRawResponses),
     undefined /* providerName */,
     1 /* llmCallCount */,
+    undefined /* contextWindow */,
+    {
+      callSite: result.summaryCallSite ?? null,
+      overrideProfile: result.summaryOverrideProfile ?? null,
+    },
   );
 }