@cluesmith/codev 2.0.2 → 2.0.6

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

@@ -3,31 +3,25 @@
  * Spec 0105: Tower Server Decomposition — Phase 4
  *
  * Contains: terminal session CRUD, file tab persistence, shell ID allocation,
- * terminal reconciliation, gate watcher, and terminal list assembly.
+ * terminal reconciliation, and terminal list assembly.
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
 import { getGlobalDb } from '../db/index.js';
-import { getGateStatusForProject } from '../utils/gate-status.js';
-import { GateWatcher } from '../utils/gate-watcher.js';
-import { saveFileTab as saveFileTabToDb, deleteFileTab as deleteFileTabFromDb, loadFileTabsForProject as loadFileTabsFromDb, } from '../utils/file-tabs.js';
+import { saveFileTab as saveFileTabToDb, deleteFileTab as deleteFileTabFromDb, loadFileTabsForWorkspace as loadFileTabsFromDb, } from '../utils/file-tabs.js';
 import { TerminalManager } from '../../terminal/pty-manager.js';
-import { normalizeProjectPath, buildArchitectArgs } from './tower-utils.js';
+import { normalizeWorkspacePath, buildArchitectArgs } from './tower-utils.js';
 // ============================================================================
 // Module-private state (lifecycle driven by orchestrator)
 // ============================================================================
 let _deps = null;
-/** Project terminal registry — tracks which terminals belong to which project */
-const projectTerminals = new Map();
+/** Workspace terminal registry — tracks which terminals belong to which workspace */
+const workspaceTerminals = new Map();
 /** Global TerminalManager instance (lazy singleton) */
 let terminalManager = null;
-/** Gate watcher state */
-const gateWatcher = new GateWatcher((...args) => {
-    if (_deps)
-        _deps.log(...args);
-});
-let gateWatcherInterval = null;
+/** True while reconcileTerminalSessions() is running — blocks on-the-fly reconnection (Bugfix #274) */
+let _reconciling = false;
 // ============================================================================
 // Lifecycle
 // ============================================================================
@@ -35,12 +29,12 @@ let gateWatcherInterval = null;
 export function initTerminals(deps) {
     _deps = deps;
 }
+/** Check if reconciliation is currently in progress (Bugfix #274) */
+export function isReconciling() {
+    return _reconciling;
+}
 /** Tear down the terminal module */
 export function shutdownTerminals() {
-    if (gateWatcherInterval) {
-        clearInterval(gateWatcherInterval);
-        gateWatcherInterval = null;
-    }
     if (terminalManager) {
         terminalManager.shutdown();
         terminalManager = null;
@@ -50,19 +44,19 @@ export function shutdownTerminals() {
 // ============================================================================
 // Accessors for shared state
 // ============================================================================
-/** Get the project terminals registry (returns the Map reference) */
-export function getProjectTerminals() {
-    return projectTerminals;
+/** Get the workspace terminals registry (returns the Map reference) */
+export function getWorkspaceTerminals() {
+    return workspaceTerminals;
 }
 /**
  * Get or create the global TerminalManager instance.
- * Uses a temporary directory as projectRoot since terminals can be for any project.
+ * Uses a temporary directory as workspaceRoot since terminals can be for any workspace.
  */
 export function getTerminalManager() {
     if (!terminalManager) {
-        const projectRoot = process.env.HOME || '/tmp';
+        const workspaceRoot = process.env.HOME || '/tmp';
         terminalManager = new TerminalManager({
-            projectRoot,
+            workspaceRoot: workspaceRoot,
             logDir: path.join(homedir(), '.agent-farm', 'logs'),
             maxSessions: 100,
             ringBufferLines: 10000,
@@ -77,15 +71,15 @@ export function getTerminalManager() {
 // Terminal session CRUD
 // ============================================================================
 /**
- * Get or create project terminal registry entry.
- * On first access for a project, hydrates file tabs from SQLite so
+ * Get or create workspace terminal registry entry.
+ * On first access for a workspace, hydrates file tabs from SQLite so
  * persisted tabs are available immediately (not just after /api/state).
  */
-export function getProjectTerminalsEntry(projectPath) {
-    let entry = projectTerminals.get(projectPath);
+export function getWorkspaceTerminalsEntry(workspacePath) {
+    let entry = workspaceTerminals.get(workspacePath);
     if (!entry) {
-        entry = { builders: new Map(), shells: new Map(), fileTabs: loadFileTabsForProject(projectPath) };
-        projectTerminals.set(projectPath, entry);
+        entry = { builders: new Map(), shells: new Map(), fileTabs: loadFileTabsForWorkspace(workspacePath) };
+        workspaceTerminals.set(workspacePath, entry);
     }
     // Migration: ensure fileTabs exists for older entries
     if (!entry.fileTabs) {
@@ -94,10 +88,10 @@ export function getProjectTerminalsEntry(projectPath) {
     return entry;
 }
 /**
- * Generate next shell ID for a project
+ * Generate next shell ID for a workspace
  */
-export function getNextShellId(projectPath) {
-    const entry = getProjectTerminalsEntry(projectPath);
+export function getNextShellId(workspacePath) {
+    const entry = getWorkspaceTerminalsEntry(workspacePath);
     let maxId = 0;
     for (const id of entry.shells.keys()) {
         const num = parseInt(id.replace('shell-', ''), 10);
@@ -108,20 +102,20 @@ export function getNextShellId(projectPath) {
 }
 /**
  * Save a terminal session to SQLite.
- * Guards against race conditions by checking if project is still active.
+ * Guards against race conditions by checking if workspace is still active.
  */
-export function saveTerminalSession(terminalId, projectPath, type, roleId, pid, shellperSocket = null, shellperPid = null, shellperStartTime = null) {
+export function saveTerminalSession(terminalId, workspacePath, type, roleId, pid, shellperSocket = null, shellperPid = null, shellperStartTime = null) {
     try {
-        const normalizedPath = normalizeProjectPath(projectPath);
-        // Race condition guard: only save if project is still in the active registry
+        const normalizedPath = normalizeWorkspacePath(workspacePath);
+        // Race condition guard: only save if workspace is still in the active registry
         // This prevents zombie rows when stop races with session creation
-        if (!projectTerminals.has(normalizedPath) && !projectTerminals.has(projectPath)) {
-            _deps?.log('INFO', `Skipping session save - project no longer active: ${projectPath}`);
+        if (!workspaceTerminals.has(normalizedPath) && !workspaceTerminals.has(workspacePath)) {
+            _deps?.log('INFO', `Skipping session save - workspace no longer active: ${workspacePath}`);
             return;
         }
         const db = getGlobalDb();
         db.prepare(`
-      INSERT OR REPLACE INTO terminal_sessions (id, project_path, type, role_id, pid, shellper_socket, shellper_pid, shellper_start_time)
+      INSERT OR REPLACE INTO terminal_sessions (id, workspace_path, type, role_id, pid, shellper_socket, shellper_pid, shellper_start_time)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `).run(terminalId, normalizedPath, type, roleId, pid, shellperSocket, shellperPid, shellperStartTime);
         _deps?.log('INFO', `Saved terminal session to SQLite: ${terminalId} (${type}) for ${path.basename(normalizedPath)}`);
@@ -150,32 +144,59 @@ export function deleteTerminalSession(terminalId) {
     }
 }
 /**
- * Delete all terminal sessions for a project from SQLite.
+ * Remove a terminal from the in-memory workspace registry.
+ * Scans all workspaces to find and remove the terminal by its ID.
+ * This is needed when a single terminal is killed (e.g. af cleanup)
+ * to keep the in-memory state consistent with SQLite.
+ * Bugfix #290: af cleanup didn't remove terminals from in-memory registry.
+ */
+export function removeTerminalFromRegistry(terminalId) {
+    for (const [, entry] of workspaceTerminals) {
+        if (entry.architect === terminalId) {
+            entry.architect = undefined;
+            return;
+        }
+        for (const [builderId, tid] of entry.builders) {
+            if (tid === terminalId) {
+                entry.builders.delete(builderId);
+                return;
+            }
+        }
+        for (const [shellId, tid] of entry.shells) {
+            if (tid === terminalId) {
+                entry.shells.delete(shellId);
+                return;
+            }
+        }
+    }
+}
+/**
+ * Delete all terminal sessions for a workspace from SQLite.
  * Normalizes path to ensure consistent cleanup regardless of how path was provided.
  */
-export function deleteProjectTerminalSessions(projectPath) {
+export function deleteWorkspaceTerminalSessions(workspacePath) {
     try {
-        const normalizedPath = normalizeProjectPath(projectPath);
+        const normalizedPath = normalizeWorkspacePath(workspacePath);
         const db = getGlobalDb();
         // Delete both normalized and raw path to handle any inconsistencies
-        db.prepare('DELETE FROM terminal_sessions WHERE project_path = ?').run(normalizedPath);
-        if (normalizedPath !== projectPath) {
-            db.prepare('DELETE FROM terminal_sessions WHERE project_path = ?').run(projectPath);
+        db.prepare('DELETE FROM terminal_sessions WHERE workspace_path = ?').run(normalizedPath);
+        if (normalizedPath !== workspacePath) {
+            db.prepare('DELETE FROM terminal_sessions WHERE workspace_path = ?').run(workspacePath);
         }
     }
     catch (err) {
-        _deps?.log('WARN', `Failed to delete project terminal sessions: ${err.message}`);
+        _deps?.log('WARN', `Failed to delete workspace terminal sessions: ${err.message}`);
     }
 }
 /**
- * Get terminal sessions from SQLite for a project.
+ * Get terminal sessions from SQLite for a workspace.
  * Normalizes path for consistent lookup.
  */
-export function getTerminalSessionsForProject(projectPath) {
+export function getTerminalSessionsForWorkspace(workspacePath) {
     try {
-        const normalizedPath = normalizeProjectPath(projectPath);
+        const normalizedPath = normalizeWorkspacePath(workspacePath);
         const db = getGlobalDb();
-        return db.prepare('SELECT * FROM terminal_sessions WHERE project_path = ?').all(normalizedPath);
+        return db.prepare('SELECT * FROM terminal_sessions WHERE workspace_path = ?').all(normalizedPath);
     }
     catch {
         return [];
@@ -188,9 +209,9 @@ export function getTerminalSessionsForProject(projectPath) {
  * Save a file tab to SQLite for persistence across Tower restarts.
  * Thin wrapper around utils/file-tabs.ts with error handling and path normalization.
  */
-export function saveFileTab(id, projectPath, filePath, createdAt) {
+export function saveFileTab(id, workspacePath, filePath, createdAt) {
     try {
-        const normalizedPath = normalizeProjectPath(projectPath);
+        const normalizedPath = normalizeWorkspacePath(workspacePath);
         saveFileTabToDb(getGlobalDb(), id, normalizedPath, filePath, createdAt);
     }
     catch (err) {
@@ -210,12 +231,12 @@ export function deleteFileTab(id) {
     }
 }
 /**
- * Load file tabs for a project from SQLite.
+ * Load file tabs for a workspace from SQLite.
  * Thin wrapper around utils/file-tabs.ts with error handling and path normalization.
  */
-export function loadFileTabsForProject(projectPath) {
+export function loadFileTabsForWorkspace(workspacePath) {
     try {
-        const normalizedPath = normalizeProjectPath(projectPath);
+        const normalizedPath = normalizeWorkspacePath(workspacePath);
         return loadFileTabsFromDb(getGlobalDb(), normalizedPath);
     }
     catch (err) {
@@ -260,6 +281,17 @@ export function processExists(pid) {
 export async function reconcileTerminalSessions() {
     if (!_deps)
         return;
+    _reconciling = true;
+    try {
+        await _reconcileTerminalSessionsInner();
+    }
+    finally {
+        _reconciling = false;
+    }
+}
+async function _reconcileTerminalSessionsInner() {
+    if (!_deps)
+        return; // Redundant guard for TypeScript narrowing
     const manager = getTerminalManager();
     const db = getGlobalDb();
     let shellperReconnected = 0;
@@ -281,12 +313,12 @@ export async function reconcileTerminalSessions() {
     if (shellperSessions.length > 0) {
         _deps.log('INFO', `Found ${shellperSessions.length} shellper session(s) in SQLite — reconnecting...`);
     }
+    const probeTasks = [];
     for (const dbSession of shellperSessions) {
-        const projectPath = dbSession.project_path;
-        // Skip sessions whose project path doesn't exist or is in temp directory
-        if (!fs.existsSync(projectPath)) {
-            _deps.log('INFO', `Skipping shellper session ${dbSession.id} — project path no longer exists: ${projectPath}`);
-            // Kill orphaned shellper process before removing row
+        const workspacePath = dbSession.workspace_path;
+        // Skip sessions whose workspace path doesn't exist or is in temp directory
+        if (!fs.existsSync(workspacePath)) {
+            _deps.log('INFO', `Skipping shellper session ${dbSession.id} — workspace path no longer exists: ${workspacePath}`);
             if (dbSession.shellper_pid && processExists(dbSession.shellper_pid)) {
                 try {
                     process.kill(dbSession.shellper_pid, 'SIGTERM');
@@ -299,9 +331,8 @@ export async function reconcileTerminalSessions() {
             continue;
         }
         const tmpDirs = ['/tmp', '/private/tmp', '/var/folders', '/private/var/folders'];
-        if (tmpDirs.some(d => projectPath === d || projectPath.startsWith(d + '/'))) {
-            _deps.log('INFO', `Skipping shellper session ${dbSession.id} — project is in temp directory: ${projectPath}`);
-            // Kill orphaned shellper process before removing row
+        if (tmpDirs.some(d => workspacePath === d || workspacePath.startsWith(d + '/'))) {
+            _deps.log('INFO', `Skipping shellper session ${dbSession.id} — workspace is in temp directory: ${workspacePath}`);
             if (dbSession.shellper_pid && processExists(dbSession.shellper_pid)) {
                 try {
                     process.kill(dbSession.shellper_pid, 'SIGTERM');
@@ -317,78 +348,98 @@ export async function reconcileTerminalSessions() {
             _deps.log('WARN', `Shellper manager not initialized — cannot reconnect ${dbSession.id}`);
             continue;
         }
-        try {
-            // For architect sessions, restore auto-restart behavior after reconnection
-            let restartOptions;
-            if (dbSession.type === 'architect') {
-                let architectCmd = 'claude';
-                const configPath = path.join(projectPath, 'af-config.json');
-                if (fs.existsSync(configPath)) {
-                    try {
-                        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                        if (config.shell?.architect) {
-                            architectCmd = config.shell.architect;
-                        }
+        // Build restart options for architect sessions (synchronous, no I/O)
+        let restartOptions;
+        if (dbSession.type === 'architect') {
+            let architectCmd = 'claude';
+            const configPath = path.join(workspacePath, 'af-config.json');
+            if (fs.existsSync(configPath)) {
+                try {
+                    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                    if (config.shell?.architect) {
+                        architectCmd = config.shell.architect;
                     }
-                    catch { /* use default */ }
                 }
-                const cmdParts = architectCmd.split(/\s+/);
-                const cleanEnv = { ...process.env };
-                delete cleanEnv['CLAUDECODE'];
-                restartOptions = {
-                    command: cmdParts[0],
-                    args: buildArchitectArgs(cmdParts.slice(1), projectPath),
-                    cwd: projectPath,
-                    env: cleanEnv,
-                    restartDelay: 2000,
-                    maxRestarts: 50,
-                };
+                catch { /* use default */ }
             }
-            const client = await _deps.shellperManager.reconnectSession(dbSession.id, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time, restartOptions);
-            if (!client) {
-                _deps.log('INFO', `Shellper session ${dbSession.id} is stale (PID/socket dead) — will clean up`);
-                continue; // Will be cleaned up in Phase 2
-            }
-            const replayData = client.getReplayData() ?? Buffer.alloc(0);
-            const label = dbSession.type === 'architect' ? 'Architect' : `${dbSession.type} ${dbSession.role_id || 'unknown'}`;
-            // Create a PtySession backed by the reconnected shellper client
-            const session = manager.createSessionRaw({ label, cwd: projectPath });
-            const ptySession = manager.getSession(session.id);
-            if (ptySession) {
-                ptySession.attachShellper(client, replayData, dbSession.shellper_pid, dbSession.id);
-            }
-            // Register in projectTerminals Map
-            const entry = getProjectTerminalsEntry(projectPath);
-            if (dbSession.type === 'architect') {
-                entry.architect = session.id;
-            }
-            else if (dbSession.type === 'builder') {
-                entry.builders.set(dbSession.role_id || dbSession.id, session.id);
-            }
-            else if (dbSession.type === 'shell') {
-                entry.shells.set(dbSession.role_id || dbSession.id, session.id);
+            const cmdParts = architectCmd.split(/\s+/);
+            const cleanEnv = { ...process.env };
+            delete cleanEnv['CLAUDECODE'];
+            restartOptions = {
+                command: cmdParts[0],
+                args: buildArchitectArgs(cmdParts.slice(1), workspacePath),
+                cwd: workspacePath,
+                env: cleanEnv,
+                restartDelay: 2000,
+                maxRestarts: 50,
+            };
+        }
+        probeTasks.push({ dbSession, restartOptions });
+    }
+    // Probe shellper sockets in parallel with bounded concurrency (Spec 0122 Phase 2)
+    const CONCURRENCY_LIMIT = 5;
+    const probeResults = [];
+    for (let i = 0; i < probeTasks.length; i += CONCURRENCY_LIMIT) {
+        const batch = probeTasks.slice(i, i + CONCURRENCY_LIMIT);
+        const results = await Promise.allSettled(batch.map(async (task) => {
+            const client = await _deps.shellperManager.reconnectSession(task.dbSession.id, task.dbSession.shellper_socket, task.dbSession.shellper_pid, task.dbSession.shellper_start_time, task.restartOptions);
+            return { dbSession: task.dbSession, client, restartOptions: task.restartOptions };
+        }));
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                probeResults.push(result.value);
             }
-            // Update SQLite with new terminal ID
-            db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(dbSession.id);
-            saveTerminalSession(session.id, projectPath, dbSession.type, dbSession.role_id, dbSession.shellper_pid, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time);
-            _deps.registerKnownProject(projectPath);
-            // Clean up on exit
-            if (ptySession) {
-                ptySession.on('exit', () => {
-                    const currentEntry = getProjectTerminalsEntry(projectPath);
-                    if (dbSession.type === 'architect' && currentEntry.architect === session.id) {
-                        currentEntry.architect = undefined;
-                    }
-                    deleteTerminalSession(session.id);
-                });
+            else {
+                // Find the corresponding task for error logging
+                const idx = results.indexOf(result);
+                const task = batch[idx];
+                _deps.log('WARN', `Failed to reconnect shellper session ${task.dbSession.id}: ${result.reason?.message ?? result.reason}`);
             }
-            matchedSessionIds.add(dbSession.id);
-            shellperReconnected++;
-            _deps.log('INFO', `Reconnected shellper session → ${session.id} (${dbSession.type} for ${path.basename(projectPath)})`);
         }
-        catch (err) {
-            _deps.log('WARN', `Failed to reconnect shellper session ${dbSession.id}: ${err.message}`);
+    }
+    // Process probe results sequentially (shared state mutations)
+    for (const { dbSession, client } of probeResults) {
+        if (!client) {
+            _deps.log('INFO', `Shellper session ${dbSession.id} is stale (PID/socket dead) — will clean up`);
+            continue; // Will be cleaned up in Phase 2
+        }
+        const workspacePath = dbSession.workspace_path;
+        const replayData = client.getReplayData() ?? Buffer.alloc(0);
+        const label = dbSession.type === 'architect' ? 'Architect' : (dbSession.role_id || 'unknown');
+        // Create a PtySession backed by the reconnected shellper client
+        const session = manager.createSessionRaw({ label, cwd: workspacePath });
+        const ptySession = manager.getSession(session.id);
+        if (ptySession) {
+            ptySession.attachShellper(client, replayData, dbSession.shellper_pid, dbSession.id);
+        }
+        // Register in workspaceTerminals Map
+        const entry = getWorkspaceTerminalsEntry(workspacePath);
+        if (dbSession.type === 'architect') {
+            entry.architect = session.id;
+        }
+        else if (dbSession.type === 'builder') {
+            entry.builders.set(dbSession.role_id || dbSession.id, session.id);
+        }
+        else if (dbSession.type === 'shell') {
+            entry.shells.set(dbSession.role_id || dbSession.id, session.id);
+        }
+        // Update SQLite with new terminal ID
+        db.prepare('DELETE FROM terminal_sessions WHERE id = ?').run(dbSession.id);
+        saveTerminalSession(session.id, workspacePath, dbSession.type, dbSession.role_id, dbSession.shellper_pid, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time);
+        _deps.registerKnownWorkspace(workspacePath);
+        // Clean up on exit
+        if (ptySession) {
+            ptySession.on('exit', () => {
+                const currentEntry = getWorkspaceTerminalsEntry(workspacePath);
+                if (dbSession.type === 'architect' && currentEntry.architect === session.id) {
+                    currentEntry.architect = undefined;
+                }
+                deleteTerminalSession(session.id);
+            });
         }
+        matchedSessionIds.add(dbSession.id);
+        shellperReconnected++;
+        _deps.log('INFO', `Reconnected shellper session → ${session.id} (${dbSession.type} for ${path.basename(workspacePath)})`);
     }
     // ---- Phase 2: Sweep stale SQLite rows ----
     for (const session of allDbSessions) {
@@ -399,7 +450,7 @@ export async function reconcileTerminalSessions() {
             continue;
         // Stale row — kill orphaned process if any, then delete
         if (session.pid && processExists(session.pid)) {
-            _deps.log('INFO', `Killing orphaned process: PID ${session.pid} (${session.type} for ${path.basename(session.project_path)})`);
+            _deps.log('INFO', `Killing orphaned process: PID ${session.pid} (${session.type} for ${path.basename(session.workspace_path)})`);
             try {
                 process.kill(session.pid, 'SIGTERM');
                 killed++;
@@ -418,74 +469,47 @@ export async function reconcileTerminalSessions() {
     }
 }
 // ============================================================================
-// Gate watcher
-// ============================================================================
-/** Start periodic gate status polling */
-export function startGateWatcher() {
-    if (!_deps)
-        return;
-    gateWatcherInterval = setInterval(async () => {
-        if (!_deps)
-            return;
-        const projectPaths = _deps.getKnownProjectPaths();
-        for (const projectPath of projectPaths) {
-            try {
-                const gateStatus = getGateStatusForProject(projectPath);
-                await gateWatcher.checkAndNotify(gateStatus, projectPath);
-            }
-            catch (err) {
-                _deps.log('WARN', `Gate watcher error for ${projectPath}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }, 10_000);
-}
-/** Stop the gate watcher interval */
-export function stopGateWatcher() {
-    if (gateWatcherInterval) {
-        clearInterval(gateWatcherInterval);
-        gateWatcherInterval = null;
-    }
-}
-// ============================================================================
 // Terminal list assembly
 // ============================================================================
 /**
- * Get terminal list for a project from tower's registry.
+ * Get terminal list for a workspace from tower's registry.
  * Phase 4 (Spec 0090): Tower manages terminals directly, no dashboard-server fetch.
  * Returns architect, builders, and shells with their URLs.
  */
-export async function getTerminalsForProject(projectPath, proxyUrl) {
+export async function getTerminalsForWorkspace(workspacePath, proxyUrl) {
     const manager = getTerminalManager();
     const terminals = [];
     // Query SQLite first, then augment with shellper reconnection
-    const dbSessions = getTerminalSessionsForProject(projectPath);
+    const dbSessions = getTerminalSessionsForWorkspace(workspacePath);
     // Use normalized path for cache consistency
-    const normalizedPath = normalizeProjectPath(projectPath);
+    const normalizedPath = normalizeWorkspacePath(workspacePath);
     // Build a fresh entry from SQLite, then replace atomically to avoid
     // destroying in-memory state that was registered via POST /api/terminals.
     // Previous approach cleared the cache then rebuilt, which lost terminals
     // if their SQLite rows were deleted by external interference (e.g., tests).
     const freshEntry = { builders: new Map(), shells: new Map(), fileTabs: new Map() };
     // Load file tabs from SQLite (persisted across restarts)
-    const existingEntry = projectTerminals.get(normalizedPath);
+    const existingEntry = workspaceTerminals.get(normalizedPath);
     if (existingEntry && existingEntry.fileTabs.size > 0) {
         // Use in-memory state if already populated (avoids redundant DB reads)
         freshEntry.fileTabs = existingEntry.fileTabs;
     }
     else {
-        freshEntry.fileTabs = loadFileTabsForProject(projectPath);
+        freshEntry.fileTabs = loadFileTabsForWorkspace(workspacePath);
     }
     for (const dbSession of dbSessions) {
         // Verify session still exists in TerminalManager (runtime state)
         let session = manager.getSession(dbSession.id);
-        if (!session && dbSession.shellper_socket && _deps?.shellperManager) {
+        if (!session && dbSession.shellper_socket && _deps?.shellperManager && !_reconciling) {
             // PTY session gone but shellper may still be alive — reconnect on-the-fly
+            // Skip during reconciliation to avoid racing with reconcileTerminalSessions()
+            // which also reconnects to shellpers (Bugfix #274).
             try {
                 // Restore auto-restart for architect sessions (same as startup reconciliation)
                 let restartOptions;
                 if (dbSession.type === 'architect') {
                     let architectCmd = 'claude';
-                    const configPath = path.join(dbSession.project_path, 'af-config.json');
+                    const configPath = path.join(dbSession.workspace_path, 'af-config.json');
                     if (fs.existsSync(configPath)) {
                         try {
                             const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
@@ -500,39 +524,41 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
                     delete cleanEnv['CLAUDECODE'];
                     restartOptions = {
                         command: cmdParts[0],
-                        args: buildArchitectArgs(cmdParts.slice(1), dbSession.project_path),
-                        cwd: dbSession.project_path,
+                        args: buildArchitectArgs(cmdParts.slice(1), dbSession.workspace_path),
+                        cwd: dbSession.workspace_path,
                         env: cleanEnv,
                         restartDelay: 2000,
                         maxRestarts: 50,
                     };
                 }
+                _deps.log('INFO', `On-the-fly shellper reconnect for ${dbSession.id}`);
                 const client = await _deps.shellperManager.reconnectSession(dbSession.id, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time, restartOptions);
                 if (client) {
                     const replayData = client.getReplayData() ?? Buffer.alloc(0);
-                    const label = dbSession.type === 'architect' ? 'Architect' : `${dbSession.type} ${dbSession.role_id || dbSession.id}`;
-                    const newSession = manager.createSessionRaw({ label, cwd: dbSession.project_path });
+                    const label = dbSession.type === 'architect' ? 'Architect' : (dbSession.role_id || dbSession.id);
+                    const newSession = manager.createSessionRaw({ label, cwd: dbSession.workspace_path });
                     const ptySession = manager.getSession(newSession.id);
                     if (ptySession) {
                         ptySession.attachShellper(client, replayData, dbSession.shellper_pid, dbSession.id);
                         // Clean up on exit (same as startup reconciliation path)
                         ptySession.on('exit', () => {
-                            const currentEntry = getProjectTerminalsEntry(dbSession.project_path);
+                            const currentEntry = getWorkspaceTerminalsEntry(dbSession.workspace_path);
                             if (dbSession.type === 'architect' && currentEntry.architect === newSession.id) {
                                 currentEntry.architect = undefined;
                             }
                             deleteTerminalSession(newSession.id);
                         });
                     }
+                    const originalSessionId = dbSession.id;
                     deleteTerminalSession(dbSession.id);
-                    saveTerminalSession(newSession.id, dbSession.project_path, dbSession.type, dbSession.role_id, dbSession.shellper_pid, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time);
+                    saveTerminalSession(newSession.id, dbSession.workspace_path, dbSession.type, dbSession.role_id, dbSession.shellper_pid, dbSession.shellper_socket, dbSession.shellper_pid, dbSession.shellper_start_time);
                     dbSession.id = newSession.id;
                     session = manager.getSession(newSession.id);
-                    _deps.log('INFO', `Reconnected to shellper on-the-fly → ${newSession.id}`);
+                    _deps.log('INFO', `On-the-fly reconnect succeeded for ${originalSessionId} → ${newSession.id}`);
                 }
             }
             catch (err) {
-                _deps.log('WARN', `Failed shellper on-the-fly reconnect for ${dbSession.id}: ${err.message}`);
+                _deps.log('WARN', `On-the-fly reconnect failed for ${dbSession.id}: ${err.message}`);
             }
         }
         if (!session) {
@@ -556,8 +582,8 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
             terminals.push({
                 type: 'builder',
                 id: builderId,
-                label: `Builder ${builderId}`,
-                url: `${proxyUrl}?tab=builder-${builderId}`,
+                label: builderId,
+                url: `${proxyUrl}?tab=${builderId}`,
                 active: true,
             });
         }
@@ -568,7 +594,7 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
                 type: 'shell',
                 id: shellId,
                 label: `Shell ${shellId.replace('shell-', '')}`,
-                url: `${proxyUrl}?tab=shell-${shellId}`,
+                url: `${proxyUrl}?tab=${shellId}`,
                 active: true,
             });
         }
@@ -597,8 +623,8 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
                     terminals.push({
                         type: 'builder',
                         id: builderId,
-                        label: `Builder ${builderId}`,
-                        url: `${proxyUrl}?tab=builder-${builderId}`,
+                        label: builderId,
+                        url: `${proxyUrl}?tab=${builderId}`,
                         active: true,
                     });
                 }
@@ -613,7 +639,7 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
                         type: 'shell',
                         id: shellId,
                         label: `Shell ${shellId.replace('shell-', '')}`,
-                        url: `${proxyUrl}?tab=shell-${shellId}`,
+                        url: `${proxyUrl}?tab=${shellId}`,
                         active: true,
                     });
                 }
@@ -621,9 +647,7 @@ export async function getTerminalsForProject(projectPath, proxyUrl) {
         }
     }
     // Atomically replace the cache entry
-    projectTerminals.set(normalizedPath, freshEntry);
-    // Read gate status from porch YAML files
-    const gateStatus = getGateStatusForProject(projectPath);
-    return { terminals, gateStatus };
+    workspaceTerminals.set(normalizedPath, freshEntry);
+    return { terminals };
 }
 //# sourceMappingURL=tower-terminals.js.map