@illuma-ai/agents 1.0.96 → 1.1.0

package/src/graphs/Graph.ts

@@ -34,9 +34,9 @@ import type * as t from '@/types';
 import {
   formatAnthropicArtifactContent,
   ensureThinkingBlockInMessages,
+  deduplicateSystemMessages,
   convertMessagesToContent,
   addBedrockCacheControl,
-  extractToolDiscoveries,
   modifyDeltaProperties,
   formatArtifactPayload,
   formatContentStrings,
@@ -53,14 +53,20 @@ import {
   MessageTypes,
   Constants,
   TOOL_TURN_THINKING_BUDGET,
+  SUMMARIZATION_CONTEXT_THRESHOLD,
 } from '@/common';
 import {
+  ToolDiscoveryCache,
   resetIfNotEmpty,
   isOpenAILike,
   isGoogleLike,
   joinKeys,
   sleep,
+  createPruneCalibration,
+  updatePruneCalibration,
+  applyCalibration,
 } from '@/utils';
+import type { PruneCalibrationState } from '@/types/graph';
 import {
   buildContextAnalytics,
   type ContextAnalytics,
@@ -69,6 +75,13 @@ import { getChatModelClass, manualToolStreamProviders } from '@/llm/providers';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
 import { safeDispatchCustomEvent } from '@/utils/events';
+import {
+  detectDocuments,
+  shouldInjectMultiDocHint,
+  buildMultiDocHintContent,
+  buildPostPruneNote,
+  hasTaskTool,
+} from '@/utils/contextPressure';
 import { createSchemaOnlyTools } from '@/tools/schema';
 import { prepareSchemaForProvider } from '@/schemas/validate';
 import { AgentContext } from '@/agents/AgentContext';
@@ -198,6 +211,13 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   runId: string | undefined;
   startIndex: number = 0;
   signal?: AbortSignal;
+  /** Cached summary from the first prune in this run.
+   * Reused for subsequent prunes to avoid blocking LLM calls on every tool iteration. */
+  private _cachedRunSummary: string | undefined;
+  /** EMA-based pruning calibration state — smooths token budget adjustments across iterations */
+  private _pruneCalibration: PruneCalibrationState;
+  /** Run-scoped tool discovery cache — avoids re-parsing conversation history on every iteration */
+  private _toolDiscoveryCache: ToolDiscoveryCache;
   /** Map of agent contexts by agent ID */
   agentContexts: Map<string, AgentContext> = new Map();
   /** Default agent ID to use */
@@ -232,6 +252,22 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     }
 
     this.defaultAgentId = agents[0].agentId;
+
+    // Seed cached summary from persisted storage so the first prune in a
+    // resumed conversation can also skip the synchronous LLM summarization call
+    const primaryContext = this.agentContexts.get(this.defaultAgentId);
+    if (primaryContext?.persistedSummary) {
+      this._cachedRunSummary = primaryContext.persistedSummary;
+    }
+
+    // Initialize EMA pruning calibration
+    this._pruneCalibration = createPruneCalibration();
+
+    // Initialize tool discovery cache, seeded with any pre-existing discoveries
+    this._toolDiscoveryCache = new ToolDiscoveryCache();
+    if (primaryContext?.discoveredToolNames.size) {
+      this._toolDiscoveryCache.seed([...primaryContext.discoveredToolNames]);
+    }
   }
 
   /* Init */
@@ -265,6 +301,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       new Map()
     );
     this.invokedToolIds = resetIfNotEmpty(this.invokedToolIds, undefined);
+    // Reset EMA calibration and tool discovery cache for fresh run
+    this._pruneCalibration = createPruneCalibration();
+    this._toolDiscoveryCache.reset();
     for (const context of this.agentContexts.values()) {
       context.reset();
     }
@@ -371,6 +410,70 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     return clientOptions;
   }
 
+  /**
+   * Determines whether summarization should trigger based on SummarizationConfig.
+   *
+   * Supports three trigger strategies:
+   * - contextPercentage (default): Trigger when context utilization >= threshold%
+   * - messageCount: Trigger when pruned message count >= threshold
+   * - tokenThreshold: Trigger when total estimated tokens >= threshold
+   *
+   * When no config is provided, always triggers (preserves backward compatibility).
+   *
+   * @param prunedMessageCount - Number of messages that were pruned
+   * @param maxContextTokens - Maximum context token budget
+   * @param indexTokenCountMap - Token count map by message index
+   * @param instructionTokens - Token count for instructions/system message
+   * @param config - Optional SummarizationConfig
+   * @returns Whether summarization should be triggered
+   */
+  private shouldTriggerSummarization(
+    prunedMessageCount: number,
+    maxContextTokens: number,
+    indexTokenCountMap: Record<string, number | undefined>,
+    instructionTokens: number,
+    config?: t.SummarizationConfig
+  ): boolean {
+    // No pruned messages means nothing to summarize
+    if (prunedMessageCount === 0) {
+      return false;
+    }
+
+    // No config = backward compatible (always summarize when messages are pruned)
+    if (!config || !config.triggerType) {
+      return true;
+    }
+
+    const threshold = config.triggerThreshold;
+
+    switch (config.triggerType) {
+      case 'contextPercentage': {
+        if (maxContextTokens <= 0) return true;
+        const effectiveThreshold = threshold ?? SUMMARIZATION_CONTEXT_THRESHOLD;
+        let totalTokens = instructionTokens;
+        for (const key in indexTokenCountMap) {
+          totalTokens += indexTokenCountMap[key] ?? 0;
+        }
+        const utilization = (totalTokens / maxContextTokens) * 100;
+        return utilization >= effectiveThreshold;
+      }
+      case 'messageCount': {
+        const effectiveThreshold = threshold ?? 5;
+        return prunedMessageCount >= effectiveThreshold;
+      }
+      case 'tokenThreshold': {
+        if (threshold == null) return true;
+        let totalTokens = instructionTokens;
+        for (const key in indexTokenCountMap) {
+          totalTokens += indexTokenCountMap[key] ?? 0;
+        }
+        return totalTokens >= threshold;
+      }
+      default:
+        return true;
+    }
+  }
+
   /**
    * Returns the normalized finish/stop reason from the last LLM invocation.
    * Used by callers to detect when the response was truncated due to max_tokens.
@@ -528,9 +631,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
   getRunMessages(): BaseMessage[] | undefined {
     const result = this.messages.slice(this.startIndex);
-    console.debug(
-      `[Graph] getRunMessages() | totalMessages=${this.messages.length} | startIndex=${this.startIndex} | runMessages=${result.length}`
-    );
     return result;
   }
 
@@ -1320,10 +1420,15 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         messages = [dynamicContextMessage, ackMessage, ...messages];
       }
 
-      // Extract tool discoveries from current turn only (similar to formatArtifactPayload pattern)
-      const discoveredNames = extractToolDiscoveries(messages);
-      if (discoveredNames.length > 0) {
-        agentContext.markToolsAsDiscovered(discoveredNames);
+      // Tool discovery caching: only scan new messages since last iteration
+      // instead of re-parsing the full history via extractToolDiscoveries()
+      const cachedDiscoveries =
+        this._toolDiscoveryCache.getNewDiscoveries(messages);
+      if (cachedDiscoveries.length > 0) {
+        agentContext.markToolsAsDiscovered(cachedDiscoveries);
+        console.debug(
+          `[Graph:ToolDiscovery] Cached ${cachedDiscoveries.length} new tools (total: ${this._toolDiscoveryCache.size})`
+        );
       }
 
       const toolsForBinding = agentContext.getToolsForBinding();
@@ -1367,45 +1472,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
       // ====================================================================
       // PRE-PRUNING DELEGATION CHECK
-      // Before pruning strips messages (losing context), check if we should
-      // delegate instead. If context would be pruned AND the agent has the
-      // task tool, inject a delegation hint and SKIP pruning — preserving
-      // the content for the LLM to understand what to delegate.
       // ====================================================================
-      let delegationInjectedPrePrune = false;
-      const hasTaskToolPrePrune = agentContext.tools?.some((tool) => {
-        const toolName =
-          typeof tool === 'object' && 'name' in tool
-            ? (tool as { name: string }).name
-            : '';
-        return toolName === 'task';
-      });
-
-      if (
-        hasTaskToolPrePrune === true &&
-        agentContext.tokenCounter &&
-        agentContext.maxContextTokens != null
-      ) {
-        // Estimate total tokens in messages BEFORE pruning
-        let prePruneTokens = 0;
-        for (const msg of messages) {
-          prePruneTokens += agentContext.tokenCounter(msg);
-        }
-        // Add instruction tokens (system prompt)
-        prePruneTokens += agentContext.instructionTokens;
-
-        const prePruneUtilization =
-          (prePruneTokens / agentContext.maxContextTokens) * 100;
-
-        if (prePruneUtilization > 70) {
-          console.warn(
-            `[Graph] PRE-PRUNE delegation check: ${prePruneUtilization.toFixed(1)}% utilization ` +
-              `(${prePruneTokens}/${agentContext.maxContextTokens} tokens). ` +
-              'Injecting delegation hint INSTEAD of pruning.'
-          );
-          delegationInjectedPrePrune = true;
-        }
-      }
+      // Context management is now fully mechanical:
+      // - Pruning always runs when needed (no delegation-based skip)
+      // - Auto-continuation in client.js handles max_tokens finish reason
+      // - LLM never sees raw token numbers (prevents voluntary bail-out)
+      // ====================================================================
 
       if (
         !agentContext.pruneMessages &&
@@ -1426,48 +1498,126 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
                 ?.thinking as t.AnthropicClientOptions['thinking']
             )?.type === 'enabled');
 
+        // Apply EMA calibration to max token budget — smooths pruning across iterations
+        const calibratedMaxTokens = applyCalibration(
+          agentContext.maxContextTokens,
+          this._pruneCalibration
+        );
+
         agentContext.pruneMessages = createPruneMessages({
           startIndex: this.startIndex,
           provider: agentContext.provider,
           tokenCounter: agentContext.tokenCounter,
-          maxTokens: agentContext.maxContextTokens,
+          maxTokens: calibratedMaxTokens,
           thinkingEnabled: isAnthropicWithThinking,
           indexTokenCountMap: agentContext.indexTokenCountMap,
         });
       }
 
-      if (agentContext.pruneMessages && !delegationInjectedPrePrune) {
-        console.debug(
-          `[Graph:ContextMgmt] Pruning messages | inputCount=${messages.length} | maxTokens=${agentContext.maxContextTokens}`
-        );
+      // Update EMA calibration with actual token usage from API response
+      if (
+        agentContext.currentUsage?.input_tokens &&
+        agentContext.maxContextTokens
+      ) {
+        const estimatedTokens = Object.values(
+          agentContext.indexTokenCountMap
+        ).reduce((sum, v) => (sum ?? 0) + (v ?? 0), 0) as number;
+        if (estimatedTokens > 0) {
+          this._pruneCalibration = updatePruneCalibration(
+            this._pruneCalibration,
+            agentContext.currentUsage.input_tokens,
+            estimatedTokens
+          );
+        }
+      }
+
+      if (agentContext.pruneMessages) {
         const { context, indexTokenCountMap, messagesToRefine } =
           agentContext.pruneMessages({
             messages,
             usageMetadata: agentContext.currentUsage,
-            // startOnMessageType: 'human',
           });
         agentContext.indexTokenCountMap = indexTokenCountMap;
         messagesToUse = context;
-        console.debug(
-          `[Graph:ContextMgmt] Pruned | kept=${context.length} | discarded=${messagesToRefine.length} | originalCount=${messages.length}`
+
+        // ── Non-blocking summarization ──────────────────────────────────
+        // NEVER block the LLM call waiting for summarization. Instead:
+        //   1. If _cachedRunSummary exists → use it, fire async update
+        //   2. If persistedSummary exists → use it as fallback, fire async update
+        //   3. If NOTHING exists (first-ever prune) → skip summary, fire async generation
+        // The summary catches up asynchronously and is available for subsequent
+        // iterations (tool calls) and the next conversation turn.
+        //
+        // SummarizationConfig integration:
+        //   - triggerType/triggerThreshold control WHEN summarization fires
+        //   - reserveRatio is enforced via calibrated maxTokens (above)
+        //   - initialSummary provides cross-run seeding as fallback before persistedSummary
+        let hasSummary = false;
+        const sumConfig = agentContext.summarizationConfig;
+        const shouldSummarize = this.shouldTriggerSummarization(
+          messagesToRefine.length,
+          agentContext.maxContextTokens ?? 0,
+          agentContext.indexTokenCountMap,
+          agentContext.instructionTokens,
+          sumConfig
         );
 
-        // Summarize discarded messages if callback provided
-        if (messagesToRefine.length > 0 && agentContext.summarizeCallback) {
-          console.debug(
-            `[Graph:ContextMgmt] Summarizing ${messagesToRefine.length} discarded messages`
-          );
+        if (
+          messagesToRefine.length > 0 &&
+          agentContext.summarizeCallback &&
+          shouldSummarize
+        ) {
           try {
-            const summary =
-              await agentContext.summarizeCallback(messagesToRefine);
+            let summary: string | undefined;
+            let summarySource: string;
+
+            if (this._cachedRunSummary != null) {
+              summary = this._cachedRunSummary;
+              summarySource = 'cached';
+            } else if (
+              agentContext.persistedSummary != null &&
+              agentContext.persistedSummary !== ''
+            ) {
+              summary = agentContext.persistedSummary;
+              this._cachedRunSummary = summary;
+              summarySource = 'persisted';
+            } else if (
+              sumConfig?.initialSummary != null &&
+              sumConfig.initialSummary !== ''
+            ) {
+              // Cross-run seed: use initialSummary when no persisted summary exists
+              summary = sumConfig.initialSummary;
+              this._cachedRunSummary = summary;
+              summarySource = 'initial-seed';
+            } else {
+              summarySource = 'none';
+            }
+
+            // Single consolidated log for the entire prune+summarize decision
             console.debug(
-              `[Graph:ContextMgmt] Summary received | len=${summary?.length ?? 0} | hasContent=${summary != null && summary !== ''}`
+              `[Graph:ContextMgmt] Pruned ${messages.length}→${context.length} msgs (${messagesToRefine.length} discarded) | summary=${summarySource}${summary ? ` (len=${summary.length})` : ''} | calibration=${this._pruneCalibration.ratio.toFixed(3)}(${this._pruneCalibration.iterations})`
             );
+
+            // Fire background summarization — updates cache for next iteration/turn
+            agentContext
+              .summarizeCallback(messagesToRefine)
+              .then((updated) => {
+                if (updated != null && updated !== '') {
+                  this._cachedRunSummary = updated;
+                }
+              })
+              .catch((err) => {
+                console.error(
+                  '[Graph] Background summary failed (non-fatal):',
+                  err
+                );
+              });
+
             if (summary != null && summary !== '') {
+              hasSummary = true;
               const summaryMsg = new SystemMessage(
                 `[Conversation Summary]\n${summary}`
               );
-              // Insert after system message (if present), before conversation messages
               const systemIdx =
                 messagesToUse[0]?.getType() === 'system' ? 1 : 0;
               messagesToUse = [
@@ -1475,18 +1625,40 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
                 summaryMsg,
                 ...messagesToUse.slice(systemIdx),
               ];
-              console.debug(
-                `[Graph:ContextMgmt] Summary injected at index ${systemIdx} | finalMsgCount=${messagesToUse.length}`
-              );
             }
           } catch (err) {
-            console.error('[Graph] Summarization callback failed:', err);
+            console.error('[Graph] Summarization failed:', err);
+          }
+        } else if (messagesToRefine.length > 0) {
+          // Log pruning even when no summarize callback (discard mode)
+          console.debug(
+            `[Graph:ContextMgmt] Pruned ${messages.length}→${context.length} msgs (${messagesToRefine.length} discarded, no summary callback) | calibration=${this._pruneCalibration.ratio.toFixed(3)}`
+          );
+        }
+
+        // Deduplicate system messages that accumulate from repeated tool iterations
+        const { messages: dedupedMessages, removedCount } =
+          deduplicateSystemMessages(messagesToUse);
+        if (removedCount > 0) {
+          messagesToUse = dedupedMessages;
+          console.debug(
+            `[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`
+          );
+        }
+
+        // Post-prune context note for task-tool-enabled agents
+        if (messagesToRefine.length > 0 && hasTaskTool(agentContext.tools)) {
+          const postPruneNote = buildPostPruneNote(
+            messagesToRefine.length,
+            hasSummary
+          );
+          if (postPruneNote) {
+            messagesToUse = [
+              ...messagesToUse,
+              new SystemMessage(postPruneNote),
+            ];
           }
         }
-      } else if (delegationInjectedPrePrune) {
-        console.info(
-          '[Graph] Skipping pruning — delegation will handle context pressure'
-        );
       }
 
       let finalMessages = messagesToUse;
@@ -1645,106 +1817,24 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       );
 
       // ====================================================================
-      // CONTEXT PRESSURE AWARENESS — Intelligent Sub-Agent Delegation
+      // MULTI-DOCUMENT DELEGATION (task-driven, not budget-driven)
       //
-      // Two triggers for delegation hints:
-      // 1. DOCUMENT COUNT: When 3+ documents are detected in the conversation,
-      //    inject a delegation hint on the FIRST iteration (before the LLM
-      //    has called any tools). This ensures the agent delegates upfront
-      //    rather than trying to process all documents itself.
-      // 2. TOKEN UTILIZATION: At EVERY iteration, if context is filling up
-      //    (70%/85%), inject escalating hints to delegate remaining work.
-      //
-      // This runs mid-chain — so even if tool responses push context up
-      // after the first LLM call, subsequent iterations get the hint.
+      // Token-based pressure hints have been removed — the LLM never sees
+      // raw token numbers. Context overflow is handled mechanically by
+      // pruning (Graph) + auto-continuation (client.js max_tokens detection).
+      // See: docs/context-overflow-architecture.md
       // ====================================================================
-      const hasTaskToolInContext = agentContext.tools?.some((tool) => {
-        const toolName =
-          typeof tool === 'object' && 'name' in tool
-            ? (tool as { name: string }).name
-            : '';
-        return toolName === 'task';
-      });
+      if (hasTaskTool(agentContext.tools)) {
+        const { count: documentCount, names: documentNames } =
+          detectDocuments(finalMessages);
 
-      if (
-        hasTaskToolInContext === true &&
-        contextAnalytics.utilizationPercent != null &&
-        contextAnalytics.maxContextTokens != null
-      ) {
-        const utilization = contextAnalytics.utilizationPercent;
-        const totalTokens = contextAnalytics.totalTokens;
-        const maxTokens = contextAnalytics.maxContextTokens;
-        const remainingTokens = maxTokens - totalTokens;
-
-        // Count attached documents by scanning for document patterns in HumanMessages:
-        // 1. # "filename" headers in "Attached document(s):" blocks (text content)
-        // 2. **filename1, filename2** in "The user has attached:" blocks (embedded files)
-        // 3. Filenames in file_search tool results
-        let documentCount = 0;
-        const documentNames: string[] = [];
-        for (const msg of finalMessages) {
-          const content =
-            typeof msg.content === 'string'
-              ? msg.content
-              : Array.isArray(msg.content)
-                ? msg.content
-                    .map((p: unknown) => {
-                      const part = p as Record<string, unknown>;
-                      return String(part.text ?? part.content ?? '');
-                    })
-                    .join(' ')
-                : '';
-          // Pattern 1: # "filename" headers in attached document blocks
-          const docMatches = content.match(/# "([^"]+)"/g);
-          if (docMatches) {
-            for (const match of docMatches) {
-              const name = match.replace(/# "/, '').replace(/"$/, '');
-              if (!documentNames.includes(name)) {
-                documentNames.push(name);
-                documentCount++;
-              }
-            }
-          }
-          // Pattern 2: "The user has attached: **file1, file2**" (embedded files)
-          const attachedMatch = content.match(
-            /user has attached:\s*\*\*([^*]+)\*\*/i
-          );
-          if (attachedMatch) {
-            const names = attachedMatch[1]
-              .split(',')
-              .map((n: string) => n.trim())
-              .filter(Boolean);
-            for (const name of names) {
-              if (!documentNames.includes(name)) {
-                documentNames.push(name);
-                documentCount++;
-              }
-            }
-          }
-        }
-
-        // BASELINE LOG: Always fires so we can verify this code path runs
-        console.debug(
-          `[Graph] Context utilization: ${utilization.toFixed(1)}% ` +
-            `(${totalTokens}/${maxTokens} tokens, ${remainingTokens} remaining) | ` +
-            `hasTaskTool: true | messages: ${finalMessages.length} | docs: ${documentCount}`
-        );
-
-        // TRIGGER 1: Multi-document delegation (3+ documents detected)
-        // Only inject on first iteration (no AI messages yet = agent hasn't responded)
+        // Multi-document delegation: first iteration only (before AI has responded)
         const hasAiResponse = finalMessages.some(
           (m) => m._getType() === 'ai' || m._getType() === 'tool'
         );
-        if (documentCount >= 3 && !hasAiResponse) {
+        if (shouldInjectMultiDocHint(documentCount, hasAiResponse)) {
           const pressureMsg = new HumanMessage({
-            content:
-              `[MULTI-DOCUMENT PROCESSING — ${documentCount} documents detected]\n` +
-              `Documents: ${documentNames.join(', ')}\n\n` +
-              `You have ${documentCount} documents attached. For thorough analysis, use the "task" tool ` +
-              'to delegate each document (or group of related documents) to a sub-agent.\n' +
-              'Each sub-agent has its own fresh context window and can use file_search to retrieve the full document content.\n' +
-              'After all sub-agents complete, synthesize their results into a comprehensive response.\n\n' +
-              'This approach ensures each document gets full attention without context limitations.',
+            content: buildMultiDocHintContent(documentCount, documentNames),
           });
           finalMessages = [...finalMessages, pressureMsg];
           console.info(
@@ -1752,43 +1842,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               `${documentNames.join(', ')}`
           );
         }
-
-        // TRIGGER 2: Token utilization thresholds (mid-chain safety net)
-        // Also fires when we skipped pruning due to delegationInjectedPrePrune
-        if (
-          utilization > 85 ||
-          (delegationInjectedPrePrune && utilization > 50)
-        ) {
-          // CRITICAL: Context is high — MANDATE delegation
-          const pressureMsg = new HumanMessage({
-            content:
-              `[CONTEXT BUDGET CRITICAL — ${utilization.toFixed(0)}% used]\n` +
-              `You have used ${totalTokens} of ${maxTokens} tokens (${remainingTokens} remaining).\n` +
-              'Your context is very large. You MUST use the "task" tool to delegate work to sub-agents.\n' +
-              'Each sub-agent runs in its own fresh context window and can use file_search to access documents.\n' +
-              'Do NOT attempt to process documents directly — delegate each document to a sub-agent, then synthesize results.',
-          });
-          finalMessages = [...finalMessages, pressureMsg];
-          console.warn(
-            `[Graph] Context pressure CRITICAL (${utilization.toFixed(0)}%): ` +
-              `Injected mandatory delegation hint. ${remainingTokens} tokens remaining. ` +
-              `prePruneSkipped: ${delegationInjectedPrePrune}`
-          );
-        } else if (utilization > 70) {
-          // WARNING: Context filling up — suggest delegation
-          const pressureMsg = new HumanMessage({
-            content:
-              `[CONTEXT BUDGET WARNING — ${utilization.toFixed(0)}% used]\n` +
-              `You have used ${totalTokens} of ${maxTokens} tokens (${remainingTokens} remaining).\n` +
-              'Your context is filling up. Consider using the "task" tool to delegate complex operations to sub-agents.\n' +
-              "Sub-agents run in fresh context windows and won't consume your remaining budget.",
-          });
-          finalMessages = [...finalMessages, pressureMsg];
-          console.info(
-            `[Graph] Context pressure WARNING (${utilization.toFixed(0)}%): ` +
-              `Injected delegation suggestion. ${remainingTokens} tokens remaining.`
-          );
-        }
       }
 
       // Structured output mode: when the agent has NO tools, produce structured JSON immediately.
@@ -2302,13 +2355,6 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
         reducer: (a, b) => {
           if (!a.length) {
             this.startIndex = a.length + b.length;
-            console.debug(
-              `[Graph:Reducer] Initial messages | startIndex=${this.startIndex} | inputMsgCount=${b.length}`
-            );
-          } else {
-            console.debug(
-              `[Graph:Reducer] Appending messages | existing=${a.length} | new=${b.length} | startIndex=${this.startIndex}`
-            );
           }
           const result = messagesStateReducer(a, b);
           this.messages = result;

package/src/graphs/contextManagement.e2e.test.ts

@@ -596,30 +596,38 @@ describe('Pre-invocation utilization gate', () => {
     expect(emergency.length).toBeLessThan(2000); // Emergency summaries are compact
   });
 
-  it('injects delegation hint at >70% utilization for agents with task tool', () => {
-    const utilization = 75;
-    const hasTaskTool = true;
-
-    if (utilization > 70 && hasTaskTool) {
-      const delegationHint = new HumanMessage({
-        content:
-          '[System] Context window is at 75% capacity. Consider delegating complex sub-tasks ' +
-          'to the task tool to maintain context availability.',
-      });
-      expect(delegationHint.content).toContain('75%');
-      expect(delegationHint.content).toContain('task tool');
+  it('does NOT inject token budget hints at any utilization level', () => {
+    // Token budget hints were removed to prevent LLM voluntary bail-out.
+    // Context overflow is handled mechanically by pruning + auto-continuation.
+    // See: docs/context-overflow-architecture.md
+    const utilizationLevels = [50, 70, 85, 95, 101];
+    for (const utilization of utilizationLevels) {
+      const messages = buildConversation(10, 200);
+      // No message should contain raw token numbers or budget percentages
+      for (const msg of messages) {
+        const content =
+          typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content);
+        expect(content).not.toMatch(/CONTEXT BUDGET/);
+        expect(content).not.toMatch(/\d+ of \d+ tokens/);
+      }
     }
   });
 
-  it('does not inject delegation hint below 70%', () => {
-    const utilization = 65;
-    let delegationInjected = false;
-
-    if (utilization > 70) {
-      delegationInjected = true;
+  it('post-prune note does not contain token numbers', () => {
+    // After pruning, a context note is injected but it must not
+    // expose any token counts or budget percentages to the LLM
+    const { buildPostPruneNote } = require('@/utils/contextPressure');
+    const noteWithSummary = buildPostPruneNote(10, true);
+    const noteWithout = buildPostPruneNote(10, false);
+    for (const note of [noteWithSummary, noteWithout]) {
+      expect(note).not.toBeNull();
+      expect(note).not.toMatch(/\d+%/);
+      expect(note).not.toMatch(/\d+ of \d+ tokens/);
+      expect(note).not.toMatch(/BUDGET/i);
+      expect(note).toContain('task');
     }
-
-    expect(delegationInjected).toBe(false);
   });
 });