@illuma-ai/agents 1.0.89 → 1.0.93

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

@@ -0,0 +1,990 @@
+/**
+ * End-to-End tests for context management across subagents, handoffs, and chaining.
+ *
+ * These tests exercise the full lifecycle of context management scenarios that
+ * span multiple agents and turns, validating that context is preserved, compacted,
+ * and transferred correctly across all agent execution patterns.
+ *
+ * Run with:
+ *   npx jest --no-coverage --forceExit src/graphs/contextManagement.e2e.test.ts
+ */
+import {
+  HumanMessage,
+  AIMessage,
+  SystemMessage,
+  ToolMessage,
+  BaseMessage,
+} from '@langchain/core/messages';
+import type { TokenCounter } from '@/types/run';
+import {
+  summarize,
+  createEmergencySummary,
+  formatMessagesForSummary,
+  buildFullSummaryPrompt,
+} from '@/messages/summarize';
+import { getContextUtilization } from '@/messages/prune';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Simple token counter: 1 token ≈ 4 chars */
+const simpleTokenCounter: TokenCounter = (msg: BaseMessage): number => {
+  const content =
+    typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+  return Math.ceil(content.length / 4);
+};
+
+/** Create a realistic conversation with N turns */
+function buildConversation(turns: number, charPerMessage = 200): BaseMessage[] {
+  const messages: BaseMessage[] = [];
+  for (let i = 0; i < turns; i++) {
+    messages.push(
+      new HumanMessage({
+        content: `User message ${i}: ${'x'.repeat(charPerMessage)}`,
+      })
+    );
+    messages.push(
+      new AIMessage({
+        content: `AI response ${i}: ${'y'.repeat(charPerMessage)}`,
+      })
+    );
+  }
+  return messages;
+}
+
+/** Simulates a summarize callback that returns a structured summary */
+const mockSummarizeCallback = async (
+  prompt: string,
+  _maxTokens: number
+): Promise<string> => {
+  return `[Summary] Conversation covered ${prompt.length} chars of content. Key topics discussed. Active context preserved.`;
+};
+
+/** Simulates a summarize callback that always fails */
+const failingSummarizeCallback = async (): Promise<string> => {
+  throw new Error('LLM unavailable');
+};
+
+// ============================================================================
+// 1. Subagent Result Truncation E2E
+// ============================================================================
+
+describe('Subagent result truncation E2E', () => {
+  it('truncated subagent result fits within parent context budget', () => {
+    // Simulate: subagent produces 50K chars, parent has 10K token budget
+    const subagentResult = 'Finding: '.repeat(5000) + 'Conclusion reached.';
+    const parentMaxTokens = 10000;
+    const maxResultChars = 8192 * 4; // 8192 tokens * 4 chars/token = 32768
+
+    // Truncation logic (mirrors TaskTool.truncateResult)
+    const truncationNotice =
+      '\n\n[... sub-agent output truncated — middle section omitted to fit parent context ...]\n\n';
+    const available = maxResultChars - truncationNotice.length;
+    const headSize = Math.floor(available * 0.6);
+    const tailSize = available - headSize;
+    const truncated =
+      subagentResult.substring(0, headSize) +
+      truncationNotice +
+      subagentResult.substring(subagentResult.length - tailSize);
+
+    // Result fits in parent budget (32768 chars ≈ 8192 tokens)
+    const resultTokens = Math.ceil(truncated.length / 4);
+    expect(resultTokens).toBeLessThanOrEqual(parentMaxTokens);
+    expect(truncated).toContain('Finding:');
+    expect(truncated).toContain('Conclusion reached.');
+    expect(truncated).toContain('sub-agent output truncated');
+  });
+
+  it('multiple subagent results combined still fit parent context', () => {
+    // Simulate 3 parallel subagent tasks each returning large results
+    const maxResultCharsPerSubagent = 8192;
+    const results = [
+      'A'.repeat(maxResultCharsPerSubagent),
+      'B'.repeat(maxResultCharsPerSubagent),
+      'C'.repeat(maxResultCharsPerSubagent),
+    ];
+
+    // Parent context: system + messages + 3 tool results
+    const systemTokens = 500;
+    const conversationTokens = 2000;
+    const totalResultTokens = results.reduce(
+      (sum, r) => sum + Math.ceil(r.length / 4),
+      0
+    );
+    const totalUsed = systemTokens + conversationTokens + totalResultTokens;
+
+    // With 3 subagents at 8192 chars each (≈2048 tokens each), total ≈ 6144 + 2500 = 8644 tokens
+    // Fits within a 16K context window
+    expect(totalUsed).toBeLessThan(16000);
+  });
+
+  it('subagent result truncation preserves actionable content', () => {
+    // Simulate a subagent that found code, data, and conclusions
+    const codeBlock = '```typescript\nfunction process() { return 42; }\n```\n';
+    const dataSection =
+      'Data: ' + JSON.stringify({ metric: 99.5, status: 'healthy' }) + '\n';
+    const middlePadding = 'Analysis details '.repeat(3000); // ~51K chars
+    const conclusion =
+      '\nFinal answer: The system is operating within normal parameters.';
+
+    const fullResult = codeBlock + dataSection + middlePadding + conclusion;
+    const maxChars = 2000;
+
+    // Truncation keeps head (60%) and tail (40%)
+    const notice =
+      '\n\n[... sub-agent output truncated — middle section omitted to fit parent context ...]\n\n';
+    const available = maxChars - notice.length;
+    const headSize = Math.floor(available * 0.6);
+    const tailSize = available - headSize;
+    const truncated =
+      fullResult.substring(0, headSize) +
+      notice +
+      fullResult.substring(fullResult.length - tailSize);
+
+    // Head should contain the code and data (actionable)
+    expect(truncated).toContain('function process()');
+    expect(truncated).toContain('metric');
+    // Tail should contain the conclusion
+    expect(truncated).toContain('Final answer');
+  });
+});
+
+// ============================================================================
+// 2. Agent Handoff with Context Compaction E2E
+// ============================================================================
+
+describe('Agent handoff with context compaction E2E', () => {
+  it('compacts context before handoff when sender exceeds receiver budget', async () => {
+    // Agent A has 200K context, Agent B has 32K context
+    const senderMessages = buildConversation(50, 500); // 50 turns, ~500 chars each ≈ lots of tokens
+    const receiverMaxTokens = 8000; // 32K chars
+
+    // Calculate sender's context tokens
+    const senderTokens = senderMessages.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+
+    // Check if compaction needed (>70% of receiver budget)
+    const compactionThreshold = receiverMaxTokens * 0.7;
+    expect(senderTokens).toBeGreaterThan(compactionThreshold);
+
+    // Compact: summarize + keep last 3 messages
+    const result = await summarize(senderMessages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+      summaryBudget: Math.floor(receiverMaxTokens * 0.2),
+    });
+
+    expect(result.tier).toBe('full');
+    expect(result.summary).toBeTruthy();
+
+    // Build compacted messages: system summary + last 3 messages
+    const compactedMessages = [
+      new SystemMessage({ content: `[Handoff Briefing]\n${result.summary}` }),
+      ...senderMessages.slice(-3),
+    ];
+
+    // Compacted context fits receiver budget
+    const compactedTokens = compactedMessages.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+    expect(compactedTokens).toBeLessThan(receiverMaxTokens);
+  });
+
+  it('preserves critical context through handoff compaction', async () => {
+    // First message has the user's original intent
+    const messages: BaseMessage[] = [
+      new HumanMessage({
+        content:
+          'Create a quarterly revenue report for Q4 2025 with charts and analysis',
+      }),
+      new AIMessage({ content: 'I will analyze the revenue data.' }),
+      // ... many intermediate messages ...
+      ...buildConversation(20, 300),
+      // Last messages have current progress
+      new HumanMessage({
+        content: 'Now add the competitor comparison section',
+      }),
+      new AIMessage({
+        content: 'Adding competitor analysis from the market data...',
+      }),
+    ];
+
+    // Emergency summary should capture first user intent and last state
+    const emergency = createEmergencySummary(messages);
+    expect(emergency).toContain('quarterly revenue report');
+    expect(emergency).toContain('competitor');
+
+    // Full summary should also capture it
+    const result = await summarize(messages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+    expect(result.summary.length).toBeGreaterThan(0);
+    expect(result.messagesCompacted).toBe(messages.length);
+  });
+
+  it('handles handoff to agent with smaller context gracefully', async () => {
+    // Simulate large context being handed to a mini agent
+    const largeContext = buildConversation(100, 400); // Very large conversation
+    const miniAgentBudget = 4000; // Very small budget (~16K chars)
+
+    // First try full summarize
+    const result = await summarize(largeContext, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+      summaryBudget: Math.floor(miniAgentBudget * 0.2),
+    });
+
+    // Should produce a summary
+    expect(result.summary.length).toBeGreaterThan(0);
+
+    // Build handoff context
+    const handoffMessages = [
+      new SystemMessage({ content: `[Handoff Briefing]\n${result.summary}` }),
+      ...largeContext.slice(-2), // Keep last exchange
+    ];
+
+    const handoffTokens = handoffMessages.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+    // Should fit within mini agent budget with room for its own responses
+    expect(handoffTokens).toBeLessThan(miniAgentBudget * 0.5);
+  });
+
+  it('generates error ToolMessage for invalid handoff destination', () => {
+    const agentContexts = new Map([
+      ['research-agent', { name: 'Research Agent', maxContextTokens: 200000 }],
+      ['writing-agent', { name: 'Writing Agent', maxContextTokens: 32000 }],
+    ]);
+
+    const invalidDest = 'coding-agent';
+    expect(agentContexts.has(invalidDest)).toBe(false);
+
+    // Build error message for self-correction
+    const availableAgents = Array.from(agentContexts.keys()).join(', ');
+    const errorMsg = new ToolMessage({
+      content: `Agent "${invalidDest}" does not exist. Available agents: ${availableAgents}. Please choose a valid agent.`,
+      tool_call_id: 'handoff_call_123',
+    });
+
+    expect(errorMsg.content).toContain('coding-agent');
+    expect(errorMsg.content).toContain('research-agent');
+    expect(errorMsg.content).toContain('writing-agent');
+  });
+});
+
+// ============================================================================
+// 3. Agent Chaining with Rolling Summaries
+// ============================================================================
+
+describe('Agent chaining with rolling summaries', () => {
+  it('maintains context across 3-agent chain via rolling summaries', async () => {
+    // Agent A: Research phase
+    const agentAMessages: BaseMessage[] = [
+      new HumanMessage({ content: 'Research the impact of AI on healthcare' }),
+      new AIMessage({
+        content:
+          'Found 15 papers on AI diagnostics, drug discovery, and telemedicine.',
+      }),
+      new HumanMessage({ content: 'Focus on drug discovery findings' }),
+      new AIMessage({
+        content:
+          'Drug discovery: AI reduces development time by 40%. Key compounds identified.',
+      }),
+    ];
+
+    // Summarize Agent A context before passing to Agent B
+    const summaryA = await summarize(agentAMessages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+    expect(summaryA.tier).toBe('full');
+
+    // Agent B: Analysis phase — receives Agent A's summary
+    const agentBMessages: BaseMessage[] = [
+      new SystemMessage({
+        content: `[Previous Agent Summary]\n${summaryA.summary}`,
+      }),
+      new HumanMessage({
+        content: 'Analyze the drug discovery data and create visualizations',
+      }),
+      new AIMessage({
+        content:
+          'Created 3 charts showing AI impact on drug development timelines.',
+      }),
+    ];
+
+    // Summarize Agent B context (including Agent A's summary) before passing to Agent C
+    const summaryB = await summarize(agentBMessages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+    expect(summaryB.tier).toBe('full');
+    // Agent B's summary should reference Agent A's work
+    expect(summaryB.messagesCompacted).toBe(agentBMessages.length);
+
+    // Agent C: Report generation — receives accumulated summaries
+    const agentCMessages: BaseMessage[] = [
+      new SystemMessage({ content: `[Chain Summary]\n${summaryB.summary}` }),
+      new HumanMessage({
+        content:
+          'Generate the final report with all findings and visualizations',
+      }),
+    ];
+
+    // Agent C has enough context to generate the report
+    const cTokens = agentCMessages.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+    expect(cTokens).toBeLessThan(8000); // Well within any model's budget
+  });
+
+  it('chain summary grows but stays within budget', async () => {
+    // Simulate a 5-agent chain where each adds to the rolling summary
+    let rollingSummary = '';
+
+    for (let i = 0; i < 5; i++) {
+      const agentMessages: BaseMessage[] = [
+        ...(rollingSummary
+          ? [
+              new SystemMessage({
+                content: `[Chain Summary]\n${rollingSummary}`,
+              }),
+            ]
+          : []),
+        new HumanMessage({ content: `Agent ${i} task: process step ${i}` }),
+        new AIMessage({
+          content: `Agent ${i} completed step ${i}. ${'Result data '.repeat(50)}`,
+        }),
+      ];
+
+      const result = await summarize(agentMessages, mockSummarizeCallback, {
+        tokenCounter: simpleTokenCounter,
+        summaryBudget: 500,
+      });
+
+      rollingSummary = result.summary;
+    }
+
+    // After 5 agents, rolling summary should still be manageable
+    const summaryTokens = Math.ceil(rollingSummary.length / 4);
+    expect(summaryTokens).toBeLessThan(1000); // Summary stays compact
+    expect(rollingSummary.length).toBeGreaterThan(0);
+  });
+
+  it('emergency summary preserves chain context when LLM fails', async () => {
+    // Agent chain where LLM fails mid-chain
+    const chainMessages: BaseMessage[] = [
+      new SystemMessage({
+        content: '[Chain Summary] Previous agents researched AI healthcare.',
+      }),
+      new HumanMessage({
+        content: 'Continue the analysis with cost projections',
+      }),
+      new AIMessage({ content: 'Cost analysis shows 30% reduction possible.' }),
+      new ToolMessage({
+        content: 'spreadsheet data loaded',
+        tool_call_id: 'tool_1',
+      }),
+      new HumanMessage({ content: 'Add regulatory compliance section' }),
+      new AIMessage({
+        content: 'Regulatory review completed for FDA pathways.',
+      }),
+    ];
+
+    // LLM unavailable — falls to emergency
+    const result = await summarize(chainMessages, failingSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+
+    expect(result.tier).toBe('emergency');
+    expect(result.summary).toContain('cost projections'); // First user msg
+    expect(result.summary).toContain('FDA'); // Last AI msg
+    expect(result.summary).toContain('Messages compacted: 6'); // Total count
+  });
+});
+
+// ============================================================================
+// 4. Continuation Exhaustion and Retry
+// ============================================================================
+
+describe('Continuation exhaustion and retry', () => {
+  it('detects max_tokens finish reason requiring continuation', () => {
+    const finishReasons = ['length', 'max_tokens', 'end_turn', 'stop', null];
+    const needsContinuation = finishReasons.filter(
+      (r) => r === 'length' || r === 'max_tokens'
+    );
+    expect(needsContinuation).toEqual(['length', 'max_tokens']);
+  });
+
+  it('enforces maxContinuations limit', () => {
+    const maxContinuations = 5;
+    let continuationCount = 0;
+    const results: string[] = [];
+
+    // Simulate continuation loop
+    while (continuationCount < maxContinuations) {
+      const finishReason = 'max_tokens'; // Always hits limit
+      if (finishReason !== 'max_tokens' && finishReason !== 'length') {
+        break;
+      }
+      continuationCount++;
+      results.push(`Continuation ${continuationCount}`);
+    }
+
+    expect(continuationCount).toBe(maxContinuations);
+    expect(results.length).toBe(maxContinuations);
+  });
+
+  it('appends truncation notice when all continuations exhausted', () => {
+    const maxContinuations = 5;
+    const continuationCount = 5;
+    const lastFinishReason = 'max_tokens';
+
+    const isExhausted =
+      continuationCount >= maxContinuations &&
+      lastFinishReason === 'max_tokens';
+    expect(isExhausted).toBe(true);
+
+    // Truncation notice appended to last content
+    const truncationNotice =
+      '\n\n[Note: Response was truncated due to length. Ask me to continue if you need the rest.]';
+    const lastContent = 'Some AI response that was cut off';
+    const withNotice = lastContent + truncationNotice;
+    expect(withNotice).toContain('truncated due to length');
+    expect(withNotice).toContain('continue');
+  });
+
+  it('retry-once logic: retries after 2s delay then gives up', async () => {
+    let attempts = 0;
+    let retried = false;
+
+    const simulateContinuation = async (): Promise<string> => {
+      attempts++;
+      if (attempts === 1) {
+        throw new Error('Temporary failure');
+      }
+      return 'Recovered content';
+    };
+
+    // First attempt fails, retry once
+    try {
+      await simulateContinuation();
+    } catch {
+      if (!retried) {
+        retried = true;
+        // In real code: await new Promise(r => setTimeout(r, 2000));
+        const result = await simulateContinuation();
+        expect(result).toBe('Recovered content');
+      }
+    }
+
+    expect(attempts).toBe(2);
+    expect(retried).toBe(true);
+  });
+
+  it('saves partial response with interruption notice on final failure', () => {
+    const partialResponse = 'Here is the beginning of the analysis...';
+    const interruptionNotice =
+      '\n\n[Response interrupted: An error occurred while generating this response. The content above may be incomplete.]';
+
+    const finalContent = partialResponse + interruptionNotice;
+    expect(finalContent).toContain('interrupted');
+    expect(finalContent).toContain('beginning of the analysis');
+  });
+
+  it('context compaction enables additional continuations', async () => {
+    // After 5 continuations, compact context to free space for more
+    const longConversation = buildConversation(30, 400); // 30 turns
+
+    // Before compaction: high utilization
+    const totalTokens = longConversation.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+    const maxTokens = totalTokens + 2000; // Just barely fits
+    const utilBefore = getContextUtilization(
+      Object.fromEntries(
+        longConversation.map((_, i) => [
+          String(i),
+          simpleTokenCounter(longConversation[i]),
+        ])
+      ),
+      500,
+      maxTokens
+    );
+    expect(utilBefore).toBeGreaterThan(80);
+
+    // After compaction
+    const result = await summarize(longConversation, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+
+    const compactedMessages = [
+      new SystemMessage({
+        content: `[Conversation Summary]\n${result.summary}`,
+      }),
+      ...longConversation.slice(-3),
+    ];
+    const compactedTokens = compactedMessages.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+
+    // After compaction, plenty of room for more continuations
+    expect(compactedTokens).toBeLessThan(maxTokens * 0.5);
+  });
+});
+
+// ============================================================================
+// 5. Pre-invocation Utilization Gate
+// ============================================================================
+
+describe('Pre-invocation utilization gate', () => {
+  it('emits warning at 70-85% utilization', () => {
+    const maxContextTokens = 10000;
+    const currentTokens = 7500; // 75%
+
+    const utilization = (currentTokens / maxContextTokens) * 100;
+    const events: Array<{ type: string; level: string }> = [];
+
+    if (utilization > 95) {
+      events.push({ type: 'ON_CONTEXT_PRESSURE', level: 'emergency' });
+    } else if (utilization > 85) {
+      events.push({ type: 'ON_CONTEXT_PRESSURE', level: 'critical' });
+    } else if (utilization > 70) {
+      events.push({ type: 'ON_CONTEXT_PRESSURE', level: 'warning' });
+    }
+
+    expect(events).toHaveLength(1);
+    expect(events[0].level).toBe('warning');
+  });
+
+  it('triggers proactive compaction at 85-95% utilization', async () => {
+    const maxContextTokens = 10000;
+    const currentTokens = 9000; // 90%
+    const utilization = (currentTokens / maxContextTokens) * 100;
+
+    expect(utilization).toBeGreaterThan(85);
+    expect(utilization).toBeLessThan(95);
+
+    // Should trigger proactive compaction
+    const messages = buildConversation(20, 200);
+    const result = await summarize(messages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+
+    expect(result.summary.length).toBeGreaterThan(0);
+    // After compaction, utilization should drop significantly
+    const compactedTokens = Math.ceil(result.summary.length / 4) + 500; // summary + last few messages
+    const newUtilization = (compactedTokens / maxContextTokens) * 100;
+    expect(newUtilization).toBeLessThan(50);
+  });
+
+  it('triggers emergency compaction at >95% utilization', async () => {
+    const maxContextTokens = 10000;
+    const currentTokens = 9600; // 96%
+    const utilization = (currentTokens / maxContextTokens) * 100;
+
+    expect(utilization).toBeGreaterThan(95);
+
+    // Emergency: no LLM call, pure extraction
+    const messages = buildConversation(30, 300);
+    const emergency = createEmergencySummary(messages);
+    expect(emergency).toBeTruthy();
+    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 delegation hint below 70%', () => {
+    const utilization = 65;
+    let delegationInjected = false;
+
+    if (utilization > 70) {
+      delegationInjected = true;
+    }
+
+    expect(delegationInjected).toBe(false);
+  });
+});
+
+// ============================================================================
+// 6. Emergency Context Preservation (First+Last Pair)
+// ============================================================================
+
+describe('Emergency context preservation', () => {
+  it('preserves first user message and last AI message from 50-turn conversation', () => {
+    const messages = buildConversation(50, 200);
+    const emergency = createEmergencySummary(messages);
+
+    // Should contain first user intent
+    expect(emergency).toContain('User message 0');
+    // Should contain last AI state
+    expect(emergency).toContain('AI response 49');
+    // Should report correct count
+    expect(emergency).toContain('Messages compacted: 100');
+  });
+
+  it('captures tool names in emergency summary', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage({ content: 'Search for revenue data' }),
+      new ToolMessage({
+        content: 'Found 5 documents',
+        tool_call_id: 'tc_1',
+        name: 'file_search',
+      }),
+      new ToolMessage({
+        content: 'Web results for Q4',
+        tool_call_id: 'tc_2',
+        name: 'web_search',
+      }),
+      new ToolMessage({
+        content: 'Code executed successfully',
+        tool_call_id: 'tc_3',
+        name: 'code_execution',
+      }),
+      new AIMessage({ content: 'Analysis complete' }),
+    ];
+
+    const emergency = createEmergencySummary(messages);
+    expect(emergency).toContain('file_search');
+    expect(emergency).toContain('web_search');
+    expect(emergency).toContain('code_execution');
+  });
+
+  it('emergency summary never throws even with malformed messages', () => {
+    const weirdMessages: BaseMessage[] = [
+      new HumanMessage({ content: '' }), // Empty
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      new AIMessage({ content: [{ type: 'text', text: '' }] as any }), // Complex empty
+      new SystemMessage({ content: 'system' }),
+    ];
+
+    expect(() => createEmergencySummary(weirdMessages)).not.toThrow();
+    const result = createEmergencySummary(weirdMessages);
+    expect(typeof result).toBe('string');
+  });
+
+  it('preserves context even when all intermediate messages are removed', async () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage({
+        content: 'CRITICAL: Build the authentication system for the app',
+      }),
+      ...buildConversation(40, 300), // 40 turns of intermediate work
+      new HumanMessage({ content: 'Now deploy to production' }),
+      new AIMessage({
+        content: 'Deploying the authentication system to AWS ECS...',
+      }),
+    ];
+
+    const emergency = createEmergencySummary(messages);
+    // First user message preserved
+    expect(emergency).toContain('authentication system');
+    // Last AI response preserved
+    expect(emergency).toContain('Deploying');
+  });
+});
+
+// ============================================================================
+// 7. Multi-Agent Context Handoff Scenarios
+// ============================================================================
+
+describe('Multi-agent context handoff scenarios', () => {
+  it('research agent → writing agent handoff preserves findings', async () => {
+    const researchMessages: BaseMessage[] = [
+      new HumanMessage({
+        content: 'Research competitors: Acme Corp, Beta Inc, Gamma Ltd',
+      }),
+      new ToolMessage({
+        content: 'Acme Corp: $50M revenue, 200 employees',
+        tool_call_id: 'ws_1',
+        name: 'web_search',
+      }),
+      new ToolMessage({
+        content: 'Beta Inc: $30M revenue, 150 employees',
+        tool_call_id: 'ws_2',
+        name: 'web_search',
+      }),
+      new AIMessage({
+        content:
+          'Found competitive data: Acme leads with $50M, Beta at $30M, Gamma data unavailable.',
+      }),
+    ];
+
+    // Summarize for handoff
+    const result = await summarize(researchMessages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+
+    expect(result.tier).toBe('full');
+    expect(result.messagesCompacted).toBe(4);
+
+    // Writing agent receives the summary
+    const writingContext = [
+      new SystemMessage({
+        content: `[Handoff from Research Agent]\n${result.summary}\n\nYou are the Writing Agent. Create a report based on the research above.`,
+      }),
+    ];
+
+    const writingTokens = writingContext.reduce(
+      (sum, m) => sum + simpleTokenCounter(m),
+      0
+    );
+    expect(writingTokens).toBeLessThan(2000);
+  });
+
+  it('handles cascade handoff: A → B → C → A (circular)', async () => {
+    // A → B handoff
+    const summaryAB = await summarize(
+      buildConversation(5, 200),
+      mockSummarizeCallback,
+      {
+        tokenCounter: simpleTokenCounter,
+      }
+    );
+
+    // B → C handoff
+    const summaryBC = await summarize(
+      [
+        new SystemMessage({ content: `[From A]\n${summaryAB.summary}` }),
+        ...buildConversation(3, 200),
+      ],
+      mockSummarizeCallback,
+      { tokenCounter: simpleTokenCounter }
+    );
+
+    // C → A handoff (back to original)
+    const summaryCA = await summarize(
+      [
+        new SystemMessage({ content: `[From B via A]\n${summaryBC.summary}` }),
+        ...buildConversation(3, 200),
+      ],
+      mockSummarizeCallback,
+      { tokenCounter: simpleTokenCounter }
+    );
+
+    // All summaries should exist and be compact
+    expect(summaryAB.summary.length).toBeGreaterThan(0);
+    expect(summaryBC.summary.length).toBeGreaterThan(0);
+    expect(summaryCA.summary.length).toBeGreaterThan(0);
+
+    // Final summary shouldn't have exploded in size
+    const finalTokens = Math.ceil(summaryCA.summary.length / 4);
+    expect(finalTokens).toBeLessThan(1000);
+  });
+
+  it('multi-agent workflow state is included in full summary prompt', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage({ content: 'Start multi-agent research' }),
+      new AIMessage({ content: 'Delegating to specialized agents.' }),
+    ];
+
+    const formatted = formatMessagesForSummary(messages);
+    const prompt = buildFullSummaryPrompt(formatted, {
+      isMultiAgent: true,
+      agentWorkflowState: {
+        currentAgentId: 'analysis-agent',
+        agentChain: ['research-agent', 'analysis-agent'],
+        pendingAgents: ['writing-agent'],
+      },
+    });
+
+    expect(prompt).toContain('analysis-agent');
+    expect(prompt).toContain('research-agent');
+    expect(prompt).toContain('writing-agent');
+    expect(prompt).toContain('Agent Workflow State');
+  });
+});
+
+// ============================================================================
+// 8. summaryModel Dedicated Cheap Model Usage
+// ============================================================================
+
+describe('summaryModel dedicated cheap model usage', () => {
+  it('summarize passes maxOutputTokens to callback for model configuration', async () => {
+    let capturedMaxTokens: number | undefined;
+
+    const trackingCallback = async (
+      prompt: string,
+      maxTokens: number
+    ): Promise<string> => {
+      capturedMaxTokens = maxTokens;
+      return '[Summary] Tracked callback.';
+    };
+
+    await summarize(buildConversation(5, 200), trackingCallback, {
+      tokenCounter: simpleTokenCounter,
+      maxOutputTokens: 2048,
+    });
+
+    expect(capturedMaxTokens).toBe(2048);
+  });
+
+  it('Tier 2 uses lower maxTokens (512) than Tier 1', async () => {
+    const capturedMaxTokens: number[] = [];
+    let callCount = 0;
+
+    const tieredCallback = async (
+      prompt: string,
+      maxTokens: number
+    ): Promise<string> => {
+      capturedMaxTokens.push(maxTokens);
+      callCount++;
+      if (callCount === 1) {
+        throw new Error('Tier 1 failed'); // Force fallback to Tier 2
+      }
+      return '[Simple Summary]';
+    };
+
+    await summarize(buildConversation(5, 200), tieredCallback, {
+      tokenCounter: simpleTokenCounter,
+      maxOutputTokens: 1024,
+    });
+
+    // Tier 1 tried with 1024, Tier 2 tried with 512
+    expect(capturedMaxTokens[0]).toBe(1024);
+    expect(capturedMaxTokens[1]).toBe(512);
+  });
+
+  it('summaryModel config follows titleModel pattern', () => {
+    // Verify the config structure matches expectations
+    const endpointConfig = {
+      titleModel: 'us.amazon.nova-micro-v1:0',
+      summaryModel: 'us.anthropic.claude-haiku-4-5-20251001-v1:0',
+      modelDisplayLabel: 'Ranger',
+    };
+
+    // summaryModel should be a different, cheaper model than the main model
+    expect(endpointConfig.summaryModel).not.toBe(endpointConfig.titleModel);
+    expect(endpointConfig.summaryModel).toContain('haiku'); // Cheap model
+  });
+
+  it('falls back through provider defaults when no summaryModel configured', () => {
+    const providers = [
+      { name: 'bedrock', expected: 'claude-3-haiku-20240307' },
+      { name: 'anthropic', expected: 'claude-3-haiku-20240307' },
+      { name: 'openAI', expected: 'gpt-4o-mini' },
+      { name: 'google', expected: 'gemini-2.0-flash' },
+      { name: 'unknown', expected: 'claude-3-haiku-20240307' },
+    ];
+
+    for (const { name, expected } of providers) {
+      let summaryModel: string;
+      if (name === 'bedrock' || name === 'anthropic') {
+        summaryModel = 'claude-3-haiku-20240307';
+      } else if (name === 'openAI' || name === 'azureOpenAI') {
+        summaryModel = 'gpt-4o-mini';
+      } else if (name === 'google') {
+        summaryModel = 'gemini-2.0-flash';
+      } else {
+        summaryModel = 'claude-3-haiku-20240307';
+      }
+      expect(summaryModel).toBe(expected);
+    }
+  });
+});
+
+// ============================================================================
+// 9. Config Wiring Validation
+// ============================================================================
+
+describe('Config wiring validation', () => {
+  it('contextManagement config has all required fields', () => {
+    const config = {
+      compactMode: 'auto',
+      recoveryMode: 'summarize',
+      continuationRetries: 1,
+      toolResultBudgetPct: 0.3,
+      subagentMaxResultTokens: 8192,
+      chainRollingSummary: false,
+      fileReadDedup: true,
+      compactionAudit: true,
+    };
+
+    // All fields present
+    expect(config.compactMode).toBeDefined();
+    expect(config.recoveryMode).toBeDefined();
+    expect(config.continuationRetries).toBeDefined();
+    expect(config.toolResultBudgetPct).toBeDefined();
+    expect(config.subagentMaxResultTokens).toBeDefined();
+    expect(config.chainRollingSummary).toBeDefined();
+    expect(config.fileReadDedup).toBeDefined();
+    expect(config.compactionAudit).toBeDefined();
+  });
+
+  it('subagentMaxResultTokens converts to chars correctly', () => {
+    const tokenValues = [4096, 8192, 16384, 32768];
+    for (const tokens of tokenValues) {
+      const chars = tokens * 4;
+      expect(chars).toBe(tokens * 4);
+      // Chars should be reasonable (not exceeding 200K chars)
+      expect(chars).toBeLessThan(200000);
+    }
+  });
+
+  it('compactMode values are valid', () => {
+    const validModes = ['auto', 'summarize', 'prune'];
+    for (const mode of validModes) {
+      expect(['auto', 'summarize', 'prune']).toContain(mode);
+    }
+  });
+
+  it('recoveryMode values are valid', () => {
+    const validModes = ['summarize', 'prune', 'emergency'];
+    for (const mode of validModes) {
+      expect(['summarize', 'prune', 'emergency']).toContain(mode);
+    }
+  });
+});
+
+// ============================================================================
+// 10. Stress Tests: Large Conversations
+// ============================================================================
+
+describe('Stress tests with large conversations', () => {
+  it('handles 200-turn conversation summarization', async () => {
+    const messages = buildConversation(200, 100); // 400 messages
+    expect(messages.length).toBe(400);
+
+    const result = await summarize(messages, mockSummarizeCallback, {
+      tokenCounter: simpleTokenCounter,
+    });
+
+    expect(result.summary.length).toBeGreaterThan(0);
+    expect(result.messagesCompacted).toBe(400);
+  });
+
+  it('emergency summary from 500-turn conversation is still compact', () => {
+    const messages = buildConversation(500, 50); // 1000 messages
+    const emergency = createEmergencySummary(messages);
+
+    // Emergency summary should be compact regardless of input size
+    expect(emergency.length).toBeLessThan(3000);
+    expect(emergency).toContain('Messages compacted: 1000');
+  });
+
+  it('getContextUtilization handles 1000-message token map', () => {
+    const map: Record<string, number> = {};
+    for (let i = 0; i < 1000; i++) {
+      map[String(i)] = 100;
+    }
+    const result = getContextUtilization(map, 500, 200000);
+    // 1000 * 100 + 500 = 100500 / 200000 = 50.25%
+    expect(result).toBeCloseTo(50.25, 1);
+  });
+});