tycono 0.3.11-beta.0 → 0.3.11

package/package.json

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

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

@@ -214,7 +214,7 @@ class ExecutionManager {
     let harnessTurnCount = 0;
     let softLimitWarned = false;
     let hardLimitReached = false;
-    let accumulatedOutput = '';
+    const outputChunks: string[] = [];
 
     const teamStatus: import('../../../shared/types').TeamStatus = {};
     for (const [, e] of this.executions) {
@@ -258,7 +258,7 @@ class ExecutionManager {
       },
       {
         onText: (text) => {
-          accumulatedOutput += text;
+          outputChunks.push(text);
           execution.stream.emit('text', params.roleId, { text });
           if (execution.sessionId) {
             this.updateSessionRoleMessage(execution, text);
@@ -501,7 +501,7 @@ class ExecutionManager {
       .catch((err: Error) => {
         if (hardLimitReached) {
           execution.result = {
-            output: accumulatedOutput,
+            output: outputChunks.join(''),
             turns: harnessTurnCount,
             totalTokens: { input: 0, output: 0 },
             toolCalls: [],

package/src/api/src/services/session-store.ts

@@ -109,16 +109,44 @@ function writeImmediate(session: Session): void {
 }
 
 /* ─── In-memory cache ───────────────────── */
+/*
+ * OOM prevention: inactive sessions cache metadata only (no messages).
+ * Messages are loaded on-demand from disk when getSession() is called.
+ * Active sessions keep messages in memory for streaming writes.
+ *
+ * Before: 61 sessions × 50KB avg messages = 3MB+ baseline, grows to 100s of MB
+ * After:  61 sessions × 1KB metadata + 5 active × 50KB = ~310KB baseline
+ */
 
 const cache = new Map<string, Session>();
 
+/** Strip messages from session to save memory (keeps metadata) */
+function stripMessages(session: Session): Session {
+  if (session.messages.length === 0) return session;
+  return { ...session, messages: [] };
+}
+
+/** Load full session from disk (with messages) */
+function loadFromDisk(id: string): Session | undefined {
+  const p = sessionPath(id);
+  if (!fs.existsSync(p)) return undefined;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf-8')) as Session;
+  } catch { return undefined; }
+}
+
 function loadAll(): void {
   ensureDir();
   const files = fs.readdirSync(sessionsDir()).filter((f) => f.endsWith('.json'));
   for (const file of files) {
     try {
       const data = JSON.parse(fs.readFileSync(path.join(sessionsDir(), file), 'utf-8')) as Session;
-      cache.set(data.id, data);
+      // Only keep messages for active sessions; strip for done/interrupted
+      if (data.status === 'active' || data.status === 'awaiting_input') {
+        cache.set(data.id, data);
+      } else {
+        cache.set(data.id, stripMessages(data));
+      }
     } catch { /* skip corrupted */ }
   }
 }
@@ -165,7 +193,15 @@ export function createSession(roleId: string, opts: CreateSessionOptions = {}):
 
 export function getSession(id: string): Session | undefined {
   ensureLoaded();
-  return cache.get(id);
+  const cached = cache.get(id);
+  if (!cached) return undefined;
+
+  // If messages were stripped (inactive session), reload from disk on demand
+  if (cached.messages.length === 0 && cached.status !== 'active') {
+    const full = loadFromDisk(id);
+    if (full) return full; // Return disk version (don't cache — it's a one-time read)
+  }
+  return cached;
 }
 
 export function listSessions(): Omit<Session, 'messages'>[] {
@@ -252,6 +288,11 @@ export function updateSession(id: string, updates: Partial<Pick<Session, 'title'
   session.updatedAt = new Date().toISOString();
   writeImmediate(session);
 
+  // OOM prevention: when session becomes inactive, strip messages from cache
+  if (updates.status && updates.status !== 'active' && updates.status !== 'awaiting_input') {
+    cache.set(id, stripMessages(session));
+  }
+
   return session;
 }
 

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

@@ -19,6 +19,7 @@ import path from 'node:path';
 import { COMPANY_ROOT } from './file-reader.js';
 import { ActivityStream } from './activity-stream.js';
 import { saveCompletedWave } from './wave-tracker.js';
+import { waveMultiplexer } from './wave-multiplexer.js';
 
 /* ─── Types ──────────────────────────────────── */
 
@@ -768,9 +769,17 @@ ${state.continuous ? `## Continuous Improvement Mode (ON)
         console.error(`[Supervisor] Failed to auto-save wave ${state.waveId}:`, err);
       }
 
-      // OOM prevention: clear accumulated directive/question history
+      // OOM prevention: clear accumulated state + wave multiplexer sessions
       state.pendingDirectives = [];
       state.pendingQuestions = [];
+
+      // Delayed cleanup: remove wave sessions from multiplexer + supervisor map
+      // (delay allows SSE clients to receive final events)
+      setTimeout(() => {
+        waveMultiplexer.cleanupWave(state.waveId);
+        this.supervisors.delete(state.waveId);
+        console.log(`[Supervisor] Cleaned up wave ${state.waveId} from memory`);
+      }, 60_000).unref(); // 1 minute after wave done
     }
   }
 

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

@@ -182,6 +182,12 @@ class WaveMultiplexer {
       const key = `${event.roleId}:${event.seq}`;
       if (client.sentEvents.has(key)) return;
       client.sentEvents.add(key);
+      // OOM prevention: cap sentEvents to prevent unbounded Set growth
+      if (client.sentEvents.size > 5000) {
+        const entries = Array.from(client.sentEvents);
+        client.sentEvents.clear();
+        for (const e of entries.slice(-2000)) client.sentEvents.add(e);
+      }
 
       const waveSeq = client.waveSeq++;
       sendSSE(client, 'wave:event', {