tycono 0.1.96-beta.3 → 0.1.96-beta.30

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,26 +25,76 @@
 
 ---
 
-**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
 ```
 
+## Core Pillars
+
+### 1. CEO Supervisor — Org-chart orchestration
+
+You give one order. The system dispatches through a real hierarchy.
+
+```
+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.
+
+- **Wave Center** — Org-tree dispatch with real-time streaming
+- **Activity Stream** — Every event logged (dispatches, tool calls, decisions)
+- **CEO Directive** — Change direction while agents are running
+- **Cost Tracking** — Per-role, per-model token breakdown
+
+### 3. Isolation Infrastructure — Agents don't collide
+
+Multiple agents working simultaneously without stepping on each other.
+
+| Resource | Isolation | Status |
+|----------|-----------|--------|
+| **Code** | Git worktree per session | Designed |
+| **Ports** | Dynamic port registry | ✅ Live |
+| **Browser** | Separate daemon per session | ✅ Live |
+| **Knowledge** | Shared reads, scoped writes | ✅ Live |
+
+### 4. AKB (Pre-K / Post-K) — Knowledge that compounds
+
+Every AI tool today: `Plan → Execute → Done`. Knowledge resets. Tycono adds what the industry doesn't have:
+
+```
+Pre-K:  Read existing knowledge → Plan grounded in what the company knows
+Execute: Do the work
+Post-K: Extract insights → Cross-link → Register in knowledge graph
+```
+
+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 — file-based, cross-linked |
-| **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 | Isometric office + Slack-style Pro dashboard |
+| **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
 
@@ -80,33 +130,46 @@ A setup wizard guides you through:
 - Node.js >= 18
 - [Anthropic API key](https://console.anthropic.com/) or Claude Max subscription
 
-## Two Ways to Work
+## Interfaces
 
-### Office View — Watch your AI team
+### Web Dashboard — Visual management
 
-An isometric pixel-art office where your AI agents sit at their desks, work, chat, and think. Click any agent to talk to them directly.
+A browser-based dashboard for visual management. Org tree, Wave dispatch, Knowledge graph, Activity stream.
 
 <p align="center">
-  <img src=".github/assets/hero-office.png" alt="Office View" width="640" />
+  <img src=".github/assets/hero-office.png" alt="Web Dashboard" width="640" />
 </p>
 
-- Pixel-art characters with personalities and levels
-- Ambient speech bubbles — agents think out loud
-- Rooms: Leadership, Engineering, Meeting, Knowledge Library
-- Edit mode — rearrange furniture, customize your office
+- **Wave Center** — selective org-tree dispatch with target checkboxes
+- **Chats** — 1:1 conversations with any role, persistent sessions
+- **Knowledge Base** — graph/tree/list views, cross-linked documents
+- **Decisions** — CEO strategic decision log with full context
 
-### Pro View — Manage your AI company
+### TUI — Terminal-native operations *(coming soon)*
 
-A Slack-style professional dashboard for serious work. Chats, Wave dispatch, Decisions log, Knowledge graph.
+For developers who live in the terminal. A k9s/lazygit-style multi-panel TUI built with [Ink](https://github.com/vadimdemedes/ink).
 
-<p align="center">
-  <img src=".github/assets/pro-view.png" alt="Pro View" width="640" />
-</p>
+```
+┌──────────────────────────────────────────────────┐
+│ TYCONO v0.2  │ Wave #37 running │ 3 active │$2.1│
+├──────────────┬───────────────────────────────────┤
+│ [Org Tree]   │ [Real-time Stream]                │
+│  CEO         │  CTO: "Reviewing architecture..." │
+│  ├ CTO ●     │    → dispatch → Engineer          │
+│  │ ├ ENG ○   │  CBO: "Market analysis done" ✓    │
+│  │ └ QA  ○   │                                   │
+│  └ CBO ●     │                                   │
+├──────────────┴───────────────────────────────────┤
+│ > wave "Write the Q1 strategy report"            │
+└──────────────────────────────────────────────────┘
+```
 
-- **Wave Center** — selective org-tree dispatch with target checkboxes
-- **Chats** — 1:1 conversations with any role, persistent sessions
-- **Knowledge Base** — graph/tree/list views, 194+ cross-linked documents
-- **Decisions** — CEO strategic decision log with full context
+```bash
+npx tycono --tui     # Terminal mode (coming soon)
+npx tycono           # Web dashboard (current)
+```
+
+Same API server, same engine — just a different frontend. Use what fits your workflow.
 
 ## Key Features
 
@@ -130,10 +193,6 @@ Every task produces knowledge. Cross-linked Markdown documents that grow with ev
 
 Each role has scoped authority defined in `role.yaml`. Engineers can't make CEO decisions. PMs can't merge code. The org chart isn't decoration — it's enforcement.
 
-### Level System
-
-Roles gain XP from completed work. Level up unlocks accessories and reflects experience. Your CTO at Lv.14 has seen things your new intern hasn't.
-
 ### Local-First, BYOK
 
 Everything runs on your machine. Your data never leaves. Bring your own Anthropic API key — no middleman, no telemetry, no tracking.
@@ -181,7 +240,8 @@ your-company/
 ## CLI Usage
 
 ```bash
-npx tycono              # Start server + open dashboard
+npx tycono              # Start server + web dashboard
+npx tycono --tui        # Terminal UI (coming soon)
 npx tycono --help       # Show help
 npx tycono --version    # Show version
 ```
@@ -194,6 +254,17 @@ npx tycono --version    # Show version
 | `PORT` | Server port | auto-detect |
 | `COMPANY_ROOT` | Company directory | current directory |
 
+## Roadmap
+
+- [x] Web dashboard (Office + Pro views)
+- [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 *(in progress)*
+- [ ] Git worktree isolation per agent session
+- [ ] **Desktop app** (.dmg / .exe) — background execution, notifications, no API key setup needed
+- [ ] Multi-LLM support (OpenAI, local models)
+
 ## Built with Tycono
 
 This isn't a demo. Tycono's own landing page, documentation, and knowledge base were built by AI agents running inside Tycono. The PM wrote the PRD. The CTO reviewed architecture. The Designer created UX specs. The Engineer implemented every section.

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,7 +243,8 @@ async function startServerForTui(): Promise<void> {
     server.listen(port, host, () => resolve());
   });
 
-  console.log(`  API server started on port ${port}`);
+  origLog(`  API server started on port ${port}`);
+  origLog(`  Logs: ${logFile}`);
 
   // Graceful shutdown
   const shutdown = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.96-beta.3",
+  "version": "0.1.96-beta.30",
   "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;
     }
@@ -497,12 +495,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', () => {

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

@@ -16,7 +16,7 @@ export function getBaseUrl(): string {
 
 /* ─── HTTP helpers ─── */
 
-async function fetchJson<T>(path: string, options?: { method?: string; body?: unknown }): Promise<T> {
+export async function fetchJson<T>(path: string, options?: { method?: string; body?: unknown }): Promise<T> {
   const url = `${BASE_URL}${path}`;
   const method = options?.method ?? 'GET';
   const bodyStr = options?.body ? JSON.stringify(options.body) : undefined;
@@ -83,6 +83,7 @@ export interface SessionInfo {
   status: string;
   source: string;
   waveId?: string;
+  parentSessionId?: string;
   createdAt: string;
 }
 
@@ -129,7 +130,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 +138,7 @@ export async function dispatchWave(directive: string, options?: {
     method: 'POST',
     body: {
       type: 'wave',
-      directive,
+      directive: directive ?? '',
       targetRoles: options?.targetRoles,
       continuous: options?.continuous ?? false,
     },
@@ -155,13 +156,46 @@ 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' });
+}
+
 /* ─── Setup API calls ─── */
 
 export interface TeamTemplate {
   id: string;
   name: string;
   description: string;
-  roles: string[];
+  roles: Array<string | { id: string; name: string; level?: string }>;
 }
 
 export interface ScaffoldResult {
@@ -232,9 +266,12 @@ export function subscribeToWaveStream(
             }
           }
 
-          if (eventType === 'activity' && data) {
+          if ((eventType === 'activity' || eventType === 'wave:event') && data) {
             try {
-              onEvent(JSON.parse(data) as SSEEvent);
+              const parsed = JSON.parse(data);
+              // wave:event wraps the actual event in .event field
+              const evt = parsed.event ?? parsed;
+              onEvent(evt as SSEEvent);
             } catch { /* ignore parse errors */ }
           } else if (eventType === 'stream:end' && data) {
             try {