@compilr-dev/agents 0.3.28 → 0.4.0

package/dist/agent.d.ts

@@ -16,6 +16,7 @@ import { PermissionManager } from './permissions/manager.js';
 import { ContextManager } from './context/manager.js';
 import { FileAccessTracker } from './context/file-tracker.js';
 import type { ObservationMaskConfig } from './context/observation-masker.js';
+import type { WindowingConfig } from './context/windowing.js';
 import type { PruneConfig } from './context/dead-message-pruner.js';
 import { AnchorManager } from './anchors/manager.js';
 import { GuardrailManager } from './guardrails/manager.js';
@@ -306,6 +307,13 @@ export interface AgentConfig {
      * Enabled by default when contextManager is provided. Set to `false` to disable.
      */
     observationMask?: Partial<ObservationMaskConfig> | false;
+    /**
+     * Smart windowing configuration. Programmatically compacts old messages when
+     * history exceeds a token budget. Three zones: recent (intact), middle
+     * (truncated), old (event log). Zero LLM calls.
+     * Enabled by default when contextManager is provided. Set to `false` to disable.
+     */
+    windowing?: Partial<WindowingConfig> | false;
     /**
      * Use compact text format for tool results in LLM messages.
      * Strips JSON wrappers and metadata, reducing token usage.
@@ -924,6 +932,10 @@ export declare class Agent {
      * Observation masker for reducing token usage by masking old tool results
      */
     private readonly observationMasker?;
+    /**
+     * Smart windowing config for programmatic context compaction
+     */
+    private readonly windowingConfig?;
     /**
      * Whether to use compact text format for tool results in LLM messages
      */

package/dist/agent.js

@@ -11,6 +11,7 @@ import { FileAccessTracker } from './context/file-tracker.js';
 import { createFileTrackingHook } from './context/file-tracking-hook.js';
 import { ToolResultDelegator, DELEGATION_SYSTEM_PROMPT } from './context/tool-result-delegator.js';
 import { ObservationMasker } from './context/observation-masker.js';
+import { applyWindowing, DEFAULT_WINDOWING_CONFIG } from './context/windowing.js';
 import { compactToolResult } from './context/result-compactor.js';
 import { DeadMessagePruner } from './context/dead-message-pruner.js';
 import { createRecallResultTool } from './tools/builtin/recall-result.js';
@@ -105,6 +106,10 @@ export class Agent {
      * Observation masker for reducing token usage by masking old tool results
      */
     observationMasker;
+    /**
+     * Smart windowing config for programmatic context compaction
+     */
+    windowingConfig;
     /**
      * Whether to use compact text format for tool results in LLM messages
      */
@@ -134,6 +139,13 @@ export class Agent {
         }
         // Compact tool results: enabled by default when contextManager is provided
         this.compactToolResults = config.compactToolResults ?? this.contextManager !== undefined;
+        // Smart windowing: enabled by default when contextManager is provided, unless explicitly false
+        if (config.windowing !== false && this.contextManager) {
+            this.windowingConfig = {
+                ...DEFAULT_WINDOWING_CONFIG,
+                ...(typeof config.windowing === 'object' ? config.windowing : {}),
+            };
+        }
         // Dead message pruning: enabled by default when contextManager is provided, unless explicitly false
         if (config.deadMessagePruning !== false && this.contextManager) {
             this.deadMessagePruner = new DeadMessagePruner(config.deadMessagePruning === undefined ? undefined : config.deadMessagePruning);
@@ -1575,6 +1587,24 @@ export class Agent {
                 const systemTokens = this.contextManager.estimateTokens(this.systemPrompt);
                 this.contextManager.updateCategoryUsage('system', systemTokens);
             }
+            // Smart windowing: programmatic compaction when history exceeds budget
+            // Runs BEFORE LLM-based compaction (lighter, zero LLM calls)
+            if (this.windowingConfig) {
+                const windowResult = applyWindowing(messages, this.windowingConfig);
+                if (windowResult.applied) {
+                    messages = windowResult.messages;
+                    // Update history to match windowed state
+                    const historyMsgs = messages.filter((m) => m.role !== 'system');
+                    // Keep conversationHistory in sync (drop system msg)
+                    this.conversationHistory = historyMsgs.slice(0, -newMessages.length);
+                    await this.contextManager.updateTokenCount(messages);
+                    emit({
+                        type: 'context_compacted',
+                        tokensBefore: windowResult.tokensBefore,
+                        tokensAfter: windowResult.tokensAfter,
+                    });
+                }
+            }
             // Check if we need to manage context before starting
             // Order: emergency (95%) → compaction (50%/20 turns) → warning (90%)
             if (this.contextManager.needsEmergencySummarization()) {

package/dist/context/index.d.ts

@@ -25,3 +25,5 @@ export { ObservationMasker, DEFAULT_MASK_CONFIG, DEFAULT_INPUT_COMPACTION, extra
 export type { InputCompactionRule, ObservationMaskConfig, MaskResult, ObservationMaskStats, } from './observation-masker.js';
 export { DeadMessagePruner, DEFAULT_PRUNE_CONFIG, isPruned } from './dead-message-pruner.js';
 export type { PruneConfig, PruneResult, PruneStats } from './dead-message-pruner.js';
+export { applyWindowing, groupIntoTurnPairs, identifyZones, scoreTurnImportance, softCompact, compactToEventLog, DEFAULT_WINDOWING_CONFIG, } from './windowing.js';
+export type { WindowingConfig, WindowingResult, TurnPair, ImportanceLevel } from './windowing.js';

package/dist/context/index.js

@@ -21,3 +21,5 @@ export { compactToolResult } from './result-compactor.js';
 export { ObservationMasker, DEFAULT_MASK_CONFIG, DEFAULT_INPUT_COMPACTION, extractInputSummary, buildMaskText, isMasked, } from './observation-masker.js';
 // Dead Message Pruning (Phase 4 Token Optimization)
 export { DeadMessagePruner, DEFAULT_PRUNE_CONFIG, isPruned } from './dead-message-pruner.js';
+// Smart Windowing (Programmatic Context Compaction)
+export { applyWindowing, groupIntoTurnPairs, identifyZones, scoreTurnImportance, softCompact, compactToEventLog, DEFAULT_WINDOWING_CONFIG, } from './windowing.js';

package/dist/context/windowing.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Smart Windowing — Programmatic context compaction
+ *
+ * Three-zone architecture:
+ *   Zone 1 (recent): Intact — last N tokens of conversation
+ *   Zone 2 (middle): Soft-compacted — importance-aware truncation
+ *   Zone 3 (old):    Event log — one line per turn
+ *
+ * Trigger: total history tokens > targetHistoryTokens
+ * Method: Purely programmatic (zero LLM calls)
+ *
+ * @see /workspace/project-docs/00-requirements/compilr-dev-agents/smart-windowing-spec.md
+ */
+import type { Message } from '../providers/types.js';
+export interface WindowingConfig {
+    /** Target maximum tokens for conversation history. Default: 60000 */
+    targetHistoryTokens: number;
+    /** Tokens reserved for recent window (never compacted). Default: 15000 */
+    recentWindowTokens: number;
+    /** Whether windowing is enabled. Default: true */
+    enabled: boolean;
+}
+export declare const DEFAULT_WINDOWING_CONFIG: WindowingConfig;
+export type ImportanceLevel = 'high' | 'medium' | 'low';
+export interface TurnPair {
+    /** User messages (usually 1, may include tool_result follow-ups) */
+    userMessages: Message[];
+    /** Assistant messages (1+ including tool loops) */
+    assistantMessages: Message[];
+    /** Total tokens for this turn pair */
+    tokenCount: number;
+    /** Importance score */
+    importance: ImportanceLevel;
+}
+interface Zones {
+    recent: TurnPair[];
+    middle: TurnPair[];
+    old: TurnPair[];
+}
+export interface WindowingResult {
+    /** Whether windowing was applied */
+    applied: boolean;
+    /** Messages after windowing */
+    messages: Message[];
+    /** Tokens before windowing */
+    tokensBefore: number;
+    /** Tokens after windowing */
+    tokensAfter: number;
+    /** Zone sizes */
+    zones: {
+        recent: number;
+        middle: number;
+        old: number;
+    };
+    /** Importance distribution */
+    importanceCounts: Record<ImportanceLevel, number>;
+}
+export declare function groupIntoTurnPairs(messages: Message[]): TurnPair[];
+export declare function identifyZones(turnPairs: TurnPair[], config: WindowingConfig): Zones;
+export declare function scoreTurnImportance(pair: TurnPair, allPairs: TurnPair[], index: number): ImportanceLevel;
+export declare function softCompact(turnPairs: TurnPair[]): Message[];
+export declare function compactToEventLog(turnPairs: TurnPair[]): Message[];
+export declare function applyWindowing(messages: Message[], config?: WindowingConfig): WindowingResult;
+export {};

package/dist/context/windowing.js

@@ -0,0 +1,428 @@
+/**
+ * Smart Windowing — Programmatic context compaction
+ *
+ * Three-zone architecture:
+ *   Zone 1 (recent): Intact — last N tokens of conversation
+ *   Zone 2 (middle): Soft-compacted — importance-aware truncation
+ *   Zone 3 (old):    Event log — one line per turn
+ *
+ * Trigger: total history tokens > targetHistoryTokens
+ * Method: Purely programmatic (zero LLM calls)
+ *
+ * @see /workspace/project-docs/00-requirements/compilr-dev-agents/smart-windowing-spec.md
+ */
+import { countMessageTokens } from '../utils/tokenizer.js';
+import { repairToolPairing } from '../messages/index.js';
+export const DEFAULT_WINDOWING_CONFIG = {
+    targetHistoryTokens: 60_000,
+    recentWindowTokens: 15_000,
+    enabled: true,
+};
+// =============================================================================
+// Importance Scoring — Keyword Patterns
+// =============================================================================
+const HIGH_IMPORTANCE_USER = /\b(let's use|don't use|go with|switch to|the approach is|instead of|not that|actually|wrong|no,|stop using|prefer|must use|never|always|requirement is|constraint is|decided|agreed|architecture|stack|database|framework|pattern|schema|API|endpoint|migration|deployment)\b/i;
+const HIGH_IMPORTANCE_AGENT = /\b(I'll use|understood|switching to|noted.*won't|will not use|as you requested|per your instruction|confirmed|decision)\b/i;
+const LOW_IMPORTANCE_USER = /^(ok|sure|got it|understood|will do|sounds good|perfect|great|yes|yeah|yep|right|correct|exactly|thanks|thank you|good|nice|cool)[\s.!]*$/i;
+const LOW_IMPORTANCE_AGENT = /^(I've |I have |Done[.!]|Here's what|The changes|Updated |Created |Modified |Deleted |Successfully )/i;
+const LOW_IMPORTANCE_TOOLS = new Set([
+    'get_tool_info',
+    'list_tools',
+    'load_capability',
+    'suggest',
+    'todo_read',
+    'todo_write',
+]);
+// =============================================================================
+// Text Extraction Helpers
+// =============================================================================
+function extractText(messages) {
+    const parts = [];
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            parts.push(msg.content);
+        }
+        else {
+            for (const block of msg.content) {
+                if (block.type === 'text') {
+                    parts.push(block.text);
+                }
+            }
+        }
+    }
+    return parts.join(' ');
+}
+function extractToolUseBlocks(messages) {
+    const blocks = [];
+    for (const msg of messages) {
+        if (typeof msg.content !== 'string') {
+            for (const block of msg.content) {
+                if (block.type === 'tool_use') {
+                    blocks.push(block);
+                }
+            }
+        }
+    }
+    return blocks;
+}
+function hasErrorToolResult(messages) {
+    for (const msg of messages) {
+        if (typeof msg.content !== 'string') {
+            for (const block of msg.content) {
+                if (block.type === 'tool_result' && block.isError)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+// =============================================================================
+// Step 1: Group Messages into Turn Pairs
+// =============================================================================
+export function groupIntoTurnPairs(messages) {
+    const pairs = [];
+    let currentUser = [];
+    let currentAssistant = [];
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            // Close previous turn pair if we have assistant messages
+            if (currentAssistant.length > 0) {
+                pairs.push({
+                    userMessages: currentUser,
+                    assistantMessages: currentAssistant,
+                    tokenCount: countMessageTokens([...currentUser, ...currentAssistant]),
+                    importance: 'medium',
+                });
+                currentUser = [];
+                currentAssistant = [];
+            }
+            currentUser.push(msg);
+        }
+        else if (msg.role === 'assistant') {
+            currentAssistant.push(msg);
+        }
+        // Skip system messages — handled separately
+    }
+    // Close final pair
+    if (currentUser.length > 0 || currentAssistant.length > 0) {
+        pairs.push({
+            userMessages: currentUser,
+            assistantMessages: currentAssistant,
+            tokenCount: countMessageTokens([...currentUser, ...currentAssistant]),
+            importance: 'medium',
+        });
+    }
+    return pairs;
+}
+// =============================================================================
+// Step 2: Identify Zones (Token-Based)
+// =============================================================================
+export function identifyZones(turnPairs, config) {
+    // Zone 1: work backwards, accumulating tokens up to recentWindowTokens
+    let recentTokens = 0;
+    let zone1Start = turnPairs.length;
+    for (let i = turnPairs.length - 1; i >= 0; i--) {
+        if (recentTokens + turnPairs[i].tokenCount > config.recentWindowTokens) {
+            break;
+        }
+        recentTokens += turnPairs[i].tokenCount;
+        zone1Start = i;
+    }
+    const recent = turnPairs.slice(zone1Start);
+    const older = turnPairs.slice(0, zone1Start);
+    if (older.length === 0) {
+        return { recent, middle: [], old: [] };
+    }
+    // Zone 2/3 split: older half = Zone 3, newer half = Zone 2
+    const zone3End = Math.floor(older.length / 2);
+    return {
+        old: older.slice(0, zone3End),
+        middle: older.slice(zone3End),
+        recent,
+    };
+}
+// =============================================================================
+// Step 3: Importance Scoring
+// =============================================================================
+export function scoreTurnImportance(pair, allPairs, index) {
+    const userText = extractText(pair.userMessages);
+    const assistantText = extractText(pair.assistantMessages);
+    const toolCalls = extractToolUseBlocks(pair.assistantMessages);
+    // Low: error-then-retry pattern (superseded by successful retry)
+    if (isErrorRetryPattern(allPairs, index))
+        return 'low';
+    // Low: turn consists entirely of low-importance tools and short messages
+    const allToolsLow = toolCalls.length > 0 && toolCalls.every((t) => LOW_IMPORTANCE_TOOLS.has(t.name));
+    if (allToolsLow && userText.length < 50 && assistantText.length < 200)
+        return 'low';
+    // Low: pure acknowledgment from user + short agent response
+    if (LOW_IMPORTANCE_USER.test(userText.trim()) && userText.length < 100)
+        return 'low';
+    // High: user made a decision or correction
+    if (HIGH_IMPORTANCE_USER.test(userText))
+        return 'high';
+    // High: agent confirmed a decision
+    if (HIGH_IMPORTANCE_AGENT.test(assistantText))
+        return 'high';
+    // Low: agent recap without user decision
+    if (LOW_IMPORTANCE_AGENT.test(assistantText.trim()) && userText.length < 50)
+        return 'low';
+    // Medium: everything else
+    return 'medium';
+}
+function isErrorRetryPattern(allPairs, index) {
+    if (index + 1 >= allPairs.length)
+        return false;
+    const current = allPairs[index];
+    const next = allPairs[index + 1];
+    // Current turn has a failed tool call
+    if (!hasErrorToolResult([...current.userMessages, ...current.assistantMessages]))
+        return false;
+    // Next turn retries a tool with the same name
+    const currentToolNames = new Set(extractToolUseBlocks(current.assistantMessages).map((t) => t.name));
+    const nextToolNames = extractToolUseBlocks(next.assistantMessages).map((t) => t.name);
+    return nextToolNames.some((name) => currentToolNames.has(name));
+}
+// =============================================================================
+// Step 4: Zone 2 — Soft Compaction
+// =============================================================================
+const TRUNCATION_LIMITS = {
+    high: { userChars: Infinity, assistantChars: Infinity },
+    medium: { userChars: 300, assistantChars: 500 },
+    low: { userChars: 100, assistantChars: 200 },
+};
+export function softCompact(turnPairs) {
+    const result = [];
+    for (const pair of turnPairs) {
+        const limits = TRUNCATION_LIMITS[pair.importance];
+        for (const msg of pair.userMessages) {
+            result.push(compactMessage(msg, limits.userChars));
+        }
+        for (const msg of pair.assistantMessages) {
+            result.push(compactMessage(msg, limits.assistantChars));
+        }
+    }
+    return result;
+}
+function compactMessage(msg, maxChars) {
+    if (typeof msg.content === 'string') {
+        if (msg.content.length <= maxChars)
+            return msg;
+        const omitted = msg.content.length - maxChars;
+        return {
+            ...msg,
+            content: `${msg.content.slice(0, maxChars)}... [+${String(omitted)} chars]`,
+        };
+    }
+    // Multi-block message: process each block
+    const compactedBlocks = [];
+    for (const block of msg.content) {
+        switch (block.type) {
+            case 'text': {
+                if (block.text.length <= maxChars) {
+                    compactedBlocks.push(block);
+                }
+                else {
+                    const omitted = block.text.length - maxChars;
+                    compactedBlocks.push({
+                        ...block,
+                        text: `${block.text.slice(0, maxChars)}... [+${String(omitted)} chars]`,
+                    });
+                }
+                break;
+            }
+            case 'tool_use': {
+                // Keep name + compact input summary
+                const inputStr = JSON.stringify(block.input);
+                compactedBlocks.push({
+                    ...block,
+                    input: inputStr.length > 100
+                        ? { _summary: `${block.name}(${inputStr.slice(0, 80)}...)` }
+                        : block.input,
+                });
+                break;
+            }
+            case 'tool_result': {
+                // Already masked by observation masker — keep as-is if short
+                if (block.content.length <= 200) {
+                    compactedBlocks.push(block);
+                }
+                else {
+                    compactedBlocks.push({
+                        ...block,
+                        content: `${block.content.slice(0, 150)}... [+${String(block.content.length - 150)} chars]`,
+                    });
+                }
+                break;
+            }
+            default:
+                // thinking blocks etc. — drop in compacted zone
+                break;
+        }
+    }
+    return { ...msg, content: compactedBlocks };
+}
+// =============================================================================
+// Step 5: Zone 3 — Event Log
+// =============================================================================
+export function compactToEventLog(turnPairs) {
+    if (turnPairs.length === 0)
+        return [];
+    const lines = [];
+    for (let i = 0; i < turnPairs.length; i++) {
+        lines.push(generateEventLine(i + 1, turnPairs[i]));
+    }
+    // Cap event log at ~3K tokens (~12K chars)
+    const MAX_EVENT_LOG_CHARS = 12_000;
+    let eventLog = lines.join('\n');
+    if (eventLog.length > MAX_EVENT_LOG_CHARS) {
+        // Drop oldest lines until under cap
+        while (lines.length > 1 && eventLog.length > MAX_EVENT_LOG_CHARS) {
+            lines.shift();
+            eventLog = `[+${String(turnPairs.length - lines.length)} earlier turns omitted]\n${lines.join('\n')}`;
+        }
+    }
+    return [
+        {
+            role: 'user',
+            content: `[Conversation history — ${String(turnPairs.length)} earlier turns compacted]\n\n${eventLog}\n\n[End of compacted history. Recent conversation follows.]`,
+        },
+        {
+            role: 'assistant',
+            content: 'Understood. I have the context from our earlier conversation.',
+        },
+    ];
+}
+function generateEventLine(turnIndex, pair) {
+    const userText = extractText(pair.userMessages).replace(/\n/g, ' ').trim().slice(0, 80);
+    const toolCalls = extractToolUseBlocks(pair.assistantMessages);
+    const isHighImportance = pair.importance === 'high';
+    const marker = isHighImportance ? '\u2605 ' : '';
+    if (toolCalls.length === 0) {
+        // Conversation-only turn
+        const agentText = extractText(pair.assistantMessages).replace(/\n/g, ' ').trim().slice(0, 80);
+        return `[Turn ${String(turnIndex)}] ${marker}User: "${userText}" \u2192 "${agentText}"`;
+    }
+    // Summarize tool usage
+    const toolSummary = summarizeTools(toolCalls);
+    return `[Turn ${String(turnIndex)}] ${marker}User: "${userText}" \u2192 ${toolSummary}`;
+}
+function summarizeTools(toolCalls) {
+    const reads = toolCalls.filter((t) => [
+        'read_file',
+        'grep',
+        'glob',
+        'git_diff',
+        'git_log',
+        'git_status',
+        'project_document_get',
+        'find_definition',
+        'find_references',
+        'web_fetch',
+        'detect_project',
+        'get_file_structure',
+    ].includes(t.name));
+    const writes = toolCalls.filter((t) => ['write_file', 'edit', 'git_commit', 'project_document_add', 'project_document_patch'].includes(t.name));
+    const runs = toolCalls.filter((t) => ['bash', 'run_tests', 'run_lint', 'run_build', 'run_format', 'task'].includes(t.name));
+    const other = toolCalls.filter((t) => !reads.includes(t) && !writes.includes(t) && !runs.includes(t));
+    const parts = [];
+    if (reads.length > 0)
+        parts.push(`read ${String(reads.length)}`);
+    if (writes.length > 0) {
+        const files = writes.map((t) => extractFileName(t.input)).filter(Boolean);
+        parts.push(files.length > 0 ? `edited ${files.join(', ')}` : `edited ${String(writes.length)}`);
+    }
+    if (runs.length > 0) {
+        const names = [...new Set(runs.map((t) => t.name))];
+        parts.push(names.join(', '));
+    }
+    if (other.length > 0)
+        parts.push(`${String(other.length)} other`);
+    return parts.join(', ') || `${String(toolCalls.length)} tools`;
+}
+function extractFileName(input) {
+    const path = (input.path ?? input.filePath ?? input.file ?? '');
+    if (!path)
+        return '';
+    const parts = path.split('/');
+    return parts[parts.length - 1];
+}
+// =============================================================================
+// Main: Apply Windowing
+// =============================================================================
+export function applyWindowing(messages, config = DEFAULT_WINDOWING_CONFIG) {
+    // Separate system messages (never compacted)
+    const systemMsgs = messages.filter((m) => m.role === 'system');
+    const historyMsgs = messages.filter((m) => m.role !== 'system');
+    const tokensBefore = countMessageTokens(historyMsgs);
+    // Check if windowing is needed
+    if (!config.enabled || tokensBefore <= config.targetHistoryTokens) {
+        return {
+            applied: false,
+            messages,
+            tokensBefore,
+            tokensAfter: tokensBefore,
+            zones: { recent: historyMsgs.length, middle: 0, old: 0 },
+            importanceCounts: { high: 0, medium: 0, low: 0 },
+        };
+    }
+    // Step 1: Group into turn pairs
+    const turnPairs = groupIntoTurnPairs(historyMsgs);
+    // Step 2: Identify zones
+    const zones = identifyZones(turnPairs, config);
+    // Step 3: Score importance for Zone 2 and 3
+    const allOlder = [...zones.old, ...zones.middle];
+    for (let i = 0; i < allOlder.length; i++) {
+        allOlder[i].importance = scoreTurnImportance(allOlder[i], allOlder, i);
+    }
+    // Count importance distribution
+    const importanceCounts = { high: 0, medium: 0, low: 0 };
+    for (const pair of allOlder) {
+        importanceCounts[pair.importance]++;
+    }
+    // Step 4: Compact Zone 3 → event log
+    const zone3Messages = compactToEventLog(zones.old);
+    // Step 5: Compact Zone 2 → soft truncation
+    const zone2Messages = softCompact(zones.middle);
+    // Step 6: Flatten Zone 1 (recent — intact)
+    const zone1Messages = [];
+    for (const pair of zones.recent) {
+        zone1Messages.push(...pair.userMessages, ...pair.assistantMessages);
+    }
+    // Step 7: Inject compaction notice between compacted and recent zones
+    const compactionNotice = zones.old.length > 0 || zones.middle.length > 0
+        ? [
+            {
+                role: 'user',
+                content: `[Context note: ${String(zones.old.length)} turns were compacted to event log, ${String(zones.middle.length)} turns were soft-compacted. Use recall_work to access full history if needed.]`,
+            },
+            {
+                role: 'assistant',
+                content: "Understood. I'll work with the available context and use recall_work if I need details from earlier.",
+            },
+        ]
+        : [];
+    // Step 8: Reassemble
+    let compactedHistory = [
+        ...zone3Messages,
+        ...zone2Messages,
+        ...compactionNotice,
+        ...zone1Messages,
+    ];
+    // Step 8: Repair tool pairing (orphaned tool_use/tool_result)
+    compactedHistory = repairToolPairing(compactedHistory);
+    const finalMessages = [...systemMsgs, ...compactedHistory];
+    const tokensAfter = countMessageTokens(compactedHistory);
+    return {
+        applied: true,
+        messages: finalMessages,
+        tokensBefore,
+        tokensAfter,
+        zones: {
+            recent: zones.recent.length,
+            middle: zones.middle.length,
+            old: zones.old.length,
+        },
+        importanceCounts,
+    };
+}

package/dist/index.d.ts

@@ -40,7 +40,7 @@ export { generateId, sleep, retry, truncate, withRetryGenerator, calculateBackof
 export type { RetryConfig as LLMRetryConfig, WithRetryOptions } from './utils/index.js';
 export { AgentError, ProviderError, ToolError, ToolTimeoutError, ToolLoopError, ValidationError, MaxIterationsError, AbortError, ContextOverflowError, isAgentError, isProviderError, isToolError, isToolTimeoutError, isToolLoopError, isContextOverflowError, wrapError, } from './errors.js';
 export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, compactToolResult, ObservationMasker, DEFAULT_MASK_CONFIG, DEFAULT_INPUT_COMPACTION, extractInputSummary, buildMaskText, isMasked, DeadMessagePruner, DEFAULT_PRUNE_CONFIG, isPruned, } from './context/index.js';
-export type { ContextManagerOptions, ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, RestorationHintMessage, DelegatedResultStoreStats, ToolResultDelegatorOptions, DelegationConfig, StoredResult, DelegationEvent, InputCompactionRule, ObservationMaskConfig, MaskResult, ObservationMaskStats, PruneConfig, PruneResult, PruneStats, } from './context/index.js';
+export type { ContextManagerOptions, ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, RestorationHintMessage, DelegatedResultStoreStats, ToolResultDelegatorOptions, DelegationConfig, StoredResult, DelegationEvent, InputCompactionRule, ObservationMaskConfig, MaskResult, ObservationMaskStats, PruneConfig, PruneResult, PruneStats, WindowingConfig, WindowingResult, ImportanceLevel, } from './context/index.js';
 export { SkillRegistry, defineSkill, createSkillRegistry, builtinSkills, getDefaultSkillRegistry, resetDefaultSkillRegistry, } from './skills/index.js';
 export type { Skill, SkillInvocationResult, SkillInvokeOptions } from './skills/index.js';
 export { JsonSerializer, CompactJsonSerializer, defaultSerializer, MemoryCheckpointer, FileCheckpointer, StateError, StateErrorCode, CURRENT_STATE_VERSION, } from './state/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/agents",
-  "version": "0.3.28",
+  "version": "0.4.0",
   "description": "Lightweight multi-LLM agent library for building CLI AI assistants",
   "type": "module",
   "main": "dist/index.js",