tycono 0.1.94-beta.1 → 0.1.94-beta.2

package/package.json

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

package/src/api/src/routes/execute.ts

@@ -21,7 +21,6 @@ import { earnCoinsInternal } from './coins.js';
 import { appendFollowUpToWave } from '../services/wave-tracker.js';
 import { waveMultiplexer } from '../services/wave-multiplexer.js';
 import { supervisorHeartbeat } from '../services/supervisor-heartbeat.js';
-import { readConfig } from '../services/company-config.js';
 
 /* ─── Auto-attach child executions to wave multiplexer ── */
 executionManager.onExecutionCreated((exec) => {
@@ -220,12 +219,8 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
 
     const targetRoles = body.targetRoles as string[] | undefined;
 
-    // Check supervision mode from config (same as legacy /api/exec/wave)
-    const config = readConfig(COMPANY_ROOT);
-    const supervisionMode = config.supervision?.mode ?? 'direct';
-
-    if (supervisionMode === 'supervisor') {
-      // Supervisor mode: start a single CEO Supervisor session that dispatches C-Levels
+    // Always use supervisor mode — CEO supervises C-Levels who supervise members
+    {
       const state = supervisorHeartbeat.start(
         `wave-${Date.now()}`,
         directive,
@@ -245,71 +240,6 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
       });
       return;
     }
-
-    // Direct mode (default): dispatch all C-Levels simultaneously
-    const orgTree = buildOrgTree(COMPANY_ROOT);
-    let cLevelRoles = getSubordinates(orgTree, 'ceo');
-
-    if (targetRoles && Array.isArray(targetRoles) && targetRoles.length > 0) {
-      const allowed = new Set(targetRoles);
-      cLevelRoles = cLevelRoles.filter(r => allowed.has(r));
-    }
-
-    if (cLevelRoles.length === 0) {
-      jsonResponse(res, 400, { error: 'No C-level roles found to dispatch wave.' });
-      return;
-    }
-
-    const fullTargetScope = targetRoles && targetRoles.length > 0 ? targetRoles : undefined;
-
-    const newWaveId = `wave-${Date.now()}`;
-    const sessionIds: string[] = [];
-
-    for (const cRole of cLevelRoles) {
-      const session = createSession(cRole, {
-        mode: 'do',
-        source: 'wave',
-        waveId: newWaveId,
-      });
-      sessionIds.push(session.id);
-
-      const ceoMsg: Message = {
-        id: `msg-${Date.now()}-ceo-${cRole}`,
-        from: 'ceo',
-        content: directive,
-        type: 'directive',
-        status: 'done',
-        timestamp: new Date().toISOString(),
-        attachments,
-      };
-      addMessage(session.id, ceoMsg);
-
-      const exec = executionManager.startExecution({
-        type: 'wave',
-        roleId: cRole,
-        task: `[CEO Wave] ${directive}`,
-        sourceRole: 'ceo',
-        parentSessionId,
-        targetRoles: fullTargetScope,
-        sessionId: session.id,
-        attachments,
-      });
-
-      waveMultiplexer.registerSession(newWaveId, exec);
-
-      const roleMsg: Message = {
-        id: `msg-${Date.now() + 1}-role-${cRole}`,
-        from: 'role',
-        content: '',
-        type: 'conversation',
-        status: 'streaming',
-        timestamp: new Date().toISOString(),
-      };
-      addMessage(session.id, roleMsg, true);
-    }
-
-    jsonResponse(res, 200, { sessionIds, waveId: newWaveId });
-    return;
   }
 
   // Assign
@@ -684,15 +614,8 @@ function handleWave(body: Record<string, unknown>, req: IncomingMessage, res: Se
 
   const targetRoles = body.targetRoles as string[] | undefined;
 
-  // Check supervision mode from config
-  const config = readConfig(COMPANY_ROOT);
-  const supervisionMode = config.supervision?.mode ?? 'direct';
-
-  if (supervisionMode === 'supervisor') {
-    handleWaveSupervisor(directive, targetRoles, req, res);
-  } else {
-    handleWaveDirect(directive, targetRoles, req, res);
-  }
+  // Always supervisor mode — CEO supervises C-Levels
+  handleWaveSupervisor(directive, targetRoles, req, res);
 }
 
 /**
@@ -721,105 +644,6 @@ function handleWaveSupervisor(directive: string, targetRoles: string[] | undefin
   });
 }
 
-/**
- * Direct mode (legacy): Dispatch all C-Levels simultaneously.
- * No CEO Supervisor — each C-Level runs independently.
- */
-function handleWaveDirect(directive: string, targetRoles: string[] | undefined, req: IncomingMessage, res: ServerResponse): void {
-  const orgTree = buildOrgTree(COMPANY_ROOT);
-  let cLevelRoles = getSubordinates(orgTree, 'ceo');
-
-  if (targetRoles && Array.isArray(targetRoles) && targetRoles.length > 0) {
-    const allowed = new Set(targetRoles);
-    cLevelRoles = cLevelRoles.filter(r => allowed.has(r));
-  }
-
-  if (cLevelRoles.length === 0) {
-    jsonResponse(res, 400, { error: 'No C-level roles found to dispatch wave.' });
-    return;
-  }
-
-  const fullTargetScope = targetRoles && targetRoles.length > 0 ? targetRoles : undefined;
-
-  const executions: Execution[] = [];
-  for (const cRole of cLevelRoles) {
-    const session = createSession(cRole, { mode: 'do' });
-    const exec = executionManager.startExecution({
-      type: 'wave',
-      roleId: cRole,
-      task: `[CEO Wave] ${directive}`,
-      sourceRole: 'ceo',
-      targetRoles: fullTargetScope,
-      sessionId: session.id,
-    });
-    executions.push(exec);
-  }
-
-  startSSE(res);
-  sendSSE(res, 'start', {
-    ids: executions.map((e) => e.id),
-    directive,
-    targetRoles: cLevelRoles,
-  });
-
-  let doneCount = 0;
-  const subscribers: Array<{ exec: Execution; sub: ActivitySubscriber }> = [];
-
-  for (const exec of executions) {
-    const subscriber: ActivitySubscriber = (event: ActivityEvent) => {
-      const rolePrefix = exec.roleId;
-      switch (event.type) {
-        case 'text':
-          sendSSE(res, 'output', { roleId: rolePrefix, text: event.data.text });
-          break;
-        case 'thinking':
-          sendSSE(res, 'thinking', { roleId: rolePrefix, text: event.data.text });
-          break;
-        case 'tool:start':
-          sendSSE(res, 'tool', { roleId: rolePrefix, name: event.data.name, input: event.data.input });
-          break;
-        case 'dispatch:start':
-          sendSSE(res, 'dispatch', { roleId: rolePrefix, targetRoleId: event.data.targetRoleId, task: event.data.task, childSessionId: event.data.childSessionId });
-          break;
-        case 'msg:turn-complete':
-          sendSSE(res, 'turn', { roleId: rolePrefix, turn: event.data.turn });
-          break;
-        case 'stderr':
-          sendSSE(res, 'stderr', { roleId: rolePrefix, message: event.data.message });
-          break;
-        case 'msg:awaiting_input':
-          sendSSE(res, 'role:awaiting_input', { roleId: rolePrefix, question: event.data.question, targetRole: event.data.targetRole, reason: event.data.reason });
-          break;
-        case 'msg:done':
-          sendSSE(res, 'role:done', { roleId: rolePrefix, ...event.data });
-          doneCount++;
-          if (doneCount >= executions.length) {
-            sendSSE(res, 'done', { directive, completedRoles: cLevelRoles });
-            res.end();
-          }
-          break;
-        case 'msg:error':
-          sendSSE(res, 'role:error', { roleId: rolePrefix, message: event.data.message });
-          doneCount++;
-          if (doneCount >= executions.length) {
-            sendSSE(res, 'done', { directive, completedRoles: cLevelRoles });
-            res.end();
-          }
-          break;
-      }
-    };
-
-    exec.stream.subscribe(subscriber);
-    subscribers.push({ exec, sub: subscriber });
-  }
-
-  req.on('close', () => {
-    for (const { exec, sub } of subscribers) {
-      exec.stream.unsubscribe(sub);
-    }
-  });
-}
-
 /* ─── POST /api/waves/:waveId/directive ──────── */
 
 function handleWaveDirective(waveId: string, body: Record<string, unknown>, res: ServerResponse): void {

package/src/api/src/services/supervisor-heartbeat.ts

@@ -12,10 +12,11 @@
  * - On restart, digest catches up with all missed events
  */
 import { executionManager, type Execution } from './execution-manager.js';
-import { createSession, getSession, listSessions } from './session-store.js';
+import { createSession, getSession, listSessions, addMessage, type Message } from './session-store.js';
 import { buildOrgTree, getSubordinates } from '../engine/org-tree.js';
 import { COMPANY_ROOT } from './file-reader.js';
 import { ActivityStream } from './activity-stream.js';
+import { saveCompletedWave } from './wave-tracker.js';
 
 /* ─── Types ──────────────────────────────────── */
 
@@ -290,6 +291,17 @@ ${recoveryContext}
     state.supervisorSessionId = session.id;
     state.status = 'running';
 
+    // Add the directive as CEO message so the session isn't empty (prevents deleteEmpty cleanup)
+    const ceoMsg: Message = {
+      id: `msg-${Date.now()}-ceo-supervisor`,
+      from: 'ceo',
+      content: state.directive,
+      type: 'directive',
+      status: 'done',
+      timestamp: new Date().toISOString(),
+    };
+    addMessage(session.id, ceoMsg);
+
     try {
       const exec = executionManager.startExecution({
         type: 'wave',
@@ -341,6 +353,18 @@ ${recoveryContext}
     } else {
       console.log(`[Supervisor] Wave ${state.waveId} complete. All subordinates done.`);
       state.status = 'stopped';
+
+      // Auto-save the completed wave to operations/waves/
+      try {
+        const result = saveCompletedWave(state.waveId, state.directive);
+        if (result.ok) {
+          console.log(`[Supervisor] Wave auto-saved: ${result.path}`);
+        } else {
+          console.warn(`[Supervisor] Wave auto-save returned no result for ${state.waveId}`);
+        }
+      } catch (err) {
+        console.error(`[Supervisor] Failed to auto-save wave ${state.waveId}:`, err);
+      }
     }
   }
 

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

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { COMPANY_ROOT } from './file-reader.js';
 import { ActivityStream, type ActivityEvent } from './activity-stream.js';
 import { executionManager } from './execution-manager.js';
+import { listSessions } from './session-store.js';
 import { type WaveRoleStatus, eventTypeToMessageStatus } from '../../../shared/types.js';
 
 /* ─── Find wave file ──────────────────────── */
@@ -158,6 +159,109 @@ export function updateFollowUpInWave(waveId: string, sessionId: string, roleId:
   }
 }
 
+/* ─── Save completed wave to operations/waves/ ── */
+
+/**
+ * Auto-save a completed wave to disk.
+ * Called by supervisor-heartbeat when all children are done.
+ * Mirrors the logic of handleSaveWave in execute.ts but callable from services.
+ */
+export function saveCompletedWave(waveId: string, directive: string): { ok: boolean; path?: string } {
+  try {
+    // Collect all sessionIds for this wave from session-store
+    const allSessions = listSessions();
+    const sessionIds = allSessions
+      .filter(s => s.waveId === waveId)
+      .map(s => s.id);
+
+    if (sessionIds.length === 0) {
+      console.warn(`[WaveTracker] No sessions found for wave ${waveId}, skipping save`);
+      return { ok: false };
+    }
+
+    console.log(`[WaveTracker] Auto-saving wave ${waveId} with ${sessionIds.length} sessions`);
+
+    interface WaveRoleData {
+      roleId: string;
+      roleName: string;
+      sessionId: string;
+      status: WaveRoleStatus | 'unknown';
+      events: ReturnType<typeof ActivityStream.readAll>;
+      childSessions: Array<{ roleId: string; roleName: string; sessionId: string; status: WaveRoleStatus | 'unknown'; events: ReturnType<typeof ActivityStream.readAll> }>;
+    }
+    const rolesData: WaveRoleData[] = [];
+
+    for (const sid of sessionIds) {
+      const events = ActivityStream.readAll(sid);
+      const startEvent = events.find(e => e.type === 'msg:start');
+      const roleId = startEvent?.roleId ?? 'unknown';
+      const roleName = (startEvent?.data?.roleName as string) ?? roleId;
+      const doneEvent = events.find(e => e.type === 'msg:done' || e.type === 'msg:awaiting_input' || e.type === 'msg:error');
+      const status: WaveRoleStatus | 'unknown' = doneEvent ? eventTypeToMessageStatus(doneEvent.type) as WaveRoleStatus : 'unknown';
+
+      const childSessions: WaveRoleData['childSessions'] = [];
+      for (const e of events) {
+        const childSessionId = e.data.childSessionId as string | undefined;
+        if (e.type === 'dispatch:start' && childSessionId) {
+          const targetRoleId = (e.data.targetRoleId as string) ?? 'unknown';
+          const childEvents = ActivityStream.readAll(childSessionId);
+          const childDone = childEvents.find(ce => ce.type === 'msg:done' || ce.type === 'msg:error' || ce.type === 'msg:awaiting_input');
+          const childStatus: WaveRoleStatus | 'unknown' = childDone ? eventTypeToMessageStatus(childDone.type) as WaveRoleStatus : 'unknown';
+          childSessions.push({
+            roleId: targetRoleId,
+            roleName: (childEvents.find(ce => ce.type === 'msg:start')?.data?.roleName as string) ?? targetRoleId,
+            sessionId: childSessionId,
+            status: childStatus,
+            events: childEvents,
+          });
+        }
+      }
+
+      rolesData.push({ roleId, roleName, sessionId: sid, status, events, childSessions });
+    }
+
+    const wavesDir = path.join(COMPANY_ROOT, 'operations', 'waves');
+    if (!fs.existsSync(wavesDir)) {
+      fs.mkdirSync(wavesDir, { recursive: true });
+    }
+
+    // Check if wave file already exists (e.g. from appendFollowUp)
+    const existing = findWaveFile(waveId);
+    const baseName = existing
+      ? path.basename(existing, '.json')
+      : waveId;
+    const jsonPath = existing ?? path.join(wavesDir, `${baseName}.json`);
+
+    const now = new Date();
+    const waveJson = {
+      id: baseName,
+      directive,
+      startedAt: now.toISOString(),
+      duration: 0,
+      roles: rolesData,
+      waveId,
+      sessionIds,
+    };
+    fs.writeFileSync(jsonPath, JSON.stringify(waveJson, null, 2), 'utf-8');
+
+    const relativePath = `operations/waves/${baseName}.json`;
+    console.log(`[WaveTracker] Wave saved: ${relativePath} (${rolesData.length} roles)`);
+
+    // Earn coins for wave completion (non-critical)
+    try {
+      const { earnCoinsInternal } = require('../routes/coins.js');
+      if (rolesData.length > 0) {
+        earnCoinsInternal(rolesData.length * 500, `Wave done: ${rolesData.length} roles`, `wave:${baseName}`);
+      }
+    } catch { /* non-critical */ }
+
+    return { ok: true, path: relativePath };
+  } catch (err) {
+    console.error(`[WaveTracker] Failed to auto-save wave ${waveId}:`, err);
+    return { ok: false };
+  }
+}
+
 /* ─── Helpers ─────────────────────────────── */
 
 function watchExecutionCompletion(waveId: string, sessionId: string, roleId: string): void {