@ekkos/cli 0.2.0

package/dist/commands/run.js

@@ -0,0 +1,829 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const state_1 = require("../utils/state");
+// Try to load node-pty (may fail on Node 24+)
+let pty = null;
+try {
+    pty = require('node-pty');
+}
+catch {
+    // node-pty not available, will use spawn fallback
+}
+function getConfig(options) {
+    return {
+        slashOpenDelayMs: options.slashOpenDelayMs ??
+            parseInt(process.env.EKKOS_SLASH_OPEN_DELAY_MS || '1000', 10),
+        charDelayMs: options.charDelayMs ??
+            parseInt(process.env.EKKOS_CHAR_DELAY_MS || '25', 10),
+        postEnterDelayMs: options.postEnterDelayMs ??
+            parseInt(process.env.EKKOS_POST_ENTER_DELAY_MS || '500', 10),
+        clearWaitMs: options.clearWaitMs ??
+            parseInt(process.env.EKKOS_CLEAR_WAIT_MS || '5000', 10),
+        idlePromptMs: parseInt(process.env.EKKOS_IDLE_PROMPT_MS || '250', 10),
+        paletteRetryMs: parseInt(process.env.EKKOS_PALETTE_RETRY_MS || '500', 10),
+        debugLogPath: options.debugLogPath ??
+            process.env.EKKOS_DEBUG_LOG_PATH ??
+            path.join(os.homedir(), '.ekkos', 'auto-continue.debug.log')
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// PATTERN MATCHING
+// ═══════════════════════════════════════════════════════════════════════════
+// ANSI escape sequence regex (covers all common codes)
+const ANSI_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+/**
+ * Strip ANSI escape codes from string
+ */
+function stripAnsi(str) {
+    return str.replace(ANSI_REGEX, '');
+}
+/**
+ * Normalize string for pattern matching (strip ANSI, collapse whitespace, lowercase)
+ */
+function normalizeForMatch(str) {
+    return stripAnsi(str)
+        .replace(/\r/g, '')
+        .replace(/\s+/g, ' ')
+        .toLowerCase();
+}
+// Context limit detection patterns
+const CONTEXT_WALL_REGEX = /context limit reached.*\/(compact|clear)\b.*to continue/i;
+// Idle prompt detection - Claude shows "> " when ready for input
+const IDLE_PROMPT_REGEX = />\s*$/;
+// Interrupted state detection - Claude shows this when Ctrl+C during generation
+const INTERRUPTED_REGEX = /interrupted.*what should claude do instead/i;
+// Command palette indicator - when / is typed, Claude shows a menu
+const PALETTE_INDICATOR_REGEX = /\/(clear|continue|compact|help|bug|config)/i;
+// ═══════════════════════════════════════════════════════════════════════════
+// LOGGING (FILE ONLY DURING TUI - NO TERMINAL CORRUPTION)
+// ═══════════════════════════════════════════════════════════════════════════
+let _debugLogPath = path.join(os.homedir(), '.ekkos', 'auto-continue.debug.log');
+/**
+ * Set the debug log path (called once during init)
+ */
+function setDebugLogPath(p) {
+    _debugLogPath = p;
+}
+/**
+ * Log to file only (not terminal) during TUI operation
+ * This is the ONLY logging function used after Claude spawns
+ */
+function dlog(...args) {
+    try {
+        fs.appendFileSync(_debugLogPath, `[${new Date().toISOString()}] ${args.map(String).join(' ')}\n`);
+    }
+    catch {
+        // Ignore log errors - never corrupt TUI
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// SLASH COMMAND INJECTION (THE SINGLE BLESSED PATH)
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Type text character by character (human-like typing)
+ */
+async function typeSlowly(shell, text, charDelayMs) {
+    for (const char of text) {
+        shell.write(char);
+        await sleep(charDelayMs);
+    }
+}
+/**
+ * Wait for idle prompt - returns true if prompt is idle, false if interrupted state detected
+ *
+ * The readiness gate: waits until the output buffer shows an idle "> " prompt
+ * that hasn't changed for idlePromptMs. This prevents injecting while Claude
+ * is busy generating ("Channelling...").
+ */
+async function waitForIdlePrompt(getOutputBuffer, config, maxWaitMs = 10000) {
+    const startTime = Date.now();
+    let lastOutput = '';
+    let stableTime = 0;
+    while (Date.now() - startTime < maxWaitMs) {
+        const currentOutput = getOutputBuffer();
+        const normalized = normalizeForMatch(currentOutput);
+        // Check for interrupted state - abort injection
+        if (INTERRUPTED_REGEX.test(normalized)) {
+            dlog('Detected interrupted state - aborting injection');
+            return { ready: false, interrupted: true };
+        }
+        // Check if output has been stable
+        if (currentOutput === lastOutput) {
+            stableTime += 50;
+            if (stableTime >= config.idlePromptMs) {
+                // Check if we have an idle prompt
+                if (IDLE_PROMPT_REGEX.test(stripAnsi(currentOutput))) {
+                    dlog('Idle prompt detected - ready to inject');
+                    return { ready: true, interrupted: false };
+                }
+            }
+        }
+        else {
+            stableTime = 0;
+            lastOutput = currentOutput;
+        }
+        await sleep(50);
+    }
+    dlog('Idle prompt wait timed out - proceeding anyway');
+    return { ready: true, interrupted: false };
+}
+/**
+ * Run a slash command by typing it like a human
+ *
+ * This is the SINGLE BLESSED PATH for command injection.
+ * Flow: Ctrl+U → / → wait for palette → type command → Enter
+ *
+ * Includes safeguards:
+ * - Readiness gate (waits for idle prompt)
+ * - Palette retry (if palette doesn't appear)
+ * - Interrupted state detection (aborts if user Ctrl+C'd)
+ */
+async function runSlashCommand(shell, command, config, getOutputBuffer, arg) {
+    dlog(`runSlashCommand: /${command}${arg ? ' ' + arg : ''}`);
+    // STEP 1: Clear current input line
+    shell.write('\x15'); // Ctrl+U
+    await sleep(60);
+    dlog('Input line cleared (Ctrl+U)');
+    // STEP 2: Type / to open command palette
+    await typeSlowly(shell, '/', config.charDelayMs);
+    dlog('Typed / to open palette');
+    // STEP 3: Wait for palette to open
+    await sleep(config.slashOpenDelayMs);
+    // STEP 4: Check if palette opened (look for command indicators in buffer)
+    const bufferAfterSlash = getOutputBuffer();
+    if (!PALETTE_INDICATOR_REGEX.test(stripAnsi(bufferAfterSlash))) {
+        // Palette might not have opened - retry once
+        dlog('Palette indicator not detected, retrying with extra wait');
+        await sleep(config.paletteRetryMs);
+        // Type / again in case first one was eaten
+        shell.write('\x15'); // Clear line again
+        await sleep(60);
+        await typeSlowly(shell, '/', config.charDelayMs);
+        await sleep(config.slashOpenDelayMs);
+    }
+    // STEP 5: Type the command
+    await typeSlowly(shell, command, config.charDelayMs);
+    dlog(`Typed command: ${command}`);
+    // STEP 6: Type argument if provided
+    if (arg) {
+        await typeSlowly(shell, ' ' + arg, config.charDelayMs);
+        dlog(`Typed argument: ${arg}`);
+    }
+    // STEP 7: Wait briefly then send Enter
+    await sleep(60);
+    shell.write('\r'); // Enter (carriage return works better than \n in PTY)
+    dlog('Sent Enter');
+    // STEP 8: Wait for command to start executing
+    await sleep(config.postEnterDelayMs);
+    return { success: true };
+}
+// Memory API URL
+const MEMORY_API_URL = 'https://mcp.ekkos.dev';
+const isWindows = os.platform() === 'win32';
+// Pinned Claude Code version for ekkos run
+// 2.1.6 has the old context calculation (95% of full 200K, not effective window)
+const PINNED_CLAUDE_VERSION = '2.1.6';
+/**
+ * Resolve full path to claude executable
+ * Returns 'npx:VERSION' to signal we should use npx with pinned version
+ */
+function resolveClaudePath() {
+    // PRIORITY 1: Use pinned version via npx
+    // This ensures ekkos run always uses the version with better context behavior
+    // Return special marker that spawn logic will handle
+    return `npx:${PINNED_CLAUDE_VERSION}`;
+}
+/**
+ * Original resolve function for fallback to global install
+ */
+function resolveGlobalClaudePath() {
+    // Windows global paths
+    if (isWindows) {
+        const windowsPaths = [
+            path.join(process.env.APPDATA || '', 'npm', 'claude.cmd'),
+            path.join(process.env.LOCALAPPDATA || '', 'npm', 'claude.cmd'),
+            path.join(os.homedir(), 'AppData', 'Roaming', 'npm', 'claude.cmd'),
+            path.join(os.homedir(), '.npm-global', 'claude.cmd')
+        ];
+        for (const p of windowsPaths) {
+            if (fs.existsSync(p)) {
+                return p;
+            }
+        }
+        try {
+            const result = (0, child_process_1.execSync)('where claude', { encoding: 'utf-8' }).trim().split('\n')[0];
+            if (result && fs.existsSync(result)) {
+                return result;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return 'claude';
+    }
+    // PRIORITY 2: Unix global paths
+    const commonPaths = [
+        '/opt/homebrew/bin/claude',
+        '/usr/local/bin/claude',
+        path.join(os.homedir(), '.local/bin/claude'),
+        path.join(os.homedir(), '.npm-global/bin/claude')
+    ];
+    for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    try {
+        const result = (0, child_process_1.execSync)('which claude', { encoding: 'utf-8' }).trim();
+        if (result && fs.existsSync(result)) {
+            return result;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return 'claude';
+}
+/**
+ * Sleep helper
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Emergency capture before clear - saves current state to ekkOS
+ */
+async function emergencyCapture(transcriptPath, sessionId) {
+    const authToken = (0, state_1.getAuthToken)();
+    if (!authToken || !transcriptPath || !fs.existsSync(transcriptPath)) {
+        return;
+    }
+    try {
+        const transcript = fs.readFileSync(transcriptPath, 'utf-8');
+        const data = JSON.parse(transcript);
+        // Extract last user and assistant messages
+        let lastUser = '';
+        let lastAssistant = '';
+        if (Array.isArray(data)) {
+            for (let i = data.length - 1; i >= 0; i--) {
+                const msg = data[i];
+                if (msg.type === 'human' && !lastUser) {
+                    lastUser = typeof msg.message?.content === 'string'
+                        ? msg.message.content
+                        : JSON.stringify(msg.message?.content || '');
+                }
+                if (msg.type === 'assistant' && !lastAssistant) {
+                    lastAssistant = typeof msg.message?.content === 'string'
+                        ? msg.message.content
+                        : JSON.stringify(msg.message?.content || '');
+                }
+                if (lastUser && lastAssistant)
+                    break;
+            }
+        }
+        // Send to ekkOS capture endpoint
+        const response = await fetch(`${MEMORY_API_URL}/api/v1/memory/capture`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                user_query: lastUser,
+                assistant_response: lastAssistant,
+                session_id: sessionId,
+                metadata: {
+                    emergency_capture: true,
+                    reason: 'context_wall_hit',
+                    timestamp: new Date().toISOString()
+                }
+            })
+        });
+        if (response.ok) {
+            dlog('Context captured to ekkOS');
+        }
+    }
+    catch (err) {
+        // Silent fail - don't block the clear process
+        dlog('Warning: Could not capture context');
+    }
+}
+async function run(options) {
+    const verbose = options.verbose || false;
+    const bypass = options.bypass || false;
+    // Get injection config (from options or env vars)
+    const config = getConfig(options);
+    setDebugLogPath(config.debugLogPath);
+    // ══════════════════════════════════════════════════════════════════════════
+    // STARTUP BANNER WITH COLOR PULSE ANIMATION
+    // ══════════════════════════════════════════════════════════════════════════
+    const logoLines = [
+        '                      ▄▄▄▄▄    ▄▄▄▄▄▄▄     ▄▄▄ ▄▄ ▄▄',
+        '      ▄▄     ▄▄     ▄███████▄ █████▀▀▀      █  █ ▀ █',
+        '▄█▀█▄ ██ ▄█▀ ██ ▄█▀ ███   ███  ▀████▄',
+        '██▄█▀ ████   ████   ███▄▄▄███    ▀████',
+        '▀█▄▄▄ ██ ▀█▄ ██ ▀█▄  ▀█████▀  ███████▀',
+        '                                      ▄▄▄▄▄▄▄▄'
+    ];
+    // Color pulse sequence (magenta → cyan → blue → magenta cycle)
+    const pulseColors = [
+        chalk_1.default.magenta,
+        chalk_1.default.hex('#FF69B4'), // Hot pink
+        chalk_1.default.cyan,
+        chalk_1.default.hex('#00CED1'), // Dark cyan
+        chalk_1.default.blue,
+        chalk_1.default.hex('#8A2BE2'), // Blue violet
+        chalk_1.default.magenta
+    ];
+    // Print initial logo
+    console.log('');
+    logoLines.forEach(line => console.log(chalk_1.default.magenta(line)));
+    // Animate: pulse through colors
+    const PULSE_CYCLES = 2;
+    const FRAME_DELAY_MS = 80;
+    for (let cycle = 0; cycle < PULSE_CYCLES; cycle++) {
+        for (const colorFn of pulseColors) {
+            // Move cursor up to overwrite logo (6 lines)
+            process.stdout.write('\x1B[6A');
+            // Reprint with new color
+            logoLines.forEach(line => console.log(colorFn(line)));
+            await sleep(FRAME_DELAY_MS);
+        }
+    }
+    // Final frame: settle on magenta
+    process.stdout.write('\x1B[6A');
+    logoLines.forEach(line => console.log(chalk_1.default.magenta(line)));
+    // ══════════════════════════════════════════════════════════════════════════
+    // SPARKLE EFFECT - Random characters flash white/cyan
+    // ══════════════════════════════════════════════════════════════════════════
+    const sparkleChars = ['▄', '█', '▀'];
+    const sparkleColors = [chalk_1.default.white, chalk_1.default.whiteBright, chalk_1.default.cyanBright, chalk_1.default.yellowBright];
+    const SPARKLE_FRAMES = 40; // ~3.2 seconds of sparkles
+    const SPARKLE_DELAY_MS = 80;
+    const SPARKLES_PER_FRAME = 3;
+    for (let frame = 0; frame < SPARKLE_FRAMES; frame++) {
+        // Create a copy of logo lines for this frame
+        const frameLines = logoLines.map(line => [...line]);
+        // Add random sparkles
+        for (let s = 0; s < SPARKLES_PER_FRAME; s++) {
+            const lineIdx = Math.floor(Math.random() * frameLines.length);
+            const line = frameLines[lineIdx];
+            // Find positions with sparkle-able characters
+            const sparklePositions = [];
+            for (let i = 0; i < line.length; i++) {
+                if (sparkleChars.includes(line[i])) {
+                    sparklePositions.push(i);
+                }
+            }
+            if (sparklePositions.length > 0) {
+                const pos = sparklePositions[Math.floor(Math.random() * sparklePositions.length)];
+                // Mark this position for sparkle (we'll handle coloring below)
+                frameLines[lineIdx][pos] = { char: line[pos], sparkle: true };
+            }
+        }
+        // Move cursor up and render frame
+        process.stdout.write('\x1B[6A');
+        for (const line of frameLines) {
+            let output = '';
+            for (const char of line) {
+                if (char && typeof char === 'object' && char.sparkle) {
+                    const sparkleColor = sparkleColors[Math.floor(Math.random() * sparkleColors.length)];
+                    output += sparkleColor(char.char);
+                }
+                else {
+                    output += chalk_1.default.magenta(char);
+                }
+            }
+            console.log(output);
+        }
+        await sleep(SPARKLE_DELAY_MS);
+    }
+    // Final settle: clean magenta
+    process.stdout.write('\x1B[6A');
+    logoLines.forEach(line => console.log(chalk_1.default.magenta(line)));
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('  Auto-Continue Wrapper'));
+    console.log(chalk_1.default.gray('  Monitors for context limit and auto-restores sessions'));
+    console.log(chalk_1.default.gray('  Uses full 200K context window - triggers on actual limit'));
+    if (bypass) {
+        console.log(chalk_1.default.yellow('  ⚡ Bypass permissions mode enabled'));
+    }
+    if (verbose) {
+        console.log(chalk_1.default.gray(`  📁 Debug log: ${config.debugLogPath}`));
+        console.log(chalk_1.default.gray(`  ⏱  Timing: slash=${config.slashOpenDelayMs}ms, char=${config.charDelayMs}ms, clear=${config.clearWaitMs}ms`));
+    }
+    console.log('');
+    // Ensure .ekkos directory exists
+    (0, state_1.ensureEkkosDir)();
+    // Clear any stale flags
+    (0, state_1.clearAutoClearFlag)();
+    // Track state
+    let currentSession = options.session || (0, state_1.getCurrentSessionName)();
+    let isAutoClearInProgress = false;
+    let transcriptPath = null;
+    let currentSessionId = null;
+    // Output buffer for pattern detection
+    let outputBuffer = '';
+    // Debounce tracking to prevent double triggers
+    let lastDetectionTime = 0;
+    const DETECTION_COOLDOWN = 30000; // 30 seconds cooldown
+    // Resolve claude path
+    const rawClaudePath = resolveClaudePath();
+    // Handle npx:VERSION format for pinned version
+    const isNpxMode = rawClaudePath.startsWith('npx:');
+    const pinnedVersion = isNpxMode ? rawClaudePath.split(':')[1] : null;
+    const claudePath = isNpxMode ? 'npx' : rawClaudePath;
+    if (verbose) {
+        if (isNpxMode) {
+            console.log(chalk_1.default.gray(`  🤖 Using claude-code@${pinnedVersion} via npx (pinned for better context)`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`  🤖 Using claude at: ${claudePath}`));
+        }
+        if (currentSession) {
+            console.log(chalk_1.default.green(`  📍 Session: ${currentSession}`));
+        }
+    }
+    // Build args - prepend package name if using npx
+    const args = [];
+    if (isNpxMode) {
+        args.push(`@anthropic-ai/claude-code@${pinnedVersion}`);
+    }
+    if (bypass) {
+        args.push('--dangerously-skip-permissions');
+    }
+    // Determine which mode to use
+    const usePty = pty !== null;
+    if (verbose) {
+        console.log(chalk_1.default.gray(`  💻 PTY mode: ${usePty ? 'node-pty' : 'spawn+script (fallback)'}`));
+        console.log('');
+    }
+    let shell;
+    if (usePty && pty) {
+        // Use node-pty for proper PTY control
+        try {
+            const ptyShell = pty.spawn(claudePath, args, {
+                name: 'xterm-256color',
+                cols: process.stdout.columns || 80,
+                rows: process.stdout.rows || 24,
+                cwd: process.cwd(),
+                env: process.env
+            });
+            shell = {
+                write: (data) => ptyShell.write(data),
+                kill: () => ptyShell.kill(),
+                resize: (cols, rows) => ptyShell.resize(cols, rows),
+                onData: (callback) => ptyShell.onData(callback),
+                onExit: (callback) => ptyShell.onExit(callback)
+            };
+            // Handle terminal resize
+            process.stdout.on('resize', () => {
+                shell.resize?.(process.stdout.columns || 80, process.stdout.rows || 24);
+            });
+        }
+        catch (err) {
+            console.log(chalk_1.default.yellow(`node-pty failed, falling back to spawn+script mode`));
+            if (verbose) {
+                console.log(chalk_1.default.gray(`Error: ${err.message}`));
+            }
+            // Fall through to spawn mode
+            return runWithSpawn(claudePath, args, options, {
+                currentSession,
+                isAutoClearInProgress,
+                transcriptPath,
+                currentSessionId,
+                outputBuffer
+            });
+        }
+    }
+    else {
+        // Fallback: use spawn+script for PTY emulation
+        return runWithSpawn(claudePath, args, options, {
+            currentSession,
+            isAutoClearInProgress,
+            transcriptPath,
+            currentSessionId,
+            outputBuffer
+        });
+    }
+    // Forward user input to PTY (named function so we can pause/resume)
+    const onStdinData = (data) => {
+        shell.write(data.toString());
+    };
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.on('data', onStdinData);
+    // Helper to get current output buffer (for readiness checks)
+    const getOutputBuffer = () => outputBuffer;
+    // Handle context wall detection
+    async function handleContextWall() {
+        // Debounce check - prevent double triggers (BEFORE pausing stdin)
+        const now = Date.now();
+        if (now - lastDetectionTime < DETECTION_COOLDOWN) {
+            dlog('Skipping - within debounce cooldown');
+            return;
+        }
+        if (isAutoClearInProgress) {
+            dlog('Already in progress, skipping');
+            return;
+        }
+        // CRITICAL: Capture session name IMMEDIATELY before any async operations
+        // This prevents shell.onData from overwriting it with the NEW session after /clear
+        let sessionToRestore = currentSession;
+        if (!sessionToRestore) {
+            const state = (0, state_1.getState)();
+            sessionToRestore = state?.sessionName || null;
+            const sessionId = state?.sessionId || null;
+            // If still no session name but we have an ID, generate it
+            if (!sessionToRestore && sessionId) {
+                sessionToRestore = (0, state_1.uuidToWords)(sessionId);
+            }
+        }
+        const sessionDisplay = sessionToRestore || 'unknown-session';
+        dlog(`Session to restore (captured before clear): ${sessionDisplay}`);
+        // CRITICAL: Clear buffer and set flags immediately
+        outputBuffer = '';
+        lastDetectionTime = now;
+        isAutoClearInProgress = true;
+        // PAUSE STDIN: Prevent user keystrokes from interleaving with injection
+        process.stdin.off('data', onStdinData);
+        dlog('Stdin paused during injection');
+        try {
+            // Log to FILE only (not terminal) during TUI operation
+            dlog('════════════════════════════════════════════════════════════');
+            dlog('CONTEXT LIMIT REACHED - AUTO-RESTORE');
+            dlog(`Session to restore: ${sessionDisplay}`);
+            dlog('════════════════════════════════════════════════════════════');
+            // Emergency capture (do this first before any UI manipulation)
+            dlog('Capturing current state...');
+            if (transcriptPath && currentSessionId) {
+                await emergencyCapture(transcriptPath, currentSessionId);
+            }
+            // READINESS GATE: Wait for idle prompt before injecting
+            dlog('Waiting for idle prompt...');
+            const readiness = await waitForIdlePrompt(getOutputBuffer, config);
+            if (readiness.interrupted) {
+                dlog('Interrupted state detected - aborting auto-restore');
+                dlog('User will need to manually /clear and /continue');
+                isAutoClearInProgress = false;
+                return;
+            }
+            // STEP 1: Run /clear command (with trailing space for clean completion)
+            dlog('Running /clear command...');
+            const clearResult = await runSlashCommand(shell, 'clear ', config, getOutputBuffer);
+            if (!clearResult.success) {
+                dlog(`/clear failed: ${clearResult.reason}`);
+            }
+            // STEP 2: Wait for /clear to complete
+            dlog(`Waiting ${config.clearWaitMs}ms for /clear to complete...`);
+            await sleep(config.clearWaitMs);
+            dlog('Wait complete.');
+            // READINESS GATE: Wait for idle prompt again before /continue
+            dlog('Waiting for idle prompt after /clear...');
+            const readiness2 = await waitForIdlePrompt(getOutputBuffer, config);
+            if (readiness2.interrupted) {
+                dlog('Interrupted state after /clear - aborting');
+                isAutoClearInProgress = false;
+                return;
+            }
+            // STEP 3: Run /continue with the ORIGINAL session name (captured before /clear)
+            dlog(`Running /continue ${sessionDisplay}...`);
+            const continueResult = await runSlashCommand(shell, 'continue', config, getOutputBuffer, sessionDisplay);
+            if (!continueResult.success) {
+                dlog(`/continue failed: ${continueResult.reason}`);
+            }
+            dlog('════════════════════════════════════════════════════════════');
+            dlog('AUTO-RESTORE COMPLETE');
+            dlog('════════════════════════════════════════════════════════════');
+            // Cooldown before allowing another trigger
+            setTimeout(() => {
+                isAutoClearInProgress = false;
+            }, DETECTION_COOLDOWN);
+        }
+        catch (error) {
+            dlog(`Error in handleContextWall: ${error.message}`);
+            dlog(`Stack: ${error.stack}`);
+            isAutoClearInProgress = false;
+        }
+        finally {
+            // RESUME STDIN: Always restore user input capability
+            process.stdin.on('data', onStdinData);
+            dlog('Stdin resumed');
+        }
+    }
+    // Monitor PTY output
+    shell.onData((data) => {
+        // Pass through to terminal
+        process.stdout.write(data);
+        // Accumulate for pattern matching
+        outputBuffer += data;
+        // Keep buffer manageable (last 5KB)
+        if (outputBuffer.length > 5000) {
+            outputBuffer = outputBuffer.slice(-2000);
+        }
+        // Try to extract transcript path from output (Claude shows it on startup)
+        const transcriptMatch = data.match(/transcript[_\s]?(?:path)?[:\s]+([^\s\n]+\.json)/i);
+        if (transcriptMatch) {
+            transcriptPath = transcriptMatch[1];
+            dlog(`Detected transcript: ${transcriptPath}`);
+        }
+        // Try to extract session ID from output
+        const sessionMatch = data.match(/session[_\s]?(?:id)?[:\s]+([a-f0-9-]{36})/i);
+        if (sessionMatch) {
+            currentSessionId = sessionMatch[1];
+            currentSession = (0, state_1.uuidToWords)(currentSessionId);
+            (0, state_1.updateState)({ sessionId: currentSessionId, sessionName: currentSession });
+            dlog(`Session detected: ${currentSession}`);
+        }
+        // Check for context wall patterns (ANSI-stripped + regex for robustness)
+        if (!isAutoClearInProgress) {
+            const normalized = normalizeForMatch(outputBuffer);
+            if (CONTEXT_WALL_REGEX.test(normalized)) {
+                dlog('Context wall detected via regex');
+                handleContextWall().catch(err => {
+                    dlog(`Error during auto-clear: ${err.message}`);
+                    isAutoClearInProgress = false;
+                });
+            }
+        }
+    });
+    // Handle PTY exit
+    shell.onExit(({ exitCode }) => {
+        (0, state_1.clearAutoClearFlag)();
+        // Restore terminal
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        // Log exit to file (not terminal - TUI already gone at this point)
+        dlog(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+    });
+    // Cleanup on exit signals
+    const cleanup = () => {
+        (0, state_1.clearAutoClearFlag)();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        shell.kill();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}
+/**
+ * Fallback implementation using spawn+script for PTY emulation
+ * Used when node-pty is not available (e.g., Node 24+)
+ */
+async function runWithSpawn(claudePath, args, options, state) {
+    const verbose = options.verbose || false;
+    let { currentSession, isAutoClearInProgress, transcriptPath, currentSessionId, outputBuffer } = state;
+    // Debounce tracking
+    let lastDetectionTime = 0;
+    const DETECTION_COOLDOWN = 30000;
+    console.log(chalk_1.default.gray('Using spawn fallback mode'));
+    console.log(chalk_1.default.yellow('Note: Auto-inject requires manual /clear + /continue'));
+    console.log('');
+    let claude;
+    if (isWindows) {
+        // On Windows, spawn Claude directly (no script equivalent)
+        // PTY features may be limited
+        console.log(chalk_1.default.gray('Windows mode: running Claude directly'));
+        claude = (0, child_process_1.spawn)(claudePath, args, {
+            stdio: ['inherit', 'pipe', 'inherit'],
+            cwd: process.cwd(),
+            env: process.env,
+            shell: true
+        });
+    }
+    else {
+        // Use script command for PTY on Unix
+        const scriptCmd = process.platform === 'darwin'
+            ? ['script', '-q', '/dev/null', claudePath, ...args]
+            : ['script', '-q', '-c', `${claudePath} ${args.join(' ')}`, '/dev/null'];
+        claude = (0, child_process_1.spawn)(scriptCmd[0], scriptCmd.slice(1), {
+            stdio: ['inherit', 'pipe', 'inherit'],
+            cwd: process.cwd(),
+            env: process.env
+        });
+    }
+    // Ensure claude was spawned
+    if (!claude) {
+        console.error(chalk_1.default.red('Failed to spawn Claude'));
+        process.exit(1);
+    }
+    // For Windows direct spawn without piped stdout
+    if (isWindows && !claude.stdout) {
+        console.log(chalk_1.default.yellow('Running in basic mode - context detection disabled'));
+        claude.on('exit', (code) => {
+            (0, state_1.clearAutoClearFlag)();
+            process.exit(code || 0);
+        });
+        return;
+    }
+    // Monitor output
+    if (claude.stdout) {
+        claude.stdout.on('data', async (data) => {
+            const chunk = data.toString();
+            process.stdout.write(chunk);
+            outputBuffer += chunk;
+            if (outputBuffer.length > 5000) {
+                outputBuffer = outputBuffer.slice(-2000);
+            }
+            // Extract session info
+            const sessionMatch = chunk.match(/session[_\s]?(?:id)?[:\s]+([a-f0-9-]{36})/i);
+            if (sessionMatch) {
+                currentSessionId = sessionMatch[1];
+                currentSession = (0, state_1.uuidToWords)(currentSessionId);
+                (0, state_1.updateState)({ sessionId: currentSessionId, sessionName: currentSession });
+            }
+            // Detect context wall - show manual instructions (ANSI-stripped + regex)
+            const now = Date.now();
+            if (!isAutoClearInProgress && (now - lastDetectionTime >= DETECTION_COOLDOWN)) {
+                const normalized = normalizeForMatch(outputBuffer);
+                if (CONTEXT_WALL_REGEX.test(normalized)) {
+                    // CRITICAL: Clear buffer immediately
+                    outputBuffer = '';
+                    lastDetectionTime = now;
+                    isAutoClearInProgress = true;
+                    if (!currentSession) {
+                        const savedState = (0, state_1.getState)();
+                        currentSession = savedState?.sessionName || 'unknown-session';
+                    }
+                    // Log to file only - don't corrupt TUI
+                    dlog('════════════════════════════════════════════════════════════');
+                    dlog('CONTEXT LIMIT REACHED (spawn fallback mode)');
+                    dlog(`Session: ${currentSession}`);
+                    dlog('Manual restore required: /clear then /continue ' + currentSession);
+                    dlog('════════════════════════════════════════════════════════════');
+                    setTimeout(() => {
+                        isAutoClearInProgress = false;
+                        // Buffer already cleared at detection time
+                    }, DETECTION_COOLDOWN);
+                }
+            }
+        });
+    }
+    claude.on('exit', (code) => {
+        (0, state_1.clearAutoClearFlag)();
+        dlog(`Claude exited with code ${code}`);
+        process.exit(code || 0);
+    });
+    claude.on('error', (err) => {
+        dlog(`Error: ${err.message}`);
+        process.exit(1);
+    });
+    // Cleanup
+    const cleanup = () => {
+        (0, state_1.clearAutoClearFlag)();
+        claude.kill();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}