tycono 0.1.107 → 0.1.109

package/package.json

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

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

@@ -129,8 +129,35 @@ class SupervisorHeartbeat {
    * Dispatch Protocol Principle 2: tick이 유일한 동기화 지점.
    */
   addDirective(waveId: string, text: string): PendingDirective | null {
-    const state = this.supervisors.get(waveId);
-    if (!state) return null;
+    let state = this.supervisors.get(waveId);
+
+    // If wave not in memory (e.g., server restarted), restore from disk
+    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');
+        state = {
+          waveId,
+          directive: text,
+          continuous: false,
+          supervisorSessionId: ceoSession?.id ?? null,
+          executionId: null,
+          status: 'stopped',
+          crashCount: 0,
+          maxCrashRetries: 10,
+          restartTimer: null,
+          pendingDirectives: [],
+          pendingQuestions: [],
+          createdAt: ceoSession?.createdAt ?? new Date().toISOString(),
+        };
+        this.supervisors.set(waveId, state);
+        console.log(`[Supervisor] Restored wave ${waveId} from disk (${waveSessions.length} sessions)`);
+      } else {
+        return null;
+      }
+    }
 
     const directive: PendingDirective = {
       id: `dir-${Date.now()}`,
@@ -283,18 +310,72 @@ class SupervisorHeartbeat {
    * Spawn a lightweight conversation session (no dispatch tools).
    * CEO reads files and answers directly.
    */
+  /**
+   * Load conversation history from activity-stream files for a wave.
+   * Used when supervisor restarts (e.g., TUI restarted) to restore context.
+   */
+  private loadWaveHistory(waveId: string): string {
+    try {
+      // Find CEO sessions for this wave from session-store
+      const allSessions = listSessions();
+      const waveCeoSessions = allSessions
+        .filter(s => s.waveId === waveId && s.roleId === 'ceo')
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+
+      if (waveCeoSessions.length === 0) return '';
+
+      const history: string[] = [];
+      for (const ses of waveCeoSessions) {
+        if (!ActivityStream.exists(ses.id)) continue;
+        const events = ActivityStream.readAll(ses.id);
+
+        // Extract CEO directives (from messages) and supervisor text responses
+        for (const e of events) {
+          if (e.type === 'msg:start' && e.data.task) {
+            // Extract directive from task (remove system prompt noise)
+            const task = String(e.data.task);
+            const directiveMatch = task.match(/\[CEO (?:Supervisor|Question)\]\s*(.*?)(?:\n|$)/);
+            if (directiveMatch) {
+              history.push(`CEO: "${directiveMatch[1].slice(0, 100)}"`);
+            }
+          }
+          if (e.type === 'text' && e.roleId === 'ceo') {
+            const text = String(e.data.text ?? '').trim();
+            if (text && text.length > 10 && !text.startsWith('#') && !text.startsWith('⛔')) {
+              history.push(`Supervisor: ${text.slice(0, 150)}`);
+            }
+          }
+        }
+      }
+
+      if (history.length === 0) return '';
+
+      // Keep last 10 exchanges to fit in context
+      const recent = history.slice(-10);
+      return `\n[Previous Conversation in Wave ${waveId}]\n${recent.join('\n')}\n`;
+    } catch {
+      return '';
+    }
+  }
+
   private spawnConversation(state: SupervisorState, directive: string): void {
-    // Build conversation context: previous directives + last execution summary
+    // Build conversation context: in-memory directives + disk history
     const deliveredDirectives = state.pendingDirectives.filter(d => d.delivered);
     const directiveHistory = deliveredDirectives.length > 0
       ? deliveredDirectives.map(d => `- CEO: "${d.text}"`).join('\n')
       : '';
 
+    // If no in-memory history, load from disk (restart case)
+    const diskHistory = !directiveHistory ? this.loadWaveHistory(state.waveId) : '';
+
     // Extract last execution's output from activity stream (what "just happened")
     let lastExecutionSummary = '';
-    if (state.supervisorSessionId) {
+    // Try current supervisorSessionId first, then search by waveId
+    const sessionIdToCheck = state.supervisorSessionId
+      || listSessions().find(s => s.waveId === state.waveId && s.roleId === 'ceo')?.id;
+    if (sessionIdToCheck) {
       try {
-        const events = ActivityStream.readAll(state.supervisorSessionId);
+        const events = ActivityStream.readAll(sessionIdToCheck);
         // 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');
@@ -315,7 +396,7 @@ class SupervisorHeartbeat {
       } catch { /* ignore */ }
     }
 
-    const context = [directiveHistory, lastExecutionSummary].filter(Boolean).join('\n');
+    const context = [directiveHistory || diskHistory, lastExecutionSummary].filter(Boolean).join('\n');
 
     const task = `${context ? context + '\n' : ''}[CEO Question] ${directive}
 

package/src/tui/app.tsx

@@ -286,28 +286,16 @@ export const App: React.FC = () => {
       setFocusedWaveId(apiWaves[apiWaves.length - 1].waveId);
       autoWaveCreated.current = true;
     } else if (api.loaded && api.pastWaves.length > 0) {
-      // No active waves, but past waves exist — load them + create a new one
+      // No active waves, past waves exist — resume last wave (don't create new)
       autoWaveCreated.current = true;
       const pastEntries: WaveInfo[] = api.pastWaves.slice(0, 10).map(pw => ({
         waveId: pw.id,
         directive: pw.directive || '',
         startedAt: pw.startedAt ? new Date(pw.startedAt).getTime() : 0,
       }));
-
-      dispatchWave().then(result => {
-        const newWave: WaveInfo = {
-          waveId: result.waveId,
-          directive: '',
-          startedAt: Date.now(),
-        };
-        setWaves([...pastEntries, newWave]);
-        setFocusedWaveId(result.waveId);
-      }).catch(() => {
-        // Even if new wave fails, show past waves
-        setWaves(pastEntries);
-        setFocusedWaveId(pastEntries[pastEntries.length - 1]?.waveId ?? null);
-        autoWaveCreated.current = true;
-      });
+      setWaves(pastEntries);
+      // Focus last wave — user can /new if they want a fresh one
+      setFocusedWaveId(pastEntries[pastEntries.length - 1]?.waveId ?? null);
     } else if (api.loaded) {
       // No active waves, no past waves — fresh start
       autoWaveCreated.current = true;