@compilr-dev/agents 0.3.11 → 0.3.13

package/dist/context/file-tracker.js

@@ -38,9 +38,13 @@ export class FileAccessTracker {
     accesses = new Map();
     maxEntries;
     deduplicateReferences;
+    inlineThreshold;
+    maxContentEntries;
     constructor(options = {}) {
         this.maxEntries = options.maxEntries ?? 100;
         this.deduplicateReferences = options.deduplicateReferences ?? true;
+        this.inlineThreshold = options.inlineThreshold ?? 200;
+        this.maxContentEntries = options.maxContentEntries ?? 10;
     }
     // ==========================================================================
     // Track Methods
@@ -48,13 +52,15 @@ export class FileAccessTracker {
     /**
      * Track a file that was fully read
      */
-    trackRead(filePath, lineCount, summary) {
+    trackRead(filePath, lineCount, summary, content) {
         const normalizedPath = this.normalizePath(filePath);
         // Read supersedes reference - remove any existing reference
         const existing = this.accesses.get(normalizedPath);
         if (existing && existing.type === 'referenced') {
             this.accesses.delete(normalizedPath);
         }
+        // Store content only for small files
+        const shouldStoreContent = content !== undefined && lineCount <= this.inlineThreshold;
         // Update or create read entry
         this.accesses.set(normalizedPath, {
             path: normalizedPath,
@@ -62,7 +68,12 @@ export class FileAccessTracker {
             timestamp: Date.now(),
             lineCount,
             summary,
+            content: shouldStoreContent ? content : undefined,
+            tokenCount: shouldStoreContent ? this.estimateTokens(content) : undefined,
         });
+        if (shouldStoreContent) {
+            this.enforceMaxContentEntries();
+        }
         this.enforceMaxEntries();
     }
     /**
@@ -184,6 +195,65 @@ export class FileAccessTracker {
             includeTimestamp,
         });
     }
+    /**
+     * Format restoration hints with inline file content (Claude Code style).
+     *
+     * Small files with stored content are inlined up to a token budget.
+     * Large files or files exceeding the budget get reference-only hints.
+     * Each file produces a separate hint message for individual injection.
+     *
+     * Priority order for inlining:
+     * 1. Modified files (most critical context)
+     * 2. Read files, most recent first
+     * 3. Once budget exhausted → remaining become reference-only
+     * 4. Referenced-only files → always reference-only
+     */
+    formatRestorationHintsWithContent(options) {
+        if (this.accesses.size === 0) {
+            return [];
+        }
+        const maxInlineTokens = options?.maxInlineTokens ?? 4000;
+        const allAccesses = this.getAccesses();
+        const hints = [];
+        let usedTokens = 0;
+        // Sort by priority: modified first, then read (most recent first), then referenced
+        const prioritized = [...allAccesses].sort((a, b) => {
+            const typePriority = { modified: 0, read: 1, referenced: 2 };
+            const aPriority = typePriority[a.type];
+            const bPriority = typePriority[b.type];
+            if (aPriority !== bPriority)
+                return aPriority - bPriority;
+            return b.timestamp - a.timestamp; // most recent first within same type
+        });
+        for (const access of prioritized) {
+            // Referenced files are always reference-only (no content was read)
+            if (access.type === 'referenced') {
+                continue; // Skip referenced files — they add noise without value
+            }
+            const canInline = access.content !== undefined &&
+                access.tokenCount !== undefined &&
+                usedTokens + access.tokenCount <= maxInlineTokens;
+            if (canInline) {
+                // Inline: simulate a read_file tool call result
+                // canInline guarantees content and tokenCount are defined
+                const fileContent = access.content;
+                const tokens = access.tokenCount;
+                const text = `Note: ${access.path} was read before the last conversation was compacted.\n` +
+                    `<file_content>\n${fileContent}\n</file_content>`;
+                usedTokens += tokens;
+                hints.push({ path: access.path, type: 'inline', text, tokens });
+            }
+            else {
+                // Reference-only
+                const lineInfo = access.lineCount !== undefined ? ` (${String(access.lineCount)} lines)` : '';
+                const text = `Note: ${access.path}${lineInfo} was read before the last conversation was compacted, ` +
+                    `but the contents are too large to include. Use read_file if you need to access it.`;
+                const tokens = this.estimateTokens(text);
+                hints.push({ path: access.path, type: 'reference', text, tokens });
+            }
+        }
+        return hints;
+    }
     // ==========================================================================
     // Lifecycle Methods
     // ==========================================================================
@@ -202,6 +272,31 @@ export class FileAccessTracker {
     // ==========================================================================
     // Private Helpers
     // ==========================================================================
+    /**
+     * Rough token estimate (4 chars ≈ 1 token). Avoids heavy tiktoken dependency
+     * in the tracker — exact counts aren't critical for budget enforcement.
+     */
+    estimateTokens(text) {
+        if (!text)
+            return 0;
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Evict oldest stored content when maxContentEntries is exceeded.
+     * Only drops the `content`/`tokenCount` fields — the access entry itself is preserved.
+     */
+    enforceMaxContentEntries() {
+        const entriesWithContent = Array.from(this.accesses.values())
+            .filter((a) => a.content !== undefined)
+            .sort((a, b) => a.timestamp - b.timestamp); // oldest first
+        while (entriesWithContent.length > this.maxContentEntries) {
+            const oldest = entriesWithContent.shift();
+            if (oldest) {
+                oldest.content = undefined;
+                oldest.tokenCount = undefined;
+            }
+        }
+    }
     normalizePath(filePath) {
         // Resolve to absolute path
         return path.resolve(filePath);

package/dist/context/file-tracking-hook.js

@@ -32,18 +32,23 @@ export function createFileTrackingHook(tracker) {
             case TOOL_NAMES.READ_FILE: {
                 const readInput = input;
                 const readResult = result;
-                const lineCount = readResult.result?.lineCount ?? 0;
-                tracker.trackRead(readInput.file_path, lineCount);
+                const content = readResult.result?.content;
+                // totalLines is set when maxLines/startLine used or content truncated;
+                // linesReturned is the actual slice size; fall back to counting content lines
+                const lineCount = readResult.result?.totalLines ??
+                    readResult.result?.linesReturned ??
+                    (content ? content.split('\n').length : 0);
+                tracker.trackRead(readInput.path, lineCount, undefined, content);
                 break;
             }
             case TOOL_NAMES.WRITE_FILE: {
                 const writeInput = input;
-                tracker.trackModification(writeInput.file_path, 'File written');
+                tracker.trackModification(writeInput.path, 'File written');
                 break;
             }
             case TOOL_NAMES.EDIT: {
                 const editInput = input;
-                tracker.trackModification(editInput.file_path, 'File edited');
+                tracker.trackModification(editInput.filePath, 'File edited');
                 break;
             }
             case TOOL_NAMES.GREP: {

package/dist/context/index.d.ts

@@ -11,6 +11,12 @@
 export { ContextManager, DEFAULT_CONTEXT_CONFIG } from './manager.js';
 export type { ContextManagerOptions } from './manager.js';
 export { FileAccessTracker } from './file-tracker.js';
-export type { FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, } from './file-tracker.js';
+export type { FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, RestorationHintMessage, } from './file-tracker.js';
 export { createFileTrackingHook, TRACKED_TOOLS } from './file-tracking-hook.js';
 export type { ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, CategorizedMessages, SmartCompactOptions, SmartCompactionResult, } from './types.js';
+export { DelegatedResultStore } from './delegated-result-store.js';
+export type { DelegatedResultStoreStats } from './delegated-result-store.js';
+export { ToolResultDelegator, DELEGATION_SYSTEM_PROMPT } from './tool-result-delegator.js';
+export type { ToolResultDelegatorOptions } from './tool-result-delegator.js';
+export { DEFAULT_DELEGATION_CONFIG } from './delegation-types.js';
+export type { DelegationConfig, StoredResult, DelegationEvent } from './delegation-types.js';

package/dist/context/index.js

@@ -11,3 +11,7 @@
 export { ContextManager, DEFAULT_CONTEXT_CONFIG } from './manager.js';
 export { FileAccessTracker } from './file-tracker.js';
 export { createFileTrackingHook, TRACKED_TOOLS } from './file-tracking-hook.js';
+// Tool Result Delegation
+export { DelegatedResultStore } from './delegated-result-store.js';
+export { ToolResultDelegator, DELEGATION_SYSTEM_PROMPT } from './tool-result-delegator.js';
+export { DEFAULT_DELEGATION_CONFIG } from './delegation-types.js';

package/dist/context/manager.js

@@ -18,6 +18,7 @@
  * ```
  */
 import { repairToolPairing } from '../messages/index.js';
+import { countTokens, countMessageTokens } from '../utils/tokenizer.js';
 /**
  * Default budget allocation
  */
@@ -122,29 +123,8 @@ export class ContextManager {
         if (this.provider.countTokens) {
             return this.provider.countTokens(messages);
         }
-        // Fallback: rough estimate based on character count
-        let charCount = 0;
-        for (const msg of messages) {
-            if (typeof msg.content === 'string') {
-                charCount += msg.content.length;
-            }
-            else {
-                for (const block of msg.content) {
-                    switch (block.type) {
-                        case 'text':
-                            charCount += block.text.length;
-                            break;
-                        case 'tool_use':
-                            charCount += JSON.stringify(block.input).length;
-                            break;
-                        case 'tool_result':
-                            charCount += block.content.length;
-                            break;
-                    }
-                }
-            }
-        }
-        return Math.ceil(charCount / 4);
+        // Fallback: count tokens using tiktoken
+        return countMessageTokens(messages);
     }
     /**
      * Update token count for messages
@@ -351,7 +331,7 @@ export class ContextManager {
             }
             // Compact this message
             if (typeof msg.content === 'string') {
-                const tokens = Math.ceil(msg.content.length / 4);
+                const tokens = countTokens(msg.content);
                 if (tokens >= this.config.compaction.minTokensToCompact) {
                     const filePath = await saveToFile(msg.content, compactedIndex++);
                     filesCreated.push(filePath);
@@ -369,7 +349,7 @@ export class ContextManager {
                 const compactedBlocks = [];
                 for (const block of msg.content) {
                     if (block.type === 'tool_result' && category === 'toolResults') {
-                        const tokens = Math.ceil(block.content.length / 4);
+                        const tokens = countTokens(block.content);
                         if (tokens >= this.config.compaction.minTokensToCompact) {
                             const filePath = await saveToFile(block.content, compactedIndex++);
                             filesCreated.push(filePath);
@@ -702,7 +682,7 @@ export class ContextManager {
      * Estimate tokens for a string content
      */
     estimateTokens(content) {
-        return Math.ceil(content.length / 4);
+        return countTokens(content);
     }
     /**
      * Check if content can be added to a category
@@ -822,13 +802,13 @@ export class ContextManager {
                 maxLines = this.config.filtering.maxErrorLines;
                 break;
             default: {
-                // For tool results, check token count estimate
-                const estimatedTokens = Math.ceil(content.length / 4);
+                // For tool results, check token count
+                const estimatedTokens = countTokens(content);
                 if (estimatedTokens <= this.config.filtering.maxToolResultTokens) {
                     return { content, filtered: false, originalLength };
                 }
-                // Truncate to roughly maxToolResultTokens
-                const maxChars = this.config.filtering.maxToolResultTokens * 4;
+                // Truncate to roughly maxToolResultTokens (~3 chars per token)
+                const maxChars = this.config.filtering.maxToolResultTokens * 3;
                 const truncated = content.slice(0, maxChars);
                 return {
                     content: truncated + '\n\n[Content truncated - see file for full output]',
@@ -877,7 +857,7 @@ export class ContextManager {
         for (const msg of oldMessages) {
             if (typeof msg.content === 'string') {
                 // Check if string content is large enough to compact
-                const tokens = Math.ceil(msg.content.length / 4);
+                const tokens = countTokens(msg.content);
                 if (tokens >= this.config.compaction.minTokensToCompact) {
                     const filePath = await saveToFile(msg.content, compactedIndex++);
                     filesCreated.push(filePath);
@@ -895,7 +875,7 @@ export class ContextManager {
                 const compactedBlocks = [];
                 for (const block of msg.content) {
                     if (block.type === 'tool_result') {
-                        const tokens = Math.ceil(block.content.length / 4);
+                        const tokens = countTokens(block.content);
                         if (tokens >= this.config.compaction.minTokensToCompact) {
                             const filePath = await saveToFile(block.content, compactedIndex++);
                             filesCreated.push(filePath);

package/dist/context/tool-result-delegator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Tool Result Delegator
+ *
+ * Intercepts large tool results via the AfterToolHook mechanism,
+ * stores the full result for optional recall, and replaces it
+ * with a compact summary to conserve context tokens.
+ */
+import type { LLMProvider } from '../providers/types.js';
+import type { AfterToolHook } from '../hooks/types.js';
+import type { DelegationConfig, DelegationEvent } from './delegation-types.js';
+import { DelegatedResultStore } from './delegated-result-store.js';
+/**
+ * Options for creating a ToolResultDelegator.
+ */
+export interface ToolResultDelegatorOptions {
+    /** LLM provider for summarization (small/medium tier preferred) */
+    provider: LLMProvider;
+    /** Delegation configuration (merged with defaults) */
+    config?: Partial<DelegationConfig>;
+    /** Event callback for delegation lifecycle events */
+    onEvent?: (event: DelegationEvent) => void;
+}
+/**
+ * Core class that creates an AfterToolHook for auto-delegating large tool results.
+ */
+export declare class ToolResultDelegator {
+    private readonly store;
+    private readonly config;
+    private readonly provider;
+    private readonly onEvent?;
+    constructor(options: ToolResultDelegatorOptions);
+    /**
+     * Returns an AfterToolHook to register with HooksManager.
+     */
+    createHook(): AfterToolHook;
+    /**
+     * Perform the actual delegation (async path).
+     */
+    private delegateResult;
+    /**
+     * Access the store (needed by recall_full_result tool).
+     */
+    getStore(): DelegatedResultStore;
+    /**
+     * Get the resolved config for a specific tool.
+     */
+    private getToolConfig;
+    /**
+     * Extractive summarization: first/last lines + prioritized structural markers.
+     * No LLM cost, fast, preserves actual code signatures.
+     */
+    private summarizeExtractive;
+    /**
+     * LLM-based summarization using the provider.
+     * Returns null if the LLM call fails.
+     */
+    private summarizeLLM;
+}
+/**
+ * System prompt addition when delegation is enabled.
+ * Append to the agent's system prompt.
+ */
+export declare const DELEGATION_SYSTEM_PROMPT: string;

package/dist/context/tool-result-delegator.js

@@ -0,0 +1,314 @@
+/**
+ * Tool Result Delegator
+ *
+ * Intercepts large tool results via the AfterToolHook mechanism,
+ * stores the full result for optional recall, and replaces it
+ * with a compact summary to conserve context tokens.
+ */
+import { DEFAULT_DELEGATION_CONFIG } from './delegation-types.js';
+import { DelegatedResultStore } from './delegated-result-store.js';
+import { countTokens } from '../utils/tokenizer.js';
+/**
+ * System prompt for LLM-based summarization.
+ */
+const SUMMARIZATION_SYSTEM_PROMPT = 'You are a tool result summarizer. Compress this tool output preserving:\n' +
+    '- ALL errors/warnings verbatim\n' +
+    '- File paths, function names, line numbers, counts\n' +
+    '- Overall structure (sections, item counts)\n' +
+    '- First few items of lists verbatim\n' +
+    'Drop: verbose repetition, successful routine output, function bodies.\n' +
+    'Never add information not in the original.\n' +
+    'Respond with ONLY the summary, no preamble.';
+/**
+ * Core class that creates an AfterToolHook for auto-delegating large tool results.
+ */
+export class ToolResultDelegator {
+    store;
+    config;
+    provider;
+    onEvent;
+    constructor(options) {
+        this.provider = options.provider;
+        this.config = { ...DEFAULT_DELEGATION_CONFIG, ...options.config };
+        this.onEvent = options.onEvent;
+        this.store = new DelegatedResultStore({
+            maxSize: this.config.maxStoredResults,
+            defaultTTL: this.config.resultTTL,
+        });
+    }
+    /**
+     * Returns an AfterToolHook to register with HooksManager.
+     */
+    createHook() {
+        const getToolConfig = this.getToolConfig.bind(this);
+        const delegateResult = this.delegateResult.bind(this);
+        return (context) => {
+            // Skip failed results — errors should always pass through
+            if (!context.result.success)
+                return undefined;
+            // Never re-delegate recall_full_result — that would create a loop
+            if (context.toolName === 'recall_full_result')
+                return undefined;
+            // Check if delegation is enabled for this tool
+            const toolConfig = getToolConfig(context.toolName);
+            if (!toolConfig.enabled)
+                return undefined;
+            // Serialize the result content
+            const content = typeof context.result.result === 'string'
+                ? context.result.result
+                : JSON.stringify(context.result.result);
+            // Count tokens
+            const tokens = countTokens(content);
+            // Below threshold — pass through unchanged
+            if (tokens <= toolConfig.threshold)
+                return undefined;
+            // Delegate asynchronously
+            return delegateResult(context, content, tokens, toolConfig);
+        };
+    }
+    /**
+     * Perform the actual delegation (async path).
+     */
+    async delegateResult(context, content, tokens, toolConfig) {
+        // If already aborted, skip delegation entirely — return original result
+        if (context.signal?.aborted) {
+            return { result: context.result };
+        }
+        // Generate delegation ID
+        const id = this.store.generateId();
+        this.onEvent?.({
+            type: 'delegation:started',
+            toolName: context.toolName,
+            originalTokens: tokens,
+            delegationId: id,
+        });
+        try {
+            // Determine strategy
+            const strategy = toolConfig.strategy === 'auto' ? 'extractive' : toolConfig.strategy;
+            let summary;
+            let usedStrategy = strategy;
+            if (strategy === 'llm') {
+                const llmSummary = await this.summarizeLLM(content, context.toolName, context.signal);
+                if (llmSummary !== null) {
+                    summary = llmSummary;
+                    usedStrategy = 'llm';
+                }
+                else {
+                    // LLM failed, fall back to extractive
+                    summary = this.summarizeExtractive(content);
+                    usedStrategy = 'extractive';
+                }
+            }
+            else if (toolConfig.strategy === 'auto') {
+                // Auto: try LLM first, fall back to extractive
+                const llmSummary = await this.summarizeLLM(content, context.toolName, context.signal);
+                if (llmSummary !== null) {
+                    summary = llmSummary;
+                    usedStrategy = 'llm';
+                }
+                else {
+                    summary = this.summarizeExtractive(content);
+                    usedStrategy = 'extractive';
+                }
+            }
+            else {
+                summary = this.summarizeExtractive(content);
+                usedStrategy = 'extractive';
+            }
+            const summaryTokens = countTokens(summary);
+            // Store the full result
+            const now = Date.now();
+            const stored = {
+                id,
+                toolName: context.toolName,
+                toolInput: context.input,
+                fullContent: content,
+                fullTokens: tokens,
+                summary,
+                summaryTokens,
+                storedAt: now,
+                expiresAt: now + this.config.resultTTL,
+            };
+            this.store.add(stored);
+            this.onEvent?.({
+                type: 'delegation:completed',
+                toolName: context.toolName,
+                originalTokens: tokens,
+                summaryTokens,
+                delegationId: id,
+                strategy: usedStrategy,
+            });
+            // Return modified result with summary
+            // The format must be unmistakable so the LLM never confuses
+            // a delegated summary with the actual tool output.
+            return {
+                result: {
+                    success: true,
+                    result: {
+                        _delegated: true,
+                        _delegationId: id,
+                        _originalTokens: tokens,
+                        _summaryTokens: summaryTokens,
+                        _warning: 'THIS IS A SUMMARY, NOT THE FULL RESULT. You did not see the full output.',
+                        summary,
+                        recall: `To get the full output, call recall_full_result with id="${id}"`,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            this.onEvent?.({
+                type: 'delegation:failed',
+                toolName: context.toolName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // On failure, return original result unchanged
+            return { result: context.result };
+        }
+    }
+    /**
+     * Access the store (needed by recall_full_result tool).
+     */
+    getStore() {
+        return this.store;
+    }
+    /**
+     * Get the resolved config for a specific tool.
+     */
+    getToolConfig(toolName) {
+        const override = this.config.toolOverrides?.[toolName];
+        return {
+            enabled: override?.enabled ?? this.config.enabled,
+            threshold: override?.threshold ?? this.config.delegationThreshold,
+            strategy: override?.strategy ?? this.config.strategy,
+        };
+    }
+    /**
+     * Extractive summarization: first/last lines + prioritized structural markers.
+     * No LLM cost, fast, preserves actual code signatures.
+     */
+    summarizeExtractive(content) {
+        const lines = content.split('\n');
+        const totalLines = lines.length;
+        if (totalLines <= 40) {
+            // Small enough to include mostly as-is
+            return content;
+        }
+        const parts = [];
+        // Header: makes it impossible to confuse with full content
+        parts.push(`[SUMMARIZED — showing first 20 + last 10 of ${String(totalLines)} lines, plus key signatures. Use recall_full_result for complete output.]`);
+        parts.push('');
+        // First 20 lines
+        parts.push(...lines.slice(0, 20));
+        // Extract structural markers from the middle, prioritized by importance
+        const middleLines = lines.slice(20, -10);
+        // High priority: exports, class/interface/function declarations with signatures
+        const highPriority = /^\s*export\s+(default\s+)?(async\s+)?(function|class|interface|type|const|enum)\s/;
+        // Medium priority: non-exported declarations, method signatures
+        const medPriority = /^\s*(async\s+)?(function|class|interface|type|const|enum)\s|^\s+(async\s+)?(\w+)\s*\([^)]*\)\s*[:{]/;
+        // Low priority: errors, headings, section markers
+        const lowPriority = /^\s*(ERROR|WARN|FAIL|error|warning|#{1,6}\s|---{3,}|\*{3,}|={3,}|\/\/\s*={3,})/;
+        const high = [];
+        const med = [];
+        const low = [];
+        for (const line of middleLines) {
+            if (highPriority.test(line)) {
+                high.push(line);
+            }
+            else if (medPriority.test(line)) {
+                med.push(line);
+            }
+            else if (lowPriority.test(line)) {
+                low.push(line);
+            }
+        }
+        // Budget: scale markers with file size, cap at 40
+        const totalMarkers = high.length + med.length + low.length;
+        const budget = Math.min(40, Math.max(15, Math.floor(totalLines / 80)));
+        // Fill budget: all high, then medium, then low
+        const selected = [];
+        for (const line of high) {
+            if (selected.length >= budget)
+                break;
+            selected.push(line);
+        }
+        for (const line of med) {
+            if (selected.length >= budget)
+                break;
+            selected.push(line);
+        }
+        for (const line of low) {
+            if (selected.length >= budget)
+                break;
+            selected.push(line);
+        }
+        if (selected.length > 0) {
+            parts.push('');
+            parts.push(`... (${String(middleLines.length)} lines omitted, ${String(totalMarkers)} structural markers found, showing ${String(selected.length)} key signatures) ...`);
+            parts.push(...selected);
+            if (totalMarkers > selected.length) {
+                parts.push(`... (${String(totalMarkers - selected.length)} more markers omitted) ...`);
+            }
+        }
+        else {
+            parts.push('');
+            parts.push(`... (${String(middleLines.length)} lines omitted) ...`);
+        }
+        // Last 10 lines
+        parts.push('');
+        parts.push(...lines.slice(-10));
+        parts.push('');
+        parts.push(`[Total: ${String(totalLines)} lines]`);
+        return parts.join('\n');
+    }
+    /**
+     * LLM-based summarization using the provider.
+     * Returns null if the LLM call fails.
+     */
+    async summarizeLLM(content, toolName, signal) {
+        try {
+            if (signal?.aborted)
+                return null;
+            const messages = [
+                {
+                    role: 'system',
+                    content: SUMMARIZATION_SYSTEM_PROMPT,
+                },
+                {
+                    role: 'user',
+                    content: `Summarize this ${toolName} tool result (keep under ${String(this.config.summaryMaxTokens)} tokens):\n\n${content}`,
+                },
+            ];
+            let text = '';
+            for await (const chunk of this.provider.chat(messages, {
+                maxTokens: this.config.summaryMaxTokens,
+                temperature: 0,
+                model: undefined, // Use the provider's default model
+                signal,
+            })) {
+                if (signal?.aborted)
+                    break;
+                if (chunk.type === 'text' && chunk.text) {
+                    text += chunk.text;
+                }
+            }
+            return text.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * System prompt addition when delegation is enabled.
+ * Append to the agent's system prompt.
+ */
+export const DELEGATION_SYSTEM_PROMPT = '\n\n## Tool Result Delegation\n' +
+    'Some tool results are automatically summarized to conserve context. When a result has `_delegated: true`, ' +
+    'you received a SUMMARY, not the full output. You MUST acknowledge this — never claim you read the full content.\n' +
+    'Delegated results include:\n' +
+    '- `_warning`: confirms this is a summary\n' +
+    '- `summary`: extracted key information\n' +
+    '- `recall`: how to get the full output\n' +
+    'Use `recall_full_result` with the delegation ID to get the full output when the summary is insufficient.\n' +
+    'Only recall when you need specific code, exact values, or the summary indicates omitted content.\n';