@ekkos/cli 0.2.18 → 0.3.3

package/dist/capture/jsonl-rewriter.js

@@ -0,0 +1,1369 @@
+"use strict";
+/**
+ * JSONL Sliding Window - Maximize Context for New Work
+ *
+ * Progressive eviction - always stay lean:
+ * - 60%+: trim junk (streaming chunks only)
+ * - 65%+: trim metadata (snapshots, system) + truncate tool_results
+ * - 70%+: trim tools (results, calls)
+ * - 80%+: emergency dump to 50%
+ *
+ * THINKING BLOCKS: Preserved (priority 6) - contain valuable reasoning
+ * Safety: Last 50 lines are NEVER evicted (recent work protection)
+ *
+ * PROXY MODE (EKKOS_PROXY_MODE=1):
+ * When API proxy is enabled, eviction happens at the API level before
+ * requests reach Anthropic. In this mode, JSONL rewriter only does
+ * junk cleanup (continuousClean) - no threshold-based eviction.
+ * This prevents duplicate eviction from two sources.
+ */
+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.evictWithHandshake = evictWithHandshake;
+exports.confirmLocalEviction = confirmLocalEviction;
+exports.isHandshakeEvictionAvailable = isHandshakeEvictionAvailable;
+exports.evictToTarget = evictToTarget;
+exports.needsEviction = needsEviction;
+exports.evictToTargetAsync = evictToTargetAsync;
+exports.continuousClean = continuousClean;
+exports.emergencyEvict = emergencyEvict;
+exports.getEvictionStats = getEvictionStats;
+exports.getEvictedContent = getEvictedContent;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const eviction_client_js_1 = require("./eviction-client.js");
+// Thresholds - evict earlier to prevent context wall
+const TRIM_JUNK = 60; // streaming/thinking - always safe
+const TRIM_META = 65; // file-history-snapshots, system messages (was 70)
+const TRIM_TOOLS = 70; // tool_results/tool_uses - now at 70% (was 80)
+const EMERGENCY = 80; // emergency eviction at 80% (was 85)
+const TARGET = 50; // target percentage after eviction
+// Safety settings
+const PROTECT_RECENT_LINES = 50; // Never evict last 50 lines (~10 turns, was 100)
+const TRUNCATE_THRESHOLD = 3000; // Truncate tool_results > 3KB (was 5KB, prefer truncation)
+// Stats log path
+const STATS_LOG = path.join(os.homedir(), '.ekkos', 'eviction-stats.json');
+// ══════════════════════════════════════════════════════════════════════════════
+// ROBUST DEBUG LOGGING - Trace exactly what causes 400 errors
+// ══════════════════════════════════════════════════════════════════════════════
+const DEBUG_LOG = path.join(os.homedir(), '.ekkos', 'logs', 'eviction-debug.log');
+function ensureLogDir() {
+    const dir = path.dirname(DEBUG_LOG);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function debugLog(category, message, data) {
+    ensureLogDir();
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] [${category}] ${message}${data ? '\n  ' + JSON.stringify(data, null, 2).replace(/\n/g, '\n  ') : ''}`;
+    fs.appendFileSync(DEBUG_LOG, line + '\n');
+}
+function logToolPairs(toolUseIdToIndex, toolResultIndexToIds, inFlightLineIndices, category) {
+    const pairs = [];
+    for (const [toolUseId, useIndex] of toolUseIdToIndex) {
+        let resultIndex = null;
+        for (const [rIndex, ids] of toolResultIndexToIds) {
+            if (ids.includes(toolUseId)) {
+                resultIndex = rIndex;
+                break;
+            }
+        }
+        const status = inFlightLineIndices.has(useIndex)
+            ? 'IN_FLIGHT (protected)'
+            : resultIndex !== null
+                ? 'PAIRED'
+                : 'ORPHAN_USE';
+        pairs.push({ toolUseId, useIndex, resultIndex, status });
+    }
+    debugLog(category, `Tool pairs analysis (${pairs.length} total):`, pairs);
+}
+function logEvictionDecision(toRemove, lines, inFlightLineIndices) {
+    const decisions = lines.map(l => ({
+        index: l.index,
+        priority: l.priority,
+        protected: l.protected,
+        inFlight: inFlightLineIndices.has(l.index),
+        evicted: toRemove.has(l.index),
+        type: l.raw.includes('"type":"tool_use"') ? 'tool_use'
+            : l.raw.includes('"type":"tool_result"') ? 'tool_result'
+                : l.raw.includes('"type":"assistant"') ? 'assistant'
+                    : l.raw.includes('"type":"human"') ? 'user'
+                        : 'other',
+        toolIds: [...extractToolUseIds(l.raw), ...extractToolResultIds(l.raw)].slice(0, 3),
+    }));
+    debugLog('EVICTION_DECISIONS', `Eviction plan (${toRemove.size} to remove):`, decisions.filter(d => d.evicted || d.type.includes('tool')));
+}
+/**
+ * Validates file state after eviction - returns true if healthy (no orphaned tool_results)
+ */
+function validateAndLogFinalState(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+        const toolUseIds = new Set();
+        const toolResultIds = new Set();
+        for (const line of lines) {
+            for (const id of extractToolUseIds(line))
+                toolUseIds.add(id);
+            for (const id of extractToolResultIds(line))
+                toolResultIds.add(id);
+        }
+        const orphanResults = [...toolResultIds].filter(id => !toolUseIds.has(id));
+        const orphanUses = [...toolUseIds].filter(id => !toolResultIds.has(id));
+        debugLog('FINAL_STATE', `After eviction:`, {
+            totalLines: lines.length,
+            toolUses: toolUseIds.size,
+            toolResults: toolResultIds.size,
+            orphanedResults: orphanResults,
+            orphanedUses: orphanUses,
+            healthy: orphanResults.length === 0,
+        });
+        if (orphanResults.length > 0) {
+            debugLog('ERROR', '❌ ORPHANED TOOL_RESULTS DETECTED - WILL CAUSE 400 ERROR', orphanResults);
+        }
+        return { healthy: orphanResults.length === 0, orphanedResults: orphanResults };
+    }
+    catch (e) {
+        debugLog('ERROR', 'Failed to analyze final state', { error: String(e) });
+        return { healthy: true, orphanedResults: [] }; // Assume healthy if we can't check
+    }
+}
+// Priority: 0 = evict first, 7 = keep longest
+function getPriority(line) {
+    if (!line.includes('"type"'))
+        return 0; // streaming chunks
+    if (line.includes('file-history-snapshot'))
+        return 2;
+    if (line.includes('"type":"system"'))
+        return 3;
+    if (line.includes('"type":"tool_result"'))
+        return 4;
+    if (line.includes('"type":"tool_use"'))
+        return 5;
+    if (line.includes('"type":"thinking"'))
+        return 6; // KEEP thinking blocks - valuable reasoning
+    if (line.includes('"type":"assistant"'))
+        return 6;
+    if (line.includes('"type":"user"'))
+        return 7;
+    return 3;
+}
+function getThreshold(priority) {
+    if (priority <= 1)
+        return TRIM_JUNK;
+    if (priority <= 3)
+        return TRIM_META;
+    if (priority <= 5)
+        return TRIM_TOOLS;
+    return EMERGENCY;
+}
+/**
+ * Extract tool_use IDs from a line (assistant message with tool_use blocks)
+ * Uses proper JSON parsing to handle nested objects correctly.
+ */
+function extractToolUseIds(line) {
+    const ids = [];
+    try {
+        const obj = JSON.parse(line);
+        const content = obj?.message?.content;
+        if (!Array.isArray(content))
+            return ids;
+        for (const block of content) {
+            if (block?.type === 'tool_use' && typeof block?.id === 'string') {
+                ids.push(block.id);
+            }
+        }
+    }
+    catch {
+        // Parse failed - fall back to regex for simple cases
+        // This regex works when "id" appears before nested objects
+        const regex = /"type"\s*:\s*"tool_use"\s*,\s*"id"\s*:\s*"(toolu_[^"]+)"/g;
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+            ids.push(match[1]);
+        }
+    }
+    return ids;
+}
+/**
+ * Extract all tool_use_ids referenced by tool_result blocks in a line.
+ * Uses proper JSON parsing to handle nested objects correctly.
+ */
+function extractToolResultIds(line) {
+    const ids = [];
+    try {
+        const obj = JSON.parse(line);
+        const content = obj?.message?.content;
+        if (!Array.isArray(content))
+            return ids;
+        for (const block of content) {
+            if (block?.type === 'tool_result' && typeof block?.tool_use_id === 'string') {
+                ids.push(block.tool_use_id);
+            }
+        }
+    }
+    catch {
+        // Parse failed - fall back to regex
+        const regex = /"type"\s*:\s*"tool_result"[^}]*?"tool_use_id"\s*:\s*"(toolu_[^"]+)"/g;
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+            ids.push(match[1]);
+        }
+    }
+    return ids;
+}
+/**
+ * Extract tool_use_id from a tool_result line (legacy single-result version)
+ * @deprecated Use extractToolResultIds for multi-result support
+ */
+function extractToolResultId(line) {
+    const ids = extractToolResultIds(line);
+    return ids.length > 0 ? ids[0] : null;
+}
+/**
+ * Truncate a tool_result line - keep stub, remove bulk
+ */
+function truncateToolResult(line) {
+    try {
+        const obj = JSON.parse(line);
+        if (!obj.message?.content)
+            return line;
+        const content = obj.message.content;
+        if (!Array.isArray(content))
+            return line;
+        let modified = false;
+        for (const block of content) {
+            if (block.type === 'tool_result' && typeof block.content === 'string') {
+                const originalLen = block.content.length;
+                if (originalLen > TRUNCATE_THRESHOLD) {
+                    const lines = block.content.split('\n').length;
+                    const preview = block.content.slice(0, 100).replace(/\n/g, ' ');
+                    block.content = `[Truncated: ${lines} lines, ${(originalLen / 1024).toFixed(1)}KB] ${preview}...`;
+                    modified = true;
+                }
+            }
+        }
+        return modified ? JSON.stringify(obj) : line;
+    }
+    catch {
+        return line;
+    }
+}
+// Evicted content store (for retrieval by ccDNA)
+const EVICTED_STORE = path.join(os.homedir(), '.ekkos', 'evicted-context.jsonl');
+const EKKOS_CAPTURE_ENDPOINT = 'https://mcp.ekkos.dev/api/v1/context/evict';
+const EKKOS_API_URL = process.env.EKKOS_API_URL || 'https://mcp.ekkos.dev';
+/**
+ * Evict messages using the Handshake Protocol (two-phase commit)
+ *
+ * CRITICAL: Returns success ONLY after R2 confirms backup.
+ * Caller must NOT delete locally until this returns success=true.
+ *
+ * @returns result with clientNonce for confirm phase, or error
+ */
+async function evictWithHandshake(lines, indices, context) {
+    const authToken = process.env.EKKOS_AUTH_TOKEN || process.env.SUPABASE_AUTH_TOKEN;
+    const userId = context.userId || process.env.EKKOS_USER_ID;
+    const tenantId = context.tenantId || process.env.EKKOS_TENANT_ID || 'default';
+    if (!authToken) {
+        debugLog('HANDSHAKE_SKIP', 'No auth token available');
+        return {
+            success: false,
+            evictionId: 'none',
+            status: 'skipped',
+            error: 'No auth token',
+        };
+    }
+    if (!userId) {
+        debugLog('HANDSHAKE_SKIP', 'No user ID available');
+        return {
+            success: false,
+            evictionId: 'none',
+            status: 'skipped',
+            error: 'No user ID',
+        };
+    }
+    // Parse messages from JSONL lines
+    const messages = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.message) {
+                messages.push({
+                    role: parsed.message.role || 'user',
+                    content: parsed.message.content,
+                });
+            }
+        }
+        catch {
+            // Skip unparseable lines
+        }
+    }
+    if (messages.length === 0) {
+        debugLog('HANDSHAKE_SKIP', 'No valid messages to evict');
+        return {
+            success: false,
+            evictionId: 'none',
+            status: 'skipped',
+            error: 'No valid messages',
+        };
+    }
+    // Estimate tokens
+    const totalChars = lines.reduce((sum, l) => sum + l.length, 0);
+    const estimatedTokens = Math.ceil(totalChars / 4);
+    const options = {
+        apiUrl: EKKOS_API_URL,
+        authToken,
+        sessionId: context.sessionId,
+        sessionName: context.sessionName,
+        userId,
+        tenantId,
+        projectPath: context.projectPath,
+    };
+    debugLog('HANDSHAKE_START', `Starting handshake eviction for ${messages.length} messages`, {
+        sessionName: context.sessionName,
+        estimatedTokens,
+        indices: indices.slice(0, 5), // Log first 5 indices
+    });
+    const result = await (0, eviction_client_js_1.handshakeEviction)(messages, indices, estimatedTokens, 'threshold', options);
+    if (result.success) {
+        debugLog('HANDSHAKE_SUCCESS', `Prepared eviction ${result.evictionId}`, {
+            r2Key: result.r2Key,
+            bytesWritten: result.bytesWritten,
+            status: result.status,
+        });
+    }
+    else {
+        debugLog('HANDSHAKE_FAIL', `Eviction failed: ${result.error}`, {
+            evictionId: result.evictionId,
+            status: result.status,
+        });
+    }
+    return result;
+}
+/**
+ * Complete the handshake by confirming local deletion
+ * Call this AFTER successfully deleting from local JSONL
+ */
+async function confirmLocalEviction(evictionId, clientNonce, deletedCount) {
+    const authToken = process.env.EKKOS_AUTH_TOKEN || process.env.SUPABASE_AUTH_TOKEN;
+    if (!authToken)
+        return false;
+    const result = await (0, eviction_client_js_1.confirmEviction)(EKKOS_API_URL, authToken, evictionId, clientNonce, deletedCount);
+    if (result.success) {
+        debugLog('HANDSHAKE_CONFIRM', `Confirmed eviction ${evictionId} (${deletedCount} lines)`);
+    }
+    else {
+        // Non-critical - data is already safe in R2
+        debugLog('HANDSHAKE_CONFIRM_FAIL', `Confirm failed (non-critical): ${result.error}`);
+    }
+    return result.success;
+}
+/**
+ * Check if handshake eviction is available (proxy reachable)
+ */
+async function isHandshakeEvictionAvailable() {
+    const authToken = process.env.EKKOS_AUTH_TOKEN || process.env.SUPABASE_AUTH_TOKEN;
+    if (!authToken)
+        return false;
+    // In proxy mode, handshake is handled by proxy - CLI should use fire-and-forget
+    if (process.env.EKKOS_PROXY_MODE === '1') {
+        return false;
+    }
+    return (0, eviction_client_js_1.checkEvictionHealth)(EKKOS_API_URL, authToken);
+}
+/**
+ * Send evicted content to ekkOS cloud for later retrieval (async, non-blocking)
+ */
+async function captureEvictedToCloud(lines, sessionId) {
+    try {
+        // Get auth token from environment
+        const authToken = process.env.EKKOS_AUTH_TOKEN || process.env.SUPABASE_AUTH_TOKEN;
+        if (!authToken) {
+            debugLog('CLOUD_CAPTURE_SKIP', 'No auth token available');
+            return;
+        }
+        // Parse messages from JSONL lines
+        const messages = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.message) {
+                    messages.push({
+                        role: parsed.message.role || 'unknown',
+                        content: parsed.message.content,
+                    });
+                }
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+        if (messages.length === 0)
+            return;
+        // Estimate tokens (rough: 1 token ≈ 4 chars)
+        const totalChars = lines.reduce((sum, l) => sum + l.length, 0);
+        const estimatedTokens = Math.ceil(totalChars / 4);
+        const payload = {
+            session_id: sessionId || 'unknown',
+            chunk_index: Date.now(), // Use timestamp as unique chunk index
+            messages,
+            token_count: estimatedTokens,
+            eviction_reason: 'sliding_window',
+        };
+        // Non-blocking fetch - don't await, let it happen in background
+        // 10s timeout to prevent lingering connections from burning resources
+        fetch(EKKOS_CAPTURE_ENDPOINT, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${authToken}`,
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(10000),
+        }).then(res => {
+            if (res.ok) {
+                debugLog('CLOUD_CAPTURE_OK', `Sent ${messages.length} msgs to cloud`);
+            }
+            else {
+                debugLog('CLOUD_CAPTURE_FAIL', `HTTP ${res.status}`);
+            }
+        }).catch(err => {
+            debugLog('CLOUD_CAPTURE_ERROR', err.message);
+        });
+    }
+    catch (err) {
+        debugLog('CLOUD_CAPTURE_ERROR', err.message);
+    }
+}
+/**
+ * Save evicted content for later retrieval
+ * Now supports handshake eviction when available
+ *
+ * @param lines - JSONL lines being evicted
+ * @param sessionId - Session ID (for legacy capture)
+ * @param sessionName - Session name (for handshake eviction)
+ * @param indices - Original indices of evicted lines
+ */
+function saveEvictedContent(lines, sessionId, sessionName, indices) {
+    if (lines.length === 0)
+        return;
+    try {
+        // Extract ALL tool IDs from evicted content for debugging
+        const evictedToolUseIds = [];
+        const evictedToolResultIds = [];
+        for (const line of lines) {
+            for (const id of extractToolUseIds(line))
+                evictedToolUseIds.push(id);
+            for (const id of extractToolResultIds(line))
+                evictedToolResultIds.push(id);
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            lineCount: lines.length,
+            evictedToolUseIds,
+            evictedToolResultIds,
+            orphanedUses: evictedToolUseIds.filter(id => !evictedToolResultIds.includes(id)),
+            orphanedResults: evictedToolResultIds.filter(id => !evictedToolUseIds.includes(id)),
+            content: lines.slice(0, 20), // Save first 20 lines as sample
+        };
+        // Also log to debug file for immediate visibility
+        debugLog('EVICTED_CONTENT', `Saved ${lines.length} evicted lines`, {
+            toolUseCount: evictedToolUseIds.length,
+            toolResultCount: evictedToolResultIds.length,
+            orphanedUses: entry.orphanedUses,
+            orphanedResults: entry.orphanedResults,
+        });
+        fs.appendFileSync(EVICTED_STORE, JSON.stringify(entry) + '\n');
+        // Keep file under 1MB
+        const stats = fs.statSync(EVICTED_STORE);
+        if (stats.size > 1024 * 1024) {
+            const content = fs.readFileSync(EVICTED_STORE, 'utf-8');
+            const entries = content.split('\n').filter(l => l.trim());
+            fs.writeFileSync(EVICTED_STORE, entries.slice(-100).join('\n') + '\n');
+        }
+        // Send to cloud for cross-session retrieval (non-blocking)
+        captureEvictedToCloud(lines, sessionId);
+    }
+    catch {
+        // Silent fail
+    }
+}
+/**
+ * Log eviction stats to file
+ */
+function logStats(stats) {
+    try {
+        let log = [];
+        if (fs.existsSync(STATS_LOG)) {
+            try {
+                log = JSON.parse(fs.readFileSync(STATS_LOG, 'utf-8'));
+            }
+            catch {
+                log = [];
+            }
+        }
+        log.push(stats);
+        // Keep last 100 entries
+        if (log.length > 100)
+            log = log.slice(-100);
+        fs.writeFileSync(STATS_LOG, JSON.stringify(log, null, 2));
+    }
+    catch {
+        // Silent fail for stats
+    }
+}
+function evictToTarget(filePath, currentPercent, sessionId, sessionName) {
+    debugLog('EVICTION_START', `evictToTarget called at ${currentPercent}%`, { filePath, currentPercent });
+    if (currentPercent < TRIM_JUNK) {
+        debugLog('EVICTION_SKIP', `Below threshold (${TRIM_JUNK}%), no eviction needed`);
+        return { success: true, evicted: 0, truncated: 0, newPercent: currentPercent };
+    }
+    if (!fs.existsSync(filePath)) {
+        debugLog('EVICTION_ERROR', 'File not found', { filePath });
+        return { success: false, evicted: 0, truncated: 0, newPercent: currentPercent };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    // CRITICAL: Handle line endings carefully to avoid corruption
+    // - Files ending with \n: last element after split is empty, drop it
+    // - Files NOT ending with \n: last line might be incomplete OR might be valid
+    //   → Include it only if it parses as valid JSON
+    const endsWithNewline = content.endsWith('\n');
+    const allLines = content.split('\n');
+    // For files ending with \n, drop the empty last element
+    // For files without trailing \n, keep last element (will be validated below)
+    const candidateLines = endsWithNewline
+        ? allLines.slice(0, -1) // Drop empty trailing element
+        : allLines; // Keep all, validate below
+    const rawLines = candidateLines
+        .filter(l => l.trim())
+        .filter(l => {
+        // Validate each line is valid JSON - this catches:
+        // 1. Incomplete lines from mid-write
+        // 2. Corrupted lines
+        // 3. Non-JSON content
+        try {
+            JSON.parse(l);
+            return true;
+        }
+        catch {
+            debugLog('INVALID_JSON_LINE', 'Skipping invalid JSON line', { preview: l.slice(0, 100) });
+            return false;
+        }
+    });
+    const totalBytes = Buffer.byteLength(content, 'utf-8');
+    debugLog('EVICTION_INIT', `Loaded file`, {
+        lines: rawLines.length,
+        bytes: totalBytes,
+        currentPercent,
+    });
+    const targetPercent = currentPercent >= EMERGENCY ? TARGET : currentPercent - 15;
+    const targetBytes = totalBytes * (targetPercent / currentPercent);
+    // First pass: truncate large tool_results (at 70%+)
+    let truncatedCount = 0;
+    const processedLines = rawLines.map(line => {
+        if (currentPercent >= TRIM_META && line.includes('"type":"tool_result"') && line.length > TRUNCATE_THRESHOLD) {
+            const truncated = truncateToolResult(line);
+            if (truncated !== line) {
+                truncatedCount++;
+                return truncated;
+            }
+        }
+        return line;
+    });
+    const totalLines = processedLines.length;
+    const protectedStart = Math.max(0, totalLines - PROTECT_RECENT_LINES);
+    const lines = processedLines.map((raw, index) => ({
+        raw,
+        index,
+        bytes: Buffer.byteLength(raw, 'utf-8') + 1,
+        priority: getPriority(raw),
+        protected: index >= protectedStart, // Protect recent turns
+    }));
+    // Build tool_use/tool_result pairing maps
+    // CRITICAL: Must keep pairs together to avoid API errors
+    const toolUseIdToIndex = new Map(); // tool_use_id -> line index
+    const toolResultIndexToIds = new Map(); // line index -> tool_use_ids it references
+    for (const line of lines) {
+        const toolUseIds = extractToolUseIds(line.raw);
+        for (const id of toolUseIds) {
+            toolUseIdToIndex.set(id, line.index);
+        }
+        const resultIds = extractToolResultIds(line.raw);
+        if (resultIds.length > 0) {
+            toolResultIndexToIds.set(line.index, resultIds);
+        }
+    }
+    // CRITICAL FIX: Identify "in-flight" tool_uses (those without results yet)
+    // These must NOT be evicted or we'll get orphaned tool_results when they complete
+    const completedToolUseIds = new Set();
+    for (const toolUseIds of toolResultIndexToIds.values()) {
+        for (const id of toolUseIds) {
+            completedToolUseIds.add(id);
+        }
+    }
+    // Find lines containing in-flight tool_uses (tool_use without result)
+    const inFlightLineIndices = new Set();
+    for (const [toolUseId, lineIndex] of toolUseIdToIndex) {
+        if (!completedToolUseIds.has(toolUseId)) {
+            inFlightLineIndices.add(lineIndex);
+        }
+    }
+    // Log the tool pairing state BEFORE eviction
+    debugLog('TOOL_PAIRS_BEFORE', `Tool pairing analysis before eviction`, {
+        totalToolUses: toolUseIdToIndex.size,
+        totalToolResults: toolResultIndexToIds.size,
+        completedPairs: completedToolUseIds.size,
+        inFlightCount: inFlightLineIndices.size,
+        inFlightLines: [...inFlightLineIndices],
+    });
+    logToolPairs(toolUseIdToIndex, toolResultIndexToIds, inFlightLineIndices, 'PAIRS_BEFORE');
+    // Recalculate bytes after truncation
+    let currentBytes = lines.reduce((sum, l) => sum + l.bytes, 0);
+    // Sort: lowest priority first, then oldest (but never protected or in-flight)
+    const evictionOrder = lines
+        .filter(l => !l.protected && !inFlightLineIndices.has(l.index))
+        .sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return a.index - b.index;
+    });
+    const toRemove = new Set();
+    const byPriority = {};
+    for (const line of evictionOrder) {
+        if (currentBytes <= targetBytes)
+            break;
+        const threshold = getThreshold(line.priority);
+        if (currentPercent >= threshold) {
+            toRemove.add(line.index);
+            currentBytes -= line.bytes;
+            byPriority[line.priority] = (byPriority[line.priority] || 0) + 1;
+        }
+    }
+    // CRITICAL: Ensure tool_use/tool_result pairs are evicted together
+    // If we evict a tool_use, we must also evict its tool_result (even if protected)
+    // If we keep a tool_result, we must also keep its tool_use
+    const pairAdjustments = [];
+    for (const [resultIndex, toolUseIds] of toolResultIndexToIds) {
+        for (const toolUseId of toolUseIds) {
+            const useIndex = toolUseIdToIndex.get(toolUseId);
+            if (useIndex === undefined)
+                continue;
+            const useEvicted = toRemove.has(useIndex);
+            const resultEvicted = toRemove.has(resultIndex);
+            if (useEvicted && !resultEvicted) {
+                // tool_use is evicted but tool_result isn't - evict the result too
+                toRemove.add(resultIndex);
+                const resultLine = lines[resultIndex];
+                if (resultLine) {
+                    currentBytes -= resultLine.bytes;
+                    byPriority[resultLine.priority] = (byPriority[resultLine.priority] || 0) + 1;
+                }
+                pairAdjustments.push({ action: 'EVICT_RESULT_WITH_USE', toolUseId, useIndex, resultIndex });
+            }
+            else if (!useEvicted && resultEvicted) {
+                // tool_result is evicted but tool_use isn't - also evict the use
+                toRemove.add(useIndex);
+                const useLine = lines[useIndex];
+                if (useLine) {
+                    currentBytes -= useLine.bytes;
+                    byPriority[useLine.priority] = (byPriority[useLine.priority] || 0) + 1;
+                }
+                pairAdjustments.push({ action: 'EVICT_USE_WITH_RESULT', toolUseId, useIndex, resultIndex });
+            }
+        }
+    }
+    if (pairAdjustments.length > 0) {
+        debugLog('PAIR_ADJUSTMENTS', `Adjusted ${pairAdjustments.length} pairs for consistency`, pairAdjustments);
+    }
+    // Log all eviction decisions
+    logEvictionDecision(toRemove, lines, inFlightLineIndices);
+    if (toRemove.size === 0 && truncatedCount === 0) {
+        debugLog('EVICTION_NOOP', 'No lines to evict or truncate');
+        return { success: true, evicted: 0, truncated: 0, newPercent: currentPercent };
+    }
+    // Save evicted content for ccDNA retrieval
+    const evictedLines = lines.filter(l => toRemove.has(l.index)).map(l => l.raw);
+    const evictedIndices = lines.filter(l => toRemove.has(l.index)).map(l => l.index);
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HANDSHAKE EVICTION PROTOCOL (Two-Phase Commit)
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CRITICAL: Do NOT delete locally until R2 confirms backup!
+    //
+    // Phase 1: Try handshake eviction (if available)
+    // Phase 2: Only delete locally after R2 ACK
+    // Fallback: Fire-and-forget if handshake unavailable
+    //
+    const useHandshake = sessionName && !process.env.EKKOS_PROXY_MODE;
+    let handshakeResult = null;
+    if (useHandshake) {
+        debugLog('HANDSHAKE_ATTEMPT', `Attempting handshake eviction for ${evictedLines.length} lines`);
+        // Sync wrapper for async handshake (evictToTarget is sync)
+        // We use a Promise that resolves immediately to check if we should proceed
+        const handshakePromise = evictWithHandshake(evictedLines, evictedIndices, {
+            sessionId: sessionId || 'unknown',
+            sessionName: sessionName,
+            projectPath: process.cwd(),
+        });
+        // For sync context, we'll use fire-and-forget but track the result
+        // The handshake will complete in background, but we proceed with local eviction
+        // This is a compromise - ideally evictToTarget should be async
+        handshakePromise.then(result => {
+            handshakeResult = result;
+            if (result.success) {
+                debugLog('HANDSHAKE_PREPARED', `Eviction ${result.evictionId} prepared in R2`, {
+                    r2Key: result.r2Key,
+                    bytesWritten: result.bytesWritten,
+                });
+                // Confirm after local deletion completes
+                if (result.clientNonce) {
+                    confirmLocalEviction(result.evictionId, result.clientNonce, evictedLines.length);
+                }
+            }
+            else {
+                debugLog('HANDSHAKE_FAILED', `Handshake failed, data may be at risk: ${result.error}`);
+            }
+        }).catch(err => {
+            debugLog('HANDSHAKE_ERROR', `Handshake error: ${err}`);
+        });
+    }
+    // Legacy fire-and-forget (always runs as backup)
+    saveEvictedContent(evictedLines, sessionId, sessionName, evictedIndices);
+    debugLog('EVICTION_WRITE', `Writing evicted file`, {
+        evicting: toRemove.size,
+        keeping: lines.length - toRemove.size,
+        truncated: truncatedCount,
+    });
+    const kept = lines.filter(l => !toRemove.has(l.index)).map(l => l.raw);
+    // RACE CONDITION FIX: Check if file was modified during eviction
+    // If new lines were appended, we must preserve them
+    const tempPath = `${filePath}.tmp`;
+    // Handle empty kept array gracefully - don't produce leading newline
+    const keptContent = kept.length > 0 ? kept.join('\n') + '\n' : '';
+    // Get original file LENGTH for comparison (NOT byte size - slice uses char indices!)
+    const originalLength = content.length;
+    // Check current file before writing
+    let currentFileContent;
+    try {
+        currentFileContent = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        currentFileContent = content;
+    }
+    const currentLength = currentFileContent.length;
+    if (currentLength > originalLength) {
+        // File grew during eviction! Append new content to our kept lines
+        // CRITICAL: Don't slice mid-line - find the boundary properly
+        const newContent = currentFileContent.slice(originalLength);
+        debugLog('RACE_CONDITION', `File grew during eviction by ${currentLength - originalLength} chars, preserving new content`);
+        // Parse new lines - only keep COMPLETE, VALID JSON lines
+        const newLines = newContent.split('\n')
+            .filter(l => l.trim())
+            .filter(l => {
+            try {
+                JSON.parse(l);
+                return true;
+            }
+            catch {
+                debugLog('RACE_INVALID_LINE', 'Skipping invalid JSON in new content', { preview: l.slice(0, 100) });
+                return false;
+            }
+        });
+        const newToolResultIds = [];
+        for (const line of newLines) {
+            for (const id of extractToolResultIds(line)) {
+                newToolResultIds.push(id);
+            }
+        }
+        // Check if any new tool_results reference tool_uses we just evicted
+        const evictedToolUseIds = new Set();
+        for (const idx of toRemove) {
+            const line = lines[idx];
+            if (line) {
+                for (const id of extractToolUseIds(line.raw)) {
+                    evictedToolUseIds.add(id);
+                }
+            }
+        }
+        const orphanedNewResults = newToolResultIds.filter(id => evictedToolUseIds.has(id));
+        if (orphanedNewResults.length > 0) {
+            debugLog('RACE_ABORT', `New tool_results reference evicted tool_uses - ABORTING eviction to prevent orphans`, {
+                orphanedNewResults,
+                evictedToolUseIds: [...evictedToolUseIds],
+            });
+            // Abort eviction to prevent 400 errors
+            return { success: false, evicted: 0, truncated: 0, newPercent: currentPercent };
+        }
+        // Safe to proceed - append validated new lines (not raw slice!)
+        const validatedNewContent = newLines.length > 0 ? newLines.join('\n') + '\n' : '';
+        fs.writeFileSync(tempPath, keptContent + validatedNewContent);
+    }
+    else {
+        fs.writeFileSync(tempPath, keptContent);
+    }
+    // Save backup before rename (in case we need to rollback)
+    const backupPath = `${filePath}.backup`;
+    try {
+        // Read current file state for backup
+        const backupContent = fs.readFileSync(filePath, 'utf-8');
+        fs.writeFileSync(backupPath, backupContent);
+    }
+    catch {
+        // If we can't backup, proceed anyway
+    }
+    fs.renameSync(tempPath, filePath);
+    // Validate final state - rollback if unhealthy
+    const { healthy, orphanedResults } = validateAndLogFinalState(filePath);
+    if (!healthy) {
+        debugLog('ROLLBACK', `Rolling back eviction due to ${orphanedResults.length} orphaned tool_results`, {
+            orphanedResults,
+        });
+        // Attempt to restore from backup
+        if (fs.existsSync(backupPath)) {
+            try {
+                const backupContent = fs.readFileSync(backupPath, 'utf-8');
+                fs.writeFileSync(filePath, backupContent);
+                debugLog('ROLLBACK', 'Successfully restored from backup');
+                fs.unlinkSync(backupPath);
+                return { success: false, evicted: 0, truncated: 0, newPercent: currentPercent };
+            }
+            catch (e) {
+                debugLog('ROLLBACK_ERROR', 'Failed to restore from backup', { error: String(e) });
+            }
+        }
+    }
+    // Clean up backup on success
+    try {
+        if (fs.existsSync(backupPath))
+            fs.unlinkSync(backupPath);
+    }
+    catch {
+        // Silent fail
+    }
+    const newPercent = Math.round((currentBytes / totalBytes) * currentPercent);
+    // Log comprehensive summary
+    debugLog('EVICTION_SUMMARY', '═══════════════════════════════════════════════════════════', {
+        result: 'SUCCESS',
+        before: {
+            percent: currentPercent,
+            lines: totalLines,
+            bytes: totalBytes,
+        },
+        after: {
+            percent: newPercent,
+            lines: totalLines - toRemove.size,
+            bytes: currentBytes,
+        },
+        actions: {
+            evicted: toRemove.size,
+            truncated: truncatedCount,
+            byPriority: Object.entries(byPriority).map(([p, c]) => {
+                const names = ['streaming', 'thinking', 'snapshot', 'system', 'tool_result', 'tool_use', 'assistant', 'user'];
+                return `${names[parseInt(p)] || 'unknown'}:${c}`;
+            }).join(', '),
+        },
+        toolPairing: {
+            healthy: true,
+            toolUsesRemaining: toolUseIdToIndex.size - [...toRemove].filter(i => [...toolUseIdToIndex.values()].includes(i)).length,
+            toolResultsRemaining: toolResultIndexToIds.size - [...toRemove].filter(i => toolResultIndexToIds.has(i)).length,
+        },
+    });
+    // Log stats
+    logStats({
+        timestamp: new Date().toISOString(),
+        beforePercent: currentPercent,
+        afterPercent: newPercent,
+        evicted: toRemove.size,
+        truncated: truncatedCount,
+        byPriority,
+    });
+    return { success: true, evicted: toRemove.size, truncated: truncatedCount, newPercent };
+}
+function needsEviction(percent) {
+    // If proxy mode is ON, proxy handles eviction at API level
+    // JSONL rewriter only does junk cleanup (priority 0-1) via continuousClean()
+    if (process.env.EKKOS_PROXY_MODE === '1') {
+        return false; // Proxy handles eviction
+    }
+    return percent >= TRIM_JUNK;
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// ASYNC EVICTION WITH PROPER TWO-PHASE COMMIT
+// ═══════════════════════════════════════════════════════════════════════════════
+//
+// This is the CORRECT implementation of the Handshake Eviction Protocol:
+// 1. Classify messages for eviction
+// 2. Call ekkOS_EvictPrepare and WAIT for R2 confirmation
+// 3. ONLY delete locally after R2 ACK
+// 4. Confirm with ekkOS_EvictConfirm
+//
+// NEVER delete locally before R2 confirms!
+/**
+ * Async eviction with proper two-phase commit handshake.
+ * Use this instead of evictToTarget when async context is available.
+ *
+ * @returns Promise<EvictionResult>
+ */
+async function evictToTargetAsync(filePath, currentPercent, sessionId, sessionName) {
+    debugLog('ASYNC_EVICTION_START', `evictToTargetAsync called at ${currentPercent}%`, { filePath, currentPercent });
+    if (currentPercent < TRIM_JUNK) {
+        debugLog('ASYNC_EVICTION_SKIP', `Below threshold (${TRIM_JUNK}%), no eviction needed`);
+        return { success: true, evicted: 0, truncated: 0, newPercent: currentPercent, handshakeUsed: false };
+    }
+    if (!fs.existsSync(filePath)) {
+        debugLog('ASYNC_EVICTION_ERROR', 'File not found', { filePath });
+        return { success: false, evicted: 0, truncated: 0, newPercent: currentPercent, error: 'File not found' };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const endsWithNewline = content.endsWith('\n');
+    const allLines = content.split('\n');
+    const candidateLines = endsWithNewline ? allLines.slice(0, -1) : allLines;
+    const rawLines = candidateLines
+        .filter(l => l.trim())
+        .filter(l => {
+        try {
+            JSON.parse(l);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    const totalBytes = Buffer.byteLength(content, 'utf-8');
+    const targetPercent = currentPercent >= EMERGENCY ? TARGET : currentPercent - 15;
+    // First pass: truncate large tool_results
+    let truncatedCount = 0;
+    const processedLines = rawLines.map(line => {
+        if (currentPercent >= TRIM_META && line.includes('"type":"tool_result"') && line.length > TRUNCATE_THRESHOLD) {
+            const truncated = truncateToolResult(line);
+            if (truncated !== line) {
+                truncatedCount++;
+                return truncated;
+            }
+        }
+        return line;
+    });
+    const totalLines = processedLines.length;
+    const protectedStart = Math.max(0, totalLines - PROTECT_RECENT_LINES);
+    const lines = processedLines.map((raw, index) => ({
+        raw,
+        index,
+        bytes: Buffer.byteLength(raw, 'utf-8') + 1,
+        priority: getPriority(raw),
+        protected: index >= protectedStart,
+    }));
+    // Build tool_use/tool_result pairing maps
+    const toolUseIdToIndex = new Map();
+    const toolResultIndexToIds = new Map();
+    for (const line of lines) {
+        const useIds = extractToolUseIds(line.raw);
+        for (const id of useIds) {
+            toolUseIdToIndex.set(id, line.index);
+        }
+        const resultIds = extractToolResultIds(line.raw);
+        if (resultIds.length > 0) {
+            toolResultIndexToIds.set(line.index, resultIds);
+        }
+    }
+    // Check for in-flight tools
+    const inFlightLineIndices = new Set();
+    for (const [toolUseId, useIndex] of toolUseIdToIndex) {
+        let hasResult = false;
+        for (const [, resultIds] of toolResultIndexToIds) {
+            if (resultIds.includes(toolUseId)) {
+                hasResult = true;
+                break;
+            }
+        }
+        if (!hasResult) {
+            inFlightLineIndices.add(useIndex);
+        }
+    }
+    // Classify lines for eviction
+    const toRemove = new Set();
+    let currentBytes = totalBytes;
+    const targetBytes = totalBytes * (targetPercent / currentPercent);
+    const sortedByPriority = [...lines].sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return a.index - b.index;
+    });
+    const byPriority = {};
+    for (const line of sortedByPriority) {
+        if (currentBytes <= targetBytes)
+            break;
+        if (line.protected)
+            continue;
+        if (inFlightLineIndices.has(line.index))
+            continue;
+        // Check tool result dependencies
+        const resultIds = toolResultIndexToIds.get(line.index);
+        if (resultIds) {
+            let hasOrphanedUse = false;
+            for (const id of resultIds) {
+                const useIndex = toolUseIdToIndex.get(id);
+                if (useIndex !== undefined && !toRemove.has(useIndex)) {
+                    hasOrphanedUse = true;
+                    break;
+                }
+            }
+            if (hasOrphanedUse)
+                continue;
+        }
+        toRemove.add(line.index);
+        currentBytes -= line.bytes;
+        byPriority[line.priority] = (byPriority[line.priority] || 0) + 1;
+    }
+    // Enforce pair consistency
+    for (const [toolUseId, useIndex] of toolUseIdToIndex) {
+        if (toRemove.has(useIndex))
+            continue;
+        for (const [resultIndex, resultIds] of toolResultIndexToIds) {
+            if (resultIds.includes(toolUseId) && toRemove.has(resultIndex)) {
+                const useLine = lines[useIndex];
+                if (!useLine.protected && !inFlightLineIndices.has(useIndex)) {
+                    toRemove.add(useIndex);
+                    currentBytes -= useLine.bytes;
+                    byPriority[useLine.priority] = (byPriority[useLine.priority] || 0) + 1;
+                }
+            }
+        }
+    }
+    if (toRemove.size === 0 && truncatedCount === 0) {
+        debugLog('ASYNC_EVICTION_NOOP', 'No lines to evict or truncate');
+        return { success: true, evicted: 0, truncated: 0, newPercent: currentPercent, handshakeUsed: false };
+    }
+    const evictedLines = lines.filter(l => toRemove.has(l.index)).map(l => l.raw);
+    const evictedIndices = lines.filter(l => toRemove.has(l.index)).map(l => l.index);
+    // ═══════════════════════════════════════════════════════════════════════════
+    // TWO-PHASE COMMIT: HANDSHAKE EVICTION
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CRITICAL: Await R2 confirmation before local deletion!
+    const useHandshake = sessionName && !process.env.EKKOS_PROXY_MODE;
+    let handshakeSucceeded = false;
+    let evictionId;
+    let clientNonce;
+    if (useHandshake) {
+        debugLog('ASYNC_HANDSHAKE_START', `Awaiting handshake for ${evictedLines.length} lines`);
+        try {
+            const handshakeResult = await evictWithHandshake(evictedLines, evictedIndices, {
+                sessionId: sessionId || 'unknown',
+                sessionName: sessionName,
+                projectPath: process.cwd(),
+            });
+            if (handshakeResult.success) {
+                handshakeSucceeded = true;
+                evictionId = handshakeResult.evictionId;
+                clientNonce = handshakeResult.clientNonce;
+                debugLog('ASYNC_HANDSHAKE_SUCCESS', `R2 confirmed eviction ${evictionId}`, {
+                    r2Key: handshakeResult.r2Key,
+                    bytesWritten: handshakeResult.bytesWritten,
+                    status: handshakeResult.status,
+                });
+            }
+            else {
+                debugLog('ASYNC_HANDSHAKE_FAILED', `Handshake failed: ${handshakeResult.error}`, {
+                    status: handshakeResult.status,
+                });
+                // Fall through to fire-and-forget fallback
+            }
+        }
+        catch (err) {
+            debugLog('ASYNC_HANDSHAKE_ERROR', `Handshake error: ${err}`);
+            // Fall through to fire-and-forget fallback
+        }
+    }
+    // If handshake failed/unavailable, fall back to local-only eviction
+    // This prevents session death when R2/proxy is down — local eviction is
+    // better than hitting Anthropic's context limit (HTTP 400)
+    if (!handshakeSucceeded) {
+        debugLog('ASYNC_HANDSHAKE_FALLBACK', 'Handshake failed/unavailable - falling back to local-only eviction (queued for R2 sync)');
+        // Save evicted content locally as best-effort backup
+        saveEvictedContent(evictedLines, sessionId, sessionName, evictedIndices);
+        // Queue for automatic R2 sync when connection is re-established
+        const authToken = process.env.EKKOS_AUTH_TOKEN || process.env.SUPABASE_AUTH_TOKEN;
+        const userId = process.env.EKKOS_USER_ID;
+        const tenantId = process.env.EKKOS_TENANT_ID || 'default';
+        if (authToken && userId && sessionName) {
+            // Parse JSONL lines into messages for the retry queue
+            const queueMessages = [];
+            for (const line of evictedLines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.message) {
+                        queueMessages.push({ role: parsed.message.role || 'user', content: parsed.message.content });
+                    }
+                }
+                catch { /* skip */ }
+            }
+            if (queueMessages.length > 0) {
+                (0, eviction_client_js_1.queueEvictionForRetry)(queueMessages, evictedIndices, Math.ceil(evictedLines.reduce((s, l) => s + l.length, 0) / 4), 'threshold', {
+                    apiUrl: EKKOS_API_URL,
+                    authToken,
+                    sessionId: sessionId || 'unknown',
+                    sessionName,
+                    userId,
+                    tenantId,
+                    projectPath: process.cwd(),
+                });
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // PHASE 2: NOW SAFE TO DELETE LOCALLY
+    // ═══════════════════════════════════════════════════════════════════════════
+    debugLog('ASYNC_EVICTION_WRITE', `Writing evicted file`, {
+        evicting: toRemove.size,
+        keeping: lines.length - toRemove.size,
+        truncated: truncatedCount,
+        handshakeUsed: handshakeSucceeded,
+    });
+    const kept = lines.filter(l => !toRemove.has(l.index)).map(l => l.raw);
+    const keptContent = kept.length > 0 ? kept.join('\n') + '\n' : '';
+    // Race condition check
+    const originalLength = content.length;
+    let currentFileContent;
+    try {
+        currentFileContent = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        currentFileContent = content;
+    }
+    const currentLength = currentFileContent.length;
+    if (currentLength > originalLength) {
+        const newContent = currentFileContent.slice(originalLength);
+        debugLog('ASYNC_RACE_CONDITION', `File grew during eviction`, { delta: currentLength - originalLength });
+        const newLines = newContent.split('\n')
+            .filter(l => l.trim())
+            .filter(l => {
+            try {
+                JSON.parse(l);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        // Check for orphaned tool_results
+        const newToolResultIds = [];
+        for (const line of newLines) {
+            for (const id of extractToolResultIds(line)) {
+                newToolResultIds.push(id);
+            }
+        }
+        const evictedToolUseIds = new Set();
+        for (const idx of toRemove) {
+            const line = lines[idx];
+            if (line) {
+                for (const id of extractToolUseIds(line.raw)) {
+                    evictedToolUseIds.add(id);
+                }
+            }
+        }
+        const orphanedNewResults = newToolResultIds.filter(id => evictedToolUseIds.has(id));
+        if (orphanedNewResults.length > 0) {
+            debugLog('ASYNC_RACE_ABORT', `Aborting - orphaned tool_results detected`, { orphanedNewResults });
+            return { success: false, evicted: 0, truncated: 0, newPercent: currentPercent, error: 'Race condition - orphaned tool_results' };
+        }
+        // Safe to append new lines
+        const finalContent = keptContent + newLines.join('\n') + (newLines.length > 0 ? '\n' : '');
+        fs.writeFileSync(filePath, finalContent);
+    }
+    else {
+        fs.writeFileSync(filePath, keptContent);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // PHASE 3: CONFIRM EVICTION (if handshake was used)
+    // ═══════════════════════════════════════════════════════════════════════════
+    if (handshakeSucceeded && evictionId && clientNonce) {
+        // Confirm in background (non-blocking) - data is already safe
+        confirmLocalEviction(evictionId, clientNonce, evictedLines.length).catch(err => {
+            debugLog('ASYNC_CONFIRM_WARN', `Confirm failed (non-critical): ${err}`);
+        });
+        // R2 is back! Drain the retry queue in background (auto-sync queued evictions)
+        const authToken = process.env.EKKOS_AUTH_TOKEN || process.env.SUPABASE_AUTH_TOKEN;
+        if (authToken) {
+            (0, eviction_client_js_1.drainRetryQueue)(EKKOS_API_URL, authToken).then(result => {
+                if (result.drained > 0) {
+                    debugLog('RETRY_QUEUE_DRAIN', `Auto-synced ${result.drained} queued evictions to R2`, result);
+                }
+            }).catch(err => {
+                debugLog('RETRY_QUEUE_ERROR', `Drain failed (non-critical): ${err}`);
+            });
+        }
+    }
+    const newPercent = Math.round((currentBytes / totalBytes) * currentPercent);
+    debugLog('ASYNC_EVICTION_COMPLETE', 'Two-phase commit complete', {
+        evicted: toRemove.size,
+        truncated: truncatedCount,
+        newPercent,
+        handshakeUsed: handshakeSucceeded,
+        evictionId,
+    });
+    return {
+        success: true,
+        evicted: toRemove.size,
+        truncated: truncatedCount,
+        newPercent,
+        handshakeUsed: handshakeSucceeded,
+        evictionId,
+    };
+}
+/**
+ * Continuous clean - run every turn, remove junk regardless of threshold
+ * Removes: thinking blocks, streaming chunks, old file-history-snapshots
+ */
+function continuousClean(filePath) {
+    if (!fs.existsSync(filePath))
+        return { cleaned: 0 };
+    const content = fs.readFileSync(filePath, 'utf-8');
+    // CRITICAL: Handle line endings carefully to avoid corruption
+    // - Files ending with \n: last element after split is empty, drop it
+    // - Files NOT ending with \n: last line might be incomplete OR might be valid
+    //   → Keep all and let JSON validation filter incomplete lines
+    const endsWithNewline = content.endsWith('\n');
+    const allLines = content.split('\n');
+    const candidateLines = endsWithNewline
+        ? allLines.slice(0, -1) // Drop empty trailing element
+        : allLines; // Keep all, validate below
+    const lines = candidateLines
+        .filter(l => l.trim())
+        .filter(l => {
+        try {
+            JSON.parse(l);
+            return true;
+        }
+        catch {
+            return false; // Skip invalid JSON silently in continuous clean
+        }
+    });
+    const totalLines = lines.length;
+    const protectedStart = Math.max(0, totalLines - PROTECT_RECENT_LINES);
+    // Remove junk (priority 0-1) from non-protected lines
+    const kept = [];
+    let cleaned = 0;
+    lines.forEach((line, index) => {
+        const isProtected = index >= protectedStart;
+        const priority = getPriority(line);
+        // Always remove streaming chunks (priority 0-1) unless protected
+        // Note: Thinking blocks are now priority 6 (kept)
+        if (!isProtected && priority <= 1) {
+            cleaned++;
+            return; // skip this line
+        }
+        kept.push(line);
+    });
+    if (cleaned === 0)
+        return { cleaned: 0 };
+    // RACE CONDITION FIX: Preserve any new lines added during cleaning
+    const tempPath = `${filePath}.tmp`;
+    // Handle empty kept array gracefully - don't produce leading newline
+    const keptContent = kept.length > 0 ? kept.join('\n') + '\n' : '';
+    const originalLength = content.length; // Use char length, NOT byte size!
+    try {
+        const currentContent = fs.readFileSync(filePath, 'utf-8');
+        const currentLength = currentContent.length;
+        if (currentLength > originalLength) {
+            // File grew - append validated new lines only
+            const newContent = currentContent.slice(originalLength);
+            const validNewLines = newContent.split('\n')
+                .filter(l => l.trim())
+                .filter(l => {
+                try {
+                    JSON.parse(l);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const validatedNewContent = validNewLines.length > 0 ? validNewLines.join('\n') + '\n' : '';
+            fs.writeFileSync(tempPath, keptContent + validatedNewContent);
+        }
+        else {
+            fs.writeFileSync(tempPath, keptContent);
+        }
+    }
+    catch {
+        fs.writeFileSync(tempPath, keptContent);
+    }
+    fs.renameSync(tempPath, filePath);
+    return { cleaned };
+}
+function emergencyEvict(filePath) {
+    const result = evictToTarget(filePath, 100);
+    return { success: result.success, evicted: result.evicted };
+}
+/**
+ * Get eviction stats
+ */
+function getEvictionStats() {
+    try {
+        if (!fs.existsSync(STATS_LOG))
+            return { entries: 0 };
+        const log = JSON.parse(fs.readFileSync(STATS_LOG, 'utf-8'));
+        return {
+            entries: log.length,
+            lastEviction: log[log.length - 1]?.timestamp,
+        };
+    }
+    catch {
+        return { entries: 0 };
+    }
+}
+/**
+ * Get evicted content for retrieval (used by ccDNA)
+ */
+function getEvictedContent(limit = 10) {
+    try {
+        if (!fs.existsSync(EVICTED_STORE))
+            return [];
+        const content = fs.readFileSync(EVICTED_STORE, 'utf-8');
+        const entries = content.split('\n').filter(l => l.trim());
+        return entries.slice(-limit).map(e => {
+            try {
+                return JSON.parse(e);
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}