tycono 0.1.96-beta.4 → 0.1.96-beta.41

package/README.md

@@ -1,12 +1,12 @@
 <p align="center">
-  <img src=".github/assets/hero-office.png" alt="Tycono — AI Office" width="720" />
+  <img src=".github/assets/wave-org-propagation.png" alt="Tycono — CEO dispatches through org hierarchy in real time" width="720" />
 </p>
 
 <h1 align="center">tycono</h1>
 
 <p align="center">
-  <strong>Build an AI company. Watch them work.</strong><br>
-  <sub>Infrastructure-as-Code defined servers. Company-as-Code defines organizations.</sub>
+  <strong>Cursor gives you one AI developer. Tycono gives you an AI team.</strong><br>
+  <sub>Give one order. Watch your AI team plan, build, and learn together.</sub>
 </p>
 
 <p align="center">
@@ -25,9 +25,11 @@
 
 ---
 
-**tycono** is an open-source platform that lets you define and run an AI-powered organization. Roles, authority, knowledge, and workflows — all defined in files, executed by AI agents, visualized in real time.
+Cursor, Lovable, Bolt — they all give you **one AI agent**. It helps, but you still drive everything.
 
-One command. Your AI company is running.
+**tycono** gives you an **AI team**. A CTO reviews architecture. Engineers write code. A PM breaks down tasks. QA catches bugs. You just give the order and watch them work.
+
+One command. Your AI team is running.
 
 ```bash
 npx tycono
@@ -45,6 +47,10 @@ dispatch → watch → relay → quality gate → re-dispatch (if needed)
 
 CEO delegates to C-levels, C-levels dispatch to their teams. Authority is enforced — engineers can't make CEO decisions, PMs can't merge code. The org chart isn't decoration, it's the execution engine.
 
+<p align="center">
+  <img src=".github/assets/wave-org-propagation.png" alt="Wave Center — org propagation with real-time status" width="640" />
+</p>
+
 ### 2. Observability — See everything, intervene anytime
 
 Your AI team isn't a black box. Watch every agent work in real time, inject directives mid-execution, and drill down to any level.
@@ -79,16 +85,16 @@ Session 50 is dramatically smarter than session 1. Your company learns.
 
 ## Why Tycono?
 
-Coding agents simulate **one developer**. Tycono simulates **the entire company**.
+Same goal as Cursor, Lovable, Bolt — **get AI to do your work**. Different method.
 
-| | Single AI Agent | Tycono |
+| | Cursor / Lovable / Bolt | Tycono |
 |---|---|---|
-| **What it runs** | One agent, one context | Multiple roles with org hierarchy |
-| **Knowledge** | Resets every session | Compounds forever (AKB Pre-K/Post-K) |
-| **Authority** | Can do anything (or nothing) | Scoped — each role has clear boundaries |
-| **Delegation** | Manual prompt chaining | CEO dispatches, org chart routes automatically |
-| **Scale** | 1 agent | 7 → 700 agents |
-| **Visibility** | Terminal output | Real-time org tree + activity stream |
+| **Agents** | 1 AI helps you | **AI team works for you** |
+| **Your role** | Keep directing | **Give one order, watch** |
+| **Knowledge** | Resets every session | **Compounds forever** |
+| **Quality** | You review everything | **QA agent catches bugs** |
+| **Scale** | 1 task at a time | **Parallel across roles** |
+| **Visibility** | Editor / chat | **Real-time org tree** |
 
 ## Company-as-Code
 
@@ -254,9 +260,9 @@ npx tycono --version    # Show version
 - [x] CEO Wave dispatch with org-tree targeting
 - [x] AKB — Pre-K / Post-K knowledge loop
 - [x] Port Registry for multi-agent isolation
-- [ ] **TUI mode** — terminal-native multi-panel interface
+- [ ] **TUI mode** — terminal-native multi-panel interface *(in progress)*
 - [ ] Git worktree isolation per agent session
-- [ ] Desktop app (.dmg / .exe) — background execution, system notifications
+- [ ] **Desktop app** (.dmg / .exe) — background execution, notifications, no API key setup needed
 - [ ] Multi-LLM support (OpenAI, local models)
 
 ## Built with Tycono

package/bin/tycono.ts

@@ -213,6 +213,27 @@ async function startServerForTui(): Promise<void> {
   const port = process.env.PORT ? Number(process.env.PORT) : await findFreePort();
   process.env.PORT = String(port);
 
+  // Suppress ALL server output BEFORE creating server — hijack process streams
+  const logFile = path.resolve(process.env.COMPANY_ROOT || process.cwd(), '.tycono', 'server.log');
+  try { fs.mkdirSync(path.dirname(logFile), { recursive: true }); } catch {}
+  const logFd = fs.openSync(logFile, 'a');
+  const logStream = fs.createWriteStream(logFile, { fd: logFd });
+  const origStdoutWrite = process.stdout.write.bind(process.stdout);
+  const origStderrWrite = process.stderr.write.bind(process.stderr);
+  // Intercept all stdout/stderr — only allow Ink's output (ANSI escape sequences)
+  const isInkOutput = (s: string) => s.includes('\x1b[') || s.includes('\x1b(');
+  process.stdout.write = ((chunk: any, ...args: any[]) => {
+    const str = typeof chunk === 'string' ? chunk : chunk.toString();
+    if (isInkOutput(str)) return origStdoutWrite(chunk, ...args);
+    logStream.write(str);
+    return true;
+  }) as any;
+  process.stderr.write = ((chunk: any, ...args: any[]) => {
+    logStream.write(typeof chunk === 'string' ? chunk : chunk.toString());
+    return true;
+  }) as any;
+  const origLog = (...args: unknown[]) => origStdoutWrite(args.join(' ') + '\n');
+
   const { createHttpServer } = await import('../src/api/src/create-server.js');
   const server = createHttpServer();
 
@@ -222,17 +243,6 @@ async function startServerForTui(): Promise<void> {
     server.listen(port, host, () => resolve());
   });
 
-  // Suppress API server logs in TUI mode — redirect to file
-  const logFile = path.resolve(process.env.COMPANY_ROOT || process.cwd(), '.tycono', 'server.log');
-  try { fs.mkdirSync(path.dirname(logFile), { recursive: true }); } catch {}
-  const logStream = fs.createWriteStream(logFile, { flags: 'a' });
-  const origLog = console.log;
-  const origErr = console.error;
-  const origWarn = console.warn;
-  console.log = (...args: unknown[]) => logStream.write(args.join(' ') + '\n');
-  console.error = (...args: unknown[]) => logStream.write('[ERROR] ' + args.join(' ') + '\n');
-  console.warn = (...args: unknown[]) => logStream.write('[WARN] ' + args.join(' ') + '\n');
-
   origLog(`  API server started on port ${port}`);
   origLog(`  Logs: ${logFile}`);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.96-beta.4",
+  "version": "0.1.96-beta.41",
   "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

@@ -51,25 +51,21 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
   // ── /api/waves/active — restore active waves after refresh ──
   if (method === 'GET' && url === '/api/waves/active') {
     // Recovery: rebuild wave→session mapping from session-store if lost
+    // Only recover ACTIVE sessions to prevent OOM on large datasets (140+ sessions)
     const waves = waveMultiplexer.getActiveWaves();
     if (waves.length === 0) {
       const allSessions = listSessions();
-      const waveGroups = new Map<string, string[]>();
+      let recovered = 0;
       for (const ses of allSessions) {
-        if (ses.waveId) {
-          if (!waveGroups.has(ses.waveId)) waveGroups.set(ses.waveId, []);
-          waveGroups.get(ses.waveId)!.push(ses.id);
+        if (!ses.waveId || ses.status !== 'active') continue;
+        const exec = executionManager.getActiveExecution(ses.id);
+        if (exec) {
+          waveMultiplexer.registerSession(ses.waveId, exec);
+          recovered++;
         }
       }
-      // BUG-W03 fix: register ALL wave sessions (including completed) for tree display
-      for (const [wid, sids] of waveGroups) {
-        for (const sid of sids) {
-          // getActiveExecution falls back to stream recovery for completed sessions
-          const exec = executionManager.getActiveExecution(sid);
-          if (exec) {
-            waveMultiplexer.registerSession(wid, exec);
-          }
-        }
+      if (recovered > 0) {
+        console.log(`[WaveRecovery] Recovered ${recovered} active sessions`);
       }
     }
     jsonResponse(res, 200, { waves: waveMultiplexer.getActiveWaves() });
@@ -212,10 +208,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 +218,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 +232,7 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
         waveId: state.waveId,
         supervisorSessionId: state.supervisorSessionId,
         mode: 'supervisor',
-        directive,
+        directive: actualDirective,
       });
       return;
     }
@@ -482,13 +476,11 @@ function handleWaveStream(waveId: string, url: string, res: ServerResponse, req:
 
   let sessionIds = waveMultiplexer.getWaveSessionIds(waveId);
 
-  // Recovery: if wave→session mapping was lost (e.g. server restart),
-  // rebuild from session-store (sessions have waveId) + executionManager
+  // Recovery: only recover ACTIVE sessions for this wave (not all 140)
   if (sessionIds.length === 0) {
     const allSessions = listSessions();
-    const waveSessions = allSessions.filter(s => s.waveId === waveId);
+    const waveSessions = allSessions.filter(s => s.waveId === waveId && s.status === 'active');
     for (const ses of waveSessions) {
-      // getActiveExecution recovers from stream files for completed sessions too
       const exec = executionManager.getActiveExecution(ses.id);
       if (exec) {
         waveMultiplexer.registerSession(waveId, exec);
@@ -497,12 +489,8 @@ function handleWaveStream(waveId: string, url: string, res: ServerResponse, req:
     sessionIds = waveMultiplexer.getWaveSessionIds(waveId);
   }
 
-  if (sessionIds.length === 0) {
-    res.writeHead(404, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: `No sessions found for wave: ${waveId}` }));
-    return;
-  }
-
+  // Don't 404 on empty waves — keep SSE alive, sessions will appear later
+  // (e.g. idle wave waiting for first directive, or supervisor restarting)
   const client = waveMultiplexer.attach(waveId, res as any, fromWaveSeq);
 
   req.on('close', () => {
@@ -769,25 +757,26 @@ function handleStatus(res: ServerResponse): void {
     );
 
     const recovered: typeof activeExecs = [];
-    for (const ses of activeSessions) {
-      // Check activity-stream for actual running state
+    // Limit recovery scan to prevent OOM on large session stores
+    const MAX_RECOVERY_SCAN = 20;
+    const recentActive = activeSessions.slice(-MAX_RECOVERY_SCAN);
+
+    for (const ses of recentActive) {
       if (!ActivityStream.exists(ses.id)) continue;
+      // Only read last few events to check done/error (not entire stream)
       const events = ActivityStream.readFrom(ses.id, 0);
       if (events.length === 0) continue;
 
-      const startEvent = events.find(e => e.type === 'msg:start');
-      if (!startEvent) continue;
-
-      const doneEvent = events.find(e => e.type === 'msg:done');
-      const errorEvent = events.find(e => e.type === 'msg:error');
-
-      // Only include sessions that haven't finished yet
-      if (doneEvent || errorEvent) continue;
+      // Check last 5 events for done/error (optimization: don't scan entire file)
+      const tail = events.slice(-5);
+      const isDone = tail.some(e => e.type === 'msg:done' || e.type === 'msg:error');
+      if (isDone) continue;
 
-      const task = (startEvent.data?.task as string) ?? ses.title ?? '';
+      const startEvent = events.find(e => e.type === 'msg:start');
+      const task = (startEvent?.data?.task as string) ?? ses.title ?? '';
       recovered.push({
         id: `recovered-${ses.id}`,
-        type: (startEvent.data?.type as string ?? 'assign') as 'assign' | 'wave' | 'consult',
+        type: (startEvent?.data?.type as string ?? 'assign') as 'assign' | 'wave' | 'consult',
         roleId: ses.roleId,
         task,
         status: 'running',

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,25 @@ 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;
+
+      // Dual Mode: Conversation vs Dispatch (code-level enforcement)
+      // If directive looks like a question/status check → spawn conversation mode
+      // If directive looks like a task → spawn full supervisor with dispatch tools
+      if (this.isConversationDirective(text)) {
+        this.spawnConversation(state, text);
+      } else {
+        this.scheduleRestart(state, 0);
+      }
+    }
+
     return directive;
   }
 
@@ -215,6 +242,120 @@ class SupervisorHeartbeat {
       .filter(s => s.status === 'running' || s.status === 'starting' || s.status === 'restarting');
   }
 
+  /* ─── Internal: Dual Mode ─────────────────── */
+
+  /**
+   * Heuristic: is this directive a question/status check (conversation)
+   * or a work task (needs dispatch)?
+   *
+   * Conversation signals: question marks, status keywords, short length
+   * Dispatch signals: imperative verbs (만들어, 수정해, 구현해), long directives
+   */
+  private isConversationDirective(text: string): boolean {
+    const t = text.trim();
+
+    // Short messages with question marks → conversation
+    if (t.includes('?') && t.length < 100) return true;
+
+    // Korean question patterns
+    const questionPatterns = [
+      /확인해/, /알려줘/, /보여줘/, /어때/, /뭐야/, /뭐지/, /뭘까/,
+      /상태/, /상황/, /진행/, /현재/, /어디/, /얼마/,
+      /what/i, /how.*going/i, /status/i, /check/i, /show/i, /tell/i,
+    ];
+    if (questionPatterns.some(p => p.test(t))) return true;
+
+    // Long directives with action verbs → dispatch
+    const taskPatterns = [
+      /만들어/, /구현해/, /개발해/, /수정해/, /변경해/, /리팩토링/,
+      /설계해/, /작성해/, /배포해/, /테스트해/, /고쳐/,
+      /build/i, /create/i, /implement/i, /develop/i, /fix/i, /deploy/i, /refactor/i,
+    ];
+    if (taskPatterns.some(p => p.test(t))) return false;
+
+    // Default: short → conversation, long → dispatch
+    return t.length < 60;
+  }
+
+  /**
+   * Spawn a lightweight conversation session (no dispatch tools).
+   * CEO reads files and answers directly.
+   */
+  private spawnConversation(state: SupervisorState, directive: string): void {
+    // Build conversation context: previous directives + last execution summary
+    const deliveredDirectives = state.pendingDirectives.filter(d => d.delivered);
+    const directiveHistory = deliveredDirectives.length > 0
+      ? deliveredDirectives.map(d => `- CEO: "${d.text}"`).join('\n')
+      : '';
+
+    // Extract last execution's output from activity stream (what "just happened")
+    let lastExecutionSummary = '';
+    if (state.supervisorSessionId) {
+      try {
+        const events = ActivityStream.readAll(state.supervisorSessionId);
+        // Get last text outputs (the supervisor's final response)
+        const textEvents = events.filter(e => e.type === 'text' && e.roleId === 'ceo');
+        const toolEvents = events.filter(e => e.type === 'tool:start' && e.roleId === 'ceo');
+
+        // Summarize: what tools were used + final text
+        const toolSummary = toolEvents.slice(-10).map(e => {
+          const name = (e.data.name as string) ?? '';
+          const inp = e.data.input as Record<string, unknown> | undefined;
+          const detail = inp?.file_path ?? inp?.command ?? '';
+          return `  → ${name} ${String(detail).slice(0, 60)}`;
+        }).join('\n');
+
+        const lastText = textEvents.slice(-5).map(e => String(e.data.text ?? '')).join('').slice(-500);
+
+        if (toolSummary || lastText) {
+          lastExecutionSummary = `\n[Previous execution in this wave]\nTools used:\n${toolSummary}\n\nLast response:\n${lastText.slice(0, 500)}\n`;
+        }
+      } catch { /* ignore */ }
+    }
+
+    const context = [directiveHistory, lastExecutionSummary].filter(Boolean).join('\n');
+
+    const task = `${context ? context + '\n' : ''}[CEO Question] ${directive}
+
+You are the CEO's AI assistant. The above shows what happened previously in this wave.
+Answer the CEO's question based on context. Be specific — reference files, results, and actions from the previous execution.
+Do NOT dispatch anyone. Do NOT create new files. Just answer concisely.`;
+
+    // Reuse session
+    let sessionId = state.supervisorSessionId;
+    if (!sessionId || !getSession(sessionId)) {
+      const session = createSession('ceo', {
+        mode: 'do',
+        source: 'wave',
+        waveId: state.waveId,
+      });
+      sessionId = session.id;
+      state.supervisorSessionId = sessionId;
+    }
+
+    state.status = 'running';
+
+    try {
+      const exec = executionManager.startExecution({
+        type: 'assign',  // assign = no supervisor tools (dispatch/watch/amend)
+        roleId: 'ceo',
+        task,
+        sourceRole: 'ceo',
+        readOnly: true,   // readOnly = no code changes, conversation only
+        sessionId,
+      });
+
+      state.executionId = exec.id;
+      this.watchExecution(state, exec);
+
+      console.log(`[Supervisor] Conversation mode for wave ${state.waveId} | directive: ${directive.slice(0, 60)}`);
+    } catch (err) {
+      console.error(`[Supervisor] Conversation spawn failed:`, err);
+      // Fallback to full supervisor
+      this.scheduleRestart(state, 0);
+    }
+  }
+
   /* ─── Internal: Spawn / Restart ────────────── */
 
   private spawnSupervisor(state: SupervisorState): void {
@@ -245,12 +386,45 @@ class SupervisorHeartbeat {
       ? `\n\n⚠️ [RECOVERY] This is a restart after crash #${state.crashCount}. Check all session states via supervision watch.`
       : '';
 
-    const supervisorTask = `[CEO Supervisor] ${state.directive}
+    // Build conversation context from previous directives
+    const deliveredDirectives = state.pendingDirectives.filter(d => d.delivered);
+    const conversationHistory = deliveredDirectives.length > 0
+      ? `\n## Previous Conversation in This Wave
+${deliveredDirectives.map((d, i) => `${i + 1}. CEO said: "${d.text}"`).join('\n')}
+
+You are continuing this conversation. The CEO's latest message builds on the above context.
+Do NOT re-analyze from scratch — reference your previous findings.\n`
+      : '';
 
+    const supervisorTask = `[CEO Supervisor] ${state.directive}
+${conversationHistory}
 ## Your Role
-You are the CEO Supervisor — the root of the supervision tree.
-Your job: dispatch C-Level roles, watch their progress, relay opinions between them,
-and ensure the CEO's directive is fulfilled.
+You are the CEO Supervisor — the CEO's AI proxy.
+You can answer questions directly OR dispatch C-Level roles for complex work.
+
+## Response Mode Decision (BEFORE dispatching)
+
+⛔ Dispatch is expensive (spawns entire teams). Judge first:
+
+**1. Direct Answer** — Can YOU handle this without dispatching?
+   - Status check, progress report → Read files/docs yourself, answer directly
+   - Simple question → Answer directly
+   - Opinion request → Answer directly
+   - Clarification on previous work → Answer from context
+   → **Do NOT dispatch. Just answer.**
+
+**2. Selective Dispatch** — Only specific C-Level(s) needed?
+   - "코드 수정해" → CTO only
+   - "디자인 개선해" → CBO only
+   - "테스트해봐" → CTO only (who dispatches QA)
+   → **Dispatch only the relevant C-Level(s).**
+
+**3. Full Dispatch** — Multi-team collaboration required?
+   - "새 기능 만들어" → CTO + CBO
+   - "출시 준비해" → All C-Levels
+   → **Dispatch multiple C-Levels with clear tasks.**
+
+**Default: Direct Answer first. Dispatch only when code changes or creative work is needed.**
 
 ## Available C-Level Roles
 ${cLevelList}
@@ -333,13 +507,14 @@ ${state.continuous ? `## Continuous Improvement Mode (ON)
 5. 사용자가 Stop을 누를 때까지 계속한다. 스스로 done 선언하지 마라.
 
 ` : ''}## Instructions
-1. Analyze the directive and decide which C-Level roles to dispatch (not necessarily all)
-2. Dispatch them with clear tasks
-3. Enter supervision watch loop
-4. Monitor, **actively relay results between teams**, course-correct
-5. When subordinates report done → **verify deliverables against requirements (G-09)**
-6. If gaps exist → re-dispatch with specific feedback. Repeat 3-5.
-7. Only when ALL requirements are met → compile results and report`;
+1. **First: Apply Response Mode Decision** — Can you answer directly? If yes, answer and report done.
+2. If dispatch is needed: decide which C-Level roles (not necessarily all)
+3. Dispatch with clear, specific tasks
+4. Enter supervision watch loop
+5. Monitor, **actively relay results between teams**, course-correct
+6. When subordinates report done → **verify deliverables against requirements (G-09)**
+7. If gaps exist → re-dispatch with specific feedback. Repeat 4-6.
+8. Only when ALL requirements are met → compile results and report`;
 
     // BUG-008 fix: Wave:Supervisor:Session = 1:1:1 invariant.
     // Reuse existing session on restart instead of creating a new one.

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);