@cluesmith/codev 2.0.0-rc.60 → 2.0.0-rc.61

package/dist/agent-farm/servers/tower-server.js

@@ -218,11 +218,23 @@ function checkTmux() {
         return false;
     }
 }
+/**
+ * Sanitize a tmux session name to match what tmux actually creates.
+ * tmux replaces dots with underscores and strips colons from session names.
+ * Without this, stored names won't match actual tmux session names,
+ * causing reconnection to fail (e.g., "builder-codevos.ai-0001" vs "builder-codevos_ai-0001").
+ */
+function sanitizeTmuxSessionName(name) {
+    return name.replace(/\./g, '_').replace(/:/g, '');
+}
 /**
  * Create a tmux session with the given command.
- * Returns true if created successfully, false on failure.
+ * Returns the sanitized session name if created successfully, null on failure.
+ * Session names are sanitized to match tmux behavior (dots → underscores, colons stripped).
  */
 function createTmuxSession(sessionName, command, args, cwd, cols, rows) {
+    // Sanitize to match what tmux actually creates (dots → underscores, colons stripped)
+    sessionName = sanitizeTmuxSessionName(sessionName);
     // Kill any stale session with this name
     if (tmuxSessionExists(sessionName)) {
         killTmuxSession(sessionName);
@@ -240,26 +252,28 @@ function createTmuxSession(sessionName, command, args, cwd, cols, rows) {
         const result = spawnSync('tmux', tmuxArgs, { stdio: 'ignore' });
         if (result.status !== 0) {
             log('WARN', `tmux new-session exited with code ${result.status} for "${sessionName}"`);
-            return false;
+            return null;
         }
         // Hide tmux status bar (dashboard has its own tabs), enable mouse, and
         // use aggressive-resize so tmux sizes to the largest client (not smallest)
         spawnSync('tmux', ['set-option', '-t', sessionName, 'status', 'off'], { stdio: 'ignore' });
         spawnSync('tmux', ['set-option', '-t', sessionName, 'mouse', 'on'], { stdio: 'ignore' });
         spawnSync('tmux', ['set-option', '-t', sessionName, 'aggressive-resize', 'on'], { stdio: 'ignore' });
-        return true;
+        return sessionName;
     }
     catch (err) {
         log('WARN', `Failed to create tmux session "${sessionName}": ${err.message}`);
-        return false;
+        return null;
     }
 }
 /**
- * Check if a tmux session exists
+ * Check if a tmux session exists.
+ * Sanitizes the name to handle legacy entries stored before dot-replacement fix.
  */
 function tmuxSessionExists(sessionName) {
+    const sanitized = sanitizeTmuxSessionName(sessionName);
     try {
-        execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`, { stdio: 'ignore' });
+        execSync(`tmux has-session -t "${sanitized}" 2>/dev/null`, { stdio: 'ignore' });
         return true;
     }
     catch {
@@ -291,90 +305,218 @@ function killTmuxSession(sessionName) {
     }
 }
 /**
- * Reconcile terminal sessions from SQLite against reality on startup.
+ * Parse a codev tmux session name to extract type, project, and role.
+ * Returns null if the name doesn't match any known codev pattern.
  *
- * For sessions with surviving tmux sessions: re-attach via new node-pty,
- * register in projectTerminals, and update SQLite with new terminal ID.
- * For dead sessions: clean up SQLite rows and kill orphaned processes.
+ * Examples:
+ *   "architect-codev-public"           → { type: 'architect', projectBasename: 'codev-public', roleId: null }
+ *   "builder-codevos_ai-0001"          → { type: 'builder', projectBasename: 'codevos_ai', roleId: '0001' }
+ *   "shell-codev-public-shell-1"       → { type: 'shell', projectBasename: 'codev-public', roleId: 'shell-1' }
  */
-async function reconcileTerminalSessions() {
-    const db = getGlobalDb();
-    let sessions;
+function parseTmuxSessionName(name) {
+    // architect-{basename}
+    const architectMatch = name.match(/^architect-(.+)$/);
+    if (architectMatch) {
+        return { type: 'architect', projectBasename: architectMatch[1], roleId: null };
+    }
+    // builder-{basename}-{specId} — specId is always the last segment (digits like "0001")
+    const builderMatch = name.match(/^builder-(.+)-(\d{4,})$/);
+    if (builderMatch) {
+        return { type: 'builder', projectBasename: builderMatch[1], roleId: builderMatch[2] };
+    }
+    // shell-{basename}-{shellId} — shellId is "shell-N" (last two segments)
+    const shellMatch = name.match(/^shell-(.+)-(shell-\d+)$/);
+    if (shellMatch) {
+        return { type: 'shell', projectBasename: shellMatch[1], roleId: shellMatch[2] };
+    }
+    return null;
+}
+/**
+ * List all tmux sessions that match codev naming conventions.
+ * Returns an array of { tmuxName, parsed } for each matching session.
+ */
+// Cache for listCodevTmuxSessions — avoid shelling out on every dashboard poll
+let _tmuxListCache = [];
+let _tmuxListCacheTime = 0;
+const TMUX_LIST_CACHE_TTL = 10_000; // 10 seconds
+function listCodevTmuxSessions(bypassCache = false) {
+    if (!tmuxAvailable)
+        return [];
+    const now = Date.now();
+    if (!bypassCache && now - _tmuxListCacheTime < TMUX_LIST_CACHE_TTL) {
+        return _tmuxListCache;
+    }
     try {
-        sessions = db.prepare('SELECT * FROM terminal_sessions').all();
+        const result = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', { encoding: 'utf-8' });
+        const sessions = result.trim().split('\n').filter(Boolean);
+        const codevSessions = [];
+        for (const name of sessions) {
+            const parsed = parseTmuxSessionName(name);
+            if (parsed) {
+                codevSessions.push({ tmuxName: name, parsed });
+            }
+        }
+        _tmuxListCache = codevSessions;
+        _tmuxListCacheTime = now;
+        return codevSessions;
     }
-    catch (err) {
-        log('WARN', `Failed to read terminal sessions for reconciliation: ${err.message}`);
-        return;
+    catch {
+        _tmuxListCache = [];
+        _tmuxListCacheTime = now;
+        return [];
     }
-    if (sessions.length === 0) {
-        log('INFO', 'No terminal sessions to reconcile');
-        return;
+}
+/**
+ * Find the SQLite row that matches a given tmux session name.
+ * Looks up by tmux_session column directly.
+ */
+function findSqliteRowForTmuxSession(tmuxName) {
+    try {
+        const db = getGlobalDb();
+        return db.prepare('SELECT * FROM terminal_sessions WHERE tmux_session = ?').get(tmuxName) || null;
     }
-    log('INFO', `Reconciling ${sessions.length} terminal sessions from previous run...`);
+    catch {
+        return null;
+    }
+}
+/**
+ * Find the full project path for a tmux session's project basename.
+ * Checks active port allocations (which have full paths) for a matching basename.
+ * Returns null if no match found.
+ */
+function resolveProjectPathFromBasename(projectBasename) {
+    const allocations = loadPortAllocations();
+    for (const alloc of allocations) {
+        if (path.basename(alloc.project_path) === projectBasename) {
+            return normalizeProjectPath(alloc.project_path);
+        }
+    }
+    // Also check projectTerminals cache (may have entries not yet in allocations)
+    for (const [projectPath] of projectTerminals) {
+        if (path.basename(projectPath) === projectBasename) {
+            return projectPath;
+        }
+    }
+    return null;
+}
+/**
+ * Reconcile terminal sessions on startup.
+ *
+ * STRATEGY: tmux is the source of truth for existence.
+ *
+ * Phase 1 — tmux-first discovery:
+ *   List all codev tmux sessions. For each, look up SQLite for metadata.
+ *   If SQLite has a matching row → reconnect with full metadata.
+ *   If SQLite has no row (orphaned tmux) → derive metadata from session name, reconnect.
+ *
+ * Phase 2 — SQLite sweep:
+ *   Any SQLite rows not matched to a tmux session are stale → clean up.
+ *   (Also kills orphaned processes that have no tmux backing.)
+ */
+async function reconcileTerminalSessions() {
     const manager = getTerminalManager();
+    const db = getGlobalDb();
+    // Phase 1: Discover living tmux sessions (bypass cache on startup)
+    const liveTmuxSessions = listCodevTmuxSessions(/* bypassCache */ true);
+    // Track which SQLite rows we matched (by tmux_session name)
+    const matchedTmuxNames = new Set();
     let reconnected = 0;
-    let killed = 0;
-    let cleaned = 0;
-    for (const session of sessions) {
-        // Can we reconnect to a surviving tmux session?
-        if (session.tmux_session && tmuxAvailable && tmuxSessionExists(session.tmux_session)) {
-            try {
-                // Create new node-pty that attaches to the surviving tmux session
-                const newSession = await manager.createSession({
-                    command: 'tmux',
-                    args: ['attach-session', '-t', session.tmux_session],
-                    cwd: session.project_path,
-                    label: session.type === 'architect' ? 'Architect' : `${session.type} ${session.role_id || session.id}`,
-                });
-                // Register in projectTerminals Map
-                const entry = getProjectTerminalsEntry(session.project_path);
-                if (session.type === 'architect') {
-                    entry.architect = newSession.id;
-                }
-                else if (session.type === 'builder') {
-                    const builderId = session.role_id || session.id;
-                    entry.builders.set(builderId, newSession.id);
-                }
-                else if (session.type === 'shell') {
-                    const shellId = session.role_id || session.id;
-                    entry.shells.set(shellId, newSession.id);
-                }
-                // Update SQLite: delete old row, insert new with new terminal ID
-                db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(session.id);
-                saveTerminalSession(newSession.id, session.project_path, session.type, session.role_id, newSession.pid, session.tmux_session);
-                log('INFO', `Reconnected to tmux session "${session.tmux_session}" → terminal ${newSession.id} (${session.type} for ${path.basename(session.project_path)})`);
+    let orphanReconnected = 0;
+    if (liveTmuxSessions.length > 0) {
+        log('INFO', `Found ${liveTmuxSessions.length} live codev tmux session(s) — reconnecting...`);
+    }
+    for (const { tmuxName, parsed } of liveTmuxSessions) {
+        // Look up SQLite for this tmux session's metadata
+        const dbRow = findSqliteRowForTmuxSession(tmuxName);
+        matchedTmuxNames.add(tmuxName);
+        // Determine metadata — prefer SQLite, fall back to parsed name
+        const projectPath = dbRow?.project_path || resolveProjectPathFromBasename(parsed.projectBasename);
+        const type = dbRow?.type || parsed.type;
+        const roleId = dbRow?.role_id || parsed.roleId;
+        if (!projectPath) {
+            log('WARN', `Cannot resolve project path for tmux session "${tmuxName}" (basename: ${parsed.projectBasename}) — skipping`);
+            continue;
+        }
+        try {
+            const label = type === 'architect' ? 'Architect' : `${type} ${roleId || 'unknown'}`;
+            const newSession = await manager.createSession({
+                command: 'tmux',
+                args: ['attach-session', '-t', tmuxName],
+                cwd: projectPath,
+                label,
+            });
+            // Register in projectTerminals Map
+            const entry = getProjectTerminalsEntry(projectPath);
+            if (type === 'architect') {
+                entry.architect = newSession.id;
+            }
+            else if (type === 'builder') {
+                entry.builders.set(roleId || tmuxName, newSession.id);
+            }
+            else if (type === 'shell') {
+                entry.shells.set(roleId || tmuxName, newSession.id);
+            }
+            // Update SQLite: delete old row (if any), insert fresh one
+            if (dbRow) {
+                db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(dbRow.id);
+            }
+            saveTerminalSession(newSession.id, projectPath, type, roleId, newSession.pid, tmuxName);
+            if (dbRow) {
+                log('INFO', `Reconnected tmux "${tmuxName}" → terminal ${newSession.id} (${type} for ${path.basename(projectPath)})`);
                 reconnected++;
-                continue;
             }
-            catch (err) {
-                log('WARN', `Failed to reconnect to tmux session "${session.tmux_session}": ${err.message}`);
-                // Fall through to cleanup
-                killTmuxSession(session.tmux_session);
-                killed++;
+            else {
+                log('INFO', `Recovered orphaned tmux "${tmuxName}" → terminal ${newSession.id} (${type} for ${path.basename(projectPath)}) [no SQLite row]`);
+                orphanReconnected++;
             }
         }
-        // No tmux or tmux session dead — check for orphaned processes
-        else if (session.tmux_session && tmuxSessionExists(session.tmux_session)) {
-            // tmux exists but tmuxAvailable is false (shouldn't happen, but be safe)
-            killTmuxSession(session.tmux_session);
-            killed++;
+        catch (err) {
+            log('WARN', `Failed to reconnect to tmux "${tmuxName}": ${err.message}`);
         }
-        else if (session.pid && processExists(session.pid)) {
-            log('INFO', `Found orphaned process: PID ${session.pid} (${session.type} for ${path.basename(session.project_path)})`);
+    }
+    // Phase 2: Sweep stale SQLite rows (those with no matching live tmux session)
+    let killed = 0;
+    let cleaned = 0;
+    let allDbSessions;
+    try {
+        allDbSessions = db.prepare('SELECT * FROM terminal_sessions').all();
+    }
+    catch (err) {
+        log('WARN', `Failed to read terminal sessions for sweep: ${err.message}`);
+        allDbSessions = [];
+    }
+    for (const session of allDbSessions) {
+        // Skip rows that were already reconnected in Phase 1
+        if (session.tmux_session && matchedTmuxNames.has(session.tmux_session)) {
+            continue;
+        }
+        // Also skip rows whose terminal is still alive in PtyManager
+        // (non-tmux sessions created during this Tower run)
+        const existing = manager.getSession(session.id);
+        if (existing && existing.status !== 'exited') {
+            continue;
+        }
+        // Stale row — kill orphaned process if any, then delete
+        if (session.pid && processExists(session.pid)) {
+            log('INFO', `Killing orphaned process: PID ${session.pid} (${session.type} for ${path.basename(session.project_path)})`);
             try {
                 process.kill(session.pid, 'SIGTERM');
                 killed++;
             }
             catch {
-                // Process may not be killable (different user, etc)
+                // Process may not be killable
             }
         }
-        // Clean up the DB row for sessions we couldn't reconnect
         db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(session.id);
         cleaned++;
     }
-    log('INFO', `Reconciliation complete: ${reconnected} reconnected, ${killed} orphaned killed, ${cleaned} cleaned up`);
+    const total = reconnected + orphanReconnected;
+    if (total > 0 || killed > 0 || cleaned > 0) {
+        log('INFO', `Reconciliation complete: ${reconnected} reconnected, ${orphanReconnected} orphan-recovered, ${killed} killed, ${cleaned} stale rows cleaned`);
+    }
+    else {
+        log('INFO', 'No terminal sessions to reconcile');
+    }
 }
 /**
  * Get terminal sessions from SQLite for a project.
@@ -719,7 +861,7 @@ async function getGateStatusForProject(basePort) {
 async function getTerminalsForProject(projectPath, proxyUrl) {
     const manager = getTerminalManager();
     const terminals = [];
-    // SQLite is authoritative - query it first (Spec 0090 requirement)
+    // Query SQLite first, then augment with tmux discovery
     const dbSessions = getTerminalSessionsForProject(projectPath);
     // Use normalized path for cache consistency
     const normalizedPath = normalizeProjectPath(projectPath);
@@ -736,22 +878,23 @@ async function getTerminalsForProject(projectPath, proxyUrl) {
     for (const dbSession of dbSessions) {
         // Verify session still exists in TerminalManager (runtime state)
         let session = manager.getSession(dbSession.id);
-        if (!session && dbSession.tmux_session && tmuxAvailable && tmuxSessionExists(dbSession.tmux_session)) {
+        const sanitizedTmux = dbSession.tmux_session ? sanitizeTmuxSessionName(dbSession.tmux_session) : null;
+        if (!session && sanitizedTmux && tmuxAvailable && tmuxSessionExists(sanitizedTmux)) {
             // PTY session gone but tmux session survives — reconnect on-the-fly
             try {
                 const newSession = await manager.createSession({
                     command: 'tmux',
-                    args: ['attach-session', '-t', dbSession.tmux_session],
+                    args: ['attach-session', '-t', sanitizedTmux],
                     cwd: dbSession.project_path,
                     label: dbSession.type === 'architect' ? 'Architect' : `${dbSession.type} ${dbSession.role_id || dbSession.id}`,
                     env: process.env,
                 });
-                // Update SQLite with new terminal ID
+                // Update SQLite with new terminal ID (use sanitized tmux name)
                 deleteTerminalSession(dbSession.id);
-                saveTerminalSession(newSession.id, dbSession.project_path, dbSession.type, dbSession.role_id, newSession.pid, dbSession.tmux_session);
+                saveTerminalSession(newSession.id, dbSession.project_path, dbSession.type, dbSession.role_id, newSession.pid, sanitizedTmux);
                 dbSession.id = newSession.id;
                 session = manager.getSession(newSession.id);
-                log('INFO', `Reconnected to tmux "${dbSession.tmux_session}" on-the-fly → ${newSession.id}`);
+                log('INFO', `Reconnected to tmux "${sanitizedTmux}" on-the-fly → ${newSession.id}`);
             }
             catch (err) {
                 log('WARN', `Failed to reconnect to tmux "${dbSession.tmux_session}": ${err.message} — will retry on next poll`);
@@ -843,6 +986,52 @@ async function getTerminalsForProject(projectPath, proxyUrl) {
             }
         }
     }
+    // Phase 3: tmux discovery — find tmux sessions for this project that are
+    // missing from both SQLite and the in-memory cache.
+    // This is the safety net: if SQLite rows got deleted but tmux survived,
+    // the session will still appear in the dashboard.
+    const projectBasename = sanitizeTmuxSessionName(path.basename(normalizedPath));
+    const liveTmux = listCodevTmuxSessions();
+    for (const { tmuxName, parsed } of liveTmux) {
+        // Only process sessions whose sanitized project basename matches
+        if (parsed.projectBasename !== projectBasename)
+            continue;
+        // Skip if we already have this session registered (from SQLite or in-memory)
+        const alreadyRegistered = (parsed.type === 'architect' && freshEntry.architect) ||
+            (parsed.type === 'builder' && parsed.roleId && freshEntry.builders.has(parsed.roleId)) ||
+            (parsed.type === 'shell' && parsed.roleId && freshEntry.shells.has(parsed.roleId));
+        if (alreadyRegistered)
+            continue;
+        // Orphaned tmux session — reconnect it
+        try {
+            const label = parsed.type === 'architect' ? 'Architect' : `${parsed.type} ${parsed.roleId || 'unknown'}`;
+            const newSession = await manager.createSession({
+                command: 'tmux',
+                args: ['attach-session', '-t', tmuxName],
+                cwd: normalizedPath,
+                label,
+            });
+            const roleId = parsed.roleId;
+            if (parsed.type === 'architect') {
+                freshEntry.architect = newSession.id;
+                terminals.push({ type: 'architect', id: 'architect', label: 'Architect', url: `${proxyUrl}?tab=architect`, active: true });
+            }
+            else if (parsed.type === 'builder' && roleId) {
+                freshEntry.builders.set(roleId, newSession.id);
+                terminals.push({ type: 'builder', id: roleId, label: `Builder ${roleId}`, url: `${proxyUrl}?tab=builder-${roleId}`, active: true });
+            }
+            else if (parsed.type === 'shell' && roleId) {
+                freshEntry.shells.set(roleId, newSession.id);
+                terminals.push({ type: 'shell', id: roleId, label: `Shell ${roleId.replace('shell-', '')}`, url: `${proxyUrl}?tab=shell-${roleId}`, active: true });
+            }
+            // Persist to SQLite so future polls find it directly
+            saveTerminalSession(newSession.id, normalizedPath, parsed.type, roleId, newSession.pid, tmuxName);
+            log('INFO', `[tmux-discovery] Recovered orphaned tmux "${tmuxName}" → ${newSession.id} (${parsed.type})`);
+        }
+        catch (err) {
+            log('WARN', `[tmux-discovery] Failed to recover tmux "${tmuxName}": ${err.message}`);
+        }
+    }
     // Atomically replace the cache entry
     projectTerminals.set(normalizedPath, freshEntry);
     // Gate status - builders don't have gate tracking yet in tower
@@ -943,6 +1132,10 @@ async function getDirectorySuggestions(inputPath) {
     if (inputPath.startsWith('~')) {
         inputPath = inputPath.replace('~', homedir());
     }
+    // Relative paths are meaningless for the tower daemon — only absolute paths
+    if (!path.isAbsolute(inputPath)) {
+        return [];
+    }
     // Determine the directory to list and the prefix to filter by
     let dirToList;
     let prefix;
@@ -1088,12 +1281,12 @@ async function launchInstance(projectPath) {
                 const tmuxName = `architect-${path.basename(projectPath)}`;
                 let activeTmuxSession = null;
                 if (tmuxAvailable) {
-                    const tmuxCreated = createTmuxSession(tmuxName, cmd, cmdArgs, projectPath, 200, 50);
-                    if (tmuxCreated) {
+                    const sanitizedName = createTmuxSession(tmuxName, cmd, cmdArgs, projectPath, 200, 50);
+                    if (sanitizedName) {
                         cmd = 'tmux';
-                        cmdArgs = ['attach-session', '-t', tmuxName];
-                        activeTmuxSession = tmuxName;
-                        log('INFO', `Created tmux session "${tmuxName}" for architect`);
+                        cmdArgs = ['attach-session', '-t', sanitizedName];
+                        activeTmuxSession = sanitizedName;
+                        log('INFO', `Created tmux session "${sanitizedName}" for architect`);
                     }
                 }
                 const session = await manager.createSession({
@@ -1433,13 +1626,13 @@ const server = http.createServer(async (req, res) => {
                 const tmuxSession = typeof body.tmuxSession === 'string' ? body.tmuxSession : null;
                 let activeTmuxSession = null;
                 if (tmuxSession && tmuxAvailable && command && cwd) {
-                    const tmuxCreated = createTmuxSession(tmuxSession, command, args || [], cwd, cols || 200, rows || 50);
-                    if (tmuxCreated) {
-                        // Override: node-pty attaches to the tmux session
+                    const sanitizedName = createTmuxSession(tmuxSession, command, args || [], cwd, cols || 200, rows || 50);
+                    if (sanitizedName) {
+                        // Override: node-pty attaches to the tmux session (use sanitized name)
                         command = 'tmux';
-                        args = ['attach-session', '-t', tmuxSession];
-                        activeTmuxSession = tmuxSession;
-                        log('INFO', `Created tmux session "${tmuxSession}" for terminal`);
+                        args = ['attach-session', '-t', sanitizedName];
+                        activeTmuxSession = sanitizedName;
+                        log('INFO', `Created tmux session "${sanitizedName}" for terminal`);
                     }
                     // If tmux creation failed, fall through to bare node-pty
                 }
@@ -1699,12 +1892,27 @@ const server = http.createServer(async (req, res) => {
         // API: Launch new instance
         if (req.method === 'POST' && url.pathname === '/api/launch') {
             const body = await parseJsonBody(req);
-            const projectPath = body.projectPath;
+            let projectPath = body.projectPath;
             if (!projectPath) {
                 res.writeHead(400, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ success: false, error: 'Missing projectPath' }));
                 return;
             }
+            // Expand ~ to home directory
+            if (projectPath.startsWith('~')) {
+                projectPath = projectPath.replace('~', homedir());
+            }
+            // Reject relative paths — tower daemon CWD is unpredictable
+            if (!path.isAbsolute(projectPath)) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    success: false,
+                    error: `Relative paths are not supported. Use an absolute path (e.g., /Users/.../project or ~/Development/project).`,
+                }));
+                return;
+            }
+            // Normalize path (resolve .. segments, trailing slashes)
+            projectPath = path.resolve(projectPath);
             const result = await launchInstance(projectPath);
             res.writeHead(result.success ? 200 : 400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(result));
@@ -1854,6 +2062,12 @@ const server = http.createServer(async (req, res) => {
                 const apiPath = subPath.replace(/^api\/?/, '');
                 // GET /api/state - Return project state (architect, builders, shells)
                 if (req.method === 'GET' && (apiPath === 'state' || apiPath === '')) {
+                    // Refresh cache via getTerminalsForProject (handles SQLite sync,
+                    // tmux reconnection, and tmux discovery in one place)
+                    const encodedPath = Buffer.from(projectPath).toString('base64url');
+                    const proxyUrl = `/project/${encodedPath}/`;
+                    await getTerminalsForProject(projectPath, proxyUrl);
+                    // Now read from the refreshed cache
                     const entry = getProjectTerminalsEntry(projectPath);
                     const manager = getTerminalManager();
                     // Build state response compatible with React dashboard
@@ -1867,53 +2081,45 @@ const server = http.createServer(async (req, res) => {
                     // Add architect if exists
                     if (entry.architect) {
                         const session = manager.getSession(entry.architect);
-                        state.architect = {
-                            port: basePort || 0,
-                            pid: session?.pid || 0,
-                            terminalId: entry.architect,
-                        };
+                        if (session) {
+                            state.architect = {
+                                port: basePort || 0,
+                                pid: session.pid || 0,
+                                terminalId: entry.architect,
+                            };
+                        }
                     }
-                    // Add shells (skip stale entries whose terminal session is gone or exited)
-                    const staleShellIds = [];
+                    // Add shells from refreshed cache
                     for (const [shellId, terminalId] of entry.shells) {
                         const session = manager.getSession(terminalId);
-                        if (!session || session.status === 'exited') {
-                            staleShellIds.push(shellId);
-                            continue;
+                        if (session) {
+                            state.utils.push({
+                                id: shellId,
+                                name: `Shell ${shellId.replace('shell-', '')}`,
+                                port: basePort || 0,
+                                pid: session.pid || 0,
+                                terminalId,
+                            });
                         }
-                        state.utils.push({
-                            id: shellId,
-                            name: `Shell ${shellId.replace('shell-', '')}`,
-                            port: basePort || 0,
-                            pid: session?.pid || 0,
-                            terminalId,
-                        });
                     }
-                    for (const id of staleShellIds)
-                        entry.shells.delete(id);
-                    // Add builders (skip stale entries whose terminal session is gone or exited)
-                    const staleBuilderIds = [];
+                    // Add builders from refreshed cache
                     for (const [builderId, terminalId] of entry.builders) {
                         const session = manager.getSession(terminalId);
-                        if (!session || session.status === 'exited') {
-                            staleBuilderIds.push(builderId);
-                            continue;
+                        if (session) {
+                            state.builders.push({
+                                id: builderId,
+                                name: `Builder ${builderId}`,
+                                port: basePort || 0,
+                                pid: session.pid || 0,
+                                status: 'running',
+                                phase: '',
+                                worktree: '',
+                                branch: '',
+                                type: 'spec',
+                                terminalId,
+                            });
                         }
-                        state.builders.push({
-                            id: builderId,
-                            name: `Builder ${builderId}`,
-                            port: basePort || 0,
-                            pid: session?.pid || 0,
-                            status: 'running',
-                            phase: '',
-                            worktree: '',
-                            branch: '',
-                            type: 'spec',
-                            terminalId,
-                        });
                     }
-                    for (const id of staleBuilderIds)
-                        entry.builders.delete(id);
                     // Add file tabs (Spec 0092 - served through Tower, no separate ports)
                     for (const [tabId, tab] of entry.fileTabs) {
                         state.annotations.push({
@@ -1938,11 +2144,11 @@ const server = http.createServer(async (req, res) => {
                         const tmuxName = `shell-${path.basename(projectPath)}-${shellId}`;
                         let activeTmuxSession = null;
                         if (tmuxAvailable) {
-                            const tmuxCreated = createTmuxSession(tmuxName, shellCmd, shellArgs, projectPath, 200, 50);
-                            if (tmuxCreated) {
+                            const sanitizedName = createTmuxSession(tmuxName, shellCmd, shellArgs, projectPath, 200, 50);
+                            if (sanitizedName) {
                                 shellCmd = 'tmux';
-                                shellArgs = ['attach-session', '-t', tmuxName];
-                                activeTmuxSession = tmuxName;
+                                shellArgs = ['attach-session', '-t', sanitizedName];
+                                activeTmuxSession = sanitizedName;
                             }
                         }
                         // Create terminal session