@leverageaiapps/locus 2.2.8 → 2.3.0

package/dist/agent/compaction.js

@@ -2,15 +2,56 @@
 /**
  * Context compaction — token estimation, truncation, and context window management.
  * Uses a provided chat function for summary generation.
+ *
+ * v2: Multi-stage map-reduce summarization, identifier preservation,
+ *     file operations tracking, tool failure preservation, progressive trimming.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.estimateTokens = estimateTokens;
 exports.estimateMessagesTokens = estimateMessagesTokens;
 exports.checkContextWindow = checkContextWindow;
+exports.progressiveTrimToolResults = progressiveTrimToolResults;
 exports.truncateOversizedToolResults = truncateOversizedToolResults;
 exports.compactBrowserContext = compactBrowserContext;
 exports.repairToolUseResultPairing = repairToolUseResultPairing;
 exports.preCompactionMemoryFlush = preCompactionMemoryFlush;
+exports.buildEnrichedSnippet = buildEnrichedSnippet;
+exports.postTaskMemoryFlush = postTaskMemoryFlush;
+exports.autoDistillMemory = autoDistillMemory;
+exports.buildTranscriptDigest = buildTranscriptDigest;
 exports.maybeCompactMessages = maybeCompactMessages;
 exports.emergencyCompactMessages = emergencyCompactMessages;
 // ─── Constants ───────────────────────────────────────────────────
@@ -20,6 +61,18 @@ const MIN_USABLE_CONTEXT = 8000;
 const COMPACTION_THRESHOLD = 150000;
 const MAX_TOOL_RESULT_CHARS = 30000;
 const SAFETY_MARGIN = 1.2; // char/3 estimate can undercount; 20% buffer prevents overflow
+// Multi-stage summarization
+const SUMMARY_PART_MAX_TOKENS = 3000;
+const SUMMARY_MERGE_MAX_TOKENS = 4000;
+const MSG_CONDENSE_CHARS = 800; // per-message truncation for summarization input
+// Identifier preservation instructions
+const IDENTIFIER_INSTRUCTIONS = `CRITICAL: Preserve all opaque identifiers EXACTLY as written — never shorten, reconstruct, or paraphrase:
+- UUIDs, hashes, commit SHAs
+- File paths and URLs
+- API keys, tokens, hostnames, IPs, ports
+- Variable names, function names, class names
+- Version numbers, error codes`;
+const SUMMARY_SYSTEM_PROMPT = `You are a concise summarizer. Output only the summary, no preamble.\n\n${IDENTIFIER_INSTRUCTIONS}`;
 // ─── Token Estimation ────────────────────────────────────────────
 function estimateTokens(text) {
     return Math.ceil(text.length / 3);
@@ -72,6 +125,41 @@ function checkContextWindow(messages, systemPromptTokens = 0) {
     }
     return { ok: true, warn: false, availableTokens: available, totalTokens };
 }
+// ─── Progressive Tool Result Trimming ────────────────────────────
+/**
+ * Age-based gradual trimming of old tool results.
+ * Runs every turn BEFORE the hard truncation pass, freeing context space
+ * progressively instead of waiting for the compaction threshold.
+ */
+function progressiveTrimToolResults(messages) {
+    const len = messages.length;
+    let trimmed = 0;
+    for (let i = 0; i < len; i++) {
+        const age = len - i; // distance from newest message
+        let limit;
+        if (age > 16)
+            limit = 1500; // 8+ turns ago: aggressive
+        else if (age > 8)
+            limit = 3000; // 4+ turns ago: moderate
+        else
+            continue; // recent: don't touch
+        const blocks = Array.isArray(messages[i].content) ? messages[i].content : [];
+        for (const block of blocks) {
+            if (block.type !== 'tool_result')
+                continue;
+            if (typeof block.content === 'string' && block.content.length > limit) {
+                const head = Math.floor(limit * 0.7);
+                const tail = Math.floor(limit * 0.2);
+                const omitted = block.content.length - head - tail;
+                block.content = block.content.substring(0, head) +
+                    `\n[... ${omitted} chars trimmed ...]\n` +
+                    block.content.substring(block.content.length - tail);
+                trimmed++;
+            }
+        }
+    }
+    return trimmed;
+}
 // ─── Truncate Oversized Tool Results ─────────────────────────────
 function truncateOversizedToolResults(messages, maxChars = MAX_TOOL_RESULT_CHARS) {
     let truncated = 0;
@@ -223,14 +311,27 @@ function repairToolUseResultPairing(messages) {
     return repaired;
 }
 // ─── Pre-Compaction Memory Flush ─────────────────────────────────
-let lastFlushTime = 0;
-const FLUSH_COOLDOWN_MS = 60000;
+let lastFlushCompactionCount = -1;
+const FLUSH_SYSTEM_PROMPT = 'Pre-compaction memory flush turn. The session is near auto-compaction; capture durable memories to disk. Be concise — bullet points only.';
+const FLUSH_USER_PROMPT_TEMPLATE = `Pre-compaction memory flush.
+Store durable memories now to today's daily log.
+IMPORTANT: Extract ONLY information worth preserving long-term:
+- User preferences, decisions, persistent instructions
+- Project details, architecture decisions, technical context
+- People, dates, facts the user mentioned
+- Anything the user asked to remember
+If nothing worth saving, respond with "NONE".
+
+Conversation:
+`;
 /**
  * Before compaction discards old messages, extract any memory-worthy
  * information and save it to the daily log.
+ * Uses compactionCount event tracking (more reliable than time-based cooldown).
  */
-async function preCompactionMemoryFlush(messages, chatFn, writeToMemory) {
-    if (Date.now() - lastFlushTime < FLUSH_COOLDOWN_MS)
+async function preCompactionMemoryFlush(messages, chatFn, writeToMemory, compactionCount = 0) {
+    // Event-based dedup: skip if already flushed for this compaction
+    if (lastFlushCompactionCount === compactionCount)
         return;
     try {
         const parts = [];
@@ -247,18 +348,128 @@ async function preCompactionMemoryFlush(messages, chatFn, writeToMemory) {
         const conversationSnippet = parts.join('\n').substring(0, 8000);
         const resp = await chatFn([{
                 role: 'user',
-                content: `Extract any information from this conversation that should be saved to long-term memory. Focus on:
-- User preferences, decisions, or persistent instructions
-- Project details, architecture decisions, or technical context
-- People, dates, or facts the user mentioned
-- Anything the user asked to remember
+                content: FLUSH_USER_PROMPT_TEMPLATE + conversationSnippet,
+            }], {
+            systemPrompt: FLUSH_SYSTEM_PROMPT,
+            tools: [],
+            maxTokens: 1000,
+        });
+        const extracted = resp.content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('');
+        if (extracted && !extracted.trim().toUpperCase().startsWith('NONE')) {
+            await writeToMemory(extracted);
+            console.log(`[Compaction] Memory flush: saved ${extracted.length} chars before compaction #${compactionCount}`);
+        }
+        lastFlushCompactionCount = compactionCount;
+    }
+    catch (err) {
+        console.warn(`[Compaction] Memory flush failed: ${err.message}`);
+    }
+}
+// ─── Post-Task Memory Flush ──────────────────────────────────────
+const POST_TASK_SYSTEM_PROMPT = `You are a memory extractor. After a task completes, extract key information worth remembering for FUTURE tasks.
+
+Extract ONLY durable, reusable information:
+- What was accomplished (files created/modified, commands run)
+- What tools/commands were used and key approaches
+- Successful approaches & lessons learned
+- Failed approaches & problems solved
+- Packages/libraries installed
+- Environment changes
+- User preferences or decisions expressed during the task
 
-If there's nothing worth saving, respond with "NONE".
+Format: concise bullet points, one line each.
+IMPORTANT: Never include API keys, passwords, tokens, secrets, or credentials in the output.
+If the conversation is trivial (simple greeting, one-word answer, etc.), respond with "NONE".
+
+Conversation:
+`;
+const POST_TASK_USER_PROMPT = `Post-task memory flush.
+A task just completed. Extract key information worth remembering for FUTURE tasks.
+Be concise — bullet points only.
 
 Conversation:
-${conversationSnippet}`,
+`;
+// ─── Sensitive Data Redaction ────────────────────────────────────
+const SENSITIVE_PATTERNS = [
+    [/(?:api[_-]?key|token|secret|password|access[_-]?key|auth)\s*[:=]\s*['"]?[\w\-./+]{20,}['"]?/gi, '[REDACTED_CREDENTIAL]'],
+    [/Bearer\s+[\w\-./+]{20,}/gi, '[REDACTED_BEARER]'],
+    [/(?:AKIA|ASIA)[A-Z0-9]{16}/g, '[REDACTED_AWS_KEY]'],
+    [/[A-Za-z0-9+/]{60,}={0,2}/g, '[REDACTED_BASE64]'],
+    [/-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----[\s\S]*?-----END/gi, '[REDACTED_PRIVATE_KEY]'],
+    [/(?:mongodb|postgres|mysql|redis):\/\/[^\s]*:[^\s@]*@/gi, '[REDACTED_CONN_STRING]'],
+];
+function redactSensitiveContent(text) {
+    let result = text;
+    for (const [pattern, replacement] of SENSITIVE_PATTERNS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}
+/** Summarize tool input for memory flush (concise but informative) */
+function summarizeToolInputForFlush(toolName, input) {
+    if (!input)
+        return '';
+    switch (toolName) {
+        case 'bash': return (input.command || '').substring(0, 200);
+        case 'write_file': return `${input.path || ''} (${(input.content || '').length} chars)`;
+        case 'read_file':
+        case 'show_file': return input.path || '';
+        case 'search_files': return `"${input.pattern || ''}" in ${input.directory || '.'}`;
+        case 'save_memory': return `${input.file ? input.file + ': ' : ''}${(input.content || '').substring(0, 80)}`;
+        case 'search_memory': return `query="${input.query || ''}"`;
+        default: return JSON.stringify(input).substring(0, 150);
+    }
+}
+/** Build enriched conversation snippet including tool call details */
+function buildEnrichedSnippet(messages, maxChars = 12000) {
+    const parts = [];
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            if (msg.content)
+                parts.push(`${msg.role}: ${msg.content.substring(0, 500)}`);
+            continue;
+        }
+        if (!Array.isArray(msg.content))
+            continue;
+        const msgParts = [];
+        for (const block of msg.content) {
+            if (block.type === 'text' && block.text) {
+                msgParts.push(block.text.substring(0, 400));
+            }
+            else if (block.type === 'tool_use' && block.name) {
+                msgParts.push(`[Tool: ${block.name}] ${summarizeToolInputForFlush(block.name, block.input)}`);
+            }
+            else if (block.type === 'tool_result') {
+                const resultText = typeof block.content === 'string' ? block.content : '';
+                const prefix = block.is_error ? '[Error] ' : '[Result] ';
+                const firstLine = resultText.split('\n').find((l) => l.trim()) || '';
+                msgParts.push(`${prefix}${firstLine.substring(0, 150)}`);
+            }
+        }
+        if (msgParts.length > 0)
+            parts.push(`${msg.role}: ${msgParts.join(' | ')}`);
+    }
+    return redactSensitiveContent(parts.join('\n').substring(0, maxChars));
+}
+/**
+ * After a task completes, extract key information from the conversation
+ * and save it to the daily memory log.
+ * Ported from container-agent — adapted to use ChatFn instead of callClaudeDirect.
+ */
+async function postTaskMemoryFlush(messages, chatFn, writeToMemory) {
+    // Skip if conversation is too short to be worth saving
+    if (messages.length < 3)
+        return;
+    try {
+        const conversationSnippet = buildEnrichedSnippet(messages, 12000);
+        const resp = await chatFn([{
+                role: 'user',
+                content: POST_TASK_USER_PROMPT + conversationSnippet,
             }], {
-            systemPrompt: 'You extract memory-worthy information from conversations. Output only the extracted memories as bullet points, or "NONE" if nothing is worth saving. Be concise.',
+            systemPrompt: POST_TASK_SYSTEM_PROMPT,
             tools: [],
             maxTokens: 1000,
         });
@@ -267,16 +478,244 @@ ${conversationSnippet}`,
             .map((b) => b.text)
             .join('');
         if (extracted && !extracted.trim().toUpperCase().startsWith('NONE')) {
-            await writeToMemory(extracted);
-            console.log(`[Compaction] Memory flush: saved ${extracted.length} chars before compaction`);
+            let safeExtracted = redactSensitiveContent(extracted);
+            // Append file artifact info extracted from tool_use blocks
+            const fileArtifacts = [];
+            for (const msg of messages) {
+                if (typeof msg.content !== 'string' && Array.isArray(msg.content)) {
+                    for (const block of msg.content) {
+                        if (block.type === 'tool_use' && (block.name === 'write_file' || block.name === 'show_file')) {
+                            const path = block.input?.path || block.input?.file_path || '';
+                            if (path)
+                                fileArtifacts.push(path);
+                        }
+                    }
+                }
+            }
+            if (fileArtifacts.length > 0) {
+                safeExtracted += `\n- Files created: ${fileArtifacts.join(', ')}`;
+            }
+            await writeToMemory(safeExtracted);
+            console.log(`[Memory] Post-task flush: saved ${safeExtracted.length} chars`);
+        }
+        else {
+            console.log('[Memory] Post-task flush: nothing worth saving');
         }
-        lastFlushTime = Date.now();
     }
     catch (err) {
-        console.warn(`[Compaction] Memory flush failed: ${err.message}`);
+        console.warn(`[Memory] Post-task flush failed: ${err.message}`);
     }
 }
-// ─── Maybe Compact Messages ──────────────────────────────────────
+// ─── Auto-Distill MEMORY.md ──────────────────────────────────────
+const DISTILL_THRESHOLD_CHARS = 8000;
+const DISTILL_COOLDOWN_MS = 4 * 60 * 60 * 1000; // 4 hours
+let lastDistillTime = 0;
+const DISTILL_SYSTEM_PROMPT = `You are a memory curator. Distill the user's MEMORY.md into a concise, well-organized document.
+
+Rules:
+- Keep ALL essential facts: project architecture, user preferences, environment details, key decisions
+- Remove duplicates, outdated entries, and trivially obvious information
+- Reorganize into clear sections with markdown headings
+- Preserve all identifiers EXACTLY (file paths, URLs, version numbers, config values)
+- Output ONLY the distilled MEMORY.md content, no preamble or explanation
+- Target length: 40-60% of the original
+- Never include API keys, passwords, tokens, secrets, or credentials`;
+/**
+ * Auto-distill MEMORY.md when it exceeds the size threshold.
+ * Called fire-and-forget after post-task flush.
+ *
+ * Safety guards:
+ * - 4-hour cooldown between distillations
+ * - Output must be 100+ chars, smaller than original, >= 20% of original
+ */
+async function autoDistillMemory(memoryDir, chatFn, writeAndSync) {
+    if (Date.now() - lastDistillTime < DISTILL_COOLDOWN_MS)
+        return false;
+    try {
+        const { readFile } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        const content = await readFile(`${memoryDir}/MEMORY.md`, 'utf-8').catch(() => '');
+        if (!content || content.length <= DISTILL_THRESHOLD_CHARS)
+            return false;
+        console.log(`[Memory] MEMORY.md is ${content.length} chars (threshold: ${DISTILL_THRESHOLD_CHARS}), distilling...`);
+        const resp = await chatFn([{
+                role: 'user',
+                content: `Distill this MEMORY.md. Keep essential facts, remove duplicates and outdated info, reorganize clearly.\n\nMEMORY.md content:\n${content}`,
+            }], {
+            systemPrompt: DISTILL_SYSTEM_PROMPT,
+            tools: [],
+            maxTokens: 4000,
+        });
+        const distilled = resp.content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('');
+        // Safety guards
+        if (!distilled || distilled.length < 100) {
+            console.warn('[Memory] Distillation produced too little output, skipping');
+            return false;
+        }
+        if (distilled.length >= content.length) {
+            console.warn('[Memory] Distillation did not reduce size, skipping');
+            return false;
+        }
+        if (distilled.length < content.length * 0.2) {
+            console.warn(`[Memory] Distillation removed too much (${distilled.length}/${content.length}), skipping`);
+            return false;
+        }
+        const safeDistilled = redactSensitiveContent(distilled);
+        await writeAndSync(safeDistilled);
+        lastDistillTime = Date.now();
+        console.log(`[Memory] MEMORY.md distilled: ${content.length} → ${safeDistilled.length} chars (${Math.round(safeDistilled.length / content.length * 100)}%)`);
+        return true;
+    }
+    catch (err) {
+        console.warn(`[Memory] Auto-distill failed: ${err.message}`);
+        return false;
+    }
+}
+// ─── Transcript Digest ───────────────────────────────────────────
+/** Build a lightweight transcript digest for daily log */
+function buildTranscriptDigest(messages, userMessage, turn, usage) {
+    const toolCounts = {};
+    let lastAssistantText = '';
+    for (const msg of messages) {
+        if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.trim()) {
+            lastAssistantText = msg.content;
+        }
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type === 'tool_use' && block.name) {
+                toolCounts[block.name] = (toolCounts[block.name] || 0) + 1;
+            }
+            if (msg.role === 'assistant' && block.type === 'text' && block.text) {
+                lastAssistantText = block.text;
+            }
+        }
+    }
+    const actions = Object.entries(toolCounts)
+        .map(([name, count]) => `${name}×${count}`)
+        .join(', ');
+    const userSnippet = userMessage.substring(0, 200).replace(/\n/g, ' ');
+    const resultSnippet = lastAssistantText.substring(0, 200).replace(/\n/g, ' ');
+    return [
+        `**User:** ${userSnippet}`,
+        actions ? `**Actions:** ${actions}` : '',
+        resultSnippet ? `**Result:** ${resultSnippet}` : '',
+        `**Turns:** ${turn}${usage ? ` | Tokens: in=${usage.input_tokens} out=${usage.output_tokens}` : ''}`,
+    ].filter(Boolean).join('\n');
+}
+// ─── Compaction Helpers ─────────────────────────────────────────
+/** Condense messages into summarization-friendly text parts */
+function condenseMsgsForSummary(msgs) {
+    const parts = [];
+    for (const msg of msgs) {
+        const content = typeof msg.content === 'string'
+            ? msg.content
+            : msg.content.map((b) => {
+                if (b.type === 'text')
+                    return b.text;
+                if (b.type === 'tool_use')
+                    return `[Used ${b.name}]`;
+                if (b.type === 'tool_result') {
+                    const text = typeof b.content === 'string' ? b.content : '';
+                    const prefix = b.is_error ? '[Error: ' : '[Result: ';
+                    return `${prefix}${text.substring(0, 200)}]`;
+                }
+                return '';
+            }).filter(Boolean).join(' ');
+        if (content)
+            parts.push(`${msg.role}: ${content.substring(0, MSG_CONDENSE_CHARS)}`);
+    }
+    return parts;
+}
+/** Find the split point that divides messages into ~50% token share */
+function findSplitPoint(messages) {
+    const total = estimateMessagesTokens(messages);
+    const half = total / 2;
+    let running = 0;
+    for (let i = 0; i < messages.length; i++) {
+        running += estimateMessagesTokens([messages[i]]);
+        if (running >= half)
+            return Math.max(1, i);
+    }
+    return Math.max(1, Math.floor(messages.length / 2));
+}
+/** Extract file operations from messages for compaction metadata */
+function extractFileOperations(messages) {
+    const read = new Set();
+    const modified = new Set();
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type !== 'tool_use')
+                continue;
+            const path = block.input?.path;
+            if (!path)
+                continue;
+            if (block.name === 'read_file' || block.name === 'show_file')
+                read.add(path);
+            if (block.name === 'write_file')
+                modified.add(path);
+        }
+    }
+    return {
+        readFiles: [...read].slice(0, 30),
+        modifiedFiles: [...modified].slice(0, 30),
+    };
+}
+/** Find the tool name that matches a given tool_use_id */
+function findToolNameForResult(messages, toolUseId) {
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type === 'tool_use' && block.id === toolUseId)
+                return block.name;
+        }
+    }
+    return null;
+}
+/** Extract tool failures from messages for compaction metadata */
+function extractToolFailures(messages) {
+    const failures = [];
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type !== 'tool_result' || !block.is_error)
+                continue;
+            const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content || '');
+            const toolName = findToolNameForResult(messages, block.tool_use_id) || 'unknown';
+            failures.push({ tool: toolName, error: content.substring(0, 200) });
+        }
+    }
+    return failures.slice(-8); // Keep last 8 failures
+}
+/** Format metadata (file ops + failures) as text to append to summary */
+function formatMetadata(fileOps, failures) {
+    const sections = [];
+    if (fileOps.readFiles.length > 0) {
+        sections.push(`<read-files>\n${fileOps.readFiles.join(', ')}\n</read-files>`);
+    }
+    if (fileOps.modifiedFiles.length > 0) {
+        sections.push(`<modified-files>\n${fileOps.modifiedFiles.join(', ')}\n</modified-files>`);
+    }
+    if (failures.length > 0) {
+        const items = failures.map(f => `- ${f.tool}: "${f.error}"`).join('\n');
+        sections.push(`<tool-failures>\n${items}\n</tool-failures>`);
+    }
+    return sections.length > 0 ? '\n\n' + sections.join('\n') : '';
+}
+/** Extract text from Claude response */
+function extractText(resp) {
+    return resp.content
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text)
+        .join('');
+}
+// ─── Maybe Compact Messages (Multi-Stage) ────────────────────────
 async function maybeCompactMessages(messages, chatFn, systemPrompt) {
     const rawTokens = estimateMessagesTokens(messages);
     const safeTokens = Math.ceil(rawTokens * SAFETY_MARGIN);
@@ -289,38 +728,52 @@ async function maybeCompactMessages(messages, chatFn, systemPrompt) {
     const recentMessages = messages.slice(messages.length - keepCount);
     if (oldMessages.length === 0)
         return messages;
-    // Build summary of old messages
-    const summaryParts = [];
-    for (const msg of oldMessages) {
-        const content = typeof msg.content === 'string'
-            ? msg.content
-            : msg.content.map((b) => {
-                if (b.type === 'text')
-                    return b.text;
-                if (b.type === 'tool_use')
-                    return `[Used ${b.name}]`;
-                if (b.type === 'tool_result')
-                    return `[Result: ${(typeof b.content === 'string' ? b.content : '').substring(0, 200)}]`;
-                return '';
-            }).filter(Boolean).join(' ');
-        if (content)
-            summaryParts.push(`${msg.role}: ${content.substring(0, 500)}`);
-    }
-    // Ask Claude to summarize via provided chat function
+    // Extract metadata before summarization
+    const fileOps = extractFileOperations(oldMessages);
+    const failures = extractToolFailures(oldMessages);
+    const metadata = formatMetadata(fileOps, failures);
+    // Try multi-stage map-reduce summarization
     try {
-        const summaryResp = await chatFn([{ role: 'user', content: `Summarize this conversation history concisely (key decisions, results, current state):\n\n${summaryParts.join('\n\n')}` }], {
-            systemPrompt: 'You are a concise summarizer. Output only the summary, no preamble.',
-            tools: [],
-            maxTokens: 2000,
-        });
-        const summaryText = summaryResp.content
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text)
-            .join('');
+        let summaryText;
+        if (oldMessages.length >= 6) {
+            // Split into 2 parts by token share and summarize in parallel
+            const mid = findSplitPoint(oldMessages);
+            const part1 = condenseMsgsForSummary(oldMessages.slice(0, mid));
+            const part2 = condenseMsgsForSummary(oldMessages.slice(mid));
+            console.log(`[Compaction] Map-reduce: part1=${part1.length} msgs, part2=${oldMessages.length - mid} msgs`);
+            const [resp1, resp2] = await Promise.all([
+                chatFn([{ role: 'user', content: `Summarize this conversation segment concisely (key decisions, actions taken, results, current state):\n\n${part1.join('\n\n')}` }], { systemPrompt: SUMMARY_SYSTEM_PROMPT, tools: [], maxTokens: SUMMARY_PART_MAX_TOKENS }),
+                chatFn([{ role: 'user', content: `Summarize this conversation segment concisely (key decisions, actions taken, results, current state):\n\n${part2.join('\n\n')}` }], { systemPrompt: SUMMARY_SYSTEM_PROMPT, tools: [], maxTokens: SUMMARY_PART_MAX_TOKENS }),
+            ]);
+            const summary1 = extractText(resp1);
+            const summary2 = extractText(resp2);
+            if (summary1 && summary2) {
+                // Merge the two partial summaries
+                try {
+                    const mergeResp = await chatFn([{ role: 'user', content: `Merge these two partial conversation summaries into one cohesive summary.\nPreserve: key decisions, current state, file paths, identifiers, TODOs, open questions.\n\n--- Part 1 ---\n${summary1}\n\n--- Part 2 ---\n${summary2}` }], { systemPrompt: SUMMARY_SYSTEM_PROMPT, tools: [], maxTokens: SUMMARY_MERGE_MAX_TOKENS });
+                    summaryText = extractText(mergeResp) || `${summary1}\n\n${summary2}`;
+                }
+                catch {
+                    // Merge failed — concatenate as fallback
+                    summaryText = `${summary1}\n\n${summary2}`;
+                    console.warn('[Compaction] Merge failed, concatenating partial summaries');
+                }
+            }
+            else {
+                summaryText = summary1 || summary2 || '';
+            }
+        }
+        else {
+            // Too few messages for map-reduce — single pass with enhanced prompt
+            const parts = condenseMsgsForSummary(oldMessages);
+            const resp = await chatFn([{ role: 'user', content: `Summarize this conversation history concisely (key decisions, actions taken, results, current state):\n\n${parts.join('\n\n')}` }], { systemPrompt: SUMMARY_SYSTEM_PROMPT, tools: [], maxTokens: SUMMARY_MERGE_MAX_TOKENS });
+            summaryText = extractText(resp);
+        }
         if (summaryText) {
-            console.log(`[Compaction] Summarized ${oldMessages.length} messages into ${summaryText.length} chars`);
+            const enrichedSummary = summaryText + metadata;
+            console.log(`[Compaction] Summarized ${oldMessages.length} messages into ${enrichedSummary.length} chars (${metadata ? 'with' : 'no'} metadata)`);
             return [
-                { role: 'user', content: `[Previous conversation summary]\n${summaryText}` },
+                { role: 'user', content: `[Previous conversation summary]\n${enrichedSummary}` },
                 { role: 'assistant', content: 'Understood, I have the context from our previous conversation. How can I continue helping?' },
                 ...recentMessages,
             ];
@@ -329,7 +782,14 @@ async function maybeCompactMessages(messages, chatFn, systemPrompt) {
     catch (err) {
         console.error(`[Compaction] Summary failed: ${err.message}`);
     }
-    // Fallback: just truncate old messages
+    // Fallback: just truncate old messages, but still append metadata
+    if (metadata) {
+        return [
+            { role: 'user', content: `[Previous conversation was compacted — details lost]${metadata}` },
+            { role: 'assistant', content: 'Understood. Continuing from the recent context.' },
+            ...recentMessages,
+        ];
+    }
     return recentMessages;
 }
 // ─── Emergency Compact ───────────────────────────────────────────
@@ -339,10 +799,14 @@ function emergencyCompactMessages(messages) {
     // Keep first message + last 4 messages
     const first = messages[0];
     const recent = messages.slice(-4);
+    // Extract file ops metadata even in emergency
+    const dropped = messages.slice(1, -4);
+    const fileOps = extractFileOperations(dropped);
+    const metadata = formatMetadata(fileOps, []);
     console.log(`[Compaction] Emergency: dropped ${messages.length - 5} middle messages`);
     return [
         first,
-        { role: 'user', content: '[Earlier conversation messages were removed due to context limits. Continue from the most recent context.]' },
+        { role: 'user', content: `[Earlier conversation messages were removed due to context limits. Continue from the most recent context.]${metadata}` },
         { role: 'assistant', content: 'Understood. Continuing from the recent context.' },
         ...recent,
     ];