@illuma-ai/agents 1.1.1 → 1.1.3

package/dist/cjs/main.cjs

@@ -249,6 +249,7 @@ exports.CONTEXT_SAFETY_BUFFER = constants.CONTEXT_SAFETY_BUFFER;
 exports.DEDUP_MAX_CONTENT_LENGTH = constants.DEDUP_MAX_CONTENT_LENGTH;
 exports.MIN_THINKING_BUDGET = constants.MIN_THINKING_BUDGET;
 exports.MULTI_DOCUMENT_THRESHOLD = constants.MULTI_DOCUMENT_THRESHOLD;
+exports.PROACTIVE_SUMMARY_THRESHOLD = constants.PROACTIVE_SUMMARY_THRESHOLD;
 exports.PRUNING_EMA_ALPHA = constants.PRUNING_EMA_ALPHA;
 exports.PRUNING_INITIAL_CALIBRATION = constants.PRUNING_INITIAL_CALIBRATION;
 exports.SUMMARIZATION_CONTEXT_THRESHOLD = constants.SUMMARIZATION_CONTEXT_THRESHOLD;

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/common/constants.mjs

@@ -51,6 +51,17 @@ const CONTEXT_SAFETY_BUFFER = 0.9;
  * When the context window is ≥80% full, pruning + summarization activates.
  */
 const SUMMARIZATION_CONTEXT_THRESHOLD = 80;
+/**
+ * Proactive summarization threshold (0-1 fraction of context window).
+ * At this utilization level, background summarization fires BEFORE pruning is needed.
+ * This gives the summary time to complete so it's ready when context actually fills up.
+ *
+ * Inspired by VS Code Copilot Chat's 3-tier strategy:
+ *   80% → proactive background summary
+ *   90% → pruning kicks in (with summary already cached)
+ *  100% → graceful: use existing summary + recent messages, never block
+ */
+const PROACTIVE_SUMMARY_THRESHOLD = 0.8;
 /**
  * Default reserve ratio (0-1) — fraction of context window to preserve as recent messages.
  * 0.3 means 30% of the context budget is reserved for the most recent messages,
@@ -88,5 +99,5 @@ const TOOL_DISCOVERY_CACHE_MAX_SIZE = 200;
  */
 const DEDUP_MAX_CONTENT_LENGTH = 10000;
 
-export { CONTEXT_SAFETY_BUFFER, DEDUP_MAX_CONTENT_LENGTH, MIN_THINKING_BUDGET, MULTI_DOCUMENT_THRESHOLD, PRUNING_EMA_ALPHA, PRUNING_INITIAL_CALIBRATION, SUMMARIZATION_CONTEXT_THRESHOLD, SUMMARIZATION_RESERVE_RATIO, TOOL_DISCOVERY_CACHE_MAX_SIZE, TOOL_TURN_THINKING_BUDGET };
+export { CONTEXT_SAFETY_BUFFER, DEDUP_MAX_CONTENT_LENGTH, MIN_THINKING_BUDGET, MULTI_DOCUMENT_THRESHOLD, PROACTIVE_SUMMARY_THRESHOLD, PRUNING_EMA_ALPHA, PRUNING_INITIAL_CALIBRATION, SUMMARIZATION_CONTEXT_THRESHOLD, SUMMARIZATION_RESERVE_RATIO, TOOL_DISCOVERY_CACHE_MAX_SIZE, TOOL_TURN_THINKING_BUDGET };
 //# sourceMappingURL=constants.mjs.map

package/dist/esm/common/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","sources":["../../../src/common/constants.ts"],"sourcesContent":["// src/common/constants.ts\n\n/**\n * Minimum thinking budget allowed by the Anthropic API.\n * Extended thinking requires at least 1024 budget_tokens.\n * @see https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking\n */\nexport const MIN_THINKING_BUDGET = 1024;\n\n/**\n * Reduced thinking budget for subsequent ReAct iterations (tool-result turns).\n *\n * In a ReAct agent loop, the first LLM call processes the user's query and\n * may need deep reasoning. Subsequent iterations (after tool results return)\n * typically only need to decide \"call next tool\" or \"generate final response\"\n * — 1024 tokens is sufficient for this routing logic.\n *\n * This reduces wall-clock time per iteration from ~20-30s to ~5-10s,\n * compounding across multi-tool conversations (e.g., 10 tool calls).\n */\nexport const TOOL_TURN_THINKING_BUDGET = 1024;\n\n// ============================================================================\n// CONTEXT OVERFLOW MANAGEMENT\n//\n// Context overflow is handled mechanically — no token budget numbers are\n// exposed to the LLM. The system uses: pruning (Graph), summarization\n// (summarizeCallback), and auto-continuation (client.js max_tokens detection).\n//\n// See: docs/context-overflow-architecture.md\n// ============================================================================\n\n/**\n * Minimum number of attached documents before the multi-document delegation\n * hint is injected. Below this threshold, the agent processes documents\n * directly within its own context.\n */\nexport const MULTI_DOCUMENT_THRESHOLD = 3;\n\n/**\n * Context utilization safety buffer multiplier (0-1).\n * Applied as: effectiveMax = (maxContextTokens - maxOutputTokens) * CONTEXT_SAFETY_BUFFER\n *\n * Reserves headroom so the LLM doesn't hit hard token limits mid-generation.\n * 0.9 = 10% reserved for safety.\n */\nexport const CONTEXT_SAFETY_BUFFER = 0.9;\n\n// ============================================================================\n// SUMMARIZATION CONFIGURATION DEFAULTS\n//\n// These constants provide sensible defaults for the SummarizationConfig.\n// They can be overridden per-agent via AgentInputs.summarizationConfig.\n// ============================================================================\n\n/**\n * Default context utilization percentage (0-100) at which summarization triggers.\n * When the context window is ≥80% full, pruning + summarization activates.\n */\nexport const SUMMARIZATION_CONTEXT_THRESHOLD = 80;\n\n/**\n * Default reserve ratio (0-1) — fraction of context window to preserve as recent messages.\n * 0.3 means 30% of the context budget is reserved for the most recent messages,\n * ensuring the model always has immediate conversation history even after aggressive pruning.\n */\nexport const SUMMARIZATION_RESERVE_RATIO = 0.3;\n\n/**\n * Default EMA (Exponential Moving Average) alpha for pruning calibration.\n * Controls how quickly the calibration adapts to new token counts.\n * Higher α = faster adaptation (more responsive to recent changes).\n * Lower α = smoother adaptation (more stable across iterations).\n * 0.3 provides a balance between responsiveness and stability.\n */\nexport const PRUNING_EMA_ALPHA = 0.3;\n\n/**\n * Default initial calibration ratio for EMA pruning.\n * 1.0 means no adjustment on the first iteration (trust the raw token counts).\n * Subsequent iterations will adjust based on actual vs. estimated token usage.\n */\nexport const PRUNING_INITIAL_CALIBRATION = 1.0;\n\n// ============================================================================\n// TOOL DISCOVERY CACHING\n// ============================================================================\n\n/**\n * Maximum number of tool discovery entries to cache per conversation.\n * Prevents unbounded memory growth in very long conversations.\n */\nexport const TOOL_DISCOVERY_CACHE_MAX_SIZE = 200;\n\n// ============================================================================\n// MESSAGE DEDUPLICATION\n// ============================================================================\n\n/**\n * Maximum length of system message content to hash for deduplication.\n * Messages longer than this are always considered unique (hashing would be expensive).\n */\nexport const DEDUP_MAX_CONTENT_LENGTH = 10000;\n"],"names":[],"mappings":"AAAA;AAEA;;;;AAIG;AACI,MAAM,mBAAmB,GAAG;AAEnC;;;;;;;;;;AAUG;AACI,MAAM,yBAAyB,GAAG;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;;AAIG;AACI,MAAM,wBAAwB,GAAG;AAExC;;;;;;AAMG;AACI,MAAM,qBAAqB,GAAG;AAErC;AACA;AACA;AACA;AACA;AACA;AAEA;;;AAGG;AACI,MAAM,+BAA+B,GAAG;AAE/C;;;;AAIG;AACI,MAAM,2BAA2B,GAAG;AAE3C;;;;;;AAMG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;AAIG;AACI,MAAM,2BAA2B,GAAG;AAE3C;AACA;AACA;AAEA;;;AAGG;AACI,MAAM,6BAA6B,GAAG;AAE7C;AACA;AACA;AAEA;;;AAGG;AACI,MAAM,wBAAwB,GAAG;;;;"}
+{"version":3,"file":"constants.mjs","sources":["../../../src/common/constants.ts"],"sourcesContent":["// src/common/constants.ts\n\n/**\n * Minimum thinking budget allowed by the Anthropic API.\n * Extended thinking requires at least 1024 budget_tokens.\n * @see https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking\n */\nexport const MIN_THINKING_BUDGET = 1024;\n\n/**\n * Reduced thinking budget for subsequent ReAct iterations (tool-result turns).\n *\n * In a ReAct agent loop, the first LLM call processes the user's query and\n * may need deep reasoning. Subsequent iterations (after tool results return)\n * typically only need to decide \"call next tool\" or \"generate final response\"\n * — 1024 tokens is sufficient for this routing logic.\n *\n * This reduces wall-clock time per iteration from ~20-30s to ~5-10s,\n * compounding across multi-tool conversations (e.g., 10 tool calls).\n */\nexport const TOOL_TURN_THINKING_BUDGET = 1024;\n\n// ============================================================================\n// CONTEXT OVERFLOW MANAGEMENT\n//\n// Context overflow is handled mechanically — no token budget numbers are\n// exposed to the LLM. The system uses: pruning (Graph), summarization\n// (summarizeCallback), and auto-continuation (client.js max_tokens detection).\n//\n// See: docs/context-overflow-architecture.md\n// ============================================================================\n\n/**\n * Minimum number of attached documents before the multi-document delegation\n * hint is injected. Below this threshold, the agent processes documents\n * directly within its own context.\n */\nexport const MULTI_DOCUMENT_THRESHOLD = 3;\n\n/**\n * Context utilization safety buffer multiplier (0-1).\n * Applied as: effectiveMax = (maxContextTokens - maxOutputTokens) * CONTEXT_SAFETY_BUFFER\n *\n * Reserves headroom so the LLM doesn't hit hard token limits mid-generation.\n * 0.9 = 10% reserved for safety.\n */\nexport const CONTEXT_SAFETY_BUFFER = 0.9;\n\n// ============================================================================\n// SUMMARIZATION CONFIGURATION DEFAULTS\n//\n// These constants provide sensible defaults for the SummarizationConfig.\n// They can be overridden per-agent via AgentInputs.summarizationConfig.\n// ============================================================================\n\n/**\n * Default context utilization percentage (0-100) at which summarization triggers.\n * When the context window is ≥80% full, pruning + summarization activates.\n */\nexport const SUMMARIZATION_CONTEXT_THRESHOLD = 80;\n\n/**\n * Proactive summarization threshold (0-1 fraction of context window).\n * At this utilization level, background summarization fires BEFORE pruning is needed.\n * This gives the summary time to complete so it's ready when context actually fills up.\n *\n * Inspired by VS Code Copilot Chat's 3-tier strategy:\n *   80% → proactive background summary\n *   90% → pruning kicks in (with summary already cached)\n *  100% → graceful: use existing summary + recent messages, never block\n */\nexport const PROACTIVE_SUMMARY_THRESHOLD = 0.8;\n\n/**\n * Default reserve ratio (0-1) — fraction of context window to preserve as recent messages.\n * 0.3 means 30% of the context budget is reserved for the most recent messages,\n * ensuring the model always has immediate conversation history even after aggressive pruning.\n */\nexport const SUMMARIZATION_RESERVE_RATIO = 0.3;\n\n/**\n * Default EMA (Exponential Moving Average) alpha for pruning calibration.\n * Controls how quickly the calibration adapts to new token counts.\n * Higher α = faster adaptation (more responsive to recent changes).\n * Lower α = smoother adaptation (more stable across iterations).\n * 0.3 provides a balance between responsiveness and stability.\n */\nexport const PRUNING_EMA_ALPHA = 0.3;\n\n/**\n * Default initial calibration ratio for EMA pruning.\n * 1.0 means no adjustment on the first iteration (trust the raw token counts).\n * Subsequent iterations will adjust based on actual vs. estimated token usage.\n */\nexport const PRUNING_INITIAL_CALIBRATION = 1.0;\n\n// ============================================================================\n// TOOL DISCOVERY CACHING\n// ============================================================================\n\n/**\n * Maximum number of tool discovery entries to cache per conversation.\n * Prevents unbounded memory growth in very long conversations.\n */\nexport const TOOL_DISCOVERY_CACHE_MAX_SIZE = 200;\n\n// ============================================================================\n// MESSAGE DEDUPLICATION\n// ============================================================================\n\n/**\n * Maximum length of system message content to hash for deduplication.\n * Messages longer than this are always considered unique (hashing would be expensive).\n */\nexport const DEDUP_MAX_CONTENT_LENGTH = 10000;\n"],"names":[],"mappings":"AAAA;AAEA;;;;AAIG;AACI,MAAM,mBAAmB,GAAG;AAEnC;;;;;;;;;;AAUG;AACI,MAAM,yBAAyB,GAAG;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;;AAIG;AACI,MAAM,wBAAwB,GAAG;AAExC;;;;;;AAMG;AACI,MAAM,qBAAqB,GAAG;AAErC;AACA;AACA;AACA;AACA;AACA;AAEA;;;AAGG;AACI,MAAM,+BAA+B,GAAG;AAE/C;;;;;;;;;AASG;AACI,MAAM,2BAA2B,GAAG;AAE3C;;;;AAIG;AACI,MAAM,2BAA2B,GAAG;AAE3C;;;;;;AAMG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;AAIG;AACI,MAAM,2BAA2B,GAAG;AAE3C;AACA;AACA;AAEA;;;AAGG;AACI,MAAM,6BAA6B,GAAG;AAE7C;AACA;AACA;AAEA;;;AAGG;AACI,MAAM,wBAAwB,GAAG;;;;"}

package/dist/esm/graphs/Graph.mjs

@@ -6,12 +6,12 @@ import { RunnableLambda } from '@langchain/core/runnables';
 import { SystemMessage, HumanMessage, AIMessageChunk } from '@langchain/core/messages';
 import { convertMessagesToContent, modifyDeltaProperties, formatAnthropicArtifactContent, formatArtifactPayload } from '../messages/core.mjs';
 import { getMessageId } from '../messages/ids.mjs';
-import { createPruneMessages } from '../messages/prune.mjs';
+import { createPruneMessages, getContextUtilization } from '../messages/prune.mjs';
 import { ensureThinkingBlockInMessages } from '../messages/format.mjs';
 import { addCacheControl, addBedrockCacheControl } from '../messages/cache.mjs';
 import { formatContentStrings } from '../messages/content.mjs';
 import { GraphNodeKeys, Providers, ContentTypes, GraphEvents, MessageTypes, StepTypes, Constants } from '../common/enum.mjs';
-import { TOOL_TURN_THINKING_BUDGET, SUMMARIZATION_CONTEXT_THRESHOLD } from '../common/constants.mjs';
+import { TOOL_TURN_THINKING_BUDGET, PROACTIVE_SUMMARY_THRESHOLD, SUMMARIZATION_CONTEXT_THRESHOLD } from '../common/constants.mjs';
 import { deduplicateSystemMessages } from '../messages/dedup.mjs';
 import { resetIfNotEmpty, joinKeys } from '../utils/graph.mjs';
 import { isOpenAILike, isGoogleLike } from '../utils/llm.mjs';
@@ -1080,69 +1080,158 @@ class StandardGraph extends Graph {
                     this._pruneCalibration = updatePruneCalibration(this._pruneCalibration, agentContext.currentUsage.input_tokens, estimatedTokens);
                 }
             }
+            // ── Proactive summarization at context pressure ───────────────────
+            // Inspired by VS Code Copilot Chat's 3-tier strategy:
+            //   80% → fire proactive background summary (BEFORE pruning needed)
+            //   90% → pruning kicks in (summary already cached from 80% trigger)
+            //  100% → graceful: use existing summary + recent messages, NEVER block
+            //
+            // This ensures the summary is READY by the time pruning actually occurs,
+            // so the user never waits and never sees a context cliff.
+            if (agentContext.maxContextTokens != null &&
+                agentContext.maxContextTokens > 0 &&
+                agentContext.summarizeCallback &&
+                !this._summaryInFlight &&
+                !this._cachedRunSummary) {
+                const utilization = getContextUtilization(agentContext.indexTokenCountMap, agentContext.instructionTokens, agentContext.maxContextTokens);
+                const threshold = (agentContext.summarizationConfig?.triggerThreshold ?? PROACTIVE_SUMMARY_THRESHOLD * 100);
+                if (utilization >= threshold) {
+                    // Identify older messages to summarize proactively.
+                    // Keep the last N messages (recent turns) intact — only summarize older history.
+                    // This is incremental: the callback checks for existing summary and updates it.
+                    const recentTurnCount = Math.max(4, Math.floor(messages.length * 0.3));
+                    const oldMessages = messages.slice(messages[0]?.getType() === 'system' ? 1 : 0, Math.max(1, messages.length - recentTurnCount));
+                    if (oldMessages.length > 0) {
+                        this._summaryInFlight = true;
+                        console.debug(`[Graph:ProactiveSummary] Context at ${utilization.toFixed(1)}% (threshold ${threshold}%) — summarizing ${oldMessages.length} older msgs in background`);
+                        agentContext
+                            .summarizeCallback(oldMessages)
+                            .then((updated) => {
+                            if (updated != null && updated !== '') {
+                                this._cachedRunSummary = updated;
+                                console.debug(`[Graph:ProactiveSummary] Background summary ready (len=${updated.length})`);
+                            }
+                        })
+                            .catch((err) => {
+                            console.error('[Graph:ProactiveSummary] Background summary failed (non-fatal):', err);
+                        })
+                            .finally(() => {
+                            this._summaryInFlight = false;
+                        });
+                    }
+                }
+            }
             if (agentContext.pruneMessages) {
-                const { context, indexTokenCountMap, messagesToRefine } = agentContext.pruneMessages({
-                    messages,
-                    usageMetadata: agentContext.currentUsage,
-                });
-                agentContext.indexTokenCountMap = indexTokenCountMap;
-                messagesToUse = context;
-                // ── 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.
+                // ── Context Compaction (Copilot-style: never delete messages) ─────
+                //
+                // DESIGN: Original messages are NEVER removed from the array.
+                // Instead, we build a "windowed view" for the LLM:
+                //   [system prompt] + [summary of older turns] + [recent turns that fit]
                 //
-                // 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;
+                // This ensures:
+                //   - No context is ever lost (summary covers older turns)
+                //   - We can always re-summarize from originals if summary is stale
+                //   - Conversation chaining works naturally across turns
+                //
+                // Flow:
+                //   1. Resolve best available summary (cached > persisted > seed)
+                //   2. Calculate token budget available for recent messages
+                //   3. Walk newest→oldest, build view of messages that fit
+                //   4. Assemble: [system] + [summary] + [recent window]
+                //   5. Fire background summary update for messages outside the window
                 const sumConfig = agentContext.summarizationConfig;
-                const shouldSummarize = this.shouldTriggerSummarization(messagesToRefine.length, agentContext.maxContextTokens ?? 0, agentContext.indexTokenCountMap, agentContext.instructionTokens, sumConfig);
-                if (messagesToRefine.length > 0 &&
-                    agentContext.summarizeCallback &&
-                    shouldSummarize) {
-                    try {
-                        let summary;
-                        let summarySource;
-                        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] Pruned ${messages.length}→${context.length} msgs (${messagesToRefine.length} discarded) | summary=${summarySource}${summary ? ` (len=${summary.length})` : ''} | calibration=${this._pruneCalibration.ratio.toFixed(3)}(${this._pruneCalibration.iterations})`);
-                        // SCALE: Debounce background summarization — if a summary call is already
-                        // in-flight (from a prior tool iteration), accumulate messages instead of
-                        // firing another concurrent LLM call. At 2000 users with 3+ tool calls
-                        // per turn, this prevents 3x summary call volume.
+                const tokenCounter = agentContext.tokenCounter;
+                const maxTokens = agentContext.maxContextTokens ?? 0;
+                // Step 1: Resolve best available summary
+                let summary;
+                let summarySource;
+                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 !== '') {
+                    summary = sumConfig.initialSummary;
+                    this._cachedRunSummary = summary;
+                    summarySource = 'initial-seed';
+                }
+                else {
+                    summarySource = 'none';
+                }
+                // Step 2: Calculate token budget
+                // Apply EMA calibration for accuracy across iterations
+                const calibratedMax = applyCalibration(maxTokens, this._pruneCalibration);
+                const systemMsg = messages[0]?.getType() === 'system' ? messages[0] : null;
+                const systemTokens = systemMsg != null
+                    ? (agentContext.indexTokenCountMap[0] ?? 0)
+                    : 0;
+                const summaryMsg = summary != null && summary !== ''
+                    ? new SystemMessage(`[Conversation Summary]\n${summary}`)
+                    : null;
+                const summaryTokens = summaryMsg != null && tokenCounter != null
+                    ? tokenCounter(summaryMsg)
+                    : 0;
+                // Budget for recent messages = total - system - summary - 3 (assistant priming)
+                const recentBudget = calibratedMax - systemTokens - summaryTokens - 3;
+                // Step 3: Walk newest→oldest, collect messages that fit in the budget
+                const contentStart = systemMsg != null ? 1 : 0;
+                let usedTokens = 0;
+                let windowStart = messages.length; // index where the recent window begins
+                for (let i = messages.length - 1; i >= contentStart; i--) {
+                    const msgTokens = agentContext.indexTokenCountMap[i] ?? 0;
+                    if (usedTokens + msgTokens > recentBudget) {
+                        break;
+                    }
+                    usedTokens += msgTokens;
+                    windowStart = i;
+                }
+                // Ensure we don't split tool-call / tool-result pairs.
+                // If windowStart lands on a ToolMessage, walk back to include its AI message.
+                while (windowStart > contentStart &&
+                    messages[windowStart]?.getType() === 'tool') {
+                    windowStart--;
+                    usedTokens += agentContext.indexTokenCountMap[windowStart] ?? 0;
+                }
+                const recentMessages = messages.slice(windowStart);
+                const compactedMessages = messages.slice(contentStart, windowStart);
+                const hasSummary = summaryMsg != null;
+                // Step 4: Assemble the windowed view
+                // [system] + [summary (covers compacted messages)] + [recent window]
+                const viewParts = [];
+                if (systemMsg != null) {
+                    viewParts.push(systemMsg);
+                }
+                if (summaryMsg != null) {
+                    viewParts.push(summaryMsg);
+                }
+                viewParts.push(...recentMessages);
+                messagesToUse = viewParts;
+                console.debug(`[Graph:Compaction] View: ${messages.length}→${viewParts.length} msgs ` +
+                    `(${compactedMessages.length} behind summary, ${recentMessages.length} in window) | ` +
+                    `summary=${summarySource}${summary ? ` (len=${summary.length})` : ''} | ` +
+                    `budget=${recentBudget}/${calibratedMax} used=${usedTokens}`);
+                // Step 5: Fire background summary update (non-blocking)
+                // Summarize messages outside the window so next iteration has a fresh summary.
+                // Only trigger if there are compacted messages worth summarizing.
+                if (compactedMessages.length > 0 &&
+                    agentContext.summarizeCallback) {
+                    const shouldSummarize = this.shouldTriggerSummarization(compactedMessages.length, maxTokens, agentContext.indexTokenCountMap, agentContext.instructionTokens, sumConfig);
+                    if (shouldSummarize) {
                         if (this._summaryInFlight) {
-                            this._pendingMessagesToRefine.push(...messagesToRefine);
-                            console.debug(`[Graph:ContextMgmt] Summary in-flight, queued ${messagesToRefine.length} msgs (pending=${this._pendingMessagesToRefine.length})`);
+                            this._pendingMessagesToRefine.push(...compactedMessages);
+                            console.debug(`[Graph:Compaction] Summary in-flight, queued ${compactedMessages.length} msgs (pending=${this._pendingMessagesToRefine.length})`);
                         }
                         else {
                             this._summaryInFlight = true;
                             const allMessages = this._pendingMessagesToRefine.length > 0
-                                ? [...this._pendingMessagesToRefine, ...messagesToRefine]
-                                : messagesToRefine;
+                                ? [...this._pendingMessagesToRefine, ...compactedMessages]
+                                : compactedMessages;
                             this._pendingMessagesToRefine = [];
                             agentContext
                                 .summarizeCallback(allMessages)
@@ -1152,40 +1241,17 @@ class StandardGraph extends Graph {
                                 }
                             })
                                 .catch((err) => {
-                                console.error('[Graph] Background summary failed (non-fatal):', err);
+                                console.error('[Graph:Compaction] Background summary update failed (non-fatal):', err);
                             })
                                 .finally(() => {
                                 this._summaryInFlight = false;
                             });
                         }
-                        if (summary != null && summary !== '') {
-                            hasSummary = true;
-                            const summaryMsg = new SystemMessage(`[Conversation Summary]\n${summary}`);
-                            const systemIdx = messagesToUse[0]?.getType() === 'system' ? 1 : 0;
-                            messagesToUse = [
-                                ...messagesToUse.slice(0, systemIdx),
-                                summaryMsg,
-                                ...messagesToUse.slice(systemIdx),
-                            ];
-                        }
-                    }
-                    catch (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);
+                // Post-compaction context note for task-tool-enabled agents
+                if (compactedMessages.length > 0 && hasTaskTool(agentContext.tools)) {
+                    const postPruneNote = buildPostPruneNote(compactedMessages.length, hasSummary);
                     if (postPruneNote) {
                         messagesToUse = [
                             ...messagesToUse,
@@ -1194,6 +1260,14 @@ class StandardGraph extends Graph {
                     }
                 }
             }
+            // Deduplicate system messages — ALWAYS runs, not just during compaction.
+            // Duplicate system messages accumulate from repeated tool iterations,
+            // summary injections, and context notes across turns.
+            const { messages: dedupedMessages, removedCount } = deduplicateSystemMessages(messagesToUse);
+            if (removedCount > 0) {
+                messagesToUse = dedupedMessages;
+                console.debug(`[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`);
+            }
             let finalMessages = messagesToUse;
             if (agentContext.useLegacyContent) {
                 finalMessages = formatContentStrings(finalMessages);