@ekkos/cli 0.2.1 → 0.2.3

package/dist/commands/run.js

@@ -97,6 +97,15 @@ 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;
 // ═══════════════════════════════════════════════════════════════════════════
+// 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;
+// Weaker signal: any 3-word slug (word-word-word pattern)
+const SESSION_NAME_REGEX = /\b([a-z]+-[a-z]+-[a-z]+)\b/i;
+// ═══════════════════════════════════════════════════════════════════════════
 // LOGGING (FILE ONLY DURING TUI - NO TERMINAL CORRUPTION)
 // ═══════════════════════════════════════════════════════════════════════════
 let _debugLogPath = path.join(os.homedir(), '.ekkos', 'auto-continue.debug.log');
@@ -464,6 +473,14 @@ async function run(options) {
     let isAutoClearInProgress = false;
     let transcriptPath = null;
     let currentSessionId = null;
+    // ══════════════════════════════════════════════════════════════════════════
+    // SESSION NAME TRACKING (from live TUI output)
+    // Claude prints: "· Turn N · groovy-koala-saves · 📅"
+    // We parse this to always know the CURRENT session, not stale persisted state
+    // ══════════════════════════════════════════════════════════════════════════
+    let lastSeenSessionName = null;
+    let lastSeenSessionAt = 0;
+    const RECENCY_WINDOW_MS = 15000; // 15s - session name must be recent to trust
     // Output buffer for pattern detection
     let outputBuffer = '';
     // Debounce tracking to prevent double triggers
@@ -571,9 +588,24 @@ async function run(options) {
             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;
+        // ════════════════════════════════════════════════════════════════════════
+        // SESSION SELECTION: Prefer most recently SEEN session from TUI output
+        // This fixes the "groovy-koala-saves" bug where stale persisted state was used
+        // Priority: lastSeenSessionName (if recent) > currentSession > persisted state
+        // ════════════════════════════════════════════════════════════════════════
+        let sessionToRestore = null;
+        // PRIORITY 1: Most recently observed session name from TUI output
+        // Only trust if seen within RECENCY_WINDOW_MS (15 seconds)
+        if (lastSeenSessionName && (Date.now() - lastSeenSessionAt) < RECENCY_WINDOW_MS) {
+            sessionToRestore = lastSeenSessionName;
+            dlog(`Using lastSeenSessionName (${Date.now() - lastSeenSessionAt}ms ago): ${sessionToRestore}`);
+        }
+        // PRIORITY 2: currentSession (in-memory, may be stale)
+        if (!sessionToRestore && currentSession) {
+            sessionToRestore = currentSession;
+            dlog(`Using currentSession (in-memory): ${sessionToRestore}`);
+        }
+        // PRIORITY 3: Persisted state (fallback)
         if (!sessionToRestore) {
             const state = (0, state_1.getState)();
             sessionToRestore = state?.sessionName || null;
@@ -582,9 +614,12 @@ async function run(options) {
             if (!sessionToRestore && sessionId) {
                 sessionToRestore = (0, state_1.uuidToWords)(sessionId);
             }
+            if (sessionToRestore) {
+                dlog(`Using persisted state (fallback): ${sessionToRestore}`);
+            }
         }
         const sessionDisplay = sessionToRestore || 'unknown-session';
-        dlog(`Session to restore (captured before clear): ${sessionDisplay}`);
+        dlog(`Session to restore (final): ${sessionDisplay}`);
         // CRITICAL: Clear buffer and set flags immediately
         outputBuffer = '';
         lastDetectionTime = now;
@@ -671,13 +706,53 @@ async function run(options) {
             transcriptPath = transcriptMatch[1];
             dlog(`Detected transcript: ${transcriptPath}`);
         }
-        // Try to extract session ID from output
+        // Try to extract session ID from output (fallback - Claude rarely prints this)
         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}`);
+            dlog(`Session detected from UUID: ${currentSession}`);
+        }
+        // ════════════════════════════════════════════════════════════════════════
+        // SESSION NAME DETECTION (PRIMARY METHOD)
+        // Claude footer: "· Turn N · groovy-koala-saves · 📅 2026-01-17"
+        // This is MORE reliable than UUID extraction
+        // ════════════════════════════════════════════════════════════════════════
+        const plain = stripAnsi(data);
+        // Strong signal: session name between dot separators in status/footer line
+        const statusMatch = plain.match(SESSION_NAME_IN_STATUS_REGEX);
+        if (statusMatch) {
+            const detectedSession = statusMatch[1].toLowerCase();
+            // Only update if different (avoid log spam)
+            if (detectedSession !== lastSeenSessionName) {
+                lastSeenSessionName = detectedSession;
+                lastSeenSessionAt = Date.now();
+                currentSession = lastSeenSessionName;
+                (0, state_1.updateState)({ sessionName: currentSession });
+                dlog(`Session detected from status line: ${currentSession}`);
+            }
+            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();
+                if (detectedSession !== lastSeenSessionName) {
+                    lastSeenSessionName = detectedSession;
+                    lastSeenSessionAt = Date.now();
+                    currentSession = lastSeenSessionName;
+                    (0, state_1.updateState)({ sessionName: currentSession });
+                    dlog(`Session detected from generic match: ${currentSession}`);
+                }
+                else {
+                    lastSeenSessionAt = Date.now();
+                }
+            }
         }
         // Check for context wall patterns (ANSI-stripped + regex for robustness)
         if (!isAutoClearInProgress) {
@@ -726,14 +801,22 @@ async function runWithSpawn(claudePath, args, options, 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(chalk_1.default.gray('Using spawn fallback mode (node-pty unavailable)'));
+    console.log(chalk_1.default.yellow('⚠️  Auto-continue requires PTY - manual /clear + /continue only'));
+    console.log(chalk_1.default.gray('   To enable auto-continue: npm rebuild node-pty'));
     console.log('');
     let claude;
     if (isWindows) {
-        // On Windows, spawn Claude directly
-        // IMPORTANT: npx mode doesn't work well on Windows because Claude Code
-        // detects non-TTY and defaults to --print mode expecting stdin input
+        // ══════════════════════════════════════════════════════════════════════════
+        // WINDOWS: Full TTY passthrough (no output monitoring, no auto-inject)
+        //
+        // Why: Without node-pty/ConPTY, we cannot simultaneously:
+        //   1. Keep Claude TUI interactive
+        //   2. Read output for context-wall detection
+        //
+        // Piping stdout triggers Claude's --print mode which breaks the TUI.
+        // Solution: stdio: 'inherit' for complete passthrough.
+        // ══════════════════════════════════════════════════════════════════════════
         if (claudePath === 'npx') {
             console.log('');
             console.log(chalk_1.default.red('═══════════════════════════════════════════════════════════════════'));
@@ -746,18 +829,38 @@ async function runWithSpawn(claudePath, args, options, state) {
             console.log(chalk_1.default.yellow('  Then try again:'));
             console.log(chalk_1.default.cyan('    ekkos run -b'));
             console.log('');
-            console.log(chalk_1.default.gray('  Why? Windows spawn mode doesn\'t provide a proper TTY,'));
-            console.log(chalk_1.default.gray('  causing Claude Code to expect piped input instead of interactive.'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.gray('Windows mode: full TTY passthrough (no auto-inject)'));
+        console.log(chalk_1.default.gray('Context wall → manual /clear + /continue <session>'));
+        console.log('');
+        // Build command for passthrough
+        const fullCmd = args.length > 0
+            ? `"${claudePath}" ${args.join(' ')}`
+            : `"${claudePath}"`;
+        // spawnSync with stdio: 'inherit' = full console passthrough
+        // This is the ONLY way to keep Claude TUI working on Windows without PTY
+        const { spawnSync } = require('child_process');
+        try {
+            const result = spawnSync('cmd.exe', ['/c', fullCmd], {
+                stdio: 'inherit', // CRITICAL: Full passthrough, no piping
+                cwd: process.cwd(),
+                env: process.env,
+                windowsHide: false,
+                shell: false
+            });
+            (0, state_1.clearAutoClearFlag)();
+            process.exit(result.status || 0);
+        }
+        catch (err) {
+            console.error(chalk_1.default.red('Failed to launch Claude:'), err.message);
+            console.log('');
+            console.log(chalk_1.default.yellow('Try running claude directly:'));
+            console.log(chalk_1.default.cyan('  claude'));
             console.log('');
             process.exit(1);
         }
-        console.log(chalk_1.default.gray('Windows mode: running Claude directly'));
-        claude = (0, child_process_1.spawn)(claudePath, args, {
-            stdio: 'inherit', // Full inherit for proper interactive mode
-            cwd: process.cwd(),
-            env: process.env,
-            shell: true
-        });
+        return; // Unreachable due to spawnSync + process.exit, but explicit
     }
     else {
         // Use script command for PTY on Unix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekkos/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {