tycono 0.1.96-beta.18 → 0.1.96-beta.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.96-beta.18",
+  "version": "0.1.96-beta.19",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/routes/active-sessions.ts

@@ -6,6 +6,7 @@
 import { Router } from 'express';
 import { portRegistry } from '../services/port-registry.js';
 import { executionManager } from '../services/execution-manager.js';
+import { getSession } from '../services/session-store.js';
 
 export const activeSessionsRouter = Router();
 
@@ -17,8 +18,10 @@ activeSessionsRouter.get('/', (_req, res) => {
 
   const enriched = sessions.map(s => {
     const exec = executionManager.getActiveExecution(s.sessionId);
+    const session = getSession(s.sessionId);
     return {
       ...s,
+      waveId: session?.waveId ?? null,
       messageStatus: exec?.status ?? null,
       roleName: exec?.roleId ?? s.roleId,
       alive: s.pid ? isAlive(s.pid) : null,

package/src/api/src/routes/execute.ts

@@ -212,10 +212,8 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
   const attachments = body.attachments as ImageAttachment[] | undefined;
 
   if (type === 'wave') {
-    if (!directive) {
-      jsonResponse(res, 400, { error: 'directive is required for wave jobs' });
-      return;
-    }
+    // directive가 없으면 idle 상태로 시작 (empty wave)
+    const actualDirective = directive || '';
 
     const targetRoles = body.targetRoles as string[] | undefined;
     const continuous = body.continuous === true;
@@ -224,7 +222,7 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
     {
       const state = supervisorHeartbeat.start(
         `wave-${Date.now()}`,
-        directive,
+        actualDirective,
         targetRoles && targetRoles.length > 0 ? targetRoles : undefined,
         continuous,
       );
@@ -238,7 +236,7 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
         waveId: state.waveId,
         supervisorSessionId: state.supervisorSessionId,
         mode: 'supervisor',
-        directive,
+        directive: actualDirective,
       });
       return;
     }

package/src/api/src/services/supervisor-heartbeat.ts

@@ -88,6 +88,14 @@ class SupervisorHeartbeat {
     };
 
     this.supervisors.set(waveId, state);
+
+    // Empty directive → idle wave (don't spawn supervisor yet)
+    if (!directive) {
+      state.status = 'stopped';
+      console.log(`[Supervisor] Idle wave created: ${waveId} (no directive)`);
+      return state;
+    }
+
     this.spawnSupervisor(state);
     return state;
   }
@@ -133,6 +141,17 @@ class SupervisorHeartbeat {
 
     state.pendingDirectives.push(directive);
     console.log(`[Supervisor] Directive queued for wave ${waveId}: ${text.slice(0, 80)}`);
+
+    // If supervisor is stopped (agent finished or idle wave), wake it up
+    if (state.status === 'stopped') {
+      // Update the wave's directive if it was empty (idle wave first message)
+      if (!state.directive) {
+        state.directive = text;
+      }
+      state.crashCount = 0;
+      this.scheduleRestart(state, 0);
+    }
+
     return directive;
   }
 

package/src/tui/api.ts

@@ -129,7 +129,7 @@ export async function fetchExecStatus(): Promise<ExecStatus> {
   return fetchJson<ExecStatus>('/api/exec/status');
 }
 
-export async function dispatchWave(directive: string, options?: {
+export async function dispatchWave(directive?: string, options?: {
   targetRoles?: string[];
   continuous?: boolean;
 }): Promise<WaveResponse> {
@@ -137,7 +137,7 @@ export async function dispatchWave(directive: string, options?: {
     method: 'POST',
     body: {
       type: 'wave',
-      directive,
+      directive: directive ?? '',
       targetRoles: options?.targetRoles,
       continuous: options?.continuous ?? false,
     },
@@ -155,6 +155,31 @@ export async function fetchActiveWaves(): Promise<{ waves: Array<{ waveId: strin
   return fetchJson('/api/waves/active');
 }
 
+/* ─── Active Sessions (port/worktree visibility) ─── */
+
+export interface ActiveSessionInfo {
+  sessionId: string;
+  roleId: string;
+  task: string;
+  ports: { api: number; vite: number; hmr?: number };
+  worktreePath?: string;
+  pid?: number;
+  startedAt: string;
+  status: 'active' | 'idle' | 'dead';
+  waveId?: string | null;
+  messageStatus?: string | null;
+  alive?: boolean | null;
+}
+
+export interface ActiveSessionsResponse {
+  sessions: ActiveSessionInfo[];
+  summary: { active: number; totalPorts: number };
+}
+
+export async function fetchActiveSessions(): Promise<ActiveSessionsResponse> {
+  return fetchJson<ActiveSessionsResponse>('/api/active-sessions');
+}
+
 /* ─── Setup API calls ─── */
 
 export interface TeamTemplate {

package/src/tui/app.tsx

@@ -1,5 +1,8 @@
 /**
- * TUI App v2 — Hybrid Mode (Command + Panel)
+ * TUI App v2 — Multi-Wave Hybrid Mode (Command + Panel)
+ *
+ * Wave = Claude Code session. Persistent, resumable.
+ * Multiple waves can be open; user switches with /focus.
  *
  * Two modes:
  *   Command Mode (default) — stream summary + command input (> prompt)
@@ -8,7 +11,7 @@
  * Tab toggles between modes, Esc returns to Command Mode.
  */
 
-import React, { useState, useCallback, useMemo, useEffect } from 'react';
+import React, { useState, useCallback, useMemo, useEffect, useRef } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { StatusBar } from './components/StatusBar';
 import { CommandMode, type StreamLine } from './components/CommandMode';
@@ -16,7 +19,9 @@ import { PanelMode } from './components/PanelMode';
 import { SetupWizard } from './components/SetupWizard';
 import { useApi } from './hooks/useApi';
 import { useSSE } from './hooks/useSSE';
-import { useCommand } from './hooks/useCommand';
+import { useCommand, type WaveInfo } from './hooks/useCommand';
+import { dispatchWave } from './api';
+import type { ActiveSessionInfo } from './api';
 import { buildOrgTree, flattenOrgRoleIds } from './store';
 
 type Mode = 'command' | 'panel';
@@ -24,6 +29,121 @@ type View = 'loading' | 'setup' | 'dashboard';
 
 let sysLineId = 100000;
 
+/** Format agent tree for /agents command */
+function formatAgentsTree(
+  waves: WaveInfo[],
+  activeSessions: ActiveSessionInfo[],
+  focusedWaveId: string | null,
+): StreamLine[] {
+  const lines: StreamLine[] = [];
+
+  if (waves.length === 0 && activeSessions.length === 0) {
+    lines.push({ id: ++sysLineId, text: 'No active agents.', color: 'gray' });
+    return lines;
+  }
+
+  // Group sessions by waveId
+  const sessionsByWave = new Map<string, ActiveSessionInfo[]>();
+  const unlinked: ActiveSessionInfo[] = [];
+  for (const s of activeSessions) {
+    if (s.waveId) {
+      if (!sessionsByWave.has(s.waveId)) sessionsByWave.set(s.waveId, []);
+      sessionsByWave.get(s.waveId)!.push(s);
+    } else {
+      unlinked.push(s);
+    }
+  }
+
+  // Display each wave
+  for (let i = 0; i < waves.length; i++) {
+    const w = waves[i];
+    const isFocused = w.waveId === focusedWaveId;
+    const marker = isFocused ? '*' : ' ';
+    const label = w.directive ? w.directive.slice(0, 50) : '(idle)';
+    lines.push({
+      id: ++sysLineId,
+      text: `${marker}Wave ${i + 1}: "${label}"`,
+      color: isFocused ? 'green' : 'cyan',
+    });
+
+    const waveSessions = sessionsByWave.get(w.waveId) ?? [];
+    if (waveSessions.length === 0) {
+      lines.push({ id: ++sysLineId, text: '  (no agents)', color: 'gray' });
+    }
+    for (const s of waveSessions) {
+      const statusIcon = s.status === 'active' ? '\u25CF' : s.status === 'dead' ? '\u25CF' : '\u25CB';
+      const statusColor = s.status === 'active' ? 'green' : s.status === 'dead' ? 'red' : 'gray';
+      const portInfo = s.ports.api ? `API:${s.ports.api} Vite:${s.ports.vite}` : '(no ports)';
+      const worktree = s.worktreePath ? `\u{1F33F} ${s.worktreePath.split('/').pop()}` : '';
+      lines.push({
+        id: ++sysLineId,
+        text: `  ${statusIcon} ${s.roleId.padEnd(14)} ${portInfo}${worktree ? ' ' + worktree : ''}`,
+        color: statusColor,
+      });
+      if (s.task) {
+        lines.push({
+          id: ++sysLineId,
+          text: `    ${s.task.slice(0, 60)}`,
+          color: 'gray',
+        });
+      }
+    }
+  }
+
+  // Unlinked sessions (not associated with any wave)
+  if (unlinked.length > 0) {
+    lines.push({ id: ++sysLineId, text: '', color: 'white' });
+    lines.push({ id: ++sysLineId, text: 'Unlinked sessions:', color: 'yellow' });
+    for (const s of unlinked) {
+      const portInfo = s.ports.api ? `API:${s.ports.api} Vite:${s.ports.vite}` : '(no ports)';
+      lines.push({
+        id: ++sysLineId,
+        text: `  ${s.roleId.padEnd(14)} ${portInfo}  ${s.task?.slice(0, 40) ?? ''}`,
+        color: 'gray',
+      });
+    }
+  }
+
+  return lines;
+}
+
+/** Format port allocations for /ports command */
+function formatPortsList(activeSessions: ActiveSessionInfo[], portSummary: { active: number; totalPorts: number }): StreamLine[] {
+  const lines: StreamLine[] = [];
+
+  if (activeSessions.length === 0) {
+    lines.push({ id: ++sysLineId, text: 'No port allocations.', color: 'gray' });
+    return lines;
+  }
+
+  lines.push({
+    id: ++sysLineId,
+    text: `Port Allocations (${portSummary.active} active, ${portSummary.totalPorts} ports):`,
+    color: 'cyan',
+  });
+
+  for (const s of activeSessions) {
+    const alive = s.alive === false ? ' DEAD' : s.pid ? ` PID:${s.pid}` : '';
+    const waveLabel = s.waveId ? ` (${s.waveId.replace('wave-', 'W')})` : '';
+    lines.push({
+      id: ++sysLineId,
+      text: `  :${s.ports.api}/:${s.ports.vite} \u2192 ${s.roleId}${waveLabel}${alive}`,
+      color: s.alive === false ? 'red' : 'white',
+    });
+  }
+
+  // Available range hint
+  const usedApi = activeSessions.map(s => s.ports.api).filter(Boolean);
+  const maxApi = usedApi.length > 0 ? Math.max(...usedApi) + 1 : 3001;
+  lines.push({
+    id: ++sysLineId,
+    text: `  Available: :${maxApi}+ API, :${5173 + activeSessions.length}+ Vite`,
+    color: 'gray',
+  });
+
+  return lines;
+}
+
 export const App: React.FC = () => {
   const { exit } = useApp();
   const api = useApi();
@@ -46,9 +166,10 @@ export const App: React.FC = () => {
   // Mode state
   const [mode, setMode] = useState<Mode>('command');
 
-  // Wave state
-  const [waveId, setWaveId] = useState<string | null>(null);
-  const [waveStatus, setWaveStatus] = useState<'idle' | 'running' | 'done'>('idle');
+  // Multi-Wave state
+  const [waves, setWaves] = useState<WaveInfo[]>([]);
+  const [focusedWaveId, setFocusedWaveId] = useState<string | null>(null);
+  const autoWaveCreated = useRef(false);
 
   // Panel mode state
   const [selectedRoleIndex, setSelectedRoleIndex] = useState(0);
@@ -77,18 +198,47 @@ export const App: React.FC = () => {
     });
   }, []);
 
-  // Auto-sync: when waveId is null (e.g. --attach), pick up api.activeWaveId
+  const addSystemLines = useCallback((lines: StreamLine[]) => {
+    setSystemMessages(prev => {
+      const next = [...prev, ...lines];
+      return next.length > 80 ? next.slice(-80) : next;
+    });
+  }, []);
+
+  // Auto-wave: on dashboard entry, create an empty wave or attach to existing
   useEffect(() => {
-    if (waveId === null && api.activeWaveId) {
-      setWaveId(api.activeWaveId);
-    }
-  }, [waveId, api.activeWaveId]);
+    if (view !== 'dashboard' || autoWaveCreated.current) return;
 
-  // Derive effective wave ID (from manual set or API polling)
-  const effectiveWaveId = waveId ?? api.activeWaveId;
+    if (api.activeWaves.length > 0) {
+      // Attach to existing waves from API
+      const apiWaves: WaveInfo[] = api.activeWaves.map(w => ({
+        waveId: w.waveId,
+        directive: w.directive ?? '',
+        startedAt: w.startedAt ?? Date.now(),
+      }));
+      setWaves(apiWaves);
+      setFocusedWaveId(apiWaves[apiWaves.length - 1].waveId);
+      autoWaveCreated.current = true;
+    } else if (api.loaded) {
+      // Create a new empty wave
+      autoWaveCreated.current = true;
+      dispatchWave().then(result => {
+        const newWave: WaveInfo = {
+          waveId: result.waveId,
+          directive: '',
+          startedAt: Date.now(),
+        };
+        setWaves([newWave]);
+        setFocusedWaveId(result.waveId);
+      }).catch(() => {
+        // If empty wave creation fails, still proceed — user can /new
+        autoWaveCreated.current = true;
+      });
+    }
+  }, [view, api.activeWaves, api.loaded]);
 
-  // SSE subscription
-  const sse = useSSE(effectiveWaveId);
+  // SSE subscription to focused wave
+  const sse = useSSE(focusedWaveId);
 
   // Build org tree — flatRoleIds follows visual top-to-bottom order
   const roles = api.company?.roles ?? [];
@@ -105,23 +255,34 @@ export const App: React.FC = () => {
   const derivedWaveStatus = useMemo(() => {
     if (sse.streamStatus === 'streaming') return 'running' as const;
     if (sse.streamStatus === 'done') return 'done' as const;
-    if (waveStatus === 'running' && activeCount > 0) return 'running' as const;
-    return waveStatus;
-  }, [sse.streamStatus, waveStatus, activeCount]);
+    if (activeCount > 0) return 'running' as const;
+    return 'idle' as const;
+  }, [sse.streamStatus, activeCount]);
+
+  // Focused wave index (1-based)
+  const focusedWaveIndex = useMemo(() => {
+    if (!focusedWaveId) return 0;
+    return waves.findIndex(w => w.waveId === focusedWaveId) + 1;
+  }, [focusedWaveId, waves]);
 
   // Command handler
   const { execute } = useCommand({
-    activeWaveId: effectiveWaveId,
-    onWaveStarted: (newWaveId) => {
-      setWaveId(newWaveId);
-      setWaveStatus('running');
+    focusedWaveId,
+    waves,
+    onWaveCreated: (newWaveId, directive) => {
+      const newWave: WaveInfo = {
+        waveId: newWaveId,
+        directive,
+        startedAt: Date.now(),
+      };
+      setWaves(prev => [...prev, newWave]);
+      setFocusedWaveId(newWaveId);
       sse.clearEvents();
       api.refresh();
     },
-    onStopped: () => {
-      setWaveId(null);
-      setWaveStatus('idle');
-      api.refresh();
+    onFocusWave: (waveId) => {
+      setFocusedWaveId(waveId);
+      sse.clearEvents();
     },
     onQuit: () => exit(),
     onShowPanel: () => setMode('panel'),
@@ -135,51 +296,73 @@ export const App: React.FC = () => {
 
     switch (result.type) {
       case 'wave_started':
-        // Don't show wave ID noise — supervisor handles it
         break;
       case 'directive_sent':
-        // Silently sent — supervisor will respond
         break;
-      case 'stopped':
-        addSystemMessage(`\u26A1 ${result.message}`, 'red');
+      case 'focus_changed':
+        addSystemMessage(`\u2192 ${result.message}`, 'cyan');
         break;
+      case 'waves_list': {
+        if (waves.length === 0) {
+          addSystemMessage('No waves.', 'gray');
+        } else {
+          addSystemMessage('Waves:', 'cyan');
+          waves.forEach((w, i) => {
+            const isFocused = w.waveId === focusedWaveId;
+            const prefix = isFocused ? '*' : ' ';
+            const label = w.directive ? w.directive.slice(0, 60) : '(idle)';
+            addSystemMessage(`${prefix}${i + 1}. Wave ${i + 1} \u2014 ${label}`, isFocused ? 'green' : 'white');
+          });
+        }
+        break;
+      }
+      case 'agents': {
+        const lines = formatAgentsTree(waves, api.activeSessions, focusedWaveId);
+        addSystemLines(lines);
+        break;
+      }
+      case 'ports': {
+        const lines = formatPortsList(api.activeSessions, api.portSummary);
+        addSystemLines(lines);
+        break;
+      }
       case 'error':
         addSystemMessage(result.message, 'red');
         break;
       case 'help':
         addSystemMessage('Type naturally to talk to your AI team.', 'cyan');
-        addSystemMessage('Commands (/ prefix):', 'cyan');
-        addSystemMessage('  /stop                Stop all executions', 'white');
+        addSystemMessage('Commands:', 'cyan');
+        addSystemMessage('  /new [text]          Create new wave', 'white');
+        addSystemMessage('  /waves               List all waves', 'white');
+        addSystemMessage('  /focus <n>           Switch to wave n', 'white');
+        addSystemMessage('  /agents              Agent tree + resources', 'white');
+        addSystemMessage('  /ports               Port allocations', 'white');
         addSystemMessage('  /status              Show current status', 'white');
         addSystemMessage('  /assign <role> <task> Assign task to role', 'white');
         addSystemMessage('  /roles               Org tree (Panel Mode)', 'white');
         addSystemMessage('  /help                Show this help', 'white');
         addSystemMessage('  /quit                Exit TUI', 'white');
-        addSystemMessage('Keys: [Tab] panel  [Esc] back  [Ctrl+C] stop/quit', 'gray');
+        addSystemMessage('Keys: [Tab] panel  [Esc] back  [Ctrl+C] quit', 'gray');
         break;
       case 'info':
         if (result.message === '__status__') {
-          const wLabel = effectiveWaveId
-            ? `Wave ${effectiveWaveId.replace('wave-', '#')}: ${derivedWaveStatus}`
+          const wLabel = focusedWaveId
+            ? `Wave ${focusedWaveIndex}: ${derivedWaveStatus}`
             : 'No active wave';
           addSystemMessage(wLabel, derivedWaveStatus === 'running' ? 'green' : 'gray');
-          addSystemMessage(`Sessions: ${api.sessions.length}  Active: ${activeCount}`, 'white');
-        } else if (result.message === '__summary__') {
-          addSystemMessage('Summary: not yet implemented', 'gray');
+          addSystemMessage(`Sessions: ${api.sessions.length}  Active: ${activeCount}  Waves: ${waves.length}  Ports: ${api.portSummary.totalPorts}`, 'white');
         }
         break;
       case 'panel':
-        // mode already switched
         break;
       case 'quit':
-        // exit already called
         break;
       default:
         if (result.message) {
           addSystemMessage(result.message, 'green');
         }
     }
-  }, [execute, addSystemMessage, effectiveWaveId, derivedWaveStatus, api.sessions.length, activeCount]);
+  }, [execute, addSystemMessage, addSystemLines, focusedWaveId, focusedWaveIndex, derivedWaveStatus, api.sessions.length, activeCount, waves, api.activeSessions, api.portSummary]);
 
   // Global key handler: Tab to toggle mode, Ctrl+C handling
   useInput((input, key) => {
@@ -187,13 +370,9 @@ export const App: React.FC = () => {
       setMode('panel');
       return;
     }
-    // Ctrl+C in command mode: stop wave or exit
+    // Ctrl+C in command mode: exit
     if (key.ctrl && input === 'c') {
-      if (derivedWaveStatus === 'running') {
-        execute('stop');
-      } else {
-        exit();
-      }
+      exit();
     }
   }, { isActive: mode === 'command' });
 
@@ -247,7 +426,7 @@ export const App: React.FC = () => {
           selectedRoleIndex={selectedRoleIndex}
           selectedRoleId={selectedRoleId}
           streamStatus={sse.streamStatus}
-          waveId={effectiveWaveId}
+          waveId={focusedWaveId}
           onMove={(dir) => {
             if (dir === 'up') {
               setSelectedRoleIndex(Math.max(0, selectedRoleIndex - 1));
@@ -267,9 +446,11 @@ export const App: React.FC = () => {
       {/* Status Bar — bottom (Claude Code style) */}
       <StatusBar
         companyName={api.company?.name ?? 'Loading...'}
-        waveId={effectiveWaveId}
+        waveIndex={focusedWaveIndex}
+        waveCount={waves.length}
         waveStatus={derivedWaveStatus}
         activeCount={activeCount}
+        portCount={api.portSummary.totalPorts}
         totalCost={0}
       />
     </Box>

package/src/tui/components/StatusBar.tsx

@@ -1,6 +1,6 @@
 /**
  * StatusBar — bottom bar (Claude Code style)
- * Shows: company name, wave status, active roles, cost
+ * Shows: company name, wave index [focused/total], active roles, ports, cost
  */
 
 import React from 'react';
@@ -8,26 +8,34 @@ import { Box, Text } from 'ink';
 
 interface StatusBarProps {
   companyName: string;
-  waveId: string | null;
+  waveIndex: number;      // 1-based focused wave index (0 = none)
+  waveCount: number;      // total waves
   waveStatus: 'idle' | 'running' | 'done';
   activeCount: number;
+  portCount: number;       // total allocated ports
   totalCost: number;
 }
 
 export const StatusBar: React.FC<StatusBarProps> = ({
   companyName,
-  waveId,
+  waveIndex,
+  waveCount,
   waveStatus,
   activeCount,
+  portCount,
   totalCost,
 }) => {
-  const waveLabel = waveId
-    ? `Wave ${waveId.replace('wave-', '#')}`
+  const statusDot = waveStatus === 'running' ? ' \u25CF'
+    : waveStatus === 'done' ? ' \u2713'
     : '';
-  const statusDot = waveStatus === 'running' ? ' ●'
-    : waveStatus === 'done' ? ' ✓'
+
+  const waveLabel = waveIndex > 0
+    ? `Wave ${waveIndex}${statusDot}`
     : '';
 
+  // Show [1/3] only when 2+ waves
+  const countLabel = waveCount >= 2 ? ` [${waveIndex}/${waveCount}]` : '';
+
   return (
     <Box width="100%" paddingX={1}>
       <Text color="cyan" bold>Tycono</Text>
@@ -37,7 +45,7 @@ export const StatusBar: React.FC<StatusBarProps> = ({
         <>
           <Text color="gray"> | </Text>
           <Text color={waveStatus === 'running' ? 'green' : 'gray'}>
-            {waveLabel}{statusDot}
+            {waveLabel}{countLabel}
           </Text>
         </>
       )}
@@ -47,6 +55,12 @@ export const StatusBar: React.FC<StatusBarProps> = ({
           <Text color="yellow">{activeCount} active</Text>
         </>
       )}
+      {portCount > 0 && (
+        <>
+          <Text color="gray"> | </Text>
+          <Text color="blue">{portCount} ports</Text>
+        </>
+      )}
       <Text color="gray"> | </Text>
       <Text color="green">${totalCost.toFixed(2)}</Text>
     </Box>

package/src/tui/hooks/useApi.ts

@@ -8,18 +8,29 @@ import {
   fetchSessions,
   fetchExecStatus,
   fetchActiveWaves,
+  fetchActiveSessions,
   type CompanyInfo,
   type SessionInfo,
   type ExecStatus,
+  type ActiveSessionInfo,
 } from '../api';
 
 const POLL_INTERVAL = 3000; // 3 seconds
 
+export interface ActiveWaveInfo {
+  waveId: string;
+  sessionIds: string[];
+  directive?: string;
+  startedAt?: number;
+}
+
 export interface ApiState {
   company: CompanyInfo | null;
   sessions: SessionInfo[];
   execStatus: ExecStatus | null;
-  activeWaveId: string | null;
+  activeWaves: ActiveWaveInfo[];
+  activeSessions: ActiveSessionInfo[];
+  portSummary: { active: number; totalPorts: number };
   error: string | null;
   loaded: boolean;
   refresh(): void;
@@ -29,18 +40,21 @@ export function useApi(): ApiState {
   const [company, setCompany] = useState<CompanyInfo | null>(null);
   const [sessions, setSessions] = useState<SessionInfo[]>([]);
   const [execStatus, setExecStatus] = useState<ExecStatus | null>(null);
-  const [activeWaveId, setActiveWaveId] = useState<string | null>(null);
+  const [activeWaves, setActiveWaves] = useState<ActiveWaveInfo[]>([]);
+  const [activeSessions, setActiveSessions] = useState<ActiveSessionInfo[]>([]);
+  const [portSummary, setPortSummary] = useState<{ active: number; totalPorts: number }>({ active: 0, totalPorts: 0 });
   const [error, setError] = useState<string | null>(null);
   const [loaded, setLoaded] = useState(false);
   const mountedRef = useRef(true);
 
   const refresh = useCallback(async () => {
     try {
-      const [comp, sess, exec, waves] = await Promise.all([
+      const [comp, sess, exec, waves, activeSess] = await Promise.all([
         fetchCompany().catch(() => null),
         fetchSessions().catch(() => []),
         fetchExecStatus().catch(() => null),
         fetchActiveWaves().catch(() => ({ waves: [] })),
+        fetchActiveSessions().catch(() => ({ sessions: [], summary: { active: 0, totalPorts: 0 } })),
       ]);
 
       if (!mountedRef.current) return;
@@ -49,11 +63,18 @@ export function useApi(): ApiState {
       setSessions(Array.isArray(sess) ? sess : []);
       if (exec) setExecStatus(exec);
 
-      // Find active wave
+      // Store full active waves array
       if (waves.waves && waves.waves.length > 0) {
-        setActiveWaveId(waves.waves[0].waveId);
+        setActiveWaves(waves.waves.map((w: { waveId: string; sessionIds: string[] }) => ({
+          waveId: w.waveId,
+          sessionIds: w.sessionIds ?? [],
+        })));
       }
 
+      // Active sessions (port/resource visibility)
+      setActiveSessions(activeSess.sessions ?? []);
+      setPortSummary(activeSess.summary ?? { active: 0, totalPorts: 0 });
+
       setError(null);
       setLoaded(true);
     } catch (err) {
@@ -73,5 +94,5 @@ export function useApi(): ApiState {
     };
   }, [refresh]);
 
-  return { company, sessions, execStatus, activeWaveId, error, loaded, refresh };
+  return { company, sessions, execStatus, activeWaves, activeSessions, portSummary, error, loaded, refresh };
 }

package/src/tui/hooks/useCommand.ts

@@ -1,9 +1,13 @@
 /**
- * useCommand — input handler for TUI v2
+ * useCommand — input handler for TUI v2 (Multi-Wave)
  *
- * Default: natural language → wave dispatch or directive (if wave active)
+ * Default: natural language → sendDirective to focused wave
  * Commands (/ prefix):
- *   /stop                — abort all active executions
+ *   /waves               — list all waves
+ *   /focus <n>           — switch to nth wave
+ *   /new [text]          — create new wave (optionally with directive)
+ *   /agents              — show wave→agent tree with resources
+ *   /ports               — show port allocations
  *   /status              — show current wave + session status
  *   /assign <role> <task> — assign task to specific role
  *   /roles               — show org tree (Panel Mode)
@@ -14,28 +18,18 @@
 import { useCallback } from 'react';
 import { dispatchWave, sendDirective, fetchJson } from '../api';
 
+export interface WaveInfo {
+  waveId: string;
+  directive: string;
+  startedAt: number;
+}
+
 export interface CommandResult {
-  type: 'success' | 'error' | 'info' | 'wave_started' | 'directive_sent' | 'stopped' | 'quit' | 'help' | 'panel';
+  type: 'success' | 'error' | 'info' | 'wave_started' | 'directive_sent' | 'stopped' | 'quit' | 'help' | 'panel' | 'waves_list' | 'focus_changed' | 'agents' | 'ports';
   message: string;
   waveId?: string;
 }
 
-async function postAbortAll(): Promise<void> {
-  try {
-    const status = await fetchJson<{
-      statuses: Record<string, string>;
-      activeExecutions: Array<{ id: string }>;
-    }>('/api/exec/status');
-
-    const abortPromises = (status.activeExecutions || []).map((exec) =>
-      fetchJson(`/api/jobs/${exec.id}/abort`, { method: 'POST' }).catch(() => {})
-    );
-    await Promise.all(abortPromises);
-  } catch {
-    // If we can't get status, silently fail
-  }
-}
-
 async function postAssign(roleId: string, task: string): Promise<{ waveId?: string }> {
   return fetchJson<{ waveId?: string }>('/api/jobs', {
     method: 'POST',
@@ -48,37 +42,63 @@ async function postAssign(roleId: string, task: string): Promise<{ waveId?: stri
 }
 
 export interface UseCommandOptions {
-  activeWaveId: string | null;
-  onWaveStarted: (waveId: string) => void;
-  onStopped: () => void;
+  focusedWaveId: string | null;
+  waves: WaveInfo[];
+  onWaveCreated: (waveId: string, directive: string) => void;
+  onFocusWave: (waveId: string) => void;
   onQuit: () => void;
   onShowPanel: () => void;
 }
 
 export function useCommand(options: UseCommandOptions) {
-  const { activeWaveId, onWaveStarted, onStopped, onQuit, onShowPanel } = options;
+  const { focusedWaveId, waves, onWaveCreated, onFocusWave, onQuit, onShowPanel } = options;
 
   const execute = useCallback(async (input: string): Promise<CommandResult> => {
     const trimmed = input.trim();
     if (!trimmed) return { type: 'info', message: '' };
 
-    // Slash commands: /stop, /status, /help, /quit, /roles, /assign
+    // Slash commands
     if (trimmed.startsWith('/')) {
       const parts = trimmed.slice(1).split(/\s+/);
       const cmd = parts[0].toLowerCase();
       const args = parts.slice(1).join(' ');
 
       switch (cmd) {
-        case 'stop': {
+        case 'waves': {
+          return { type: 'waves_list', message: '__waves__' };
+        }
+
+        case 'focus': {
+          const idx = parseInt(args, 10);
+          if (isNaN(idx) || idx < 1 || idx > waves.length) {
+            return { type: 'error', message: `Usage: /focus <1-${waves.length}>` };
+          }
+          const target = waves[idx - 1];
+          onFocusWave(target.waveId);
+          return { type: 'focus_changed', message: `Focused on Wave ${idx}`, waveId: target.waveId };
+        }
+
+        case 'new': {
+          const directive = args || undefined;
           try {
-            await postAbortAll();
-            onStopped();
-            return { type: 'stopped', message: 'All active executions stopped.' };
+            const result = await dispatchWave(directive);
+            onWaveCreated(result.waveId, directive ?? '');
+            return {
+              type: 'wave_started',
+              message: `Wave created`,
+              waveId: result.waveId,
+            };
           } catch (err) {
-            return { type: 'error', message: `Stop failed: ${err instanceof Error ? err.message : 'unknown'}` };
+            return { type: 'error', message: `New wave failed: ${err instanceof Error ? err.message : 'unknown'}` };
           }
         }
 
+        case 'agents':
+          return { type: 'agents', message: '__agents__' };
+
+        case 'ports':
+          return { type: 'ports', message: '__ports__' };
+
         case 'status':
           return { type: 'info', message: '__status__' };
 
@@ -91,9 +111,6 @@ export function useCommand(options: UseCommandOptions) {
           const task = args.slice(spaceIdx + 1);
           try {
             const result = await postAssign(roleId, task);
-            if (result.waveId) {
-              onWaveStarted(result.waveId);
-            }
             return { type: 'success', message: `Task assigned to ${roleId}`, waveId: result.waveId };
           } catch (err) {
             return { type: 'error', message: `Assign failed: ${err instanceof Error ? err.message : 'unknown'}` };
@@ -117,28 +134,29 @@ export function useCommand(options: UseCommandOptions) {
       }
     }
 
-    // Default: natural language → directive (if wave active) or new wave
-    if (activeWaveId) {
+    // Default: natural language → directive to focused wave
+    if (focusedWaveId) {
       try {
-        await sendDirective(activeWaveId, trimmed);
+        await sendDirective(focusedWaveId, trimmed);
         return { type: 'directive_sent', message: `Directive sent` };
       } catch (err) {
         return { type: 'error', message: `Failed: ${err instanceof Error ? err.message : 'unknown'}` };
       }
     } else {
+      // No focused wave — create one with the directive
       try {
         const result = await dispatchWave(trimmed);
-        onWaveStarted(result.waveId);
+        onWaveCreated(result.waveId, trimmed);
         return {
           type: 'wave_started',
-          message: `Wave ${result.waveId.replace('wave-', '#')} started`,
+          message: `Wave created`,
           waveId: result.waveId,
         };
       } catch (err) {
         return { type: 'error', message: `Wave failed: ${err instanceof Error ? err.message : 'unknown'}` };
       }
     }
-  }, [activeWaveId, onWaveStarted, onStopped, onQuit, onShowPanel]);
+  }, [focusedWaveId, waves, onWaveCreated, onFocusWave, onQuit, onShowPanel]);
 
   return { execute };
 }