tycono 0.1.96-beta.40 → 0.1.96-beta.42

package/package.json

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

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

@@ -51,25 +51,21 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
   // ── /api/waves/active — restore active waves after refresh ──
   if (method === 'GET' && url === '/api/waves/active') {
     // Recovery: rebuild wave→session mapping from session-store if lost
+    // Only recover ACTIVE sessions to prevent OOM on large datasets (140+ sessions)
     const waves = waveMultiplexer.getActiveWaves();
     if (waves.length === 0) {
       const allSessions = listSessions();
-      const waveGroups = new Map<string, string[]>();
+      let recovered = 0;
       for (const ses of allSessions) {
-        if (ses.waveId) {
-          if (!waveGroups.has(ses.waveId)) waveGroups.set(ses.waveId, []);
-          waveGroups.get(ses.waveId)!.push(ses.id);
+        if (!ses.waveId || ses.status !== 'active') continue;
+        const exec = executionManager.getActiveExecution(ses.id);
+        if (exec) {
+          waveMultiplexer.registerSession(ses.waveId, exec);
+          recovered++;
         }
       }
-      // BUG-W03 fix: register ALL wave sessions (including completed) for tree display
-      for (const [wid, sids] of waveGroups) {
-        for (const sid of sids) {
-          // getActiveExecution falls back to stream recovery for completed sessions
-          const exec = executionManager.getActiveExecution(sid);
-          if (exec) {
-            waveMultiplexer.registerSession(wid, exec);
-          }
-        }
+      if (recovered > 0) {
+        console.log(`[WaveRecovery] Recovered ${recovered} active sessions`);
       }
     }
     jsonResponse(res, 200, { waves: waveMultiplexer.getActiveWaves() });
@@ -480,13 +476,11 @@ function handleWaveStream(waveId: string, url: string, res: ServerResponse, req:
 
   let sessionIds = waveMultiplexer.getWaveSessionIds(waveId);
 
-  // Recovery: if wave→session mapping was lost (e.g. server restart),
-  // rebuild from session-store (sessions have waveId) + executionManager
+  // Recovery: only recover ACTIVE sessions for this wave (not all 140)
   if (sessionIds.length === 0) {
     const allSessions = listSessions();
-    const waveSessions = allSessions.filter(s => s.waveId === waveId);
+    const waveSessions = allSessions.filter(s => s.waveId === waveId && s.status === 'active');
     for (const ses of waveSessions) {
-      // getActiveExecution recovers from stream files for completed sessions too
       const exec = executionManager.getActiveExecution(ses.id);
       if (exec) {
         waveMultiplexer.registerSession(waveId, exec);
@@ -763,25 +757,26 @@ function handleStatus(res: ServerResponse): void {
     );
 
     const recovered: typeof activeExecs = [];
-    for (const ses of activeSessions) {
-      // Check activity-stream for actual running state
+    // Limit recovery scan to prevent OOM on large session stores
+    const MAX_RECOVERY_SCAN = 20;
+    const recentActive = activeSessions.slice(-MAX_RECOVERY_SCAN);
+
+    for (const ses of recentActive) {
       if (!ActivityStream.exists(ses.id)) continue;
+      // Only read last few events to check done/error (not entire stream)
       const events = ActivityStream.readFrom(ses.id, 0);
       if (events.length === 0) continue;
 
-      const startEvent = events.find(e => e.type === 'msg:start');
-      if (!startEvent) continue;
-
-      const doneEvent = events.find(e => e.type === 'msg:done');
-      const errorEvent = events.find(e => e.type === 'msg:error');
-
-      // Only include sessions that haven't finished yet
-      if (doneEvent || errorEvent) continue;
+      // Check last 5 events for done/error (optimization: don't scan entire file)
+      const tail = events.slice(-5);
+      const isDone = tail.some(e => e.type === 'msg:done' || e.type === 'msg:error');
+      if (isDone) continue;
 
-      const task = (startEvent.data?.task as string) ?? ses.title ?? '';
+      const startEvent = events.find(e => e.type === 'msg:start');
+      const task = (startEvent?.data?.task as string) ?? ses.title ?? '';
       recovered.push({
         id: `recovered-${ses.id}`,
-        type: (startEvent.data?.type as string ?? 'assign') as 'assign' | 'wave' | 'consult',
+        type: (startEvent?.data?.type as string ?? 'assign') as 'assign' | 'wave' | 'consult',
         roleId: ses.roleId,
         task,
         status: 'running',

package/src/api/src/server.ts

@@ -1,11 +1,40 @@
 import { COMPANY_ROOT } from './services/file-reader.js';
 import { applyConfig } from './services/company-config.js';
 import { createHttpServer } from './create-server.js';
+import { listSessions, updateSession } from './services/session-store.js';
+import { ActivityStream } from './services/activity-stream.js';
 
 // Load .tycono/config.json and apply to process.env
 const config = applyConfig(COMPANY_ROOT);
 console.log(`[STARTUP] Engine: ${config.engine}, API key: ${config.apiKey ? 'set' : 'none'}`);
 
+// Startup: mark orphaned 'active' sessions as 'interrupted'
+// These are sessions from a previous server that crashed or was killed
+{
+  const allSessions = listSessions();
+  let orphaned = 0;
+  for (const ses of allSessions) {
+    if (ses.status !== 'active') continue;
+    // Check activity stream — if it has msg:done/msg:error, mark done
+    // If not, mark interrupted (previous server died mid-execution)
+    if (ActivityStream.exists(ses.id)) {
+      const events = ActivityStream.readFrom(ses.id, 0);
+      const tail = events.slice(-5);
+      const isDone = tail.some(e => e.type === 'msg:done' || e.type === 'msg:error');
+      if (isDone) {
+        updateSession(ses.id, { status: 'done' });
+        orphaned++;
+        continue;
+      }
+    }
+    updateSession(ses.id, { status: 'interrupted' as any });
+    orphaned++;
+  }
+  if (orphaned > 0) {
+    console.log(`[STARTUP] Cleaned ${orphaned} orphaned sessions (active → done/interrupted)`);
+  }
+}
+
 const PORT = Number(process.env.PORT) || 3001;
 const server = createHttpServer();
 
@@ -13,3 +42,18 @@ server.listen(PORT, () => {
   console.log(`[API] Server running on http://localhost:${PORT}`);
   console.log(`[API] COMPANY_ROOT: ${COMPANY_ROOT}`);
 });
+
+// Graceful shutdown: mark running sessions as interrupted
+function gracefulShutdown(signal: string) {
+  console.log(`[SHUTDOWN] ${signal} received, marking active sessions as interrupted...`);
+  const sessions = listSessions();
+  for (const ses of sessions) {
+    if (ses.status === 'active') {
+      updateSession(ses.id, { status: 'interrupted' as any });
+    }
+  }
+  process.exit(0);
+}
+
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

package/src/api/src/services/execution-manager.ts

@@ -10,7 +10,7 @@ import { estimateCost } from './pricing.js';
 import { readConfig, getConversationLimits, resolveCodeRoot } from './company-config.js';
 import { postKnowledgingCheck, type KnowledgeDebtItem } from '../engine/knowledge-gate.js';
 import { earnCoinsInternal } from '../routes/coins.js';
-import { getSession, createSession, addMessage, updateMessage as updateSessionMessage, appendMessageEvent, type Message, type ImageAttachment } from './session-store.js';
+import { getSession, createSession, addMessage, updateMessage as updateSessionMessage, updateSession, appendMessageEvent, type Message, type ImageAttachment } from './session-store.js';
 import { portRegistry, type PortAllocation } from './port-registry.js';
 import { type MessageStatus, isMessageActive, canTransition, messageStatusToRoleStatus } from '../../../shared/types.js';
 
@@ -603,6 +603,12 @@ class ExecutionManager {
         knowledgeDebt: execution.knowledgeDebt.map(d => ({ type: d.type, file: d.file, message: d.message })),
       }),
     });
+
+    // Mark session as done in session-store (persisted to file)
+    // Skip CEO supervisor sessions — they stay active for wave lifecycle
+    if (session.roleId !== 'ceo' || session.source !== 'wave') {
+      updateSession(execution.sessionId, { status: 'done' });
+    }
   }
 
   private cleanupOrphanedChildren(parentSessionId: string): void {