tycono 0.3.9 → 0.3.10

package/package.json

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

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

@@ -86,6 +86,21 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
     return;
   }
 
+  // ── /api/waves/:waveId/stop — Stop wave execution ──
+  const stopMatch = url.match(/^\/api\/waves\/([^/]+)\/stop$/);
+  if (method === 'POST' && stopMatch) {
+    const waveId = stopMatch[1];
+    supervisorHeartbeat.stop(waveId);
+    // Also abort all running executions for this wave
+    const waveSessions = listSessions().filter(s => s.waveId === waveId && s.status === 'active');
+    let aborted = 0;
+    for (const ses of waveSessions) {
+      if (executionManager.abortSession(ses.id)) aborted++;
+    }
+    jsonResponse(res, 200, { ok: true, waveId, abortedSessions: aborted });
+    return;
+  }
+
   // ── /api/waves/:waveId/directive — CEO adds directive mid-execution ──
   const directiveMatch = url.match(/^\/api\/waves\/([^/]+)\/directive$/);
   if (method === 'POST' && directiveMatch) {
@@ -167,16 +182,6 @@ function handleJobsRequest(url: string, method: string, req: IncomingMessage, re
     return;
   }
 
-  // GET /api/jobs/:id/history — internal only
-  const historyMatch = reqPath.match(/^\/api\/jobs\/([^/]+)\/history$/);
-  if (method === 'GET' && historyMatch) {
-    const id = historyMatch[1];
-    const events = ActivityStream.readAll(id);
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ events }));
-    return;
-  }
-
   // POST /api/jobs/:id/abort — abort by execution ID or session ID
   const abortMatch = reqPath.match(/^\/api\/jobs\/([^/]+)\/abort$/);
   if (method === 'POST' && abortMatch) {
@@ -711,7 +716,17 @@ function handleWaveDirective(waveId: string, body: Record<string, unknown>, res:
     return;
   }
 
-  const directive = supervisorHeartbeat.addDirective(waveId, text);
+  let directive = supervisorHeartbeat.addDirective(waveId, text);
+  if (!directive) {
+    // Fallback: wave exists but addDirective couldn't restore.
+    // Use start() with the SAME waveId to keep it in the same wave context.
+    console.log(`[WaveDirective] No supervisor found for wave ${waveId}, creating supervisor in-place`);
+    const state = supervisorHeartbeat.start(waveId, text);
+    if (state.status !== 'error') {
+      directive = { id: `dir-fallback-${Date.now()}`, text, createdAt: new Date().toISOString(), delivered: false };
+    }
+  }
+
   if (!directive) {
     jsonResponse(res, 404, { error: `No active supervisor for wave ${waveId}` });
     return;

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

@@ -98,10 +98,38 @@ class SupervisorHeartbeat {
       return state;
     }
 
+    // Save wave file immediately so directive persists across restarts
+    this.saveWaveFile(waveId, directive);
+
     this.spawnSupervisor(state);
     return state;
   }
 
+  /**
+   * Save wave file immediately so directive persists across restarts.
+   * saveCompletedWave() adds session/role details on completion.
+   */
+  private saveWaveFile(waveId: string, directive: string): void {
+    try {
+      const wavesDir = path.join(COMPANY_ROOT, 'operations', 'waves');
+      if (!fs.existsSync(wavesDir)) fs.mkdirSync(wavesDir, { recursive: true });
+      const wavePath = path.join(wavesDir, `${waveId}.json`);
+      if (!fs.existsSync(wavePath)) {
+        fs.writeFileSync(wavePath, JSON.stringify({
+          id: waveId,
+          waveId,
+          directive,
+          startedAt: new Date().toISOString(),
+          sessionIds: [],
+          roles: [],
+        }, null, 2));
+        console.log(`[Supervisor] Wave file created: ${wavePath}`);
+      }
+    } catch (err) {
+      console.warn(`[Supervisor] Failed to save wave file for ${waveId}:`, err);
+    }
+  }
+
   /**
    * Stop the supervisor for a wave (graceful).
    */
@@ -137,18 +165,20 @@ class SupervisorHeartbeat {
     if (!state) {
       // Check if this wave existed before (has sessions in session-store)
       const waveSessions = listSessions().filter(s => s.waveId === waveId);
-      if (waveSessions.length > 0) {
-        // Restore supervisor state for this wave
-        const ceoSession = waveSessions.find(s => s.roleId === 'ceo');
-        // Read original directive from wave artifact file (not the new text)
-        let originalDirective = '';
-        try {
-          const waveFile = path.join(COMPANY_ROOT, 'operations', 'waves', `${waveId}.json`);
-          if (fs.existsSync(waveFile)) {
-            const waveData = JSON.parse(fs.readFileSync(waveFile, 'utf-8'));
-            originalDirective = waveData.directive ?? '';
-          }
-        } catch { /* ignore */ }
+      const ceoSession = waveSessions.find(s => s.roleId === 'ceo') ?? null;
+
+      // Read original directive from wave artifact file
+      let originalDirective = '';
+      try {
+        const waveFile = path.join(COMPANY_ROOT, 'operations', 'waves', `${waveId}.json`);
+        if (fs.existsSync(waveFile)) {
+          const waveData = JSON.parse(fs.readFileSync(waveFile, 'utf-8'));
+          originalDirective = waveData.directive ?? '';
+        }
+      } catch { /* ignore */ }
+
+      if (waveSessions.length > 0 || originalDirective) {
+        // Restore supervisor state — from sessions or wave file
         state = {
           waveId,
           directive: originalDirective || text,
@@ -164,7 +194,7 @@ class SupervisorHeartbeat {
           createdAt: ceoSession?.createdAt ?? new Date().toISOString(),
         };
         this.supervisors.set(waveId, state);
-        console.log(`[Supervisor] Restored wave ${waveId} from disk (${waveSessions.length} sessions)`);
+        console.log(`[Supervisor] Restored wave ${waveId} from disk (${waveSessions.length} sessions, directive=${originalDirective ? 'yes' : 'no'})`);
       } else {
         return null;
       }

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

@@ -16,6 +16,7 @@ export interface WaveStreamEnvelope {
 interface AttachedSession {
   sessionId: string;
   roleId: string;
+  executionId: string;
   unsubscribe: () => void;
 }
 
@@ -137,7 +138,15 @@ class WaveMultiplexer {
   }
 
   private subscribeSessionToClient(waveId: string, client: WaveStreamClient, execution: Execution, sendNotification: boolean): void {
-    if (client.attachedSessions.has(execution.sessionId)) return;
+    // If already attached to this session with a DIFFERENT execution, re-subscribe
+    // This handles the resume case where a new execution reuses the same sessionId
+    const existing = client.attachedSessions.get(execution.sessionId);
+    if (existing) {
+      if (existing.executionId === execution.id) return; // Same execution, skip
+      existing.unsubscribe();
+      client.attachedSessions.delete(execution.sessionId);
+      console.log(`[WaveMux] re-subscribing session=${execution.sessionId} (new exec=${execution.id})`);
+    }
 
     const sessionId = execution.sessionId;
     const roleId = execution.roleId;
@@ -197,6 +206,7 @@ class WaveMultiplexer {
     client.attachedSessions.set(sessionId, {
       sessionId,
       roleId,
+      executionId: execution.id,
       unsubscribe: () => execution.stream.unsubscribe(subscriber),
     });
 

package/src/tui/api.ts

@@ -155,6 +155,12 @@ export async function sendDirective(waveId: string, text: string): Promise<{ ok:
   });
 }
 
+export async function stopWave(waveId: string): Promise<{ ok: boolean; abortedSessions: number }> {
+  return fetchJson<{ ok: boolean; abortedSessions: number }>(`/api/waves/${waveId}/stop`, {
+    method: 'POST',
+  });
+}
+
 export async function fetchActiveWaves(): Promise<{ waves: Array<{ waveId: string; sessionIds: string[] }> }> {
   return fetchJson('/api/waves/active');
 }

package/src/tui/app.tsx

@@ -258,41 +258,6 @@ export const App: React.FC = () => {
     });
   }, []);
 
-  // Load previous conversation from wave's activity stream into system messages
-  const loadPreviousConversation = useCallback(async (waveId: string) => {
-    try {
-      const sessions = api.sessions.filter(s => s.waveId === waveId && s.roleId === 'ceo');
-      if (sessions.length === 0) return;
-
-      for (const ses of sessions.slice(-2)) { // Last 2 sessions
-        try {
-          const resp = await import('./api').then(m => m.fetchJson<{ events: any[] }>(`/api/jobs/${ses.id}/history`));
-          const events = resp?.events ?? (Array.isArray(resp) ? resp : []);
-          if (!events.length) continue;
-
-          for (const e of events) {
-            if (e.type === 'msg:start' && e.data?.task) {
-              const task = String(e.data.task);
-              const match = task.match(/\[CEO (?:Supervisor|Question)\]\s*(.*?)(?:\n|$)/);
-              if (match) {
-                addSystemMessage(`> ${match[1].slice(0, 80)}`, 'green');
-              }
-            }
-            if (e.type === 'text' && e.roleId === 'ceo') {
-              const text = String(e.data?.text ?? '').trim();
-              if (text && text.length > 5 && !text.startsWith('#') && !text.startsWith('\u26D4') && !text.startsWith('[')) {
-                addSystemMessage(text.slice(0, 200), 'white');
-              }
-            }
-          }
-        } catch { /* skip individual session errors */ }
-      }
-
-      addSystemMessage('\u2500'.repeat(40), 'gray');
-      addSystemMessage('(previous conversation loaded)', 'gray');
-    } catch { /* ignore */ }
-  }, [api.sessions, addSystemMessage]);
-
   // Auto-wave: on dashboard entry, create an empty wave or attach to existing
   useEffect(() => {
     if (view !== 'dashboard' || autoWaveCreated.current) return;
@@ -342,44 +307,6 @@ export const App: React.FC = () => {
   // SSE subscription to focused wave
   const sse = useSSE(focusedWaveId);
 
-  // Load wave history into SSE events (for Panel Mode Stream tab)
-  const historyLoadingRef = useRef<string | null>(null);
-  const loadWaveHistoryEvents = useCallback(async (waveId: string) => {
-    // Guard: skip if already loading this wave
-    if (historyLoadingRef.current === waveId) return;
-    historyLoadingRef.current = waveId;
-    // Wait for SSE reconnection to settle (it calls setEvents([]) on connect)
-    await new Promise(r => setTimeout(r, 500));
-
-    try {
-      const sessions = api.sessions.filter(s => s.waveId === waveId && s.roleId === 'ceo');
-      const allEvents: import('./api').SSEEvent[] = [];
-
-      for (const ses of sessions.slice(-2)) {
-        // Abort if wave changed during loading
-        if (historyLoadingRef.current !== waveId) return;
-        try {
-          const resp = await import('./api').then(m => m.fetchJson<{ events: any[] }>(`/api/jobs/${ses.id}/history`));
-          const events = resp?.events ?? [];
-          for (const e of events) {
-            if (['text', 'tool:start', 'msg:start', 'msg:done', 'msg:error', 'dispatch:start', 'thinking'].includes(e.type)) {
-              allEvents.push(e as import('./api').SSEEvent);
-            }
-          }
-        } catch { /* skip */ }
-      }
-
-      // Only apply if still on this wave
-      if (historyLoadingRef.current === waveId && allEvents.length > 0) {
-        sse.loadHistory(allEvents);
-      }
-    } catch { /* ignore */ } finally {
-      if (historyLoadingRef.current === waveId) {
-        historyLoadingRef.current = null;
-      }
-    }
-  }, [api.sessions, sse]);
-
   // Build org tree — flatRoleIds follows visual top-to-bottom order
   const roles = api.company?.roles ?? [];
   const statuses = api.execStatus?.statuses ?? {};
@@ -554,6 +481,10 @@ export const App: React.FC = () => {
         }
         break;
       }
+      case 'success':
+        addSystemMessage(result.message, 'green');
+        api.refresh();
+        break;
       case 'error':
         addSystemMessage(result.message, 'red');
         break;
@@ -563,6 +494,7 @@ export const App: React.FC = () => {
         addSystemMessage('  /new [text]          Create new wave', 'white');
         addSystemMessage('  /waves               List all waves', 'white');
         addSystemMessage('  /focus <n>           Switch to wave n', 'white');
+        addSystemMessage('  /stop                Stop current wave execution', 'white');
         addSystemMessage('  /docs                Files created in this wave', 'white');
         addSystemMessage('  /read <path>         Preview file content', 'white');
         addSystemMessage('  /open <path>         Open in $EDITOR', 'white');

package/src/tui/components/CommandMode.tsx

@@ -164,8 +164,14 @@ export function summarizeEvent(event: SSEEvent, allRoleIds: string[]): StreamLin
     case 'msg:start': {
       const task = ((event.data.task as string) ?? '');
       const cleanTask = task.replace(/\u26D4[^\u26D4]*\u26D4[^"]*/g, '').trim().slice(0, 60);
-      // Hide supervisor started message (internal noise)
-      if (isSupervisor) return null;
+      if (isSupervisor) {
+        // Show minimal feedback so user knows input was received
+        return {
+          id: ++lineCounter,
+          text: '\u2026 processing',
+          color: 'gray',
+        };
+      }
       return {
         id: ++lineCounter,
         prefix: event.roleId,

package/src/tui/hooks/useCommand.ts

@@ -16,7 +16,7 @@
  */
 
 import { useCallback } from 'react';
-import { dispatchWave, sendDirective, fetchJson, killSession, cleanupSessions, fetchActiveSessions } from '../api';
+import { dispatchWave, sendDirective, stopWave, fetchJson, killSession, cleanupSessions, fetchActiveSessions } from '../api';
 
 export interface WaveInfo {
   waveId: string;
@@ -102,6 +102,20 @@ export function useCommand(options: UseCommandOptions) {
         case 'sessions':
           return { type: 'sessions', message: '__sessions__' };
 
+        case 'stop': {
+          // Stop current wave execution
+          const targetWaveId = args?.trim() || focusedWaveId;
+          if (!targetWaveId) {
+            return { type: 'error', message: 'No wave to stop. Use /stop or focus a wave first.' };
+          }
+          try {
+            const result = await stopWave(targetWaveId);
+            return { type: 'success', message: `Wave stopped. ${result.abortedSessions} sessions aborted.` };
+          } catch (err) {
+            return { type: 'error', message: `Stop failed: ${err instanceof Error ? err.message : 'unknown'}` };
+          }
+        }
+
         case 'kill': {
           if (!args) {
             return { type: 'error', message: 'Usage: /kill <sessionId>' };

package/src/tui/hooks/useSSE.ts

@@ -45,7 +45,6 @@ export interface SSEState {
   events: SSEEvent[];
   streamStatus: 'idle' | 'streaming' | 'done' | 'error';
   clearEvents(): void;
-  loadHistory(events: SSEEvent[]): void;
 }
 
 export function useSSE(waveId: string | null): SSEState {
@@ -79,10 +78,6 @@ export function useSSE(waveId: string | null): SSEState {
     maxSeqRef.current = 0;
   }, []);
 
-  const loadHistory = useCallback((historyEvents: SSEEvent[]) => {
-    setEvents(historyEvents.slice(-MAX_EVENTS));
-  }, []);
-
   useEffect(() => {
     if (waveIdRef.current !== waveId) {
       connRef.current?.close();
@@ -176,5 +171,5 @@ export function useSSE(waveId: string | null): SSEState {
     };
   }, [waveId, flushBatch]);
 
-  return { events, streamStatus, clearEvents, loadHistory };
+  return { events, streamStatus, clearEvents };
 }