@ekkos/cli 0.2.2 → 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, Node.js spawn doesn't provide proper TTY support
-        // Claude Code detects non-TTY and defaults to --print mode
-        // Solution: Use cmd.exe /c to run claude directly with proper console
+        // ══════════════════════════════════════════════════════════════════════════
+        // 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('═══════════════════════════════════════════════════════════════════'));
@@ -748,24 +831,24 @@ async function runWithSpawn(claudePath, args, options, state) {
             console.log('');
             process.exit(1);
         }
-        console.log(chalk_1.default.gray('Windows mode: launching Claude with proper TTY...'));
-        // Build the full command
+        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}"`;
-        // Use cmd.exe /c to get proper console behavior
-        // This replaces the current process with claude
+        // 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');
-        // First try: Direct exec replacement
         try {
             const result = spawnSync('cmd.exe', ['/c', fullCmd], {
-                stdio: 'inherit',
+                stdio: 'inherit', // CRITICAL: Full passthrough, no piping
                 cwd: process.cwd(),
                 env: process.env,
                 windowsHide: false,
                 shell: false
             });
-            // If we get here, claude exited
             (0, state_1.clearAutoClearFlag)();
             process.exit(result.status || 0);
         }
@@ -777,8 +860,7 @@ async function runWithSpawn(claudePath, args, options, state) {
             console.log('');
             process.exit(1);
         }
-        // This line won't be reached due to spawnSync + process.exit
-        return;
+        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.2",
+  "version": "0.2.3",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {