tycono 0.1.96-beta.9 → 0.1.97

package/src/api/src/services/wave-multiplexer.ts

@@ -83,19 +83,30 @@ class WaveMultiplexer {
 
     const sessions = this.waveSessions.get(waveId);
     if (sessions) {
-      // Phase 1: Replay all historical events sorted by timestamp
-      const allEvents: { event: ActivityEvent; sessionId: string }[] = [];
+      // Phase 1: Replay recent historical events (capped to prevent OOM)
+      // Only replay from recent sessions (last 5) to avoid 120-session waves killing memory
+      const MAX_REPLAY_SESSIONS = 5;
+      const MAX_REPLAY_EVENTS = 200;
+
+      const sessionList = Array.from(sessions.values());
+      const recentSessions = sessionList.slice(-MAX_REPLAY_SESSIONS);
 
-      for (const [, exec] of sessions) {
+      const allEvents: { event: ActivityEvent; sessionId: string }[] = [];
+      for (const exec of recentSessions) {
         const events = ActivityStream.readFrom(exec.sessionId, 0);
-        for (const event of events) {
+        // Take last N events per session
+        const recent = events.slice(-50);
+        for (const event of recent) {
           allEvents.push({ event, sessionId: exec.sessionId });
         }
       }
 
       allEvents.sort((a, b) => a.event.ts.localeCompare(b.event.ts));
 
-      for (const item of allEvents) {
+      // Cap total replay events
+      const replayEvents = allEvents.slice(-MAX_REPLAY_EVENTS);
+
+      for (const item of replayEvents) {
         const waveSeq = client.waveSeq++;
         if (waveSeq < fromWaveSeq) continue;
 
@@ -111,8 +122,10 @@ class WaveMultiplexer {
         } as WaveStreamEnvelope);
       }
 
+      console.log(`[WaveMux] Replayed ${replayEvents.length} events (${sessionList.length} total sessions, ${recentSessions.length} replayed)`);
+
       // Phase 2: Subscribe to live events for active sessions
-      for (const [, exec] of sessions) {
+      for (const exec of sessionList) {
         if (exec.status === 'running' || exec.status === 'awaiting_input') {
           this.subscribeSessionToClient(waveId, client, exec, true);
         }
@@ -137,7 +150,8 @@ class WaveMultiplexer {
       });
 
       const events = ActivityStream.readFrom(execution.sessionId, 0);
-      for (const event of events) {
+      const recentEvents = events.slice(-50); // Cap replay per session
+      for (const event of recentEvents) {
         const key = `${event.roleId}:${event.seq}`;
         if (client.sentEvents.has(key)) continue;
         client.sentEvents.add(key);

package/src/tui/api.ts

@@ -52,6 +52,9 @@ export async function fetchJson<T>(path: string, options?: { method?: string; bo
       },
     );
     req.on('error', reject);
+    req.setTimeout(10_000, () => {
+      req.destroy(new Error(`Timeout: ${path}`));
+    });
     if (bodyStr) req.write(bodyStr);
     req.end();
   });
@@ -83,6 +86,7 @@ export interface SessionInfo {
   status: string;
   source: string;
   waveId?: string;
+  parentSessionId?: string;
   createdAt: string;
 }
 
@@ -129,7 +133,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 +141,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 +159,61 @@ 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');
+}
+
+export async function killSession(sessionId: string): Promise<{ ok: boolean }> {
+  return fetchJson<{ ok: boolean }>(`/api/active-sessions/${sessionId}`, { method: 'DELETE' });
+}
+
+export async function cleanupSessions(): Promise<{ cleaned: number; remaining: number }> {
+  return fetchJson<{ cleaned: number; remaining: number }>('/api/active-sessions/cleanup', { method: 'POST' });
+}
+
+/* ─── Knowledge docs ─── */
+
+export interface KnowledgeDoc {
+  id: string;
+  title: string;
+  path: string;
+  type?: string;
+  domain?: string;
+  status?: string;
+  updatedAt?: string;
+}
+
+export async function fetchKnowledgeDocs(): Promise<KnowledgeDoc[]> {
+  return fetchJson<KnowledgeDoc[]>('/api/knowledge');
+}
+
+/** Scan COMPANY_ROOT for all .md files (not API-dependent) */
+export async function fetchCompanyRoot(): Promise<string> {
+  const health = await fetchJson<{ companyRoot: string }>('/api/health');
+  return health.companyRoot;
+}
+
 /* ─── Setup API calls ─── */
 
 export interface TeamTemplate {