tycono 0.1.96-beta.9 → 0.1.96

package/bin/tycono.ts

@@ -19,18 +19,17 @@ function printHelp(): void {
   Build an AI company. Watch them work.
 
   Usage:
-    tycono [path]       Start the server (optionally point to a company directory)
-    tycono tui          Start API server + TUI mode
-    tycono tui --attach Connect TUI to existing API server
+    tycono [path]       Start TUI (default, optionally point to a company directory)
+    tycono --classic    Start pixel office web UI
+    tycono --attach     Connect TUI to existing API server
     tycono --help       Show this help message
     tycono --version    Show version
 
   Examples:
-    tycono                      Start in current directory
-    tycono ./my-company         Start with existing company folder
-    tycono /path/to/akb         Start with absolute path
-    tycono tui                  Start with terminal UI
-    PORT=3000 tycono tui --attach  Attach TUI to running server
+    tycono                      Start TUI in current directory
+    tycono ./my-company         Start TUI with existing company folder
+    tycono --classic            Start pixel office web UI
+    PORT=3000 tycono --attach   Attach TUI to running server
 
   AI Engine (auto-detected):
     1. Claude Code CLI       Install from https://claude.ai/download (recommended)
@@ -219,8 +218,16 @@ async function startServerForTui(): Promise<void> {
   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 origLog = (...args: unknown[]) => origStdoutWrite(args.join(' ') + '\n');
+
+  // Redirect console + stdout.write to suppress server logs
+  // ⛔ Do NOT redirect process.stderr.write — breaks Node.js http client
+  console.log = (...a: unknown[]) => { logStream.write(a.join(' ') + '\n'); };
+  console.error = (...a: unknown[]) => { logStream.write(a.join(' ') + '\n'); };
+  console.warn = (...a: unknown[]) => { logStream.write(a.join(' ') + '\n'); };
+  console.info = (...a: unknown[]) => { logStream.write(a.join(' ') + '\n'); };
+
+  // Intercept stdout.write — allow Ink (ANSI), redirect server text to log
   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();
@@ -228,19 +235,12 @@ async function startServerForTui(): Promise<void> {
     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();
 
-  const host = process.env.HOST || '0.0.0.0';
-
   await new Promise<void>((resolve) => {
-    server.listen(port, host, () => resolve());
+    server.listen(port, '0.0.0.0', () => resolve());
   });
 
   origLog(`  API server started on port ${port}`);
@@ -254,7 +254,7 @@ async function startServerForTui(): Promise<void> {
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 
-  // Start TUI
+  // Start TUI — stdout.write is NOT intercepted, Ink has full control
   const { startTui } = await import('../src/tui/index.tsx');
   await startTui({ port });
 }
@@ -272,24 +272,37 @@ export async function main(args: string[]): Promise<void> {
     return;
   }
 
-  // tui subcommand: start API server + TUI mode
+  // --classic: legacy pixel office web UI
+  if (command === '--classic' || args.includes('--classic')) {
+    if (command === '--classic' && args[1] && !args[1].startsWith('-')) {
+      process.env.COMPANY_ROOT = path.resolve(args[1]);
+    }
+    await startServer();
+    return;
+  }
+
+  // --attach: connect TUI to existing API server
+  if (command === '--attach' || args.includes('--attach')) {
+    const port = process.env.PORT ? Number(process.env.PORT) : 3000;
+    const { startTui } = await import('../src/tui/index.tsx');
+    await startTui({ port });
+    return;
+  }
+
+  // Legacy: `tui` subcommand still works
   if (command === 'tui') {
-    const attachMode = args.includes('--attach');
-    // If --attach, skip server start — just connect to existing API
-    if (attachMode) {
+    if (args.includes('--attach')) {
       const port = process.env.PORT ? Number(process.env.PORT) : 3000;
       const { startTui } = await import('../src/tui/index.tsx');
       await startTui({ port });
       return;
     }
-
-    // Start API server, then TUI
     await startServerForTui();
     return;
   }
 
+  // Path argument: treat as company directory
   if (command && !command.startsWith('-')) {
-    // Treat as path to company directory
     const resolved = path.resolve(command);
     if (!fs.existsSync(resolved)) {
       console.error(`  Path not found: ${resolved}`);
@@ -298,5 +311,27 @@ export async function main(args: string[]): Promise<void> {
     process.env.COMPANY_ROOT = resolved;
   }
 
-  await startServer();
+  // Show first-run notice (once only)
+  const prefsPath = path.resolve(process.env.COMPANY_ROOT || process.cwd(), '.tycono', 'preferences.json');
+  let prefs: Record<string, unknown> = {};
+  try { prefs = JSON.parse(fs.readFileSync(prefsPath, 'utf-8')); } catch {}
+  if (!prefs.tuiNoticeShown) {
+    console.log('');
+    console.log('  Tycono v' + VERSION + ' — AI Company OS');
+    console.log('');
+    console.log('  New: Terminal mode is now the default.');
+    console.log('  Faster, scriptable, built for work.');
+    console.log('');
+    console.log('  Looking for the pixel office?');
+    console.log('  → npx tycono --classic');
+    console.log('');
+    prefs.tuiNoticeShown = true;
+    try {
+      fs.mkdirSync(path.dirname(prefsPath), { recursive: true });
+      fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2));
+    } catch {}
+  }
+
+  // Default: TUI mode
+  await startServerForTui();
 }

package/package.json

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

package/src/api/src/create-server.ts

@@ -227,8 +227,12 @@ export function createExpressApp(): express.Application {
   }
 
   app.use((err: Error, req: express.Request, res: express.Response, _next: express.NextFunction) => {
-    console.error(`[ERROR] ${req.method} ${req.url} — ${err.message}`);
     const status = err.name === 'FileNotFoundError' ? 404 : 500;
+    // Log server errors via console.error (redirected to log file in TUI mode)
+    // 404 errors are expected (e.g. fresh install, no company.md) — skip
+    if (status >= 500) {
+      console.error(`[ERROR] ${req.method} ${req.url} — ${err.message}`);
+    }
     res.status(status).json({ error: err.message });
   });
 

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/server.ts

@@ -1,11 +1,40 @@
 import { COMPANY_ROOT } from './services/file-reader.js';
 import { applyConfig } from './services/company-config.js';
 import { createHttpServer } from './create-server.js';
+import { listSessions, updateSession } from './services/session-store.js';
+import { ActivityStream } from './services/activity-stream.js';
 
 // Load .tycono/config.json and apply to process.env
 const config = applyConfig(COMPANY_ROOT);
 console.log(`[STARTUP] Engine: ${config.engine}, API key: ${config.apiKey ? 'set' : 'none'}`);
 
+// Startup: mark orphaned 'active' sessions as 'interrupted'
+// These are sessions from a previous server that crashed or was killed
+{
+  const allSessions = listSessions();
+  let orphaned = 0;
+  for (const ses of allSessions) {
+    if (ses.status !== 'active') continue;
+    // Check activity stream — if it has msg:done/msg:error, mark done
+    // If not, mark interrupted (previous server died mid-execution)
+    if (ActivityStream.exists(ses.id)) {
+      const events = ActivityStream.readFrom(ses.id, 0);
+      const tail = events.slice(-5);
+      const isDone = tail.some(e => e.type === 'msg:done' || e.type === 'msg:error');
+      if (isDone) {
+        updateSession(ses.id, { status: 'done' });
+        orphaned++;
+        continue;
+      }
+    }
+    updateSession(ses.id, { status: 'interrupted' as any });
+    orphaned++;
+  }
+  if (orphaned > 0) {
+    console.log(`[STARTUP] Cleaned ${orphaned} orphaned sessions (active → done/interrupted)`);
+  }
+}
+
 const PORT = Number(process.env.PORT) || 3001;
 const server = createHttpServer();
 
@@ -13,3 +42,18 @@ server.listen(PORT, () => {
   console.log(`[API] Server running on http://localhost:${PORT}`);
   console.log(`[API] COMPANY_ROOT: ${COMPANY_ROOT}`);
 });
+
+// Graceful shutdown: mark running sessions as interrupted
+function gracefulShutdown(signal: string) {
+  console.log(`[SHUTDOWN] ${signal} received, marking active sessions as interrupted...`);
+  const sessions = listSessions();
+  for (const ses of sessions) {
+    if (ses.status === 'active') {
+      updateSession(ses.id, { status: 'interrupted' as any });
+    }
+  }
+  process.exit(0);
+}
+
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

package/src/api/src/services/execution-manager.ts

@@ -10,7 +10,7 @@ import { estimateCost } from './pricing.js';
 import { readConfig, getConversationLimits, resolveCodeRoot } from './company-config.js';
 import { postKnowledgingCheck, type KnowledgeDebtItem } from '../engine/knowledge-gate.js';
 import { earnCoinsInternal } from '../routes/coins.js';
-import { getSession, createSession, addMessage, updateMessage as updateSessionMessage, appendMessageEvent, type Message, type ImageAttachment } from './session-store.js';
+import { getSession, createSession, addMessage, updateMessage as updateSessionMessage, updateSession, appendMessageEvent, type Message, type ImageAttachment } from './session-store.js';
 import { portRegistry, type PortAllocation } from './port-registry.js';
 import { type MessageStatus, isMessageActive, canTransition, messageStatusToRoleStatus } from '../../../shared/types.js';
 
@@ -603,6 +603,12 @@ class ExecutionManager {
         knowledgeDebt: execution.knowledgeDebt.map(d => ({ type: d.type, file: d.file, message: d.message })),
       }),
     });
+
+    // Mark session as done in session-store (persisted to file)
+    // Skip CEO supervisor sessions — they stay active for wave lifecycle
+    if (session.roleId !== 'ceo' || session.source !== 'wave') {
+      updateSession(execution.sessionId, { status: 'done' });
+    }
   }
 
   private cleanupOrphanedChildren(parentSessionId: string): void {

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.