@dmsdc-ai/aigentry-telepty 0.1.56 → 0.1.58

package/URGENT_ISSUES.resolved.md

@@ -0,0 +1 @@
+RESOLVED - all 3 urgent issues fixed in 40b8e47

package/cli.js

@@ -598,6 +598,12 @@ async function main() {
     return;
   }
 
+  if (cmd === 'tui' || cmd === 'dashboard') {
+    const { TuiDashboard } = require('./tui');
+    new TuiDashboard();
+    return;
+  }
+
   if (cmd === 'list') {
     try {
       const sessions = await discoverSessions({ silent: true });
@@ -667,10 +673,21 @@ async function main() {
       process.exit(1);
     }
 
-    // Default session ID = command name
+    // Default session ID = {folder}-{cli} (e.g. aigentry-dustcraw-claude)
     if (!sessionId) {
-      sessionId = path.basename(command);
+      const folder = path.basename(process.cwd());
+      const cli = path.basename(command).replace(/\..*$/, '');
+      sessionId = `${folder}-${cli}`;
+    }
+
+    // Override inherited TELEPTY_SESSION_ID — prevent parent session hijacking
+    // When launched via kitty @ launch, the parent's env leaks through.
+    // With --id flag, we always use the explicitly requested session ID.
+    if (process.env.TELEPTY_SESSION_ID && process.env.TELEPTY_SESSION_ID !== sessionId) {
+      console.error(`⚠️  [allow] Overriding inherited TELEPTY_SESSION_ID="${process.env.TELEPTY_SESSION_ID}" → "${sessionId}"`);
     }
+    delete process.env.TELEPTY_SESSION_ID;
+    process.env.TELEPTY_SESSION_ID = sessionId;
 
     await ensureDaemonRunning({ requiredCapabilities: ['wrapped-sessions'] });
 
@@ -735,7 +752,9 @@ async function main() {
     }
 
     // Connect to daemon WebSocket with auto-reconnect
-    const wsUrl = `ws://${REMOTE_HOST}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}?token=${encodeURIComponent(TOKEN)}`;
+    // owner=1 tells daemon this is the allow bridge (owner), not an attach viewer.
+    // Daemon uses this to reclaim ownership even if a stale ownerWs is still registered.
+    const wsUrl = `ws://${REMOTE_HOST}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}?token=${encodeURIComponent(TOKEN)}&owner=1`;
     let daemonWs = null;
     let wsReady = false;
     let reconnectAttempts = 0;
@@ -776,10 +795,17 @@ async function main() {
         try {
           const msg = JSON.parse(message);
           if (msg.type === 'inject') {
-            const isFollowUpCr = msg.data === '\r' && (Date.now() - lastInjectTextTime) < 1000;
-            if (promptReady || isFollowUpCr) {
+            const isCr = msg.data === '\r';
+            if (isCr && injectQueue.length > 0) {
+              // CR with pending queued text — queue CR too and flush immediately.
+              // Prevents the busy-session bug where CR fires before queued text,
+              // causing empty submit followed by orphaned text without Return.
+              injectQueue.push(msg.data);
+              if (queueFlushTimer) { clearTimeout(queueFlushTimer); queueFlushTimer = null; }
+              flushInjectQueue();
+            } else if (isCr || promptReady) {
               child.write(msg.data);
-              if (msg.data !== '\r' && msg.data.length > 1) {
+              if (!isCr && msg.data.length > 1) {
                 promptReady = false;
                 lastInjectTextTime = Date.now();
               }
@@ -1151,6 +1177,243 @@ async function main() {
     return;
   }
 
+  if (cmd === 'session' && args[1] === 'start') {
+    // Generate kitty session file and launch
+    const configArg = args.find(a => a.startsWith('--config='));
+    const configPath = configArg ? configArg.split('=').slice(1).join('=') : null;
+    const cliArg = args.find(a => a.startsWith('--cli='));
+    const cli = cliArg ? cliArg.split('=')[1] : 'claude --dangerously-skip-permissions';
+    const projectsDir = args.find(a => a.startsWith('--dir=')) ? args.find(a => a.startsWith('--dir=')).split('=')[1] : process.cwd();
+
+    // Discover project folders (subdirectories with .git)
+    let projects;
+    if (configPath) {
+      projects = JSON.parse(fs.readFileSync(configPath, 'utf8')).projects;
+    } else {
+      projects = fs.readdirSync(projectsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && fs.existsSync(path.join(projectsDir, d.name, '.git')))
+        .map(d => ({ name: d.name, cwd: path.join(projectsDir, d.name) }));
+    }
+
+    if (projects.length === 0) {
+      console.error('❌ No git projects found in', projectsDir);
+      process.exit(1);
+    }
+
+    // Resolve full paths (kitty @ launch has no shell PATH)
+    const cliParts = cli.split(' ');
+    let teleptyFullPath, cliFullPath;
+    try {
+      teleptyFullPath = execSync('which telepty', { encoding: 'utf8' }).trim();
+    } catch {
+      teleptyFullPath = process.argv[1];
+    }
+    try {
+      cliFullPath = execSync(`which ${cliParts[0]}`, { encoding: 'utf8' }).trim();
+    } catch {
+      cliFullPath = cliParts[0];
+    }
+    const cliFullArgs = cliParts.slice(1).join(' ');
+    const nodeFullPath = process.execPath; // Bypass #!/usr/bin/env node shebang (nvm not in PATH for non-interactive shells)
+
+    // Generate kitty session file
+    const sessionFile = path.join(os.tmpdir(), `telepty-session-${Date.now()}.conf`);
+    let conf = '# Auto-generated telepty session\n';
+    projects.forEach((p, i) => {
+      const name = p.name;
+      const cwd = p.cwd || path.join(projectsDir, name);
+      const sessionId = `${name}-${cli.split(' ')[0]}`;
+      if (i === 0) {
+        conf += `new_tab ${name}\n`;
+      } else {
+        conf += `\nnew_tab ${name}\n`;
+      }
+      conf += `layout tall\n`;
+      conf += `cd ${cwd}\n`;
+      conf += `title ${name}\n`;
+      conf += `env TELEPTY_SESSION_ID=\n`;
+      conf += `env PATH=${process.env.PATH}\n`;
+      conf += `launch --type=window /bin/zsh -c 'unset TELEPTY_SESSION_ID; ${nodeFullPath} ${teleptyFullPath} allow --id ${sessionId} ${cliFullPath}${cliFullArgs ? ' ' + cliFullArgs : ''}'\n`;
+    });
+
+    fs.writeFileSync(sessionFile, conf);
+    console.log(`✅ Kitty session file: ${sessionFile}`);
+    console.log(`   ${projects.length} projects, CLI: ${cli}`);
+
+    // Auto-launch if --launch flag
+    if (args.includes('--launch')) {
+      const { spawn, execFileSync } = require('child_process');
+
+      // Detect existing kitty instance via remote control socket
+      let kittySocket = null;
+      try {
+        const sockFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('kitty-sock'));
+        if (sockFiles.length > 0) {
+          const candidate = '/tmp/' + sockFiles[0];
+          // Verify socket is alive
+          execFileSync('kitty', ['@', '--to', `unix:${candidate}`, 'ls'], {
+            timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+          });
+          kittySocket = candidate;
+        }
+      } catch { kittySocket = null; }
+
+      if (kittySocket) {
+        // Launch tabs in existing kitty instance (single Dock icon, kitty @ controllable)
+        let launched = 0;
+        for (const p of projects) {
+          const name = p.name;
+          const cwd = p.cwd || path.join(projectsDir, name);
+          const sessionIdForProject = `${name}-${cli.split(' ')[0]}`;
+          const shellCmd = `unset TELEPTY_SESSION_ID; ${nodeFullPath} ${teleptyFullPath} allow --id ${sessionIdForProject} ${cliFullPath}${cliFullArgs ? ' ' + cliFullArgs : ''}`;
+          const launchArgs = ['@', '--to', `unix:${kittySocket}`,
+            'launch', '--type=tab', '--tab-title', name, '--cwd', cwd,
+            '--env', 'TELEPTY_SESSION_ID=',
+            '--env', `PATH=${process.env.PATH}`,
+            '/bin/zsh', '-c', shellCmd];
+          try {
+            execFileSync('kitty', launchArgs, { timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
+            launched++;
+          } catch (e) {
+            console.error(`⚠️  Failed to launch tab for ${name}: ${e.message}`);
+          }
+        }
+        console.log(`🚀 ${launched}/${projects.length} tabs launched in existing kitty instance.`);
+      } else {
+        // No existing kitty — start a new instance with session file
+        console.log(`\n   Launch: kitty --session ${sessionFile}\n`);
+        spawn('kitty', ['--session', sessionFile], { detached: true, stdio: 'ignore' }).unref();
+        console.log('🚀 Kitty launched (new instance).');
+      }
+    } else {
+      console.log(`\n   Launch: kitty --session ${sessionFile}\n`);
+    }
+    return;
+  }
+
+  if (cmd === 'layout') {
+    const layoutType = args[1] || 'grid';
+    const validLayouts = ['grid', 'tall', 'stack'];
+    if (!validLayouts.includes(layoutType)) {
+      console.error(`❌ Invalid layout: ${layoutType}. Valid: ${validLayouts.join(', ')}`);
+      process.exit(1);
+    }
+
+    await ensureDaemonRunning();
+    const { execSync } = require('child_process');
+
+    // Get active session count for grid calculation
+    try {
+      const sessionsRes = await fetchWithAuth(`${DAEMON_URL}/api/sessions`);
+      const sessionsList = await sessionsRes.json();
+      const activeIds = Object.keys(sessionsList);
+      if (activeIds.length === 0) {
+        console.log('No active sessions to arrange.');
+        return;
+      }
+    } catch (e) {
+      console.error('❌ Could not fetch sessions:', e.message);
+      process.exit(1);
+    }
+
+    // Detect kitty process name
+    let processName = 'kitty';
+    try {
+      execSync(`osascript -e 'tell application "System Events" to get name of first process whose name is "kitty"'`, {
+        timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+      });
+    } catch {
+      processName = 'stable';
+    }
+
+    // Get screen dimensions
+    let screenW = 2560, screenH = 1440;
+    try {
+      const bounds = execSync(`osascript -e 'tell application "Finder" to get bounds of window of desktop'`, {
+        encoding: 'utf8', timeout: 3000
+      }).trim();
+      const parts = bounds.split(', ');
+      screenW = parseInt(parts[2]);
+      screenH = parseInt(parts[3]);
+    } catch {}
+
+    const menuBarH = 25;
+    const dockH = 70;
+    const usableH = screenH - menuBarH - dockH;
+
+    // Build AppleScript — collect windows from ALL kitty process instances
+    // (kitty --session spawns separate processes, each with its own window)
+    const collectWindows = `
+          set wList to {}
+          set kittyProcs to every process whose name is "${processName}"
+          repeat with p in kittyProcs
+            repeat with w in (every window of p)
+              set end of wList to w
+            end repeat
+          end repeat
+          set n to count of wList
+          if n = 0 then return "0"`;
+
+    let layoutBody;
+    if (layoutType === 'grid') {
+      layoutBody = `
+            set numCols to (n ^ 0.5) as integer
+            if numCols * numCols < n then set numCols to numCols + 1
+            set numRows to ((n - 1) div numCols) + 1
+            set cellW to ${screenW} div numCols
+            set cellH to ${usableH} div numRows
+            repeat with i from 1 to n
+              set c to ((i - 1) mod numCols)
+              set r to ((i - 1) div numCols)
+              set position of (item i of wList) to {c * cellW, ${menuBarH} + r * cellH}
+              set size of (item i of wList) to {cellW, cellH}
+            end repeat`;
+    } else if (layoutType === 'tall') {
+      layoutBody = `
+            set halfW to ${screenW} div 2
+            if n = 1 then
+              set position of (item 1 of wList) to {0, ${menuBarH}}
+              set size of (item 1 of wList) to {${screenW}, ${usableH}}
+            else
+              set position of (item 1 of wList) to {0, ${menuBarH}}
+              set size of (item 1 of wList) to {halfW, ${usableH}}
+              set rightH to ${usableH} div (n - 1)
+              repeat with i from 2 to n
+                set y to ${menuBarH} + ((i - 2) * rightH)
+                set position of (item i of wList) to {halfW, y}
+                set size of (item i of wList) to {halfW, rightH}
+              end repeat
+            end if`;
+    } else if (layoutType === 'stack') {
+      layoutBody = `
+            set cellH to ${usableH} div n
+            repeat with i from 1 to n
+              set y to ${menuBarH} + ((i - 1) * cellH)
+              set position of (item i of wList) to {0, y}
+              set size of (item i of wList) to {${screenW}, cellH}
+            end repeat`;
+    }
+
+    const script = `
+        tell application "System Events"
+          ${collectWindows}
+          ${layoutBody}
+          return n
+        end tell`;
+
+    try {
+      const result = execSync(`osascript -e '${script}'`, { encoding: 'utf8', timeout: 10000 }).trim();
+      if (result === '0') {
+        console.log('⚠️  No kitty windows found. Sessions may be in tabs — use kitty @ launch --type=os-window for separate windows.');
+      } else {
+        console.log(`✅ Layout '${layoutType}' applied to ${result} kitty windows.`);
+      }
+    } catch (e) {
+      console.error(`❌ Layout failed: ${e.message}`);
+    }
+    return;
+  }
+
   if (cmd === 'deliberate') {
     await ensureDaemonRunning();
     const subCmd = args[1];
@@ -1674,6 +1937,7 @@ Usage:
   telepty listen                                 Listen to the event bus and print JSON to stdout
   telepty monitor                                Human-readable real-time billboard of bus events
   telepty update                                 Update telepty to the latest version
+  telepty layout [grid|tall|stack]               Arrange kitty windows on screen (default: grid)
 
   Handoff Commands:
     handoff list [--status=S]        List handoffs (filter: pending/claimed/executing/completed)

package/daemon.js

@@ -785,7 +785,10 @@ app.post('/api/sessions/:id/inject', (req, res) => {
           });
           kittyOk = true;
           console.log(`[INJECT] Kitty send-text for ${id} (window ${wid})`);
-        } catch {}
+        } catch {
+          // Invalidate cached window ID — window may have changed or been closed
+          session.kittyWindowId = null;
+        }
       }
       if (!kittyOk) {
         // Fallback: WS (works with new allow bridges that have queue flush)
@@ -795,22 +798,37 @@ app.post('/api/sessions/:id/inject', (req, res) => {
 
       if (!no_enter) {
         setTimeout(() => {
+          // Primary: osascript keystroke (reliable across all CLIs)
+          const submitStrategy = getSubmitStrategy(session.command);
+          const keyCombo = submitStrategy === 'osascript_cmd_enter' ? 'cmd_enter' : 'return_key';
+          const osascriptOk = submitViaOsascript(id, keyCombo);
+
+          if (!osascriptOk) {
+            // Fallback: kitty send-text → WS
+            console.log(`[INJECT] osascript submit failed for ${id}, trying fallback`);
+            if (wid && sock) {
+              try {
+                require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} $'\\r'`, {
+                  timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+                });
+              } catch {
+                writeToSession('\r');
+              }
+            } else {
+              writeToSession('\r');
+            }
+          }
+
+          // Update tab title regardless of submit method
           if (wid && sock) {
             try {
-              require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} $'\\r'`, {
-                timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
-              });
               require('child_process').execSync(`kitty @ --to unix:${sock} set-tab-title --match id:${wid} '⚡ telepty :: ${id}'`, {
                 timeout: 2000, stdio: ['pipe', 'pipe', 'pipe']
               });
-            } catch {
-              writeToSession('\r');
-            }
-          } else {
-            writeToSession('\r');
+            } catch {}
           }
         }, 500);
-        submitResult = { deferred: true, strategy: kittyOk ? 'kitty_text_key' : 'ws_split_cr' };
+        submitResult = { deferred: true, strategy: 'osascript_with_fallback' };
       }
     } else {
       // Spawned sessions: direct PTY write
@@ -942,14 +960,21 @@ app.delete('/api/sessions/:id', (req, res) => {
 function busAutoRoute(msg) {
   const eventType = msg.type || msg.kind;
   const isRoutable = (eventType === 'turn_request' || eventType === 'deliberation_route_turn') && (msg.target || msg.target_session_id);
-  if (!isRoutable) return;
+  if (!isRoutable) {
+    // Log all bus messages for debugging (excluding health checks)
+    if (eventType && eventType !== 'session_health') {
+      console.log(`[BUS] Event: ${eventType} (not routable)`);
+    }
+    return;
+  }
 
   const rawTarget = (msg.target || msg.target_session_id).split('@')[0];
-  console.log(`[BUS-ROUTE] Received ${eventType}: target=${rawTarget}`);
+  const turnId = (msg.payload && msg.payload.turn_id) || null;
+  console.log(`[BUS-ROUTE] ${eventType}: target=${rawTarget} turn=${turnId} msg_id=${msg.message_id || 'none'}`);
   const targetId = resolveSessionAlias(rawTarget);
   const targetSession = targetId ? sessions[targetId] : null;
   if (!targetSession) {
-    console.log(`[BUS-ROUTE] Target ${rawTarget} not found`);
+    console.log(`[BUS-ROUTE] Target ${rawTarget} not found among: ${Object.keys(sessions).join(', ')}`);
     return;
   }
 
@@ -1002,6 +1027,8 @@ function busAutoRoute(msg) {
     source_host: MACHINE_ID,
     target_agent: targetId,
     source_type: 'bus_auto_route',
+    turn_id: (msg.payload && msg.payload.turn_id) || null,
+    original_message_id: msg.message_id || null,
     delivered,
     timestamp: new Date().toISOString()
   });
@@ -1327,6 +1354,21 @@ wss.on('connection', (ws, req) => {
   const url = new URL(req.url, 'http://' + req.headers.host);
   const sessionId = url.pathname.split('/').pop();
   const session = sessions[sessionId];
+  // ?owner=1 indicates the allow bridge (PTY owner), not an attach viewer
+  const isOwnerConnect = url.searchParams.get('owner') === '1';
+
+  // Ping/pong heartbeat — detect and terminate stale TCP half-open connections (30s interval)
+  let isAlive = true;
+  ws.on('pong', () => { isAlive = true; });
+  const pingInterval = setInterval(() => {
+    if (!isAlive) {
+      console.log(`[WS] Terminating stale connection (no pong) for ${sessionId}`);
+      ws.terminate();
+      return;
+    }
+    isAlive = false;
+    ws.ping();
+  }, 30000);
 
   if (!session) {
     // Auto-register wrapped session on WS connect (supports reconnect after daemon restart)
@@ -1363,10 +1405,17 @@ wss.on('connection', (ws, req) => {
 
   const activeSession = sessions[sessionId];
 
-  // For wrapped sessions, first connector becomes the owner
-  if (activeSession.type === 'wrapped' && !activeSession.ownerWs) {
+  // For wrapped sessions, first connector OR explicit ?owner=1 claim becomes the owner.
+  // ?owner=1 reclaim handles the stale-ownerWs bug: allow bridge reconnects but stale TCP
+  // half-open connection still holds ownerWs slot → reconnect wrongly becomes a viewer.
+  if (activeSession.type === 'wrapped' && (!activeSession.ownerWs || isOwnerConnect)) {
+    if (isOwnerConnect && activeSession.ownerWs && activeSession.ownerWs !== ws) {
+      // Terminate the stale owner connection before claiming ownership
+      console.log(`[WS] Replacing stale ownerWs for session ${sessionId}`);
+      activeSession.ownerWs.terminate();
+    }
     activeSession.ownerWs = ws;
-    console.log(`[WS] Wrap owner connected for session ${sessionId} (Total: ${activeSession.clients.size})`);
+    console.log(`[WS] Wrap owner ${isOwnerConnect && activeSession.clients.size > 1 ? 're-' : ''}connected for session ${sessionId} (Total: ${activeSession.clients.size})`);
   } else {
     console.log(`[WS] Client attached to session ${sessionId} (Total: ${activeSession.clients.size})`);
   }
@@ -1408,6 +1457,7 @@ wss.on('connection', (ws, req) => {
   });
 
   ws.on('close', () => {
+    clearInterval(pingInterval);
     activeSession.clients.delete(ws);
     if (activeSession.type === 'wrapped' && ws === activeSession.ownerWs) {
       activeSession.ownerWs = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "main": "daemon.js",
   "bin": {
     "aigentry-telepty": "install.js",
@@ -17,6 +17,7 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
+    "blessed": "^0.1.81",
     "cors": "^2.8.6",
     "express": "^5.2.1",
     "node-pty": "^1.2.0-beta.11",

package/session-routing.js

@@ -48,6 +48,20 @@ function pickSessionTarget(sessionRef, sessions, defaultHost = '127.0.0.1') {
   const matches = sessions.filter((session) => session.id === parsed.id);
 
   if (matches.length === 0) {
+    // Project-based fallback: match sessions whose ID starts with the requested prefix.
+    // e.g., "aigentry-dustcraw" matches "aigentry-dustcraw-001" or "aigentry-dustcraw-claude".
+    const prefixMatches = sessions.filter((s) =>
+      s.id.startsWith(parsed.id + '-') || s.id.startsWith(parsed.id)
+    );
+    if (prefixMatches.length === 1) {
+      return { id: prefixMatches[0].id, host: prefixMatches[0].host };
+    }
+    if (prefixMatches.length > 1) {
+      // Multiple candidates: prefer same host, then first alphabetically
+      const local = prefixMatches.find((s) => s.host === '127.0.0.1');
+      const best = local || prefixMatches.sort((a, b) => a.id.localeCompare(b.id))[0];
+      return { id: best.id, host: best.host };
+    }
     return null;
   }
 

package/tui.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+const blessed = require('blessed');
+const { getConfig } = require('./auth');
+
+const PORT = process.env.PORT || 3848;
+const DAEMON_URL = `http://localhost:${PORT}`;
+const POLL_INTERVAL = 2000;
+const STALE_THRESHOLD = 120; // seconds idle before "stale"
+
+class TuiDashboard {
+  constructor() {
+    const cfg = getConfig();
+    this.token = cfg.authToken;
+    this.sessions = [];
+    this.selectedIndex = 0;
+    this.pollTimer = null;
+    this.busWs = null;
+    this.busLog = [];
+    this.setupScreen();
+    this.startPolling();
+    this.connectBus();
+  }
+
+  // ── API helpers ──────────────────────────────────────────────
+
+  async apiFetch(path, options = {}) {
+    const headers = { 'x-telepty-token': this.token, ...options.headers };
+    if (options.body) headers['Content-Type'] = 'application/json';
+    const res = await fetch(`${DAEMON_URL}${path}`, { ...options, headers });
+    return res.json();
+  }
+
+  async fetchSessions() {
+    try {
+      this.sessions = await this.apiFetch('/api/sessions');
+      this.sessions.sort((a, b) => a.id.localeCompare(b.id));
+      if (this.selectedIndex >= this.sessions.length) {
+        this.selectedIndex = Math.max(0, this.sessions.length - 1);
+      }
+      this.renderSessionList();
+    } catch {
+      this.setStatus('{red-fg}Daemon unreachable{/}');
+    }
+  }
+
+  async injectToSession(id, prompt) {
+    try {
+      const res = await this.apiFetch(`/api/sessions/${encodeURIComponent(id)}/inject`, {
+        method: 'POST',
+        body: JSON.stringify({ prompt })
+      });
+      if (res.success) {
+        this.setStatus(`{green-fg}Injected to ${id}{/}`);
+      } else {
+        this.setStatus(`{red-fg}Inject failed: ${res.error || 'unknown'}{/}`);
+      }
+    } catch (e) {
+      this.setStatus(`{red-fg}Inject error: ${e.message}{/}`);
+    }
+  }
+
+  async broadcastMessage(prompt) {
+    try {
+      const res = await this.apiFetch('/api/sessions/broadcast/inject', {
+        method: 'POST',
+        body: JSON.stringify({ prompt })
+      });
+      const ok = res.results?.successful?.length || 0;
+      this.setStatus(`{green-fg}Broadcast to ${ok} sessions{/}`);
+    } catch (e) {
+      this.setStatus(`{red-fg}Broadcast error: ${e.message}{/}`);
+    }
+  }
+
+  // ── Event Bus ────────────────────────────────────────────────
+
+  connectBus() {
+    try {
+      const WebSocket = require('ws');
+      this.busWs = new WebSocket(
+        `ws://localhost:${PORT}/api/bus?token=${encodeURIComponent(this.token)}`
+      );
+      this.busWs.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data);
+          const ts = new Date().toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+          let line = `${ts} `;
+          if (msg.type === 'inject_written') {
+            line += `{cyan-fg}inject{/} -> ${msg.target || '?'}`;
+          } else if (msg.type === 'injection') {
+            line += `{cyan-fg}broadcast{/} -> ${msg.target_agent || 'all'}`;
+          } else if (msg.type === 'message_routed') {
+            line += `{yellow-fg}${msg.from || '?'}{/} -> {green-fg}${msg.to || '?'}{/}`;
+          } else {
+            line += `{white-fg}${msg.type || 'event'}{/}`;
+          }
+          this.busLog.push(line);
+          if (this.busLog.length > 100) this.busLog.shift();
+          this.renderBusLog();
+        } catch { /* ignore malformed */ }
+      });
+      this.busWs.on('close', () => {
+        setTimeout(() => this.connectBus(), 3000);
+      });
+      this.busWs.on('error', () => {});
+    } catch { /* ws not available */ }
+  }
+
+  // ── Screen setup ─────────────────────────────────────────────
+
+  setupScreen() {
+    this.screen = blessed.screen({
+      smartCSR: true,
+      title: 'telepty dashboard',
+      fullUnicode: true
+    });
+
+    // Header
+    this.header = blessed.box({
+      parent: this.screen,
+      top: 0, left: 0, width: '100%', height: 1,
+      tags: true,
+      style: { fg: 'white', bg: 'blue' },
+      content: ' {bold}telepty dashboard{/bold}'
+    });
+
+    // Session list (left panel)
+    this.sessionList = blessed.list({
+      parent: this.screen,
+      top: 1, left: 0, width: '60%', bottom: 3,
+      border: { type: 'line' },
+      label: ' Sessions ',
+      tags: true,
+      keys: true,
+      vi: true,
+      mouse: true,
+      scrollbar: { ch: '│', style: { fg: 'cyan' } },
+      style: {
+        border: { fg: 'cyan' },
+        selected: { bg: 'blue', fg: 'white', bold: true },
+        item: { fg: 'white' }
+      }
+    });
+
+    this.sessionList.on('select item', (item, index) => {
+      this.selectedIndex = index;
+    });
+
+    // Event bus log (right panel)
+    this.busPanel = blessed.log({
+      parent: this.screen,
+      top: 1, left: '60%', right: 0, bottom: 3,
+      border: { type: 'line' },
+      label: ' Event Bus ',
+      tags: true,
+      scrollbar: { ch: '│', style: { fg: 'yellow' } },
+      style: {
+        border: { fg: 'yellow' }
+      }
+    });
+
+    // Shortcut bar
+    this.shortcutBar = blessed.box({
+      parent: this.screen,
+      bottom: 1, left: 0, width: '100%', height: 1,
+      tags: true,
+      style: { fg: 'white', bg: 'gray' },
+      content: ' {bold}i{/}:Inject  {bold}b{/}:Broadcast  {bold}r{/}:Refresh  {bold}q{/}:Quit'
+    });
+
+    // Status bar
+    this.statusBar = blessed.box({
+      parent: this.screen,
+      bottom: 0, left: 0, width: '100%', height: 1,
+      tags: true,
+      style: { fg: 'white', bg: 'black' },
+      content: ' Ready'
+    });
+
+    // ── Keyboard handlers ──────────────────────────────────────
+
+    this.screen.key(['q', 'C-c'], () => {
+      this.cleanup();
+      process.exit(0);
+    });
+
+    this.screen.key(['i'], () => {
+      const session = this.sessions[this.selectedIndex];
+      if (!session) return this.setStatus('{red-fg}No session selected{/}');
+      this.promptInput(`Inject to ${session.id}:`, (text) => {
+        if (text) this.injectToSession(session.id, text);
+      });
+    });
+
+    this.screen.key(['b'], () => {
+      this.promptInput('Broadcast to all:', (text) => {
+        if (text) this.broadcastMessage(text);
+      });
+    });
+
+    this.screen.key(['r'], () => {
+      this.fetchSessions();
+      this.setStatus('{green-fg}Refreshed{/}');
+    });
+
+    this.sessionList.focus();
+    this.screen.render();
+  }
+
+  // ── Input prompt ─────────────────────────────────────────────
+
+  promptInput(label, callback) {
+    const inputBox = blessed.textbox({
+      parent: this.screen,
+      bottom: 0, left: 0, width: '100%', height: 3,
+      border: { type: 'line' },
+      label: ` ${label} `,
+      tags: true,
+      inputOnFocus: true,
+      style: {
+        border: { fg: 'green' },
+        fg: 'white'
+      }
+    });
+
+    inputBox.focus();
+    inputBox.readInput((err, value) => {
+      inputBox.destroy();
+      this.sessionList.focus();
+      this.screen.render();
+      if (!err && value) callback(value);
+    });
+    this.screen.render();
+  }
+
+  // ── Rendering ────────────────────────────────────────────────
+
+  getStatusInfo(session) {
+    const idle = session.idleSeconds;
+    const clients = session.active_clients || 0;
+
+    if (clients === 0) return { icon: '{red-fg}✕{/}', label: '{red-fg}dead{/}' };
+    if (idle !== null && idle > STALE_THRESHOLD) return { icon: '{yellow-fg}○{/}', label: '{yellow-fg}stale{/}' };
+    if (idle !== null && idle < 10) return { icon: '{green-fg}●{/}', label: '{green-fg}busy{/}' };
+    return { icon: '{green-fg}●{/}', label: '{white-fg}idle{/}' };
+  }
+
+  renderSessionList() {
+    const items = this.sessions.map((s) => {
+      const { icon, label } = this.getStatusInfo(s);
+      const shortId = s.id.replace(/^aigentry-/, '').replace(/-claude$/, '');
+      return ` ${icon}  ${shortId.padEnd(24)} ${label}  {gray-fg}C:${s.active_clients}{/}`;
+    });
+
+    this.sessionList.setItems(items);
+    this.sessionList.setLabel(` Sessions (${this.sessions.length}) `);
+    if (this.selectedIndex < items.length) {
+      this.sessionList.select(this.selectedIndex);
+    }
+    this.screen.render();
+  }
+
+  renderBusLog() {
+    // Show last N lines that fit
+    const height = this.busPanel.height - 2;
+    const visible = this.busLog.slice(-height);
+    this.busPanel.setContent(visible.join('\n'));
+    this.screen.render();
+  }
+
+  setStatus(msg) {
+    this.statusBar.setContent(` ${msg}`);
+    this.screen.render();
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────
+
+  startPolling() {
+    this.fetchSessions();
+    this.pollTimer = setInterval(() => this.fetchSessions(), POLL_INTERVAL);
+  }
+
+  cleanup() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.busWs) this.busWs.close();
+    this.screen.destroy();
+  }
+}
+
+// ── Entry point ──────────────────────────────────────────────────
+
+function main() {
+  new TuiDashboard();
+}
+
+module.exports = { TuiDashboard };
+
+if (require.main === module) {
+  main();
+}

package/URGENT_ISSUES.md

@@ -1,31 +0,0 @@
-# Telepty 긴급 수정 사항 3건
-
-## 1. 데몬 재시작 시 전체 세션 끊김 → 자동 재접속
-
-**현상**: 데몬이 재시작되면 모든 allow 브릿지 세션이 끊기고 수동으로 다시 연결해야 함.
-
-**필요한 수정**:
-- allow 브릿지가 데몬 재시작/연결 끊김을 감지
-- 자동 재접속 retry loop (exponential backoff: 1s → 2s → 4s → max 30s)
-- 세션 메타데이터(ID, command, CWD)가 재접속 시 복원되어야 함
-
-## 2. inject 시 엔터 미전송
-
-**현상**: inject된 메시지가 프롬프트에 표시되지만 엔터가 자동으로 안 눌림. 사용자가 수동으로 엔터를 눌러야 실행됨.
-
-**0.1.21에서 수정했다고 했으나 여전히 발생 중.**
-
-**필요한 수정**:
-- 모든 CLI(Claude, Codex, Gemini)에서 inject 후 엔터 자동 전송 보장
-- HTTP API inject (POST /api/sessions/:id/inject)도 동일하게 동작해야 함
-- deferred/split_cr 전략이 실제로 엔터를 전송하는지 검증
-
-## 3. 통신 대상 세션 소실 시 자동 재검색
-
-**현상**: inject 대상 세션이 사라지면 에러 후 종료. 통신 단절.
-
-**필요한 수정**:
-- 세션이 사라지면 같은 프로젝트(CWD)에서 새로 생성된 세션을 자동 검색
-- 예: `aigentry-dustcraw-001`이 사라지고 `aigentry-dustcraw-002`가 생기면 자동 라우팅
-- project-based routing: CWD 또는 session name prefix로 매칭
-- `telepty inject --project aigentry-dustcraw "메시지"` 같은 project alias 지원 검토