@ekkos/cli 0.3.3 → 1.0.1

package/dist/commands/run.js

@@ -76,50 +76,63 @@ function findCcdnaPath() {
  * @param claudePath - Path to Claude Code to patch (if different from default)
  */
 function applyCcdnaPatches(verbose, claudePath) {
+    // DISABLED: ccDNA patching is currently corrupting cli.js (JSON parse error at position 7945)
+    // See: https://github.com/anthropics/ekkos/issues/2856
+    // The patching process is injecting code that breaks the minified cli.js
+    // Temporarily disabled until ccDNA is fixed upstream
+    if (verbose) {
+        console.log(chalk_1.default.gray('  ccDNA patching disabled (see issue #2856)'));
+    }
+    return null;
+    // Original implementation (disabled):
+    /*
     const ccdnaPath = findCcdnaPath();
     if (!ccdnaPath) {
-        if (verbose) {
-            console.log(chalk_1.default.gray('  ccDNA not found - skipping patches'));
-        }
-        return null;
+      if (verbose) {
+        console.log(chalk.gray('  ccDNA not found - skipping patches'));
+      }
+      return null;
     }
+  
     // Read ccDNA version from package.json FIRST
     let ccdnaVersion = 'unknown';
     try {
-        const pkgPath = path.join(path.dirname(ccdnaPath), '..', 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            ccdnaVersion = pkg.version || 'unknown';
-        }
-    }
-    catch {
-        // Ignore version detection errors
-    }
+      const pkgPath = path.join(path.dirname(ccdnaPath), '..', 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        ccdnaVersion = pkg.version || 'unknown';
+      }
+    } catch {
+      // Ignore version detection errors
+    }
+  
     try {
-        // Set env var to tell ccDNA which Claude to patch
-        // eslint-disable-next-line no-restricted-syntax
-        const env = { ...process.env };
-        if (claudePath) {
-            // ccDNA checks CCDNA_CC_INSTALLATION_PATH to override default detection
-            env.CCDNA_CC_INSTALLATION_PATH = claudePath;
-        }
-        // Run ccDNA in apply mode (non-interactive)
-        (0, child_process_1.execSync)(`node "${ccdnaPath}" -a`, {
-            stdio: verbose ? 'inherit' : 'pipe',
-            timeout: 30000, // 30 second timeout
-            env,
-        });
-        if (verbose) {
-            console.log(chalk_1.default.green(`  ✓ ccDNA v${ccdnaVersion} patches applied`));
-        }
-        return ccdnaVersion;
-    }
-    catch (err) {
-        if (verbose) {
-            console.log(chalk_1.default.yellow(`  ⚠ ccDNA patch failed: ${err.message}`));
-        }
-        return null;
-    }
+      // Set env var to tell ccDNA which Claude to patch
+      // eslint-disable-next-line no-restricted-syntax
+      const env = { ...process.env };
+      if (claudePath) {
+        // ccDNA checks CCDNA_CC_INSTALLATION_PATH to override default detection
+        env.CCDNA_CC_INSTALLATION_PATH = claudePath;
+      }
+  
+      // Run ccDNA in apply mode (non-interactive)
+      execSync(`node "${ccdnaPath}" -a`, {
+        stdio: verbose ? 'inherit' : 'pipe',
+        timeout: 30000, // 30 second timeout
+        env,
+      });
+  
+      if (verbose) {
+        console.log(chalk.green(`  ✓ ccDNA v${ccdnaVersion} patches applied`));
+      }
+      return ccdnaVersion;
+    } catch (err) {
+      if (verbose) {
+        console.log(chalk.yellow(`  ⚠ ccDNA patch failed: ${(err as Error).message}`));
+      }
+      return null;
+    }
+    */
 }
 /**
  * Restore original Claude Code (remove ccDNA patches) on exit
@@ -164,20 +177,27 @@ function restoreCcdnaPatches(verbose, claudePath) {
     }
 }
 const state_1 = require("../utils/state");
+const session_binding_1 = require("../utils/session-binding");
 const doctor_1 = require("./doctor");
 const stream_tailer_1 = require("../capture/stream-tailer");
 const jsonl_rewriter_1 = require("../capture/jsonl-rewriter");
 const transcript_repair_1 = require("../capture/transcript-repair");
 // Try to load node-pty (may fail on Node 24+)
+// IMPORTANT: This must be awaited in run() to avoid racey false fallbacks.
 let pty = null;
-(async () => {
-    try {
-        pty = await Promise.resolve().then(() => __importStar(require('node-pty')));
-    }
-    catch {
-        // node-pty not available, will use spawn fallback
-    }
-})();
+let ptyLoadPromise = null;
+async function loadPty() {
+    if (pty)
+        return pty;
+    if (!ptyLoadPromise) {
+        ptyLoadPromise = Promise.resolve().then(() => __importStar(require('node-pty'))).then(mod => {
+            pty = mod;
+            return mod;
+        })
+            .catch(() => null);
+    }
+    return ptyLoadPromise;
+}
 function getConfig(options) {
     /* eslint-disable no-restricted-syntax -- Config timing values, not API keys */
     return {
@@ -230,9 +250,9 @@ const PALETTE_INDICATOR_REGEX = /\/(clear|continue|compact|help|bug|config)/i;
 // SESSION NAME DETECTION (3-word slug: word-word-word)
 // Claude prints session name in footer: · Turn N · groovy-koala-saves · 📅
 // ═══════════════════════════════════════════════════════════════════════════
-// Strong signal: session name between dot separators in Claude status/footer line
-// Matches: "· groovy-koala-saves ·" or "· velvet-monk-skips ·"
-const SESSION_NAME_IN_STATUS_REGEX = /·\s*([a-z]+-[a-z]+-[a-z]+)\s*·/i;
+// Strong signal: explicit turn footer emitted by Claude/ekkOS status line.
+// Requires "Turn <n> · <session> ·" to avoid matching arbitrary slug text.
+const SESSION_NAME_IN_STATUS_REGEX = /turn\s+\d+\s*·\s*([a-z]+-[a-z]+-[a-z]+)\s*·/i;
 // Weaker signal: any 3-word slug (word-word-word pattern)
 const SESSION_NAME_REGEX = /\b([a-z]+-[a-z]+-[a-z]+)\b/i;
 // Orphan tool_result marker emitted by ccDNA validate mode
@@ -413,7 +433,7 @@ const isWindows = os.platform() === 'win32';
 // 'latest' = use latest version, or specify like '2.1.33' for specific version
 // Core ekkOS patches (eviction, context management) work with all recent versions
 // Cosmetic patches may fail on newer versions but don't affect functionality
-const PINNED_CLAUDE_VERSION = '2.1.33';
+const PINNED_CLAUDE_VERSION = '2.1.45';
 // Max output tokens for Claude responses
 // Default: 16384 (safe for Sonnet 4.5)
 // Opus 4.5 supports up to 64k - set EKKOS_MAX_OUTPUT_TOKENS=32768 or =65536 to use higher limits
@@ -421,7 +441,7 @@ const PINNED_CLAUDE_VERSION = '2.1.33';
 const EKKOS_MAX_OUTPUT_TOKENS = process.env.EKKOS_MAX_OUTPUT_TOKENS || '16384';
 // Default proxy URL for context eviction
 // eslint-disable-next-line no-restricted-syntax -- Config URL, not API key
-const EKKOS_PROXY_URL = process.env.EKKOS_PROXY_URL || 'https://mcp.ekkos.dev';
+const EKKOS_PROXY_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.dev';
 // Track proxy mode for getEkkosEnv (set by run() based on options)
 let proxyModeEnabled = true;
 // ═══════════════════════════════════════════════════════════════════════════
@@ -450,7 +470,7 @@ function getEkkosEnv() {
     /* eslint-disable no-restricted-syntax -- System env spreading, not API key access */
     const env = {
         ...process.env,
-        CLAUDE_CODE_MAX_OUTPUT_TOKENS: EKKOS_MAX_OUTPUT_TOKENS,
+        // Let Claude Code use its own default max_tokens (don't override)
     };
     /* eslint-enable no-restricted-syntax */
     // Check if proxy is disabled via env var or options
@@ -464,10 +484,14 @@ function getEkkosEnv() {
         // This fixes the mismatch where CLI generated one name but Claude Code used another
         // The hook calls POST /proxy/session/bind with Claude's actual session name
         if (!cliSessionName) {
-            cliSessionName = '_pending'; // Placeholder - hook will bind real name
-            cliSessionId = `pending-${Date.now()}`;
-            console.log(chalk_1.default.gray(`  📂 Session: pending (will bind to Claude session)`));
-        }
+            const pendingSeed = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+            cliSessionName = `_pending-${pendingSeed}`; // Unique placeholder per CLI run
+            cliSessionId = `pending-${pendingSeed}`;
+            console.log(chalk_1.default.gray(`  📂 Session: ${cliSessionName} (will bind to Claude session)`));
+        }
+        env.EKKOS_PENDING_SESSION = cliSessionName;
+        if (cliSessionId)
+            env.EKKOS_PENDING_SESSION_ID = cliSessionId;
         // Get full userId from config (NOT the truncated version from auth token)
         // Config has full UUID like "d4532ba0-0a86-42ce-bab4-22aa62b55ce6"
         // This matches the turns/ R2 structure: turns/{fullUserId}/{sessionName}/
@@ -492,7 +516,7 @@ function getEkkosEnv() {
         const projectPathEncoded = Buffer.from(projectPath).toString('base64url');
         const proxyUrl = `${EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/${encodeURIComponent(cliSessionName)}?project=${projectPathEncoded}`;
         env.ANTHROPIC_BASE_URL = proxyUrl;
-        console.log(chalk_1.default.gray(`  📡 Proxy: ${proxyUrl.replace(userId, userId.slice(0, 8) + '...')}`));
+        // Proxy URL contains userId + project path — don't leak to terminal
     }
     else {
         env.EKKOS_PROXY_MODE = '0';
@@ -783,6 +807,85 @@ function cleanupInstanceFile(instanceId) {
         // Ignore cleanup errors
     }
 }
+/**
+ * Launch ekkos run + dashboard in isolated tmux panes (60/40 split)
+ */
+function launchWithDashboard(options) {
+    const tmuxSession = `ekkos-${Date.now().toString(36)}`;
+    const launchTime = Date.now();
+    // Build the ekkos run command WITHOUT --dashboard (prevent recursion)
+    const runArgs = ['run'];
+    if (options.session)
+        runArgs.push('-s', options.session);
+    if (options.bypass)
+        runArgs.push('-b');
+    if (options.verbose)
+        runArgs.push('-v');
+    if (options.doctor)
+        runArgs.push('-d');
+    if (options.research)
+        runArgs.push('-r');
+    if (options.noInject)
+        runArgs.push('--skip-inject');
+    if (options.noDna)
+        runArgs.push('--skip-dna');
+    if (options.noProxy)
+        runArgs.push('--skip-proxy');
+    runArgs.push('--kickstart'); // Auto-send "test" to create session immediately for dashboard
+    const ekkosCmd = process.argv[1]; // Path to ekkos CLI
+    const cwd = process.cwd();
+    const termCols = process.stdout.columns ?? 160;
+    const termRows = process.stdout.rows ?? 48;
+    // Write a marker file with launch timestamp + CWD so dashboard knows to wait for NEW session
+    const markerPath = path.join(state_1.EKKOS_DIR, '.dashboard-launch-ts');
+    try {
+        fs.writeFileSync(markerPath, `${launchTime}\n${cwd}`);
+    }
+    catch { }
+    const runCommand = `node "${ekkosCmd}" ${runArgs.join(' ')}`;
+    // Use --wait-for-new flag to wait for a session that started AFTER this launch
+    const dashCommand = `node "${ekkosCmd}" dashboard --wait-for-new --refresh 2000`;
+    try {
+        // Pane 0 (left): start with inert command (no interactive shell startup noise).
+        // Claude is launched AFTER split so Ink gets final pane geometry at startup.
+        (0, child_process_1.execSync)(`tmux new-session -d -s "${tmuxSession}" -x ${termCols} -y ${termRows} -n "claude" 'sleep 86400'`, { stdio: 'pipe' });
+        const applyTmuxOpt = (cmd) => {
+            try {
+                (0, child_process_1.execSync)(`tmux ${cmd}`, { stdio: 'pipe' });
+            }
+            catch (err) {
+                if (options.verbose) {
+                    console.log(chalk_1.default.gray(`  tmux option skipped: ${cmd} (${err.message})`));
+                }
+            }
+        };
+        // Session/window isolation and quality-of-life settings
+        applyTmuxOpt(`set-option -t "${tmuxSession}" mouse on`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}" history-limit 100000`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}" mode-keys vi`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}:claude" synchronize-panes off`);
+        // Keep pane geometry synced to the active client so vertical window resizing
+        // immediately gives dashboard/table more rows.
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}:claude" window-size latest`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}:claude" aggressive-resize on`);
+        applyTmuxOpt(`set-option -t "${tmuxSession}" remain-on-exit off`);
+        applyTmuxOpt(`set-option -t "${tmuxSession}" escape-time 0`);
+        // Pane 1 (right): dashboard at 40% width
+        (0, child_process_1.execSync)(`tmux split-window -t "${tmuxSession}:claude" -h -p 40 -c "${cwd}" '${dashCommand}'`, { stdio: 'pipe' });
+        // Launch Claude in left pane AFTER split to avoid initial Ink width mis-detection
+        (0, child_process_1.execSync)(`tmux respawn-pane -k -t "${tmuxSession}:claude.0" '${runCommand}'`, { stdio: 'pipe' });
+        // Keep focus on left pane so Claude retains immediate keyboard/mouse interaction
+        (0, child_process_1.execSync)(`tmux select-pane -t "${tmuxSession}:claude.0"`, { stdio: 'pipe' });
+        console.log(chalk_1.default.cyan('\n  Dashboard launched in right pane (40%)'));
+        console.log(chalk_1.default.gray('  Pane switch: Ctrl+B then o'));
+        // Attach to tmux session
+        (0, child_process_1.execSync)(`tmux attach -t "${tmuxSession}"`, { stdio: 'inherit' });
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`tmux error: ${err.message}`));
+        console.log(chalk_1.default.gray('Falling back to normal mode. Run "ekkos dashboard --latest" in another terminal.'));
+    }
+}
 async function run(options) {
     const verbose = options.verbose || false;
     const bypass = options.bypass || false;
@@ -795,6 +898,23 @@ async function run(options) {
     else if (verbose) {
         console.log(chalk_1.default.yellow('  ⏭️  API proxy disabled (--no-proxy)'));
     }
+    // ══════════════════════════════════════════════════════════════════════════
+    // DASHBOARD MODE: Launch via tmux with isolated dashboard pane (60/40)
+    // ══════════════════════════════════════════════════════════════════════════
+    if (options.dashboard) {
+        try {
+            const tmuxPath = (0, child_process_1.execSync)('which tmux', { encoding: 'utf-8' }).trim();
+            if (tmuxPath) {
+                launchWithDashboard(options);
+                return;
+            }
+        }
+        catch {
+            console.log(chalk_1.default.yellow('  tmux not found. Install: brew install tmux'));
+            console.log(chalk_1.default.gray('  Alternative: run "ekkos dashboard --latest" in a separate terminal'));
+            console.log(chalk_1.default.gray('  Continuing without dashboard...\n'));
+        }
+    }
     // Generate instance ID for this run
     const instanceId = generateInstanceId();
     // eslint-disable-next-line no-restricted-syntax -- Instance tracking, not API key
@@ -875,8 +995,14 @@ async function run(options) {
     if (bypass) {
         earlyArgs.push('--dangerously-skip-permissions');
     }
-    // Check PTY availability early
-    const usePty = pty !== null;
+    if (options.addDirs && options.addDirs.length > 0) {
+        for (const dir of options.addDirs) {
+            earlyArgs.push('--add-dir', dir);
+        }
+    }
+    // Check PTY availability early (deterministic, no async race)
+    const loadedPty = await loadPty();
+    const usePty = loadedPty !== null;
     // ══════════════════════════════════════════════════════════════════════════
     // CONCURRENT STARTUP: Spawn Claude while animation runs
     // Buffer output until animation completes, then flush
@@ -925,187 +1051,205 @@ async function run(options) {
     // ══════════════════════════════════════════════════════════════════════════
     // 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++) {
-                const charItem = line[i];
-                if (typeof charItem === 'string' && sparkleChars.includes(charItem)) {
-                    sparklePositions.push(i);
-                }
-            }
-            if (sparklePositions.length > 0) {
-                const pos = sparklePositions[Math.floor(Math.random() * sparklePositions.length)];
-                const charAtPos = line[pos];
-                // Mark this position for sparkle (we'll handle coloring below)
-                if (typeof charAtPos === 'string') {
-                    frameLines[lineIdx][pos] = { char: charAtPos, sparkle: true };
-                }
+    const skipFancyIntro = process.env.EKKOS_REMOTE_SESSION === '1' || process.env.EKKOS_NO_SPLASH === '1';
+    if (!skipFancyIntro) {
+        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);
             }
         }
-        // Move cursor up and render frame
+        // Final frame: settle on magenta
         process.stdout.write('\x1B[6A');
-        for (const line of frameLines) {
-            let output = '';
-            for (const char of line) {
-                if (typeof char === 'object' && 'sparkle' in char && char.sparkle) {
-                    const sparkleColor = sparkleColors[Math.floor(Math.random() * sparkleColors.length)];
-                    output += sparkleColor(char.char);
+        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++) {
+            // Track sparkle positions for this frame (lineIdx -> Set<charIdx>)
+            const sparkleMap = new Map();
+            // Pick random sparkle positions
+            for (let s = 0; s < SPARKLES_PER_FRAME; s++) {
+                const lineIdx = Math.floor(Math.random() * logoLines.length);
+                const line = logoLines[lineIdx];
+                // Find sparkle-able character positions in this line
+                const sparklePositions = [];
+                for (let i = 0; i < line.length; i++) {
+                    if (sparkleChars.includes(line[i])) {
+                        sparklePositions.push(i);
+                    }
                 }
-                else {
-                    output += chalk_1.default.magenta(char);
+                if (sparklePositions.length > 0) {
+                    const pos = sparklePositions[Math.floor(Math.random() * sparklePositions.length)];
+                    if (!sparkleMap.has(lineIdx)) {
+                        sparkleMap.set(lineIdx, new Set());
+                    }
+                    sparkleMap.get(lineIdx).add(pos);
                 }
             }
-            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('');
-    // ══════════════════════════════════════════════════════════════════════════
-    // ANIMATED TITLE: "Cognitive Continuity Engine" with orange/white shine
-    // ══════════════════════════════════════════════════════════════════════════
-    const titleText = 'Cognitive Continuity Engine';
-    const taglineText = 'Context is finite. Intelligence isn\'t.';
-    // Color palette for shine effect
-    const whiteShine = chalk_1.default.whiteBright;
-    // Phase 1: Typewriter effect for title
-    process.stdout.write('  ');
-    for (let i = 0; i < titleText.length; i++) {
-        const char = titleText[i];
-        // Flash white then settle to orange
-        process.stdout.write(whiteShine(char));
-        await sleep(25);
-        process.stdout.write('\b' + chalk_1.default.hex('#FF6B35').bold(char));
-    }
-    console.log('');
-    // Phase 2: Shine sweep across title (3 passes)
-    const SHINE_PASSES = 3;
-    const SHINE_WIDTH = 4;
-    for (let pass = 0; pass < SHINE_PASSES; pass++) {
-        for (let shinePos = -SHINE_WIDTH; shinePos <= titleText.length + SHINE_WIDTH; shinePos++) {
-            process.stdout.write('\x1B[1A'); // Move up one line
-            process.stdout.write('\r  '); // Return to start
-            let output = '';
-            for (let i = 0; i < titleText.length; i++) {
-                const distFromShine = Math.abs(i - shinePos);
-                if (distFromShine === 0) {
-                    output += whiteShine.bold(titleText[i]);
-                }
-                else if (distFromShine === 1) {
-                    output += chalk_1.default.hex('#FFFFFF')(titleText[i]);
-                }
-                else if (distFromShine === 2) {
-                    output += chalk_1.default.hex('#FFD700')(titleText[i]);
-                }
-                else if (distFromShine === 3) {
-                    output += chalk_1.default.hex('#FFA500')(titleText[i]);
+            // Render frame with sparkles
+            process.stdout.write('\x1B[6A'); // Move cursor up 6 lines
+            for (let lineIdx = 0; lineIdx < logoLines.length; lineIdx++) {
+                const line = logoLines[lineIdx];
+                const sparkles = sparkleMap.get(lineIdx);
+                let output = '';
+                for (let charIdx = 0; charIdx < line.length; charIdx++) {
+                    const char = line[charIdx];
+                    if (sparkles && sparkles.has(charIdx)) {
+                        const sparkleColor = sparkleColors[Math.floor(Math.random() * sparkleColors.length)];
+                        output += sparkleColor(char);
+                    }
+                    else {
+                        output += chalk_1.default.magenta(char);
+                    }
                 }
-                else {
-                    output += chalk_1.default.hex('#FF6B35').bold(titleText[i]);
+                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('');
+        // ══════════════════════════════════════════════════════════════════════════
+        // ANIMATED TITLE: "Cognitive Continuity Engine" with orange/white shine
+        // ══════════════════════════════════════════════════════════════════════════
+        const titleText = 'Cognitive Continuity Engine';
+        const taglineText = 'Context is finite. Intelligence isn\'t.';
+        // Color palette for shine effect
+        const whiteShine = chalk_1.default.whiteBright;
+        // Phase 1: Typewriter effect for title
+        process.stdout.write('  ');
+        for (let i = 0; i < titleText.length; i++) {
+            const char = titleText[i];
+            // Flash white then settle to orange
+            process.stdout.write(whiteShine(char));
+            await sleep(25);
+            process.stdout.write('\b' + chalk_1.default.hex('#FF6B35').bold(char));
+        }
+        console.log('');
+        // Phase 2: Shine sweep across title (3 passes)
+        const SHINE_PASSES = 3;
+        const SHINE_WIDTH = 4;
+        for (let pass = 0; pass < SHINE_PASSES; pass++) {
+            for (let shinePos = -SHINE_WIDTH; shinePos <= titleText.length + SHINE_WIDTH; shinePos++) {
+                process.stdout.write('\x1B[1A'); // Move up one line
+                process.stdout.write('\r  '); // Return to start
+                let output = '';
+                for (let i = 0; i < titleText.length; i++) {
+                    const distFromShine = Math.abs(i - shinePos);
+                    if (distFromShine === 0) {
+                        output += whiteShine.bold(titleText[i]);
+                    }
+                    else if (distFromShine === 1) {
+                        output += chalk_1.default.hex('#FFFFFF')(titleText[i]);
+                    }
+                    else if (distFromShine === 2) {
+                        output += chalk_1.default.hex('#FFD700')(titleText[i]);
+                    }
+                    else if (distFromShine === 3) {
+                        output += chalk_1.default.hex('#FFA500')(titleText[i]);
+                    }
+                    else {
+                        output += chalk_1.default.hex('#FF6B35').bold(titleText[i]);
+                    }
                 }
+                process.stdout.write(output + '\n'); // Write and move down for next frame
+                await sleep(15);
             }
-            process.stdout.write(output + '\n'); // Write and move down for next frame
-            await sleep(15);
-        }
-    }
-    // Final title state
-    process.stdout.write('\x1B[1A\r');
-    console.log('  ' + chalk_1.default.hex('#FF6B35').bold(titleText));
-    // Phase 3: Tagline fade-in with shimmer
-    await sleep(100);
-    // Build up tagline with wave effect
-    const taglineColors = [
-        chalk_1.default.hex('#444444'),
-        chalk_1.default.hex('#666666'),
-        chalk_1.default.hex('#888888'),
-        chalk_1.default.hex('#AAAAAA'),
-        chalk_1.default.hex('#CCCCCC'),
-        chalk_1.default.hex('#EEEEEE'),
-        chalk_1.default.gray,
-    ];
-    for (let wave = 0; wave < taglineColors.length; wave++) {
-        process.stdout.write('\r  ');
-        process.stdout.write(taglineColors[wave](taglineText));
-        await sleep(40);
-    }
-    console.log('');
-    // Phase 4: Quick orange accent pulse on tagline
-    for (let pulse = 0; pulse < 2; pulse++) {
-        await sleep(80);
+        }
+        // Final title state
         process.stdout.write('\x1B[1A\r');
-        console.log('  ' + chalk_1.default.hex('#FF8C00')(taglineText));
-        await sleep(80);
+        console.log('  ' + chalk_1.default.hex('#FF6B35').bold(titleText));
+        // Phase 3: Tagline fade-in with shimmer
+        await sleep(100);
+        // Build up tagline with wave effect
+        const taglineColors = [
+            chalk_1.default.hex('#444444'),
+            chalk_1.default.hex('#666666'),
+            chalk_1.default.hex('#888888'),
+            chalk_1.default.hex('#AAAAAA'),
+            chalk_1.default.hex('#CCCCCC'),
+            chalk_1.default.hex('#EEEEEE'),
+            chalk_1.default.gray,
+        ];
+        for (let wave = 0; wave < taglineColors.length; wave++) {
+            process.stdout.write('\r  ');
+            process.stdout.write(taglineColors[wave](taglineText));
+            await sleep(40);
+        }
+        console.log('');
+        // Phase 4: Quick orange accent pulse on tagline
+        for (let pulse = 0; pulse < 2; pulse++) {
+            await sleep(80);
+            process.stdout.write('\x1B[1A\r');
+            console.log('  ' + chalk_1.default.hex('#FF8C00')(taglineText));
+            await sleep(80);
+            process.stdout.write('\x1B[1A\r');
+            console.log('  ' + chalk_1.default.gray(taglineText));
+        }
+        // Final tagline state with subtle orange tint
         process.stdout.write('\x1B[1A\r');
-        console.log('  ' + chalk_1.default.gray(taglineText));
-    }
-    // Final tagline state with subtle orange tint
-    process.stdout.write('\x1B[1A\r');
-    console.log('  ' + chalk_1.default.hex('#B8860B')(taglineText));
-    console.log('');
-    if (bypass) {
-        console.log(chalk_1.default.yellow('  ⚡ Bypass permissions mode enabled'));
-    }
-    if (noDna) {
-        console.log(chalk_1.default.yellow('  ⏭️  ccDNA injection skipped (--no-dna)'));
+        console.log('  ' + chalk_1.default.hex('#B8860B')(taglineText));
+        console.log('');
+        if (bypass) {
+            console.log(chalk_1.default.yellow('  ⚡ Bypass permissions mode enabled'));
+        }
+        if (noDna) {
+            console.log(chalk_1.default.yellow('  ⏭️  ccDNA injection skipped (--no-dna)'));
+        }
+        if (verbose) {
+            console.log(chalk_1.default.gray(`  📁 Debug log: ${config.debugLogPath}`));
+            console.log(chalk_1.default.gray(`  ⏱  Timing: clear=${config.clearWaitMs}ms, idleMax=${config.maxIdleWaitMs}ms (~${Math.round((config.clearWaitMs + config.maxIdleWaitMs * 2 + 1700) / 1000)}s total)`));
+        }
+        console.log('');
     }
-    if (verbose) {
-        console.log(chalk_1.default.gray(`  📁 Debug log: ${config.debugLogPath}`));
-        console.log(chalk_1.default.gray(`  ⏱  Timing: clear=${config.clearWaitMs}ms, idleMax=${config.maxIdleWaitMs}ms (~${Math.round((config.clearWaitMs + config.maxIdleWaitMs * 2 + 1700) / 1000)}s total)`));
+    else {
+        console.log('');
+        console.log(chalk_1.default.cyan('  ekkOS remote session ready'));
+        if (bypass) {
+            console.log(chalk_1.default.yellow('  ⚡ Bypass permissions mode enabled'));
+        }
+        if (noDna) {
+            console.log(chalk_1.default.yellow('  ⏭️  ccDNA injection skipped (--no-dna)'));
+        }
+        if (verbose) {
+            console.log(chalk_1.default.gray(`  📁 Debug log: ${config.debugLogPath}`));
+        }
+        console.log('');
     }
-    console.log('');
     // ══════════════════════════════════════════════════════════════════════════
     // ANIMATION COMPLETE: Mark ready and flush buffered Claude output
     // ══════════════════════════════════════════════════════════════════════════
@@ -1118,8 +1262,9 @@ async function run(options) {
         await sleep(100);
         process.stdout.write('\r' + ' '.repeat(30) + '\r'); // Clear the line
     }
-    // Track state
-    let currentSession = options.session || (0, state_1.getCurrentSessionName)();
+    // Track state — only use explicit -s option; never inherit stale session from state.json
+    // The real session name will be detected from Claude Code's output (line ~2552)
+    let currentSession = options.session || null;
     // Write initial instance file
     const startedAt = new Date().toISOString();
     writeInstanceFile(instanceId, {
@@ -1199,7 +1344,8 @@ async function run(options) {
     catch {
         dlog('[TRANSCRIPT] Project dir does not exist yet');
     }
-    // Poll for new transcript file every 500ms for up to 30 seconds
+    // Poll for new transcript file every 500ms for up to 30 seconds.
+    // Safety rule: do NOT guess using "most recent" files; that can cross-bind sessions.
     let transcriptPollInterval = null;
     function pollForNewTranscript() {
         if (transcriptPath) {
@@ -1212,9 +1358,9 @@ async function run(options) {
         }
         // Stop after 30 seconds
         if (Date.now() - launchTime > 30000) {
-            // FALLBACK FIX: If no transcript found yet, pick most recent jsonl as best guess
-            // This handles /continue scenarios where the file already existed
-            if (!transcriptPath) {
+            // Local mode fallback: transcript maintenance features need a file path.
+            // In proxy mode this is intentionally disabled to avoid cross-session mixing.
+            if (!proxyModeEnabled && !transcriptPath) {
                 try {
                     const files = fs.readdirSync(projectDir);
                     const jsonlFiles = files
@@ -1228,23 +1374,23 @@ async function run(options) {
                     if (jsonlFiles.length > 0) {
                         transcriptPath = jsonlFiles[0].path;
                         currentSessionId = jsonlFiles[0].name.replace('.jsonl', '');
-                        dlog(`[TRANSCRIPT] TIMEOUT FALLBACK: Using most recent file ${transcriptPath}`);
-                        evictionDebugLog('TRANSCRIPT_SET', 'Polling timeout fallback - using most recent jsonl', {
-                            transcriptPath,
-                            currentSessionId,
-                            fileCount: jsonlFiles.length,
-                        });
+                        dlog(`[TRANSCRIPT] Local-mode timeout fallback: ${transcriptPath}`);
                         startStreamTailer(transcriptPath, currentSessionId);
                     }
-                    else {
-                        dlog('[TRANSCRIPT] TIMEOUT FALLBACK: No jsonl files found in project dir');
-                    }
                 }
-                catch (err) {
-                    dlog(`[TRANSCRIPT] TIMEOUT FALLBACK ERROR: ${err.message}`);
+                catch {
+                    // Ignore local-mode timeout errors
                 }
             }
-            dlog('[TRANSCRIPT] Polling timeout - fallback complete');
+            if (proxyModeEnabled) {
+                dlog('[TRANSCRIPT] Polling timeout - no safe transcript candidate found');
+            }
+            else if (transcriptPath) {
+                dlog('[TRANSCRIPT] Polling timeout - local fallback transcript selected');
+            }
+            else {
+                dlog('[TRANSCRIPT] Polling timeout - no transcript candidate found');
+            }
             if (transcriptPollInterval) {
                 clearInterval(transcriptPollInterval);
                 transcriptPollInterval = null;
@@ -1277,27 +1423,6 @@ async function run(options) {
                     return;
                 }
             }
-            // Also check for recently modified files (in case we missed the creation)
-            const recentFiles = jsonlFiles
-                .map(f => ({ name: f, path: path.join(projectDir, f), mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
-                .filter(f => f.mtime > launchTime - 2000) // Modified within 2s of launch
-                .sort((a, b) => b.mtime - a.mtime);
-            if (recentFiles.length > 0) {
-                const newest = recentFiles[0];
-                transcriptPath = newest.path;
-                currentSessionId = newest.name.replace('.jsonl', '');
-                dlog(`[TRANSCRIPT] FAST DETECT: Recent transcript found! ${transcriptPath}`);
-                evictionDebugLog('TRANSCRIPT_SET', 'Fast poll found recent file', {
-                    transcriptPath,
-                    currentSessionId,
-                    elapsedMs: Date.now() - launchTime
-                });
-                startStreamTailer(transcriptPath, currentSessionId);
-                if (transcriptPollInterval) {
-                    clearInterval(transcriptPollInterval);
-                    transcriptPollInterval = null;
-                }
-            }
         }
         catch {
             // Project dir doesn't exist yet, keep polling
@@ -1318,6 +1443,8 @@ async function run(options) {
     // Track if we've EVER observed a session in THIS process run
     // This is the authoritative flag - if false, don't trust persisted state
     let observedSessionThisRun = false;
+    let boundProxySession = null;
+    let bindingSessionInFlight = null;
     // Output buffer for pattern detection
     let outputBuffer = '';
     // Debounce tracking to prevent double triggers
@@ -1391,6 +1518,48 @@ async function run(options) {
         }
         return true;
     }
+    function resolveTranscriptFromSessionId(source) {
+        if (!currentSessionId || transcriptPath)
+            return;
+        const candidate = path.join(projectDir, `${currentSessionId}.jsonl`);
+        if (!fs.existsSync(candidate))
+            return;
+        transcriptPath = candidate;
+        evictionDebugLog('TRANSCRIPT_SET', `Set from session ID (${source})`, {
+            transcriptPath,
+            currentSessionId,
+        });
+        dlog(`[TRANSCRIPT] Resolved by session ID (${source}): ${candidate}`);
+        startStreamTailer(transcriptPath, currentSessionId, currentSession || undefined);
+    }
+    function bindRealSessionToProxy(sessionName, source) {
+        if (!proxyModeEnabled)
+            return;
+        if (!sessionName || sessionName === '_pending' || sessionName === 'pending' || sessionName.startsWith('_pending-'))
+            return;
+        if (boundProxySession === sessionName || bindingSessionInFlight === sessionName)
+            return;
+        bindingSessionInFlight = sessionName;
+        void (async () => {
+            const maxAttempts = 3;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                const pendingSession = cliSessionName && cliSessionName.startsWith('_pending') ? cliSessionName : undefined;
+                const success = await (0, session_binding_1.bindSession)(sessionName, process.cwd(), pendingSession);
+                if (success) {
+                    boundProxySession = sessionName;
+                    bindingSessionInFlight = null;
+                    cliSessionName = sessionName;
+                    dlog(`[SESSION_BIND] Bound ${sessionName} from ${source} (attempt ${attempt}/${maxAttempts})`);
+                    return;
+                }
+                if (attempt < maxAttempts) {
+                    await sleep(200 * attempt);
+                }
+            }
+            dlog(`[SESSION_BIND] Failed to bind ${sessionName} from ${source}`);
+            bindingSessionInFlight = null;
+        })();
+    }
     /**
      * Check if there are in-flight tool calls (tool_uses without matching tool_results)
      * CRITICAL: We must NOT evict while tools are in-flight or we'll orphan tool_results
@@ -1444,6 +1613,12 @@ async function run(options) {
     async function handleTurnEnd() {
         if (!transcriptPath || isAutoClearInProgress)
             return;
+        if (proxyModeEnabled) {
+            // Proxy is the SOLE eviction authority. It strips old turns before forwarding to Anthropic,
+            // keeping API payloads small and consistent for prompt cache hits.
+            // CLI does NOT touch the local JSONL - Claude Code sends full history, proxy handles the rest.
+            return;
+        }
         // DEFENSIVE: Validate path before using
         if (!validateTranscriptPath(transcriptPath)) {
             evictionDebugLog('TURN_END_ABORT', 'Invalid transcriptPath detected - resetting to null', {
@@ -1472,13 +1647,12 @@ async function run(options) {
             dlog(`🧹 Turn-end: Cleaned ${cleanResult.cleaned} junk lines`);
             evictionDebugLog('CONTINUOUS_CLEAN', `Cleaned ${cleanResult.cleaned} junk lines`);
         }
-        // Then run eviction if needed (disabled when proxy handles it, or via EKKOS_DISABLE_EVICTION=1)
-        // CRITICAL: When proxy mode is enabled, the proxy does seamless eviction - local JSONL eviction must be disabled
+        // Then run eviction if needed (local mode only - proxy handles eviction in proxy mode)
         // eslint-disable-next-line no-restricted-syntax -- Feature flag, not API key
         const evictionDisabled = process.env.EKKOS_DISABLE_EVICTION === '1' || proxyModeEnabled;
         if (evictionDisabled) {
             evictionDebugLog('EVICTION_DISABLED', proxyModeEnabled
-                ? 'Eviction disabled - proxy handles context management'
+                ? 'Proxy is sole eviction authority - CLI does not touch local JSONL'
                 : 'Eviction disabled via EKKOS_DISABLE_EVICTION=1');
         }
         else if ((0, jsonl_rewriter_1.needsEviction)(lastContextPercent)) {
@@ -2148,17 +2322,8 @@ async function run(options) {
             // Also update global state for backwards compatibility
             (0, state_1.updateState)({ sessionId: currentSessionId, sessionName: currentSession });
             dlog(`Session detected from UUID: ${currentSession}`);
-            // Try to find/construct transcript path from session ID
-            if (!transcriptPath) {
-                const encodedCwd = process.cwd().replace(/\//g, '-');
-                const possibleTranscript = path.join(os.homedir(), '.claude', 'projects', encodedCwd, `${currentSessionId}.jsonl`);
-                if (fs.existsSync(possibleTranscript)) {
-                    transcriptPath = possibleTranscript;
-                    evictionDebugLog('TRANSCRIPT_SET', 'Set from session ID', { transcriptPath, source: 'sessionId' });
-                    dlog(`Found transcript from session ID: ${transcriptPath}`);
-                    startStreamTailer(transcriptPath, currentSessionId, currentSession || undefined);
-                }
-            }
+            resolveTranscriptFromSessionId('session-id-from-output');
+            bindRealSessionToProxy(currentSession, 'session-id-from-output');
         }
         // ════════════════════════════════════════════════════════════════════════
         // SESSION NAME DETECTION (PRIMARY METHOD)
@@ -2175,69 +2340,14 @@ async function run(options) {
                 dlog(`Session rejected (invalid words): ${detectedSession}`);
             }
             else if (detectedSession !== lastSeenSessionName) {
-                // Only update if different (avoid log spam)
-                lastSeenSessionName = detectedSession;
-                lastSeenSessionAt = Date.now();
-                currentSession = lastSeenSessionName;
-                observedSessionThisRun = true; // Mark that we've seen a session in THIS process
-                // Update THIS process's session entry (not global state.json)
-                (0, state_1.updateCurrentProcessSession)(currentSessionId || 'unknown', currentSession);
-                // Also update global state for backwards compatibility
-                (0, state_1.updateState)({ sessionName: currentSession });
-                dlog(`Session detected from status line: ${currentSession} (observedSessionThisRun=true)`);
-                // Try to start stream tailer - scan for matching transcript file
-                dlog(`[TRANSCRIPT_SCAN] streamTailer=${!!streamTailer}, transcriptPath=${transcriptPath || 'NULL'}`);
-                if (!streamTailer) {
-                    const encodedCwd = process.cwd().replace(/\//g, '-');
-                    const projectDir = path.join(os.homedir(), '.claude', 'projects', encodedCwd);
-                    dlog(`[TRANSCRIPT_SCAN] Scanning projectDir: ${projectDir}`);
-                    try {
-                        const files = fs.readdirSync(projectDir);
-                        dlog(`[TRANSCRIPT_SCAN] Found ${files.length} files in projectDir`);
-                        // Find most recent .jsonl file (likely current session)
-                        const jsonlFiles = files
-                            .filter(f => f.endsWith('.jsonl'))
-                            .map(f => ({
-                            name: f,
-                            path: path.join(projectDir, f),
-                            mtime: fs.statSync(path.join(projectDir, f)).mtimeMs
-                        }))
-                            .sort((a, b) => b.mtime - a.mtime);
-                        dlog(`[TRANSCRIPT_SCAN] Found ${jsonlFiles.length} .jsonl files`);
-                        if (jsonlFiles.length > 0) {
-                            transcriptPath = jsonlFiles[0].path;
-                            currentSessionId = jsonlFiles[0].name.replace('.jsonl', '');
-                            dlog(`[TRANSCRIPT_SCAN] SUCCESS! transcriptPath=${transcriptPath}`);
-                            evictionDebugLog('TRANSCRIPT_SET', 'Set from session name detection', { transcriptPath, currentSessionId });
-                            startStreamTailer(transcriptPath, currentSessionId, currentSession);
-                        }
-                        else {
-                            dlog(`[TRANSCRIPT_SCAN] No jsonl files found!`);
-                        }
-                    }
-                    catch (err) {
-                        dlog(`[TRANSCRIPT_SCAN] ERROR: ${err.message}`);
-                    }
+                // Do not allow session switching from parsed output once a run has
+                // already locked onto a session. This prevents rebinding from echoed
+                // status/footer text in model responses (e.g. pasted transcripts).
+                if (observedSessionThisRun && currentSession && detectedSession !== currentSession) {
+                    dlog(`Ignoring session switch from status line: ${currentSession} -> ${detectedSession}`);
                 }
                 else {
-                    dlog(`[TRANSCRIPT_SCAN] Skipped - streamTailer already running`);
-                }
-            }
-            else {
-                // Same session, just update timestamp
-                lastSeenSessionAt = Date.now();
-            }
-        }
-        else {
-            // Weaker signal: any 3-word slug (only if no status match)
-            const anyMatch = plain.match(SESSION_NAME_REGEX);
-            if (anyMatch) {
-                const detectedSession = anyMatch[1].toLowerCase();
-                // Validate against word lists (SOURCE OF TRUTH)
-                if (!isValidSessionName(detectedSession)) {
-                    dlog(`Session rejected (invalid words): ${detectedSession}`);
-                }
-                else if (detectedSession !== lastSeenSessionName) {
+                    // Only update if different (avoid log spam)
                     lastSeenSessionName = detectedSession;
                     lastSeenSessionAt = Date.now();
                     currentSession = lastSeenSessionName;
@@ -2246,13 +2356,27 @@ async function run(options) {
                     (0, state_1.updateCurrentProcessSession)(currentSessionId || 'unknown', currentSession);
                     // Also update global state for backwards compatibility
                     (0, state_1.updateState)({ sessionName: currentSession });
-                    dlog(`Session detected from generic match: ${currentSession} (observedSessionThisRun=true)`);
+                    dlog(`Session detected from status line: ${currentSession} (observedSessionThisRun=true)`);
+                    bindRealSessionToProxy(currentSession, 'status-line');
+                    resolveTranscriptFromSessionId('status-line');
                 }
-                else {
-                    lastSeenSessionAt = Date.now();
+            }
+            else {
+                // Same session, just update timestamp
+                lastSeenSessionAt = Date.now();
+                if (boundProxySession !== detectedSession) {
+                    bindRealSessionToProxy(detectedSession, 'status-line-refresh');
                 }
             }
         }
+        else {
+            // Weak signal: any 3-word slug can appear in arbitrary output.
+            // Ignore it to avoid accidental cross-session rebinding.
+            const anyMatch = plain.match(SESSION_NAME_REGEX);
+            if (anyMatch && !observedSessionThisRun) {
+                dlog(`Ignoring weak session candidate (awaiting strong signal): ${anyMatch[1].toLowerCase()}`);
+            }
+        }
         // ══════════════════════════════════════════════════════════════════════════
         // TURN-END EVICTION - Track context % and run cleanup when Claude goes idle
         // This is MUCH safer than mid-stream eviction because:
@@ -2261,7 +2385,7 @@ async function run(options) {
         // 3. Claude Code is between operations
         // ══════════════════════════════════════════════════════════════════════════
         // ════════════════════════════════════════════════════════════════════════
-        // CONTEXT % CALCULATION - Only when proxy mode is OFF (hook handles it otherwise)
+        // CONTEXT % CALCULATION - Local mode only (proxy handles its own token tracking)
         // ════════════════════════════════════════════════════════════════════════
         if (!proxyModeEnabled) {
             // Track context percentage - PRIMARY: calculate from JSONL file size
@@ -2288,8 +2412,7 @@ async function run(options) {
             }
         }
         // ════════════════════════════════════════════════════════════════════════
-        // CONTINUOUS CLEANUP - Runs ALWAYS (proxy handles big evictions, local handles junk)
-        // handleTurnEnd() has internal check to skip threshold eviction when proxy is on
+        // TURN-END MAINTENANCE - Local mode only (proxy is sole eviction authority)
         // ════════════════════════════════════════════════════════════════════════
         // Detect idle prompt (turn end) and schedule cleanup
         const strippedOutput = stripAnsi(outputBuffer);
@@ -2303,7 +2426,7 @@ async function run(options) {
                 outputBufferEnd: strippedOutput.slice(-100),
             });
         }
-        if (idlePromptDetected && transcriptPath && !isAutoClearInProgress) {
+        if (!proxyModeEnabled && idlePromptDetected && transcriptPath && !isAutoClearInProgress) {
             // Cancel any existing timer
             if (turnEndTimeout) {
                 clearTimeout(turnEndTimeout);
@@ -2317,7 +2440,7 @@ async function run(options) {
             }, TURN_END_STABLE_MS);
         }
         // SLIDING WINDOW: Inject /clear after eviction to force transcript reload
-        if (idlePromptDetected && pendingClearAfterEviction && !isAutoClearInProgress) {
+        if (!proxyModeEnabled && idlePromptDetected && pendingClearAfterEviction && !isAutoClearInProgress) {
             pendingClearAfterEviction = false;
             isAutoClearInProgress = true;
             dlog('🔄 SLIDING WINDOW: Injecting /clear to reload evicted transcript');
@@ -2350,8 +2473,8 @@ async function run(options) {
                 }
             })();
         }
-        // BACKUP: Context wall detection - emergency evict
-        if (!isAutoClearInProgress && transcriptPath) {
+        // BACKUP: Context wall detection - emergency evict (all modes)
+        if (!proxyModeEnabled && !isAutoClearInProgress && transcriptPath) {
             const normalized = normalizeForMatch(outputBuffer);
             if (CONTEXT_WALL_REGEX.test(normalized)) {
                 dlog('⚠️ CONTEXT WALL - emergency evict to 50%');
@@ -2368,6 +2491,36 @@ async function run(options) {
         }
     });
     // ══════════════════════════════════════════════════════════════════════════
+    // KICKSTART MODE: Auto-send "test" to create session immediately
+    // Used by --dashboard to eliminate wait for first user message
+    // ══════════════════════════════════════════════════════════════════════════
+    if (options.kickstart) {
+        dlog('Kickstart mode enabled - will auto-send "test" to create session');
+        setTimeout(async () => {
+            dlog('Starting kickstart injection...');
+            const readiness = await waitForIdlePrompt(getOutputBuffer, config);
+            if (!readiness.ready || readiness.interrupted) {
+                dlog('Claude not ready for kickstart - aborting');
+                return;
+            }
+            // PAUSE STDIN during injection
+            process.stdin.off('data', onStdinData);
+            dlog('Stdin paused during kickstart');
+            try {
+                shell.write('\x15'); // Ctrl+U - clear any existing input
+                await sleep(60);
+                await typeSlowly(shell, 'test', config.charDelayMs);
+                await sleep(100);
+                shell.write('\r'); // Enter
+                dlog('Kickstart "test" sent - session should be created');
+            }
+            finally {
+                process.stdin.on('data', onStdinData);
+                dlog('Stdin resumed after kickstart');
+            }
+        }, 3000); // 3s for Claude to initialize
+    }
+    // ══════════════════════════════════════════════════════════════════════════
     // RESEARCH MODE: Auto-type research prompt after Claude is ready
     // Triggers: `ekkos run -r` or `ekkos run --research`
     // Works like /clear continue - waits for idle prompt, then injects text