agentic-qe 3.8.13 → 3.9.0

package/dist/context/compaction/llm-caller-adapter.js

@@ -0,0 +1,47 @@
+/**
+ * Agentic QE v3 - LLM Caller Adapter for Tier 3 Compaction (IMP-08)
+ *
+ * Lightweight adapter that creates an LLMCompactCaller from an Anthropic
+ * API key. Uses Haiku-class model for cost efficiency. Falls back
+ * gracefully when no API key is available.
+ */
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create an LLMCompactCaller if an Anthropic API key is available.
+ * Returns undefined if no key is found (Tier 3 will use extractive fallback).
+ */
+export function createLLMCompactCaller() {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        return undefined;
+    const baseUrl = process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com';
+    const model = 'claude-haiku-4-5-20251001'; // Cost-effective for summarization
+    return {
+        async call(systemPrompt, userPrompt) {
+            const response = await fetch(`${baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'anthropic-version': '2023-06-01',
+                    'x-api-key': apiKey,
+                },
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 4096,
+                    system: systemPrompt,
+                    messages: [{ role: 'user', content: userPrompt }],
+                }),
+            });
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(`LLM compact call failed (${response.status}): ${errorData.error?.message ?? 'unknown'}`);
+            }
+            const data = await response.json();
+            const textBlock = data.content.find(b => b.type === 'text');
+            return textBlock?.text ?? '';
+        },
+    };
+}
+//# sourceMappingURL=llm-caller-adapter.js.map

package/dist/context/compaction/tier1-microcompact.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agentic QE v3 - Tier 1: Microcompact Bridge (IMP-08)
+ *
+ * Thin integration layer that bridges the IMP-01 MicrocompactEngine into
+ * the 4-tier compaction pipeline. Tier 1 is zero-API-call: it evicts stale
+ * tool results based on age and context pressure.
+ *
+ * This module does NOT duplicate IMP-01 logic — it delegates to the existing
+ * MicrocompactEngine and translates its results into the CompactionResult
+ * format used by the pipeline.
+ */
+import { MicrocompactEngine, type MicrocompactOptions } from '../../mcp/middleware/microcompact';
+export interface Tier1Result {
+    tier: 1;
+    tokensSaved: number;
+    clearedCount: number;
+    totalTokens: number;
+    totalResults: number;
+}
+export declare class Tier1Microcompact {
+    private readonly engine;
+    constructor(options?: MicrocompactOptions);
+    /**
+     * Construct from an existing MicrocompactEngine instance
+     * (e.g., the one already registered as middleware via IMP-01).
+     */
+    static fromEngine(engine: MicrocompactEngine): Tier1Microcompact;
+    /** Run microcompact eviction and return a pipeline-compatible result. */
+    compact(): Tier1Result;
+    /** Expose the underlying engine for callers that need direct access. */
+    getEngine(): MicrocompactEngine;
+}
+//# sourceMappingURL=tier1-microcompact.d.ts.map

package/dist/context/compaction/tier1-microcompact.js

@@ -0,0 +1,47 @@
+/**
+ * Agentic QE v3 - Tier 1: Microcompact Bridge (IMP-08)
+ *
+ * Thin integration layer that bridges the IMP-01 MicrocompactEngine into
+ * the 4-tier compaction pipeline. Tier 1 is zero-API-call: it evicts stale
+ * tool results based on age and context pressure.
+ *
+ * This module does NOT duplicate IMP-01 logic — it delegates to the existing
+ * MicrocompactEngine and translates its results into the CompactionResult
+ * format used by the pipeline.
+ */
+import { MicrocompactEngine, } from '../../mcp/middleware/microcompact';
+// ============================================================================
+// Tier1Microcompact
+// ============================================================================
+export class Tier1Microcompact {
+    engine;
+    constructor(options) {
+        this.engine = new MicrocompactEngine(options);
+    }
+    /**
+     * Construct from an existing MicrocompactEngine instance
+     * (e.g., the one already registered as middleware via IMP-01).
+     */
+    static fromEngine(engine) {
+        const tier = new Tier1Microcompact();
+        // Replace internal engine with the shared one
+        tier.engine = engine;
+        return tier;
+    }
+    /** Run microcompact eviction and return a pipeline-compatible result. */
+    compact() {
+        const result = this.engine.compact();
+        return {
+            tier: 1,
+            tokensSaved: result.tokensSaved,
+            clearedCount: result.clearedCount,
+            totalTokens: result.totalTokens,
+            totalResults: result.totalResults,
+        };
+    }
+    /** Expose the underlying engine for callers that need direct access. */
+    getEngine() {
+        return this.engine;
+    }
+}
+//# sourceMappingURL=tier1-microcompact.js.map

package/dist/context/compaction/tier2-session-summary.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Agentic QE v3 - Tier 2: QE Session Summary (IMP-08)
+ *
+ * Builds a structured session summary from already-captured context data,
+ * without making any API calls. Uses ContextCompiler output (memory,
+ * coverage, test results, requirements, defects, git) to produce a
+ * condensed representation that preserves QE-relevant state.
+ *
+ * Key constraints:
+ *   - Zero API calls (purely local computation)
+ *   - Preserves tool_use / tool_result message pairs (never breaks pairs)
+ *   - Retains at least `minRecentTokens` of recent conversation
+ *   - Caps summary at `maxSummaryTokens`
+ */
+export interface ConversationMessage {
+    role: 'user' | 'assistant' | 'tool_use' | 'tool_result';
+    content: string;
+    toolName?: string;
+    timestamp?: number;
+    estimatedTokens?: number;
+    /** If this is a tool_use, the ID linking it to its tool_result pair */
+    toolUseId?: string;
+}
+export interface SessionSummaryOptions {
+    /** Minimum tokens of recent conversation to preserve (default: 10_000) */
+    minRecentTokens?: number;
+    /** Maximum tokens for the summary output (default: 40_000) */
+    maxSummaryTokens?: number;
+}
+export interface Tier2Result {
+    tier: 2;
+    /** The condensed summary text */
+    summary: string;
+    /** Tokens in the summary */
+    summaryTokens: number;
+    /** Messages preserved verbatim (recent tail) */
+    preservedMessages: ConversationMessage[];
+    /** Tokens in preserved messages */
+    preservedTokens: number;
+    /** Total messages before compaction */
+    originalMessageCount: number;
+    /** Messages removed */
+    removedMessageCount: number;
+    /** Tokens freed */
+    tokensSaved: number;
+}
+export declare class Tier2SessionSummary {
+    private readonly minRecentTokens;
+    private readonly maxSummaryTokens;
+    constructor(options?: SessionSummaryOptions);
+    /**
+     * Compact a conversation by summarizing old messages and preserving recent ones.
+     *
+     * Algorithm:
+     *   1. Walk backward from the end, accumulating tokens until `minRecentTokens`
+     *      is reached. Never split a tool_use/tool_result pair.
+     *   2. Everything before the split point is summarized into structured sections.
+     *   3. Return summary + preserved tail.
+     */
+    compact(messages: ConversationMessage[]): Tier2Result;
+    /**
+     * Walk backward to find the first index where we've accumulated enough
+     * recent tokens. Never splits a tool_use/tool_result pair.
+     */
+    private findSplitIndex;
+    /**
+     * Build a structured summary from older messages.
+     * Sections mirror QE-specific concerns.
+     */
+    private buildSummary;
+}
+//# sourceMappingURL=tier2-session-summary.d.ts.map

package/dist/context/compaction/tier2-session-summary.js

@@ -0,0 +1,172 @@
+/**
+ * Agentic QE v3 - Tier 2: QE Session Summary (IMP-08)
+ *
+ * Builds a structured session summary from already-captured context data,
+ * without making any API calls. Uses ContextCompiler output (memory,
+ * coverage, test results, requirements, defects, git) to produce a
+ * condensed representation that preserves QE-relevant state.
+ *
+ * Key constraints:
+ *   - Zero API calls (purely local computation)
+ *   - Preserves tool_use / tool_result message pairs (never breaks pairs)
+ *   - Retains at least `minRecentTokens` of recent conversation
+ *   - Caps summary at `maxSummaryTokens`
+ */
+import { estimateTokensPadded } from '../../mcp/middleware/microcompact';
+// ============================================================================
+// Defaults
+// ============================================================================
+const DEFAULT_MIN_RECENT_TOKENS = 10_000;
+const DEFAULT_MAX_SUMMARY_TOKENS = 40_000;
+// ============================================================================
+// Tier2SessionSummary
+// ============================================================================
+export class Tier2SessionSummary {
+    minRecentTokens;
+    maxSummaryTokens;
+    constructor(options = {}) {
+        this.minRecentTokens = options.minRecentTokens ?? DEFAULT_MIN_RECENT_TOKENS;
+        this.maxSummaryTokens = options.maxSummaryTokens ?? DEFAULT_MAX_SUMMARY_TOKENS;
+    }
+    /**
+     * Compact a conversation by summarizing old messages and preserving recent ones.
+     *
+     * Algorithm:
+     *   1. Walk backward from the end, accumulating tokens until `minRecentTokens`
+     *      is reached. Never split a tool_use/tool_result pair.
+     *   2. Everything before the split point is summarized into structured sections.
+     *   3. Return summary + preserved tail.
+     */
+    compact(messages) {
+        if (messages.length === 0) {
+            return {
+                tier: 2,
+                summary: '',
+                summaryTokens: 0,
+                preservedMessages: [],
+                preservedTokens: 0,
+                originalMessageCount: 0,
+                removedMessageCount: 0,
+                tokensSaved: 0,
+            };
+        }
+        // Annotate with token estimates if missing
+        const annotated = messages.map(m => ({
+            ...m,
+            estimatedTokens: m.estimatedTokens ?? estimateTokensPadded(m.content),
+        }));
+        // Find the split point: walk backward, preserving at least minRecentTokens
+        const splitIndex = this.findSplitIndex(annotated);
+        const toSummarize = annotated.slice(0, splitIndex);
+        const toPreserve = annotated.slice(splitIndex);
+        const originalTokens = annotated.reduce((s, m) => s + m.estimatedTokens, 0);
+        const preservedTokens = toPreserve.reduce((s, m) => s + m.estimatedTokens, 0);
+        // Build summary from the older messages
+        const summary = this.buildSummary(toSummarize);
+        const summaryTokens = Math.min(estimateTokensPadded(summary), this.maxSummaryTokens);
+        const tokensSaved = originalTokens - preservedTokens - summaryTokens;
+        return {
+            tier: 2,
+            summary,
+            summaryTokens,
+            preservedMessages: toPreserve,
+            preservedTokens,
+            originalMessageCount: messages.length,
+            removedMessageCount: toSummarize.length,
+            tokensSaved: Math.max(0, tokensSaved),
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Internal
+    // --------------------------------------------------------------------------
+    /**
+     * Walk backward to find the first index where we've accumulated enough
+     * recent tokens. Never splits a tool_use/tool_result pair.
+     */
+    findSplitIndex(messages) {
+        let accumulatedTokens = 0;
+        let splitIndex = messages.length;
+        // Map each toolUseId to the index of its tool_use and tool_result messages
+        const toolUseIndex = new Map();
+        const toolResultIndex = new Map();
+        for (let i = 0; i < messages.length; i++) {
+            const m = messages[i];
+            if (m.toolUseId) {
+                if (m.role === 'tool_use')
+                    toolUseIndex.set(m.toolUseId, i);
+                if (m.role === 'tool_result')
+                    toolResultIndex.set(m.toolUseId, i);
+            }
+        }
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            accumulatedTokens += msg.estimatedTokens ?? 0;
+            splitIndex = i;
+            if (accumulatedTokens >= this.minRecentTokens) {
+                // Before finalizing the split, check we're not orphaning a pair.
+                // Case 1: We landed on a tool_result — pull its tool_use into the preserved set.
+                if (msg.role === 'tool_result' && msg.toolUseId) {
+                    const tuIdx = toolUseIndex.get(msg.toolUseId);
+                    if (tuIdx !== undefined && tuIdx < i) {
+                        splitIndex = tuIdx;
+                    }
+                }
+                // Case 2: We landed on a tool_use whose tool_result is in the preserved tail.
+                // The tool_use is already included, so this is fine — no action needed.
+                // Case 3: We landed on a tool_use whose tool_result is BEFORE us (summarized away).
+                // This means the result is already gone — the tool_use without its result is
+                // useless, so push split one further back to exclude it too.
+                if (msg.role === 'tool_use' && msg.toolUseId) {
+                    const trIdx = toolResultIndex.get(msg.toolUseId);
+                    if (trIdx !== undefined && trIdx < i) {
+                        // The result is in the summarized section — exclude this orphaned tool_use
+                        splitIndex = i + 1;
+                    }
+                }
+                break;
+            }
+        }
+        return splitIndex;
+    }
+    /**
+     * Build a structured summary from older messages.
+     * Sections mirror QE-specific concerns.
+     */
+    buildSummary(messages) {
+        if (messages.length === 0)
+            return '';
+        const sections = [];
+        // Extract user requests
+        const userRequests = messages
+            .filter(m => m.role === 'user')
+            .map(m => m.content.slice(0, 200));
+        if (userRequests.length > 0) {
+            sections.push(`## User Requests\n${userRequests.map(r => `- ${r}`).join('\n')}`);
+        }
+        // Extract tool calls and results
+        const toolCalls = messages.filter(m => m.role === 'tool_use');
+        if (toolCalls.length > 0) {
+            const toolSummary = toolCalls.map(t => `- ${t.toolName ?? 'unknown'}: ${t.content.slice(0, 100)}`);
+            sections.push(`## Tool Calls (${toolCalls.length})\n${toolSummary.join('\n')}`);
+        }
+        // Extract assistant responses (non-tool)
+        const assistantMsgs = messages.filter(m => m.role === 'assistant');
+        if (assistantMsgs.length > 0) {
+            const keyFindings = assistantMsgs
+                .map(m => m.content.slice(0, 150))
+                .slice(-5); // Keep last 5 findings
+            sections.push(`## Key Findings\n${keyFindings.map(f => `- ${f}`).join('\n')}`);
+        }
+        const summary = `# Session Summary (Tier 2 Compaction)\n\n` +
+            `Compacted ${messages.length} messages at ${new Date().toISOString()}\n\n` +
+            sections.join('\n\n');
+        // Truncate if over budget
+        const tokens = estimateTokensPadded(summary);
+        if (tokens > this.maxSummaryTokens) {
+            const charLimit = this.maxSummaryTokens * 3; // reverse of ceil(chars/3)
+            return summary.slice(0, charLimit) + '\n\n[Summary truncated to fit budget]';
+        }
+        return summary;
+    }
+}
+//# sourceMappingURL=tier2-session-summary.js.map

package/dist/context/compaction/tier3-llm-compact.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Agentic QE v3 - Tier 3: LLM-Powered Compaction (IMP-08)
+ *
+ * When session context exceeds safe thresholds and Tier 2 is insufficient,
+ * Tier 3 forks a single LLM call to produce a structured 9-section QE
+ * summary. This is the most expensive compaction tier (one API call) but
+ * produces the highest-quality summaries.
+ *
+ * The 9-section format is QE-specific:
+ *   1. Primary QE Objective
+ *   2. Key Technical Findings
+ *   3. Files and Test Artifacts
+ *   4. Errors and Fixes Applied
+ *   5. Quality Gates Status
+ *   6. All User Requests (verbatim intent)
+ *   7. Pending QE Tasks
+ *   8. Current Analysis State
+ *   9. Suggested Next Action
+ */
+import type { ConversationMessage } from './tier2-session-summary';
+export interface Tier3Options {
+    /** Max tokens reserved for the summary output (default: 20_000) */
+    maxSummaryTokens?: number;
+    /** LLM caller — injected to decouple from routing layer */
+    llmCall?: LLMCompactCaller;
+}
+/**
+ * Abstraction over the LLM call used for compaction.
+ * Implementors wire this to their routing layer (e.g., model-route MCP tool).
+ */
+export interface LLMCompactCaller {
+    /**
+     * Send a single-turn prompt and get a text response.
+     * Should use a cost-effective model (Haiku-class).
+     */
+    call(systemPrompt: string, userPrompt: string): Promise<string>;
+}
+export interface Tier3Result {
+    tier: 3;
+    /** The structured 9-section summary */
+    summary: string;
+    /** Tokens in the summary */
+    summaryTokens: number;
+    /** Original message count */
+    originalMessageCount: number;
+    /** Tokens freed */
+    tokensSaved: number;
+    /** Whether fallback (no LLM) was used */
+    usedFallback: boolean;
+}
+export declare class Tier3LLMCompact {
+    private readonly maxSummaryTokens;
+    private readonly llmCall;
+    constructor(options?: Tier3Options);
+    /**
+     * Compact a conversation using a single LLM call.
+     * Falls back to a local extractive summary if no LLM caller is configured.
+     */
+    compact(messages: ConversationMessage[]): Promise<Tier3Result>;
+    /** Build a compact transcript for the LLM prompt. */
+    private buildTranscript;
+    /** Extractive fallback when no LLM is available. */
+    private extractiveFallback;
+}
+//# sourceMappingURL=tier3-llm-compact.d.ts.map

package/dist/context/compaction/tier3-llm-compact.js

@@ -0,0 +1,166 @@
+/**
+ * Agentic QE v3 - Tier 3: LLM-Powered Compaction (IMP-08)
+ *
+ * When session context exceeds safe thresholds and Tier 2 is insufficient,
+ * Tier 3 forks a single LLM call to produce a structured 9-section QE
+ * summary. This is the most expensive compaction tier (one API call) but
+ * produces the highest-quality summaries.
+ *
+ * The 9-section format is QE-specific:
+ *   1. Primary QE Objective
+ *   2. Key Technical Findings
+ *   3. Files and Test Artifacts
+ *   4. Errors and Fixes Applied
+ *   5. Quality Gates Status
+ *   6. All User Requests (verbatim intent)
+ *   7. Pending QE Tasks
+ *   8. Current Analysis State
+ *   9. Suggested Next Action
+ */
+import { estimateTokensPadded } from '../../mcp/middleware/microcompact';
+// ============================================================================
+// Defaults
+// ============================================================================
+const DEFAULT_MAX_SUMMARY_TOKENS = 20_000;
+const COMPACTION_SYSTEM_PROMPT = `You are a QE session compaction agent. Summarize the conversation into exactly 9 sections.
+Be concise but preserve all actionable information. Use bullet points.
+Output ONLY the 9 sections with their headers — no preamble, no closing.`;
+const COMPACTION_USER_TEMPLATE = `Summarize this QE session into 9 sections:
+
+## 1. Primary QE Objective
+## 2. Key Technical Findings
+## 3. Files and Test Artifacts
+## 4. Errors and Fixes Applied
+## 5. Quality Gates Status
+## 6. All User Requests
+## 7. Pending QE Tasks
+## 8. Current Analysis State
+## 9. Suggested Next Action
+
+Session transcript:
+`;
+// ============================================================================
+// Tier3LLMCompact
+// ============================================================================
+export class Tier3LLMCompact {
+    maxSummaryTokens;
+    llmCall;
+    constructor(options = {}) {
+        this.maxSummaryTokens = options.maxSummaryTokens ?? DEFAULT_MAX_SUMMARY_TOKENS;
+        this.llmCall = options.llmCall;
+    }
+    /**
+     * Compact a conversation using a single LLM call.
+     * Falls back to a local extractive summary if no LLM caller is configured.
+     */
+    async compact(messages) {
+        const originalTokens = messages.reduce((s, m) => s + (m.estimatedTokens ?? estimateTokensPadded(m.content)), 0);
+        if (messages.length === 0) {
+            return {
+                tier: 3,
+                summary: '',
+                summaryTokens: 0,
+                originalMessageCount: 0,
+                tokensSaved: 0,
+                usedFallback: false,
+            };
+        }
+        // Build the transcript to send to the LLM
+        const transcript = this.buildTranscript(messages);
+        let summary;
+        let usedFallback;
+        if (this.llmCall) {
+            try {
+                const userPrompt = COMPACTION_USER_TEMPLATE + transcript;
+                summary = await this.llmCall.call(COMPACTION_SYSTEM_PROMPT, userPrompt);
+                usedFallback = false;
+            }
+            catch {
+                // LLM call failed — fall back to extractive summary
+                summary = this.extractiveFallback(messages);
+                usedFallback = true;
+            }
+        }
+        else {
+            // No LLM configured — use extractive fallback
+            summary = this.extractiveFallback(messages);
+            usedFallback = true;
+        }
+        // Truncate if over budget
+        const summaryTokens = estimateTokensPadded(summary);
+        if (summaryTokens > this.maxSummaryTokens) {
+            const charLimit = this.maxSummaryTokens * 3;
+            summary = summary.slice(0, charLimit) + '\n\n[LLM summary truncated to fit budget]';
+        }
+        const finalTokens = estimateTokensPadded(summary);
+        return {
+            tier: 3,
+            summary,
+            summaryTokens: finalTokens,
+            originalMessageCount: messages.length,
+            tokensSaved: Math.max(0, originalTokens - finalTokens),
+            usedFallback,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Internal
+    // --------------------------------------------------------------------------
+    /** Build a compact transcript for the LLM prompt. */
+    buildTranscript(messages) {
+        // Budget: leave room for system prompt + template + output
+        const maxTranscriptChars = (this.maxSummaryTokens * 3) * 2; // 2x output budget for input
+        const lines = [];
+        let charCount = 0;
+        for (const msg of messages) {
+            const prefix = msg.role === 'tool_use'
+                ? `[tool:${msg.toolName ?? 'unknown'}]`
+                : `[${msg.role}]`;
+            const line = `${prefix} ${msg.content.slice(0, 500)}`;
+            if (charCount + line.length > maxTranscriptChars) {
+                lines.push(`... (${messages.length - lines.length} earlier messages omitted)`);
+                break;
+            }
+            lines.push(line);
+            charCount += line.length;
+        }
+        return lines.join('\n');
+    }
+    /** Extractive fallback when no LLM is available. */
+    extractiveFallback(messages) {
+        const sections = [];
+        // Section 1: Objective — first user message
+        const firstUser = messages.find(m => m.role === 'user');
+        sections.push(`## 1. Primary QE Objective\n${firstUser?.content.slice(0, 300) ?? 'Unknown'}`);
+        // Section 2: Findings — assistant messages
+        const findings = messages
+            .filter(m => m.role === 'assistant')
+            .slice(-3)
+            .map(m => `- ${m.content.slice(0, 150)}`);
+        sections.push(`## 2. Key Technical Findings\n${findings.join('\n') || '- None captured'}`);
+        // Section 3: Files — extract paths from tool calls
+        const filePaths = new Set();
+        for (const m of messages) {
+            const pathMatches = m.content.match(/[\w/.-]+\.(ts|js|json|yaml|md)/g);
+            if (pathMatches)
+                pathMatches.forEach(p => filePaths.add(p));
+        }
+        sections.push(`## 3. Files and Test Artifacts\n${[...filePaths].slice(0, 20).map(f => `- ${f}`).join('\n') || '- None'}`);
+        // Section 4: Errors
+        const errors = messages
+            .filter(m => m.content.toLowerCase().includes('error') || m.content.toLowerCase().includes('fail'))
+            .slice(-3)
+            .map(m => `- ${m.content.slice(0, 100)}`);
+        sections.push(`## 4. Errors and Fixes Applied\n${errors.join('\n') || '- None'}`);
+        // Sections 5-9: minimal placeholders
+        sections.push(`## 5. Quality Gates Status\n- Not assessed (extractive fallback)`);
+        const userReqs = messages
+            .filter(m => m.role === 'user')
+            .map(m => `- ${m.content.slice(0, 200)}`);
+        sections.push(`## 6. All User Requests\n${userReqs.join('\n') || '- None'}`);
+        sections.push(`## 7. Pending QE Tasks\n- Resume from last action`);
+        sections.push(`## 8. Current Analysis State\n- Session compacted at ${new Date().toISOString()}`);
+        sections.push(`## 9. Suggested Next Action\n- Review compacted summary and continue`);
+        return `# QE Session Summary (Tier 3 — Extractive Fallback)\n\n${sections.join('\n\n')}`;
+    }
+}
+//# sourceMappingURL=tier3-llm-compact.js.map

package/dist/context/compaction/tier4-reactive.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Agentic QE v3 - Tier 4: Reactive Compaction (IMP-08)
+ *
+ * Last-resort compaction triggered by 413 errors or context overflow
+ * detection. Aggressively peels the oldest conversation rounds until
+ * the estimated token count drops below the recovery target.
+ *
+ * This tier is destructive — it drops messages entirely (no summary).
+ * It exists to recover from situations where the context window is
+ * critically full and the session would otherwise fail.
+ */
+import type { ConversationMessage } from './tier2-session-summary';
+export interface Tier4Options {
+    /** Target remaining tokens after reactive compaction (default: 30_000) */
+    recoveryTarget?: number;
+    /** Minimum messages to always preserve at the tail (default: 4) */
+    minPreservedMessages?: number;
+}
+export interface Tier4Result {
+    tier: 4;
+    /** Messages surviving after compaction */
+    survivingMessages: ConversationMessage[];
+    /** Surviving token count */
+    survivingTokens: number;
+    /** Messages dropped */
+    droppedCount: number;
+    /** Tokens freed */
+    tokensSaved: number;
+    /** The trigger that caused reactive compaction */
+    trigger: 'status_413' | 'context_overflow' | 'manual';
+}
+export declare class Tier4Reactive {
+    private readonly recoveryTarget;
+    private readonly minPreserved;
+    constructor(options?: Tier4Options);
+    /**
+     * Aggressively peel oldest messages until under the recovery target.
+     *
+     * Algorithm:
+     *   1. Compute total tokens.
+     *   2. If already under target, return early.
+     *   3. Walk forward from the oldest message, dropping messages until
+     *      remaining tokens are at or below recoveryTarget.
+     *   4. Never drop below minPreservedMessages from the tail.
+     *   5. When dropping a tool_result, also drop its paired tool_use (and vice versa).
+     */
+    compact(messages: ConversationMessage[], trigger?: Tier4Result['trigger']): Tier4Result;
+    /**
+     * Convenience: check if a given HTTP status or error message indicates
+     * a context overflow that should trigger reactive compaction.
+     */
+    static isContextOverflow(statusOrMessage: number | string): boolean;
+}
+//# sourceMappingURL=tier4-reactive.d.ts.map