tycono 0.1.96-beta.13 → 0.1.96-beta.15

package/package.json

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

package/src/tui/app.tsx

@@ -134,10 +134,10 @@ export const App: React.FC = () => {
 
     switch (result.type) {
       case 'wave_started':
-        addSystemMessage(`\u26A1 ${result.message}`, 'yellow');
+        // Don't show wave ID noise — supervisor handles it
         break;
       case 'directive_sent':
-        addSystemMessage(`\u26A1 ${result.message}`, 'yellow');
+        // Silently sent — supervisor will respond
         break;
       case 'stopped':
         addSystemMessage(`\u26A1 ${result.message}`, 'red');
@@ -146,16 +146,14 @@ export const App: React.FC = () => {
         addSystemMessage(result.message, 'red');
         break;
       case 'help':
-        addSystemMessage('Commands:', 'cyan');
-        addSystemMessage('  wave <directive> [--continuous]  Start a wave', 'white');
-        addSystemMessage('  directive <text>                 Send directive to active wave', 'white');
-        addSystemMessage('  stop                             Stop all active executions', 'white');
-        addSystemMessage('  status                           Show current status', 'white');
-        addSystemMessage('  assign <role> <task>             Assign task to role', 'white');
-        addSystemMessage('  summary                          Show last wave summary', 'white');
-        addSystemMessage('  roles                            Show org tree (Panel Mode)', 'white');
-        addSystemMessage('  help                             Show this help', 'white');
-        addSystemMessage('  quit                             Exit TUI', 'white');
+        addSystemMessage('Type naturally to talk to your AI team.', 'cyan');
+        addSystemMessage('Commands (/ prefix):', 'cyan');
+        addSystemMessage('  /stop                Stop all executions', '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');
         break;
       case 'info':
@@ -231,20 +229,6 @@ export const App: React.FC = () => {
 
   return (
     <Box flexDirection="column" height={termHeight}>
-      {/* Status Bar — always shown */}
-      <StatusBar
-        companyName={api.company?.name ?? 'Loading...'}
-        waveId={effectiveWaveId}
-        waveStatus={derivedWaveStatus}
-        activeCount={activeCount}
-        totalCost={0}
-      />
-
-      {/* Separator */}
-      <Box width="100%">
-        <Text color="gray">{'─'.repeat(process.stdout.columns || 70)}</Text>
-      </Box>
-
       {/* Mode content — fill remaining height */}
       <Box flexGrow={1} flexDirection="column">
       {mode === 'command' ? (
@@ -278,6 +262,15 @@ export const App: React.FC = () => {
         />
       )}
       </Box>
+
+      {/* Status Bar — bottom (Claude Code style) */}
+      <StatusBar
+        companyName={api.company?.name ?? 'Loading...'}
+        waveId={effectiveWaveId}
+        waveStatus={derivedWaveStatus}
+        activeCount={activeCount}
+        totalCost={0}
+      />
     </Box>
   );
 };

package/src/tui/components/CommandMode.tsx

@@ -1,13 +1,10 @@
 /**
- * CommandMode — default mode: stream summary flowing above, command input below
+ * CommandMode — chat-first mode
  *
- * SSE events are compressed into one-line summaries:
- *   dispatch:start → "CEO -> CTO Su (supervising...)"
- *   text           → "FE: Canvas game loop implementation..."
- *   tool:start     → "FE: -> edit index.html +87 lines"
- *   msg:done       → "QA: done (12 turns)"
- *   msg:error      → "FE: TypeError at line 42"
- *   thinking, heartbeat, trace → hidden
+ * User = CEO. Supervisor (ceo role) = user's AI proxy.
+ * - Supervisor responses: shown directly (no prefix), like a conversation
+ * - Team activity: indented with roleId, concise
+ * - System prompts, internal noise: filtered out
  */
 
 import React, { useState, useCallback } from 'react';
@@ -16,7 +13,8 @@ import TextInput from 'ink-text-input';
 import type { SSEEvent } from '../api';
 import { getRoleColor } from '../theme';
 
-const MAX_STREAM_LINES = 20;
+const MAX_STREAM_LINES = 30;
+const SUPERVISOR_ROLE = 'ceo';
 
 export interface StreamLine {
   id: number;
@@ -24,6 +22,7 @@ export interface StreamLine {
   color: string;
   prefix?: string;
   prefixColor?: string;
+  indent?: boolean;
 }
 
 interface CommandModeProps {
@@ -35,21 +34,70 @@ interface CommandModeProps {
 
 let lineCounter = 0;
 
-/** Convert SSE event to a one-line summary. Returns null if event should be hidden. */
+/** Filter out system prompt noise from text */
+function isSystemNoise(text: string): boolean {
+  const t = text.trim();
+  if (!t) return true;
+  // System prompt fragments
+  if (t.startsWith('## Your Role')) return true;
+  if (t.startsWith('You are')) return true;
+  if (t.startsWith('[CEO Supervisor]')) return true;
+  if (t.startsWith('[Question from')) return true;
+  if (t.includes('⛔ AKB Rule')) return true;
+  if (t.includes('⛔  Read the')) return true;
+  if (t.startsWith('⛔')) return true;
+  return false;
+}
+
+/** Convert SSE event to stream lines */
 export function summarizeEvent(event: SSEEvent, allRoleIds: string[]): StreamLine | null {
+  const isSupervisor = event.roleId === SUPERVISOR_ROLE;
   const roleColor = getRoleColor(event.roleId, allRoleIds);
-  const roleName = event.roleId;
 
   switch (event.type) {
+    case 'text': {
+      const text = ((event.data.text as string) ?? '');
+      if (isSystemNoise(text)) return null;
+
+      if (isSupervisor) {
+        // Supervisor text → direct response (no prefix, generous length)
+        return {
+          id: ++lineCounter,
+          text: text.slice(0, 200),
+          color: 'white',
+        };
+      } else {
+        // Team text → indented with role prefix, concise
+        return {
+          id: ++lineCounter,
+          prefix: event.roleId,
+          prefixColor: roleColor,
+          text: text.slice(0, 80),
+          color: 'white',
+          indent: true,
+        };
+      }
+    }
+
     case 'dispatch:start': {
       const target = (event.data.targetRole as string) ?? '';
-      const task = ((event.data.task as string) ?? '').slice(0, 50);
+      const task = ((event.data.task as string) ?? '');
+      // Filter out system prompt from task display
+      const cleanTask = task.replace(/⛔[^⛔]*⛔[^"]*/g, '').trim().slice(0, 50);
+      if (isSupervisor) {
+        return {
+          id: ++lineCounter,
+          text: `→ ${target} 배정${cleanTask ? ': ' + cleanTask : ''}`,
+          color: 'yellow',
+        };
+      }
       return {
         id: ++lineCounter,
-        prefix: roleName,
+        prefix: event.roleId,
         prefixColor: roleColor,
-        text: `\u2192 ${target} (${task || 'dispatching...'})`,
+        text: `→ ${target} 배정`,
         color: 'yellow',
+        indent: true,
       };
     }
 
@@ -57,22 +105,11 @@ export function summarizeEvent(event: SSEEvent, allRoleIds: string[]): StreamLin
       const target = (event.data.targetRole as string) ?? '';
       return {
         id: ++lineCounter,
-        prefix: roleName,
+        prefix: event.roleId,
         prefixColor: roleColor,
-        text: `\u2190 ${target} completed`,
+        text: `← ${target} 완료`,
         color: 'yellow',
-      };
-    }
-
-    case 'text': {
-      const text = ((event.data.text as string) ?? '').slice(0, 60);
-      if (!text.trim()) return null;
-      return {
-        id: ++lineCounter,
-        prefix: roleName,
-        prefixColor: roleColor,
-        text,
-        color: 'white',
+        indent: !isSupervisor,
       };
     }
 
@@ -85,35 +122,49 @@ export function summarizeEvent(event: SSEEvent, allRoleIds: string[]): StreamLin
         if (inp.file_path) detail = ` ${String(inp.file_path).split('/').pop()}`;
         else if (inp.command) detail = ` ${String(inp.command).slice(0, 40)}`;
       }
+
+      if (isSupervisor) {
+        // Supervisor tool use → subtle
+        return {
+          id: ++lineCounter,
+          text: `  → ${toolName}${detail}`,
+          color: 'gray',
+        };
+      }
       return {
         id: ++lineCounter,
-        prefix: roleName,
+        prefix: event.roleId,
         prefixColor: roleColor,
-        text: `\u2192 ${toolName}${detail}`,
+        text: `→ ${toolName}${detail}`,
         color: 'gray',
+        indent: true,
       };
     }
 
     case 'msg:start': {
-      const task = ((event.data.task as string) ?? '').slice(0, 50);
+      if (isSupervisor) return null; // Hide supervisor start (noise)
+      const task = ((event.data.task as string) ?? '');
+      const cleanTask = task.replace(/⛔[^⛔]*⛔[^"]*/g, '').trim().slice(0, 40);
       return {
         id: ++lineCounter,
-        prefix: roleName,
+        prefix: event.roleId,
         prefixColor: roleColor,
-        text: `\u25B6 ${task || 'started'}`,
+        text: `▶ ${cleanTask || 'started'}`,
         color: 'green',
+        indent: true,
       };
     }
 
     case 'msg:done': {
       const turns = event.data.turns as number | undefined;
-      const turnLabel = turns ? ` (${turns} turns)` : '';
+      if (isSupervisor) return null; // Hide supervisor done
       return {
         id: ++lineCounter,
-        prefix: roleName,
+        prefix: event.roleId,
         prefixColor: roleColor,
-        text: `\u2713 done${turnLabel}`,
+        text: `✓ done${turns ? ` (${turns} turns)` : ''}`,
         color: 'green',
+        indent: true,
       };
     }
 
@@ -121,24 +172,22 @@ export function summarizeEvent(event: SSEEvent, allRoleIds: string[]): StreamLin
       const error = ((event.data.error as string) ?? '').slice(0, 60);
       return {
         id: ++lineCounter,
-        prefix: roleName,
+        prefix: event.roleId,
         prefixColor: roleColor,
-        text: `\u2717 ${error}`,
+        text: `✗ ${error}`,
         color: 'red',
+        indent: !isSupervisor,
       };
     }
 
-    case 'msg:awaiting_input': {
+    case 'msg:awaiting_input':
       return {
         id: ++lineCounter,
-        prefix: roleName,
-        prefixColor: roleColor,
-        text: '? Awaiting input...',
+        text: isSupervisor ? '...' : `  ${event.roleId}: waiting`,
         color: 'yellow',
       };
-    }
 
-    // Hidden events
+    // Hidden
     case 'thinking':
     case 'heartbeat:tick':
     case 'heartbeat:skip':
@@ -185,18 +234,17 @@ export const CommandMode: React.FC<CommandModeProps> = ({
         {allLines.length === 0 && (
           <Box marginTop={1}>
             <Text color="gray" dimColor>
-              Ready. Type "wave &lt;directive&gt;" to start, or "help" for commands.
+              Type a message to your AI team, or /help for commands.
             </Text>
           </Box>
         )}
         {allLines.map((line) => (
           <Box key={line.id}>
+            {line.indent && <Text>  </Text>}
             {line.prefix && (
-              <>
-                <Text color={line.prefixColor} bold>
-                  {(line.prefix + ':').padEnd(14)}
-                </Text>
-              </>
+              <Text color={line.prefixColor} bold>
+                {(line.prefix).padEnd(12)}
+              </Text>
             )}
             <Text color={line.color}>{line.text}</Text>
           </Box>
@@ -208,10 +256,10 @@ export const CommandMode: React.FC<CommandModeProps> = ({
         <Text color="gray">{'─'.repeat(process.stdout.columns || 70)}</Text>
       </Box>
 
-      {/* Command input */}
+      {/* Input */}
       <Box paddingX={1} justifyContent="space-between">
         <Box>
-          <Text color="green" bold>&gt; </Text>
+          <Text color="yellow" bold>&gt; </Text>
           <TextInput
             value={input}
             onChange={setInput}

package/src/tui/components/StatusBar.tsx

@@ -1,5 +1,6 @@
 /**
- * StatusBar — top bar showing company name, wave status, active count, cost
+ * StatusBar — bottom bar (Claude Code style)
+ * Shows: company name, wave status, active roles, cost
  */
 
 import React from 'react';
@@ -21,29 +22,33 @@ export const StatusBar: React.FC<StatusBarProps> = ({
   totalCost,
 }) => {
   const waveLabel = waveId
-    ? `Wave ${waveId.replace('wave-', '#')} ${waveStatus === 'running' ? '\u25CF' : waveStatus === 'done' ? '\u2713' : ''} ${waveStatus}`
-    : 'No active wave';
+    ? `Wave ${waveId.replace('wave-', '#')}`
+    : '';
+  const statusDot = waveStatus === 'running' ? ' ●'
+    : waveStatus === 'done' ? ' ✓'
+    : '';
 
   return (
-    <Box
-      width="100%"
-      paddingX={1}
-      justifyContent="space-between"
-    >
-      <Box>
-        <Text bold color="cyan">TYCONO</Text>
-        <Text color="white"> </Text>
-        <Text color="white">{companyName}</Text>
-      </Box>
-      <Box>
-        <Text color={waveStatus === 'running' ? 'green' : 'gray'}>
-          {waveLabel}
-        </Text>
-        <Text color="white">  </Text>
-        <Text color="yellow">{activeCount} active</Text>
-        <Text color="white">  </Text>
-        <Text color="green">${totalCost.toFixed(2)}</Text>
-      </Box>
+    <Box width="100%" paddingX={1}>
+      <Text color="cyan" bold>Tycono</Text>
+      <Text color="gray"> | </Text>
+      <Text color="white">{companyName}</Text>
+      {waveLabel && (
+        <>
+          <Text color="gray"> | </Text>
+          <Text color={waveStatus === 'running' ? 'green' : 'gray'}>
+            {waveLabel}{statusDot}
+          </Text>
+        </>
+      )}
+      {activeCount > 0 && (
+        <>
+          <Text color="gray"> | </Text>
+          <Text color="yellow">{activeCount} active</Text>
+        </>
+      )}
+      <Text color="gray"> | </Text>
+      <Text color="green">${totalCost.toFixed(2)}</Text>
     </Box>
   );
 };

package/src/tui/hooks/useCommand.ts

@@ -1,54 +1,25 @@
 /**
- * useCommand — command parsing + execution for TUI v2 Command Mode
+ * useCommand — input handler for TUI v2
  *
- * Commands:
- *   wave <directive> [--continuous]  — dispatch a wave
- *   directive <text>                 — send directive to active wave
- *   stop                            — abort all active executions
- *   status                          — show current wave + session status
- *   assign <role> <task>            — assign task to specific role
- *   summary                         — show last wave summary
- *   roles                           — show org tree inline
- *   help                            — show help
- *   quit                            — exit
+ * Default: natural language → wave dispatch or directive (if wave active)
+ * Commands (/ prefix):
+ *   /stop                — abort all active executions
+ *   /status              — show current wave + session status
+ *   /assign <role> <task> — assign task to specific role
+ *   /roles               — show org tree (Panel Mode)
+ *   /help                — show help
+ *   /quit                — exit
  */
 
 import { useCallback } from 'react';
 import { dispatchWave, sendDirective, fetchJson } from '../api';
 
-export interface ParsedCommand {
-  cmd: string;
-  args: string;
-  flags: Record<string, boolean>;
-}
-
 export interface CommandResult {
   type: 'success' | 'error' | 'info' | 'wave_started' | 'directive_sent' | 'stopped' | 'quit' | 'help' | 'panel';
   message: string;
   waveId?: string;
 }
 
-export function parseCommand(input: string): ParsedCommand {
-  const trimmed = input.trim();
-  if (!trimmed) return { cmd: '', args: '', flags: {} };
-
-  const parts = trimmed.split(/\s+/);
-  const cmd = parts[0].toLowerCase();
-  const flags: Record<string, boolean> = {};
-  const argParts: string[] = [];
-
-  for (let i = 1; i < parts.length; i++) {
-    if (parts[i].startsWith('--')) {
-      const flagName = parts[i].slice(2);
-      if (flagName) flags[flagName] = true;
-    } else {
-      argParts.push(parts[i]);
-    }
-  }
-
-  return { cmd, args: argParts.join(' '), flags };
-}
-
 async function postAbortAll(): Promise<void> {
   try {
     const status = await fetchJson<{
@@ -88,97 +59,83 @@ export function useCommand(options: UseCommandOptions) {
   const { activeWaveId, onWaveStarted, onStopped, onQuit, onShowPanel } = options;
 
   const execute = useCallback(async (input: string): Promise<CommandResult> => {
-    const { cmd, args, flags } = parseCommand(input);
-
-    if (!cmd) return { type: 'info', message: '' };
-
-    switch (cmd) {
-      case 'wave': {
-        if (!args) {
-          return { type: 'error', message: 'Usage: wave <directive> [--continuous]' };
-        }
-        try {
-          const result = await dispatchWave(args, { continuous: flags.continuous });
-          onWaveStarted(result.waveId);
-          const modeLabel = flags.continuous ? ' (continuous)' : '';
-          return {
-            type: 'wave_started',
-            message: `Wave ${result.waveId.replace('wave-', '#')} started${modeLabel}`,
-            waveId: result.waveId,
-          };
-        } catch (err) {
-          return { type: 'error', message: `Wave failed: ${err instanceof Error ? err.message : 'unknown'}` };
-        }
-      }
-
-      case 'directive': {
-        if (!args) {
-          return { type: 'error', message: 'Usage: directive <text>' };
-        }
-        if (!activeWaveId) {
-          return { type: 'error', message: 'No active wave. Start one with: wave <directive>' };
-        }
-        try {
-          await sendDirective(activeWaveId, args);
-          return { type: 'directive_sent', message: `Directive sent to ${activeWaveId.replace('wave-', 'Wave #')}` };
-        } catch (err) {
-          return { type: 'error', message: `Directive failed: ${err instanceof Error ? err.message : 'unknown'}` };
-        }
-      }
-
-      case 'stop': {
-        try {
-          await postAbortAll();
-          onStopped();
-          return { type: 'stopped', message: 'All active executions stopped.' };
-        } catch (err) {
-          return { type: 'error', message: `Stop failed: ${err instanceof Error ? err.message : 'unknown'}` };
+    const trimmed = input.trim();
+    if (!trimmed) return { type: 'info', message: '' };
+
+    // Slash commands: /stop, /status, /help, /quit, /roles, /assign
+    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': {
+          try {
+            await postAbortAll();
+            onStopped();
+            return { type: 'stopped', message: 'All active executions stopped.' };
+          } catch (err) {
+            return { type: 'error', message: `Stop failed: ${err instanceof Error ? err.message : 'unknown'}` };
+          }
         }
-      }
 
-      case 'status': {
-        return { type: 'info', message: '__status__' };
-      }
+        case 'status':
+          return { type: 'info', message: '__status__' };
 
-      case 'assign': {
-        const spaceIdx = args.indexOf(' ');
-        if (spaceIdx === -1 || !args) {
-          return { type: 'error', message: 'Usage: assign <role> <task>' };
-        }
-        const roleId = args.slice(0, spaceIdx);
-        const task = args.slice(spaceIdx + 1);
-        try {
-          const result = await postAssign(roleId, task);
-          if (result.waveId) {
-            onWaveStarted(result.waveId);
+        case 'assign': {
+          const spaceIdx = args.indexOf(' ');
+          if (spaceIdx === -1 || !args) {
+            return { type: 'error', message: 'Usage: /assign <role> <task>' };
+          }
+          const roleId = args.slice(0, spaceIdx);
+          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'}` };
           }
-          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'}` };
         }
-      }
 
-      case 'summary': {
-        return { type: 'info', message: '__summary__' };
-      }
+        case 'roles':
+          onShowPanel();
+          return { type: 'panel', message: '' };
 
-      case 'roles': {
-        onShowPanel();
-        return { type: 'panel', message: 'Switching to Panel Mode...' };
-      }
+        case 'help':
+          return { type: 'help', message: '__help__' };
 
-      case 'help': {
-        return { type: 'help', message: '__help__' };
-      }
+        case 'quit':
+        case 'exit':
+          onQuit();
+          return { type: 'quit', message: 'Goodbye!' };
 
-      case 'quit':
-      case 'exit': {
-        onQuit();
-        return { type: 'quit', message: 'Goodbye!' };
+        default:
+          return { type: 'error', message: `Unknown command: /${cmd}. Type /help for commands.` };
       }
+    }
 
-      default: {
-        return { type: 'error', message: `Unknown command: ${cmd}. Type "help" for available commands.` };
+    // Default: natural language → directive (if wave active) or new wave
+    if (activeWaveId) {
+      try {
+        await sendDirective(activeWaveId, trimmed);
+        return { type: 'directive_sent', message: `Directive sent` };
+      } catch (err) {
+        return { type: 'error', message: `Failed: ${err instanceof Error ? err.message : 'unknown'}` };
+      }
+    } else {
+      try {
+        const result = await dispatchWave(trimmed);
+        onWaveStarted(result.waveId);
+        return {
+          type: 'wave_started',
+          message: `Wave ${result.waveId.replace('wave-', '#')} started`,
+          waveId: result.waveId,
+        };
+      } catch (err) {
+        return { type: 'error', message: `Wave failed: ${err instanceof Error ? err.message : 'unknown'}` };
       }
     }
   }, [activeWaveId, onWaveStarted, onStopped, onQuit, onShowPanel]);