@myrialabs/clopen 0.2.10 → 0.2.12

package/backend/engine/adapters/opencode/stream.ts

@@ -770,20 +770,15 @@ export class OpenCodeEngine implements AIEngine {
 	}
 
 	async cancel(): Promise<void> {
-		// Abort the OpenCode session on the server so it stops processing
-		const client = getClient();
-		if (client && this.activeSessionId) {
-			try {
-				await client.session.abort({
-					path: { id: this.activeSessionId },
-					...(this.activeProjectPath && { query: { directory: this.activeProjectPath } }),
-				});
-				debug.log('engine', 'Open Code session aborted:', this.activeSessionId);
-			} catch (error) {
-				debug.warn('engine', 'Failed to abort Open Code session:', error);
-			}
-		}
-
+		// Capture refs before clearing — needed for server-side abort below
+		const sessionId = this.activeSessionId;
+		const projectPath = this.activeProjectPath;
+
+		// 1. FIRST: Abort local stream processing immediately.
+		//    This breaks the SSE event stream and causes the for-await loop
+		//    in processStream() to throw AbortError, stopping all local processing.
+		//    Must happen BEFORE the HTTP call because client.session.abort() can
+		//    hang indefinitely if the OpenCode server is busy/unresponsive.
 		if (this.activeAbortController) {
 			this.activeAbortController.abort();
 			this.activeAbortController = null;
@@ -792,6 +787,26 @@ export class OpenCodeEngine implements AIEngine {
 		this.activeSessionId = null;
 		this.activeProjectPath = null;
 		this.pendingQuestions.clear();
+
+		// 2. THEN: Tell the OpenCode server to stop processing (with timeout).
+		//    This is a courtesy cleanup — local processing is already stopped.
+		//    The server-side session would otherwise keep running (consuming
+		//    LLM API calls and compute resources) until it naturally completes.
+		const client = getClient();
+		if (client && sessionId) {
+			try {
+				await Promise.race([
+					client.session.abort({
+						path: { id: sessionId },
+						...(projectPath && { query: { directory: projectPath } }),
+					}),
+					new Promise<void>(resolve => setTimeout(resolve, 5000))
+				]);
+				debug.log('engine', 'Open Code session aborted:', sessionId);
+			} catch (error) {
+				debug.warn('engine', 'Failed to abort Open Code session (non-fatal):', error);
+			}
+		}
 	}
 
 	/**
@@ -802,13 +817,16 @@ export class OpenCodeEngine implements AIEngine {
 		const client = getClient();
 		if (!client || !sessionId) return;
 		try {
-			await client.session.abort({
-				path: { id: sessionId },
-				...(projectPath && { query: { directory: projectPath } }),
-			});
+			await Promise.race([
+				client.session.abort({
+					path: { id: sessionId },
+					...(projectPath && { query: { directory: projectPath } }),
+				}),
+				new Promise<void>(resolve => setTimeout(resolve, 5000))
+			]);
 			debug.log('engine', 'Open Code session aborted (per-stream):', sessionId);
 		} catch (error) {
-			debug.warn('engine', 'Failed to abort Open Code session:', error);
+			debug.warn('engine', 'Failed to abort Open Code session (non-fatal):', error);
 		}
 	}
 

package/backend/index.ts

@@ -27,11 +27,15 @@ import { statSync } from 'node:fs';
 // Import WebSocket router
 import { wsRouter } from './ws';
 
+// Import browser preview manager for graceful shutdown
+import { browserPreviewServiceManager } from './preview';
+
 // MCP remote server for Open Code custom tools
 import { handleMcpRequest, closeMcpServer } from './mcp/remote-server';
 
 // Auth middleware
 import { checkRouteAccess } from './auth/permissions';
+import { authRateLimiter } from './auth';
 import { ws as wsServer } from './utils/ws';
 
 // Register auth gate on WebSocket router — blocks unauthenticated/unauthorized access
@@ -162,20 +166,32 @@ async function gracefulShutdown() {
 	if (isShuttingDown) return;
 	isShuttingDown = true;
 
+	// Force exit after 5 seconds — prevents port from being held by slow cleanup
+	// during bun --watch restarts, which causes ECONNREFUSED on the Vite WS proxy.
+	const forceExitTimer = setTimeout(() => {
+		debug.warn('server', '⚠️ Shutdown timeout — forcing exit to release port');
+		process.exit(1);
+	}, 5_000);
+
 	console.log('\n🛑 Shutting down server...');
 	try {
+		// Stop accepting new connections first — release the port ASAP
+		app.stop();
+		// Dispose rate limiter timer
+		authRateLimiter.dispose();
 		// Close MCP remote server (before engines, as they may still reference it)
 		await closeMcpServer();
+		// Cleanup browser preview sessions
+		await browserPreviewServiceManager.cleanup();
 		// Dispose all AI engines
 		await disposeAllEngines();
-		// Stop accepting new connections
-		app.stop();
 		// Close database connection
 		closeDatabase();
 		debug.log('server', '✅ Graceful shutdown completed');
 	} catch (error) {
 		debug.error('server', '❌ Error during shutdown:', error);
 	}
+	clearTimeout(forceExitTimer);
 	process.exit(0);
 }
 

package/backend/mcp/servers/browser-automation/browser.ts

@@ -177,6 +177,8 @@ export async function switchTabHandler(args: { tabId: string; projectId?: string
 					isError: true
 				};
 			}
+			// Promote tab to end of session's set so getActiveTabSession() targets it next
+			browserMcpControl.promoteSessionTab(tab.id, chatSessionId);
 		}
 
 		return {

package/backend/preview/browser/browser-mcp-control.ts

@@ -206,6 +206,22 @@ export class BrowserMcpControl extends EventEmitter {
 	// Control Acquisition
 	// ============================================================================
 
+	/**
+	 * Promote a tab to the end of the session's controlled set.
+	 * This ensures getSessionTabs()[last] returns the most recently activated tab,
+	 * which is used by getActiveTabSession to determine which tab MCP operates on.
+	 *
+	 * Must be called after switch_tab to reflect the new active tab.
+	 */
+	promoteSessionTab(browserTabId: string, chatSessionId: string): void {
+		const sessionSet = this.sessionTabs.get(chatSessionId);
+		if (sessionSet && sessionSet.has(browserTabId)) {
+			sessionSet.delete(browserTabId);
+			sessionSet.add(browserTabId);
+			debug.log('mcp', `🔀 Promoted tab ${browserTabId} to end of session ${chatSessionId.slice(0, 8)} set`);
+		}
+	}
+
 	/**
 	 * Acquire control of a browser tab for a chat session.
 	 *

package/backend/preview/browser/browser-navigation-tracker.ts

@@ -6,10 +6,35 @@ import { debug } from '$shared/utils/logger';
 export class BrowserNavigationTracker extends EventEmitter {
 	private cdpSessions = new Map<string, CDPSession>();
 
+	// Deduplication: track the last emitted navigation URL+timestamp per session.
+	// framenavigated and load often fire for the same navigation;
+	// this prevents emitting duplicate 'navigation' events that would cause
+	// parallel handleNavigation calls and double streaming restarts.
+	private lastNavigationEmit = new Map<string, { url: string; time: number }>();
+	private readonly DEDUP_WINDOW_MS = 500; // Ignore duplicate within 500ms
+
 	constructor() {
 		super();
 	}
 
+	/**
+	 * Emit a navigation event with deduplication.
+	 * Returns true if the event was emitted, false if it was a duplicate.
+	 */
+	private emitNavigationDeduped(event: string, sessionId: string, url: string, data: any): boolean {
+		const now = Date.now();
+		const last = this.lastNavigationEmit.get(sessionId);
+
+		if (last && last.url === url && (now - last.time) < this.DEDUP_WINDOW_MS) {
+			debug.log('preview', `⏭️ Deduped ${event} for ${url} (${now - last.time}ms since last emit)`);
+			return false;
+		}
+
+		this.lastNavigationEmit.set(sessionId, { url, time: now });
+		this.emit(event, data);
+		return true;
+	}
+
 	/**
 	 * Check if two URLs differ only by hash/fragment.
 	 * Hash-only changes are same-document navigations and should NOT trigger
@@ -134,8 +159,9 @@ export class BrowserNavigationTracker extends EventEmitter {
 				// Update session URL
 				session.url = newUrl;
 
-				// Emit navigation completed event to frontend
-				this.emit('navigation', {
+				// Emit navigation completed event (deduplicated to prevent double events
+				// from framenavigated + load firing for the same navigation)
+				this.emitNavigationDeduped('navigation', sessionId, newUrl, {
 					sessionId,
 					type: 'navigation',
 					url: newUrl,
@@ -184,7 +210,8 @@ export class BrowserNavigationTracker extends EventEmitter {
 
 				session.url = currentUrl;
 
-				this.emit('navigation', {
+				// Deduplicated: framenavigated already emitted for this URL
+				this.emitNavigationDeduped('navigation', sessionId, currentUrl, {
 					sessionId,
 					type: 'navigation',
 					url: currentUrl,
@@ -246,6 +273,7 @@ export class BrowserNavigationTracker extends EventEmitter {
 			}
 			this.cdpSessions.delete(sessionId);
 		}
+		this.lastNavigationEmit.delete(sessionId);
 	}
 
 	async navigateSession(sessionId: string, session: BrowserTab, url: string): Promise<string> {

package/backend/preview/browser/browser-preview-service.ts

@@ -869,37 +869,3 @@ class BrowserPreviewServiceManager {
 // Service manager instance (singleton)
 export const browserPreviewServiceManager = new BrowserPreviewServiceManager();
 
-// Graceful shutdown handlers
-const gracefulShutdown = async (signal: string) => {
-	try {
-		await browserPreviewServiceManager.cleanup();
-		process.exit(0);
-	} catch (error) {
-		process.exit(1);
-	}
-};
-
-// Handle various termination signals
-process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
-
-// Handle Windows-specific signals
-if (process.platform === 'win32') {
-	process.on('SIGBREAK', () => gracefulShutdown('SIGBREAK'));
-}
-
-// Handle uncaught exceptions and unhandled rejections
-process.on('uncaughtException', async (error) => {
-	await browserPreviewServiceManager.cleanup();
-	process.exit(1);
-});
-
-process.on('unhandledRejection', async (reason, promise) => {
-	await browserPreviewServiceManager.cleanup();
-	process.exit(1);
-});
-
-// Handle process exit
-process.on('exit', (code) => {
-});

package/backend/preview/browser/browser-video-capture.ts

@@ -42,6 +42,7 @@ interface VideoStreamSession {
 	pendingCandidates: RTCIceCandidateInit[];
 	scriptInjected: boolean; // Track if persistent script was injected
 	scriptsPreInjected: boolean; // Track if scripts were pre-injected during tab creation
+	audioOnNewDocumentInjected: boolean; // Track if evaluateOnNewDocument was registered for audio
 	stats: {
 		videoBytesSent: number;
 		audioBytesSent: number;
@@ -97,6 +98,7 @@ export class BrowserVideoCapture extends EventEmitter {
 				pendingCandidates: [],
 				scriptInjected: true,
 				scriptsPreInjected: false, // Set to true only after injection completes
+				audioOnNewDocumentInjected: false,
 				stats: {
 					videoBytesSent: 0,
 					audioBytesSent: 0,
@@ -162,7 +164,16 @@ export class BrowserVideoCapture extends EventEmitter {
 			});
 		}
 
-		// Inject video encoder + audio capture scripts
+		// Register audio capture as a startup script — runs before page scripts on every new document load.
+		// Critical for SPAs that create AudioContext during initialization (before page.evaluate runs).
+		// The idempotency guard in audioCaptureScript prevents double-injection.
+		const session = this.sessions.get(sessionId);
+		if (session && !session.audioOnNewDocumentInjected) {
+			await page.evaluateOnNewDocument(audioCaptureScript, config.audio);
+			session.audioOnNewDocumentInjected = true;
+		}
+
+		// Inject video encoder + audio capture scripts into the current page context
 		await page.evaluate(videoEncoderScript, videoConfig);
 		await page.evaluate(audioCaptureScript, config.audio);
 	}
@@ -220,6 +231,7 @@ export class BrowserVideoCapture extends EventEmitter {
 					pendingCandidates: [],
 					scriptInjected: false,
 					scriptsPreInjected: false,
+					audioOnNewDocumentInjected: false,
 					stats: {
 						videoBytesSent: 0,
 						audioBytesSent: 0,

package/backend/preview/browser/scripts/audio-stream.ts

@@ -16,6 +16,11 @@ import type { StreamingConfig } from '../types';
  * This script intercepts AudioContext and captures all audio
  */
 export function audioCaptureScript(config: StreamingConfig['audio']) {
+	// Idempotency guard — prevent double-injection when both evaluateOnNewDocument
+	// and page.evaluate inject this script into the same page context.
+	if ((window as any).__audioCaptureInstalled) return;
+	(window as any).__audioCaptureInstalled = true;
+
 	// Check AudioEncoder support
 	if (typeof AudioEncoder === 'undefined') {
 		(window as any).__audioEncoderSupported = false;

package/backend/preview/browser/types.ts

@@ -229,10 +229,11 @@ export interface StreamingConfig {
 /**
  * Default streaming configuration
  *
- * Optimized for visual quality with reasonable bandwidth:
+ * Optimized for visual quality with reduced resource usage:
  * - Software encoding (hardwareAcceleration: 'no-preference')
- * - JPEG quality 70 preserves thin borders/text, VP8 handles bandwidth
- * - VP8 at 1.2Mbps for crisp UI/text rendering
+ * - JPEG quality 65: slightly lower than before but still preserves thin borders/text
+ * - VP8 at 1.0Mbps: ~17% reduction from 1.2Mbps, sharp edges preserved by VP8 codec
+ * - keyframeInterval 5s: less frequent large keyframes, saves bandwidth on static pages
  * - Opus for audio (efficient and widely supported)
  */
 export const DEFAULT_STREAMING_CONFIG: StreamingConfig = {
@@ -241,9 +242,9 @@ export const DEFAULT_STREAMING_CONFIG: StreamingConfig = {
 		width: 0,
 		height: 0,
 		framerate: 24,
-		bitrate: 1_200_000,
-		keyframeInterval: 3,
-		screenshotQuality: 70,
+		bitrate: 1_000_000,
+		keyframeInterval: 5,
+		screenshotQuality: 65,
 		hardwareAcceleration: 'no-preference',
 		latencyMode: 'realtime'
 	},

package/backend/snapshot/blob-store.ts

@@ -4,7 +4,6 @@
  *
  * Structure:
  *   ~/.clopen/snapshots/blobs/{hash[0:2]}/{hash}.gz  - compressed file blobs
- *   ~/.clopen/snapshots/trees/{snapshotId}.json       - tree maps (filepath -> hash)
  *
  * Deduplication: Same file content across any snapshot is stored only once.
  * Compression: All blobs are gzip compressed to minimize disk usage.
@@ -18,7 +17,6 @@ import { getClopenDir } from '../utils/index.js';
 
 const SNAPSHOTS_DIR = join(getClopenDir(), 'snapshots');
 const BLOBS_DIR = join(SNAPSHOTS_DIR, 'blobs');
-const TREES_DIR = join(SNAPSHOTS_DIR, 'trees');
 
 export interface TreeMap {
 	[filepath: string]: string; // filepath -> blob hash
@@ -45,7 +43,6 @@ class BlobStore {
 	async init(): Promise<void> {
 		if (this.initialized) return;
 		await fs.mkdir(BLOBS_DIR, { recursive: true });
-		await fs.mkdir(TREES_DIR, { recursive: true });
 		this.initialized = true;
 	}
 
@@ -112,69 +109,6 @@ class BlobStore {
 		return gunzipSync(compressed);
 	}
 
-	/**
-	 * Store a tree (snapshot state) as a JSON file.
-	 * Returns the tree hash for reference.
-	 */
-	async storeTree(snapshotId: string, tree: TreeMap): Promise<string> {
-		await this.init();
-		const treePath = join(TREES_DIR, `${snapshotId}.json`);
-		const content = JSON.stringify(tree);
-		const treeHash = this.hashContent(Buffer.from(content, 'utf-8'));
-		await fs.writeFile(treePath, content, 'utf-8');
-		return treeHash;
-	}
-
-	/**
-	 * Read a tree by snapshot ID
-	 */
-	async readTree(snapshotId: string): Promise<TreeMap> {
-		const treePath = join(TREES_DIR, `${snapshotId}.json`);
-		const content = await fs.readFile(treePath, 'utf-8');
-		return JSON.parse(content) as TreeMap;
-	}
-
-	/**
-	 * Check if a tree exists
-	 */
-	async hasTree(snapshotId: string): Promise<boolean> {
-		try {
-			await fs.access(join(TREES_DIR, `${snapshotId}.json`));
-			return true;
-		} catch {
-			return false;
-		}
-	}
-
-	/**
-	 * Resolve a tree to full file contents (as Buffers).
-	 * Reads all blobs in parallel for performance.
-	 * Returns { filepath: Buffer } map for binary-safe handling.
-	 */
-	async resolveTree(tree: TreeMap): Promise<Record<string, Buffer>> {
-		const result: Record<string, Buffer> = {};
-
-		const entries = Object.entries(tree);
-		const blobPromises = entries.map(async ([filepath, hash]) => {
-			try {
-				const content = await this.readBlob(hash);
-				return { filepath, content };
-			} catch (err) {
-				debug.warn('snapshot', `Could not read blob ${hash} for ${filepath}:`, err);
-				return null;
-			}
-		});
-
-		const results = await Promise.all(blobPromises);
-		for (const r of results) {
-			if (r) {
-				result[r.filepath] = r.content;
-			}
-		}
-
-		return result;
-	}
-
 	/**
 	 * Hash a file using mtime cache. Returns { hash, content? }.
 	 * If the file hasn't changed (same mtime+size), returns cached hash without reading content.
@@ -191,10 +125,15 @@ class BlobStore {
 		// Check mtime cache
 		const cached = this.fileHashCache.get(filepath);
 		if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-			return { hash: cached.hash, content: null, cached: true };
+			// Verify blob still exists on disk (could have been cleaned up)
+			if (await this.hasBlob(cached.hash)) {
+				return { hash: cached.hash, content: null, cached: true };
+			}
+			// Blob was deleted — invalidate cache, fall through to re-read and re-store
+			this.fileHashCache.delete(filepath);
 		}
 
-		// File changed - read as Buffer (binary-safe, no encoding conversion)
+		// File changed or cache miss - read as Buffer (binary-safe, no encoding conversion)
 		const content = await fs.readFile(fullPath);
 		const hash = this.hashContent(content);
 
@@ -212,14 +151,55 @@ class BlobStore {
 	}
 
 	/**
-	 * Delete a tree file (cleanup)
+	 * Delete multiple blobs by hash.
+	 * Also invalidates fileHashCache entries whose hash matches a deleted blob.
 	 */
-	async deleteTree(snapshotId: string): Promise<void> {
+	async deleteBlobs(hashes: string[]): Promise<number> {
+		const hashSet = new Set(hashes);
+		let deleted = 0;
+		for (const hash of hashes) {
+			try {
+				await fs.unlink(this.getBlobPath(hash));
+				deleted++;
+			} catch {
+				// Ignore - might not exist
+			}
+		}
+
+		// Invalidate fileHashCache entries pointing to deleted blobs
+		for (const [filepath, entry] of this.fileHashCache) {
+			if (hashSet.has(entry.hash)) {
+				this.fileHashCache.delete(filepath);
+			}
+		}
+
+		return deleted;
+	}
+
+	/**
+	 * Scan all blob files on disk and return their hashes.
+	 * Used for full garbage collection — compare with DB references to find orphans.
+	 */
+	async scanAllBlobHashes(): Promise<Set<string>> {
+		const hashes = new Set<string>();
 		try {
-			await fs.unlink(join(TREES_DIR, `${snapshotId}.json`));
+			const prefixDirs = await fs.readdir(BLOBS_DIR);
+			for (const prefix of prefixDirs) {
+				const prefixPath = join(BLOBS_DIR, prefix);
+				const stat = await fs.stat(prefixPath);
+				if (!stat.isDirectory()) continue;
+
+				const files = await fs.readdir(prefixPath);
+				for (const file of files) {
+					if (file.endsWith('.gz')) {
+						hashes.add(file.slice(0, -3)); // Remove .gz suffix
+					}
+				}
+			}
 		} catch {
-			// Ignore - might not exist
+			// Directory might not exist yet
 		}
+		return hashes;
 	}
 }
 

package/backend/snapshot/snapshot-service.ts

@@ -691,6 +691,30 @@ export class SnapshotService {
 		return calculateFileChangeStats(previousSnapshot, currentSnapshot);
 	}
 
+	/**
+	 * Get all blob hashes from the in-memory baseline for a session.
+	 * Must be called BEFORE clearSessionBaseline.
+	 */
+	getSessionBaselineHashes(sessionId: string): Set<string> {
+		const baseline = this.sessionBaselines.get(sessionId);
+		if (!baseline) return new Set();
+		return new Set(Object.values(baseline));
+	}
+
+	/**
+	 * Get all blob hashes from ALL in-memory baselines (all active sessions).
+	 * Used to protect blobs still needed by other sessions during cleanup.
+	 */
+	getAllBaselineHashes(): Set<string> {
+		const hashes = new Set<string>();
+		for (const baseline of this.sessionBaselines.values()) {
+			for (const hash of Object.values(baseline)) {
+				hashes.add(hash);
+			}
+		}
+		return hashes;
+	}
+
 	/**
 	 * Clean up session baseline cache when session is no longer active.
 	 */

package/backend/terminal/stream-manager.ts

@@ -4,8 +4,9 @@
  */
 
 import type { IPty } from 'bun-pty';
-import { existsSync, mkdirSync, readFileSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
+import { getClopenDir } from '../utils/paths';
 
 interface TerminalStream {
   streamId: string;
@@ -25,7 +26,7 @@ interface TerminalStream {
 class TerminalStreamManager {
   private streams: Map<string, TerminalStream> = new Map();
   private sessionToStream: Map<string, string> = new Map();
-  private tempDir: string = '.terminal-output-cache';
+  private tempDir: string = join(getClopenDir(), 'terminal-cache');
 
   constructor() {
     // Create temp directory for output caching
@@ -296,6 +297,44 @@ class TerminalStreamManager {
     };
   }
   
+  /**
+   * Clean up terminal cache files for a specific project
+   */
+  cleanupProjectCache(projectId: string): number {
+    let deleted = 0;
+    try {
+      const files = readdirSync(this.tempDir);
+      for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+        try {
+          const filePath = join(this.tempDir, file);
+          const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+          if (data.projectId === projectId) {
+            unlinkSync(filePath);
+            deleted++;
+          }
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    } catch {
+      // Directory may not exist
+    }
+
+    // Also remove in-memory streams for this project
+    for (const [streamId, stream] of this.streams) {
+      if (stream.projectId === projectId) {
+        if (stream.status === 'active' && stream.pty) {
+          try { stream.pty.kill(); } catch {}
+        }
+        this.streams.delete(streamId);
+        this.sessionToStream.delete(stream.sessionId);
+      }
+    }
+
+    return deleted;
+  }
+
   /**
    * Clean up all streams
    */

package/backend/ws/chat/stream.ts

@@ -22,11 +22,11 @@ import { sessionQueries, messageQueries } from '../../database/queries';
 // exists (e.g., after browser refresh when user is on a different project).
 // Ensures cross-project notifications (presence update, sound, push) always work.
 // ============================================================================
-streamManager.on('stream:lifecycle', (event: { status: string; streamId: string; projectId?: string; chatSessionId?: string; timestamp: string }) => {
-	const { status, projectId, chatSessionId, timestamp } = event;
+streamManager.on('stream:lifecycle', (event: { status: string; streamId: string; projectId?: string; chatSessionId?: string; timestamp: string; reason?: string }) => {
+	const { status, projectId, chatSessionId, timestamp, reason } = event;
 	if (!projectId) return;
 
-	debug.log('chat', `Stream lifecycle: ${status} for project ${projectId} session ${chatSessionId}`);
+	debug.log('chat', `Stream lifecycle: ${status} for project ${projectId} session ${chatSessionId}${reason ? ` (reason: ${reason})` : ''}`);
 
 	// Mark any tool_use blocks that never got a tool_result as interrupted (persisted to DB)
 	if (chatSessionId) {
@@ -42,7 +42,8 @@ streamManager.on('stream:lifecycle', (event: { status: string; streamId: string;
 		projectId,
 		chatSessionId: chatSessionId || '',
 		status: status as 'completed' | 'error' | 'cancelled',
-		timestamp
+		timestamp,
+		reason
 	});
 
 	// Broadcast updated presence (status indicators for all projects)
@@ -254,8 +255,11 @@ export const streamHandler = createRouter()
 							break;
 					}
 				} catch (err) {
+					// Log but do NOT unsubscribe — one bad event must not kill the
+					// entire stream subscription. The bridge between StreamManager
+					// and the WS room would be permanently broken, causing the UI
+					// to stop receiving stream output while the WS stays connected.
 					debug.error('chat', 'Error handling stream event:', err);
-					unsubscribe();
 				}
 			};
 
@@ -393,8 +397,10 @@ export const streamHandler = createRouter()
 							break;
 					}
 				} catch (err) {
+					// Log but do NOT unsubscribe — same rationale as the initial
+					// stream handler: a transient error must not permanently break
+					// the EventEmitter → WS room bridge.
 					debug.error('chat', 'Error handling reconnected stream event:', err);
-					unsubscribe();
 				}
 			};
 
@@ -789,7 +795,8 @@ export const streamHandler = createRouter()
 		projectId: t.String(),
 		chatSessionId: t.String(),
 		status: t.Union([t.Literal('completed'), t.Literal('error'), t.Literal('cancelled')]),
-		timestamp: t.String()
+		timestamp: t.String(),
+		reason: t.Optional(t.String())
 	}))
 
 	.emit('chat:waiting-input', t.Object({