@myrialabs/clopen 0.2.10 → 0.2.12

package/README.md

@@ -1,26 +1,64 @@
-# Clopen
+<p align="center">
+  <img src="https://clopen.myrialabs.dev/favicon.svg" alt="Clopen" width="72" height="72" />
+</p>
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![Built with Bun](https://img.shields.io/badge/Built%20with-Bun-black)](https://bun.sh)
+<h1 align="center">Clopen</h1>
 
-**Clopen** provides a modern web interface for AI-assisted development, supporting both **Claude Code** and **OpenCode** as AI engines. It runs as a standalone web application — manage multiple Claude Code accounts, use built-in git source control, preview your app in a real browser, edit files, collaborate in real-time, and never lose progress with git-like checkpoints.
+<p align="center">
+  <strong>Build more. Switch less.</strong><br />
+  All-in-one workspace for Claude Code & OpenCode
+</p>
+
+<p align="center">
+  <a href="https://clopen.myrialabs.dev">Website</a> ·
+  <a href="https://github.com/myrialabs/clopen/issues">Issues</a> ·
+  <a href="https://www.npmjs.com/package/@myrialabs/clopen">npm</a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@myrialabs/clopen"><img src="https://img.shields.io/npm/v/@myrialabs/clopen" alt="npm version" /></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT" /></a>
+  <a href="https://github.com/myrialabs/clopen/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome" /></a>
+  <a href="https://bun.sh"><img src="https://img.shields.io/badge/Built%20with-Bun-black" alt="Built with Bun" /></a>
+</p>
+
+<p align="center">
+  <img src="https://clopen.myrialabs.dev/images/workspace-overview.webp" alt="Clopen workspace overview" />
+</p>
+
+All-in-one workspace for Claude Code & OpenCode. Chat, terminal, git, browser preview, and real-time collaboration, built for multi-project and multi-session workflows.
+
+---
+
+## Screenshots
+
+![AI chat interface](https://clopen.myrialabs.dev/images/ai-chat-interface.webp)
+
+![Multi-account manager](https://clopen.myrialabs.dev/images/multi-account-claude-code.webp)
+
+![Browser preview panel](https://clopen.myrialabs.dev/images/browser-preview-panel.webp)
+
+![Checkpoint restore](https://clopen.myrialabs.dev/images/checkpoint-restore.webp)
 
 ---
 
 ## Features
 
-- **Multi-Account Claude Code** - Manage multiple accounts (personal, work, team) and switch instantly per session, isolated under `~/.clopen/claude/user/` (or `~/.clopen-dev/` in development) without touching system-level Claude config
-- **Multi-Engine Support** - Switch between Claude Code and OpenCode
-- **AI Chat Interface** - Streaming responses with tool use visualization
-- **Background Processing** - Chat, terminal, and other processes continue running even when you close the browser — come back later and pick up where you left off
-- **Git-like Checkpoints** - Multi-branch undo/redo system with file and folder snapshots
-- **Real Browser Preview** - Puppeteer-based Chromium rendering with WebCodecs streaming (80-90% bandwidth reduction), full click/type/scroll/drag interaction
-- **Integrated Terminal** - Multi-tab terminal with full PTY control
-- **File Management** - Directory browsing, live editing, and real-time file watching
-- **Git Management** - Full source control: staging, commits, branches, push/pull, stash, log, conflict resolution
-- **Flexible Authentication** - No Login or With Login mode with admin/member roles, invite links, rate-limited login, CLI token recovery — configurable during setup and in Settings
-- **Real-time Collaboration** - Multiple users can work on the same project simultaneously
-- **Built-in Cloudflare Tunnel** - Expose local projects publicly for testing and sharing
+A complete development environment designed around AI-assisted workflows, built to disappear into the background and just work.
+
+- **Multi-Account Claude Code** — Manage multiple Claude Code accounts (personal, work, or team) and switch between them instantly per chat session
+- **Multi-Engine Support** — Switch between Claude Code and OpenCode as your AI engine, per session
+- **Integrated Terminal** — Full PTY emulation with xterm.js UI. Multi-tab terminal sessions with complete ANSI/VT sequence support and full keyboard control
+- **Full Git Management** — Stage, commit, branch, push, pull, stash, log, and resolve conflicts, all from a clean UI. Powered by native git CLI for accuracy
+- **Real Browser Preview** — A live browser preview streams directly into your workspace. Interact with your app manually, or let the AI drive: clicking, typing, and scrolling for autonomous visual testing
+- **Git-Like Checkpoints** — Multi-branch undo/redo with full file snapshots. Roll back to any point in your AI conversation without touching your actual git history
+- **Real-Time Collaboration** — WebSocket-based presence tracking per project. Multiple users can work on the same codebase simultaneously with live awareness
+- **Monaco File Editor** — VS Code's editor embedded in the browser. Full syntax highlighting, autocomplete, and live file watching, right beside your AI chat
+- **Cloudflare Tunnel** — One-click public HTTPS URL for your local dev server. Built-in QR code for instant mobile access. Share your work without deploying
+- **MCP Support** — Full Model Context Protocol integration. Connect AI tools, external APIs, and custom capabilities to your AI agents with zero friction
+- **Flexible Authentication** — No Login or With Login mode with admin/member roles, invite links, rate-limited login, and CLI token recovery
+- **Background Processing** — Chat, terminal, and other processes continue running even when you close the browser — come back later and pick up where you left off
+- **Database Management** — Browse tables, run queries, and inspect your database directly from the workspace *(coming soon)*
 
 ---
 
@@ -28,8 +66,8 @@
 
 ### Prerequisites
 
-- [Bun](https://bun.sh/) v1.2.12+
-- [Claude Code](https://github.com/anthropics/claude-code) and/or [OpenCode](https://github.com/anomalyco/opencode) — required for AI chat functionality
+- [Bun.js](https://bun.sh/) v1.2.12+
+- [Claude Code](https://github.com/anthropics/claude-code) or [OpenCode](https://opencode.ai) — required for AI functionality
 
 ### Installation
 
@@ -82,7 +120,9 @@ This regenerates and displays a new admin PAT.
 
 ---
 
-## Development
+## Contributing
+
+Clopen is open source and contributions are welcome! Whether it's a bug fix, new feature, or improvement to docs — feel free to open an issue or submit a pull request.
 
 ```bash
 git clone https://github.com/myrialabs/clopen.git
@@ -94,6 +134,8 @@ bun run check   # Type checking
 
 When running in development mode, Clopen uses `~/.clopen-dev` instead of `~/.clopen`, keeping dev data separate from any production instance.
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines and [DECISIONS.md](DECISIONS.md) for architectural decisions.
+
 ---
 
 ## Architecture
@@ -112,14 +154,6 @@ Clopen uses an engine-agnostic adapter pattern — both engines normalize output
 
 ---
 
-## Documentation
-
-- [Technical Decisions](DECISIONS.md) - Architectural and technical decision log
-- [Contributing](CONTRIBUTING.md) - How to contribute to this project
-- [Development Guidelines](CLAUDE.md) - Guidelines for working with Claude Code on this project
-
----
-
 ## Troubleshooting
 
 ### Port 9141 Already in Use

package/backend/chat/stream-manager.ts

@@ -103,7 +103,7 @@ class StreamManager extends EventEmitter {
 	 * This event fires regardless of per-connection subscribers.
 	 * Used by the WS layer to send cross-project notifications (presence, sound, push).
 	 */
-	private emitStreamLifecycle(streamState: StreamState, status: 'completed' | 'error' | 'cancelled'): void {
+	private emitStreamLifecycle(streamState: StreamState, status: 'completed' | 'error' | 'cancelled', reason?: string): void {
 		if (this.lifecycleEmitted.has(streamState.streamId)) return;
 		this.lifecycleEmitted.add(streamState.streamId);
 
@@ -112,7 +112,8 @@ class StreamManager extends EventEmitter {
 			streamId: streamState.streamId,
 			projectId: streamState.projectId,
 			chatSessionId: streamState.chatSessionId,
-			timestamp: (streamState.completedAt || new Date()).toISOString()
+			timestamp: (streamState.completedAt || new Date()).toISOString(),
+			reason
 		});
 
 		// Clean up guard after 60s (no need to keep forever)
@@ -707,10 +708,16 @@ class StreamManager extends EventEmitter {
 							});
 						} else if ((event as any).content_block?.type === 'text') {
 							// Reset partial text for new text content block
-							// Don't emit the initial text — deltas will provide the content
-							// This prevents double-counting if content_block_start.text repeats
-							// the first content_block_delta.text
 							streamState.currentPartialText = '';
+							// Emit a start event so frontend has a text stream_event
+							// before deltas arrive (matches thinking block behavior)
+							this.emitStreamEvent(streamState, 'partial', {
+								processId: streamState.processId,
+								eventType: 'start',
+								partialText: '',
+								deltaText: '',
+								timestamp: new Date().toISOString()
+							});
 						}
 					} else if (event.type === 'content_block_delta') {
 						debug.log('chat', `[SM] content_block_delta: deltaType=${(event as any).delta?.type}, hasThinking=${'thinking' in ((event as any).delta || {})}, hasText=${'text' in ((event as any).delta || {})}`);
@@ -830,6 +837,9 @@ class StreamManager extends EventEmitter {
 							savedReasoningParentId = saved?.parent_message_id || null;
 						}
 
+						// Clear reasoning text after save to prevent stale catchup injection
+						streamState.currentReasoningText = undefined;
+
 						this.emitStreamEvent(streamState, 'message', {
 							processId: streamState.processId,
 							message: reasoningMsg,
@@ -890,6 +900,16 @@ class StreamManager extends EventEmitter {
 					savedParentId = saved?.parent_message_id || null;
 				}
 
+				// Clear partial text after saving a complete assistant message to prevent
+				// cancelStream from saving a duplicate text-only message to DB.
+				// Also prevents catchupActiveStream from injecting a stale stream_event
+				// with text that's already part of the saved message.
+				if (message.type === 'assistant' && !message.metadata?.reasoning) {
+					streamState.currentPartialText = undefined;
+				} else if (message.type === 'assistant' && message.metadata?.reasoning) {
+					streamState.currentReasoningText = undefined;
+				}
+
 				streamState.messages.push({
 					processId: streamState.processId,
 					message,
@@ -1083,7 +1103,7 @@ class StreamManager extends EventEmitter {
 		return engine.resolveUserAnswer(toolUseId, answers);
 	}
 
-	async cancelStream(streamId: string): Promise<boolean> {
+	async cancelStream(streamId: string, reason?: string): Promise<boolean> {
 		const streamState = this.activeStreams.get(streamId);
 		if (!streamState || streamState.status !== 'active') {
 			return false;
@@ -1093,6 +1113,37 @@ class StreamManager extends EventEmitter {
 		streamState.status = 'cancelled';
 		streamState.completedAt = new Date();
 
+		// Save partial reasoning text to DB before cancelling (persists across refresh/project switch)
+		if (streamState.currentReasoningText && streamState.chatSessionId) {
+			try {
+				const reasoningMessage = {
+					type: 'assistant' as const,
+					parent_tool_use_id: null,
+					message: {
+						role: 'assistant' as const,
+						content: [{ type: 'text' as const, text: streamState.currentReasoningText }]
+					},
+					session_id: streamState.sdkSessionId || '',
+					metadata: { reasoning: true }
+				};
+
+				const timestamp = new Date().toISOString();
+				const currentHead = sessionQueries.getHead(streamState.chatSessionId);
+
+				const savedMessage = messageQueries.create({
+					session_id: streamState.chatSessionId,
+					sdk_message: reasoningMessage as any,
+					timestamp,
+					parent_message_id: currentHead || undefined
+				});
+
+				sessionQueries.updateHead(streamState.chatSessionId, savedMessage.id);
+				debug.log('chat', 'Saved partial reasoning on cancel:', savedMessage.id);
+			} catch (error) {
+				debug.error('chat', 'Failed to save partial reasoning on cancel:', error);
+			}
+		}
+
 		// Save partial text to DB before cancelling (persists across refresh/project switch)
 		if (streamState.currentPartialText && streamState.chatSessionId) {
 			try {
@@ -1141,16 +1192,19 @@ class StreamManager extends EventEmitter {
 			}
 		}
 
-		// Cancel the per-project engine — this sends an interrupt to the
-		// still-alive SDK subprocess, then aborts the controller. If we abort
-		// the controller first, the subprocess dies and the SDK's subsequent
-		// interrupt write fails with "Operation aborted" (unhandled rejection
-		// that crashes Bun).
+		// Cancel the per-project engine with a bounded timeout.
+		// engine.cancel() stops the SDK process (Claude Code: close() kills subprocess,
+		// OpenCode: aborts controller + HTTP abort to server). If cancel() hangs
+		// (e.g. unresponsive SDK), the timeout ensures we always proceed to emit
+		// events and update presence — preventing infinite loader on the frontend.
 		const projectId = streamState.projectId || 'default';
 		try {
 			const engine = getProjectEngine(projectId, streamState.engine);
 			if (engine.isActive) {
-				await engine.cancel();
+				await Promise.race([
+					engine.cancel(),
+					new Promise<void>(resolve => setTimeout(resolve, 5000))
+				]);
 			}
 		} catch (error) {
 			debug.error('chat', 'Error cancelling engine (non-fatal):', error);
@@ -1158,7 +1212,8 @@ class StreamManager extends EventEmitter {
 
 		// Abort the stream-manager's controller as a fallback.
 		// engine.cancel() already aborts the same controller, so this is
-		// typically a no-op but ensures cleanup if the engine wasn't active.
+		// typically a no-op but ensures cleanup if the engine timed out
+		// or wasn't active.
 		if (!streamState.abortController?.signal.aborted) {
 			streamState.abortController?.abort();
 		}
@@ -1168,7 +1223,7 @@ class StreamManager extends EventEmitter {
 			timestamp: streamState.completedAt.toISOString()
 		});
 
-		this.emitStreamLifecycle(streamState, 'cancelled');
+		this.emitStreamLifecycle(streamState, 'cancelled', reason);
 
 		// Auto-release all MCP-controlled tabs for this chat session
 		if (streamState.chatSessionId) {
@@ -1186,8 +1241,16 @@ class StreamManager extends EventEmitter {
 		const streamState = this.activeStreams.get(streamId);
 		if (streamState) {
 			const sessionKey = this.getSessionKey(streamState.projectId, streamState.chatSessionId);
-			this.sessionStreams.delete(sessionKey);
-			this.sessionStreams.delete(streamState.chatSessionId);
+			// Only delete session key if it still points to THIS stream.
+			// A newer stream for the same session may have overridden the key;
+			// blindly deleting it would orphan the active stream — making it
+			// unfindable by getSessionStream() and breaking cancel/reconnect.
+			if (this.sessionStreams.get(sessionKey) === streamId) {
+				this.sessionStreams.delete(sessionKey);
+			}
+			if (this.sessionStreams.get(streamState.chatSessionId) === streamId) {
+				this.sessionStreams.delete(streamState.chatSessionId);
+			}
 			this.activeStreams.delete(streamId);
 
 			// Cleanup project context service
@@ -1372,6 +1435,41 @@ class StreamManager extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Cancel and clean up all streams for a specific chat session.
+	 * Used when a session is deleted to remove green/amber status indicators.
+	 */
+	async cleanupSessionStreams(chatSessionId: string): Promise<void> {
+		const streamsToCancel: string[] = [];
+		const streamsToClean: string[] = [];
+
+		this.activeStreams.forEach((stream, streamId) => {
+			if (stream.chatSessionId === chatSessionId) {
+				if (stream.status === 'active') {
+					streamsToCancel.push(streamId);
+				} else {
+					streamsToClean.push(streamId);
+				}
+			}
+		});
+
+		// Cancel active streams and await their processStream promise so the
+		// finally block (snapshot capture) completes before the caller deletes
+		// the session — preventing FOREIGN KEY constraint failures.
+		for (const streamId of streamsToCancel) {
+			await this.cancelStream(streamId, 'session-deleted');
+			const stream = this.activeStreams.get(streamId);
+			if (stream?.streamPromise) {
+				await stream.streamPromise.catch(() => {});
+			}
+		}
+
+		// Clean up non-active streams
+		for (const streamId of streamsToClean) {
+			this.cleanupStream(streamId);
+		}
+	}
+
 	/**
 	 * Clean up all completed streams
 	 */

package/backend/database/queries/project-queries.ts

@@ -57,11 +57,8 @@ export const projectQueries = {
 		`).run(now, id);
 	},
 
-	delete(id: string): void {
+	deleteProject(id: string): void {
 		const db = getDatabase();
-		// Delete related data first
-		db.prepare('DELETE FROM messages WHERE session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)').run(id);
-		db.prepare('DELETE FROM chat_sessions WHERE project_id = ?').run(id);
 		db.prepare('DELETE FROM user_projects WHERE project_id = ?').run(id);
 		db.prepare('DELETE FROM projects WHERE id = ?').run(id);
 	},

package/backend/database/queries/session-queries.ts

@@ -125,11 +125,46 @@ export const sessionQueries = {
 
 	delete(id: string): void {
 		const db = getDatabase();
-		// Delete related messages first
+		// Delete all related data
+		db.prepare('DELETE FROM branches WHERE session_id = ?').run(id);
+		db.prepare('DELETE FROM message_snapshots WHERE session_id = ?').run(id);
+		db.prepare('DELETE FROM session_relationships WHERE parent_session_id = ? OR child_session_id = ?').run(id, id);
 		db.prepare('DELETE FROM messages WHERE session_id = ?').run(id);
+		db.prepare('DELETE FROM user_unread_sessions WHERE session_id = ?').run(id);
+		// Clear current_session_id references in user_projects
+		db.prepare('UPDATE user_projects SET current_session_id = NULL WHERE current_session_id = ?').run(id);
 		db.prepare('DELETE FROM chat_sessions WHERE id = ?').run(id);
 	},
 
+	/**
+	 * Delete all sessions for a project and their related data.
+	 * Returns the list of deleted session IDs.
+	 */
+	deleteAllByProjectId(projectId: string): string[] {
+		const db = getDatabase();
+		const sessions = db.prepare('SELECT id FROM chat_sessions WHERE project_id = ?')
+			.all(projectId) as { id: string }[];
+		const sessionIds = sessions.map(s => s.id);
+
+		if (sessionIds.length === 0) return [];
+
+		// Delete all related data for the project's sessions
+		db.prepare('DELETE FROM branches WHERE session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)').run(projectId);
+		db.prepare('DELETE FROM message_snapshots WHERE project_id = ?').run(projectId);
+		db.prepare(`
+			DELETE FROM session_relationships
+			WHERE parent_session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)
+			   OR child_session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)
+		`).run(projectId, projectId);
+		db.prepare('DELETE FROM messages WHERE session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)').run(projectId);
+		db.prepare('DELETE FROM user_unread_sessions WHERE project_id = ?').run(projectId);
+		// Clear current_session_id references in user_projects for this project
+		db.prepare('UPDATE user_projects SET current_session_id = NULL WHERE project_id = ?').run(projectId);
+		db.prepare('DELETE FROM chat_sessions WHERE project_id = ?').run(projectId);
+
+		return sessionIds;
+	},
+
 	/**
 	 * Get the active shared session for a project
 	 * Returns the most recent session that hasn't ended

package/backend/database/queries/snapshot-queries.ts

@@ -325,5 +325,127 @@ export const snapshotQueries = {
 		`).all(projectId) as SessionRelationship[];
 
 		return relationships;
+	},
+
+	/**
+	 * Get ALL snapshots for a session (including soft-deleted).
+	 * Used for cleanup — getBySessionId filters is_deleted which misses hashes.
+	 */
+	getAllBySessionId(sessionId: string): MessageSnapshot[] {
+		const db = getDatabase();
+		return db.prepare(`
+			SELECT * FROM message_snapshots WHERE session_id = ?
+			ORDER BY created_at ASC
+		`).all(sessionId) as MessageSnapshot[];
+	},
+
+	/**
+	 * Get ALL snapshots for a project (including soft-deleted).
+	 * Used for cleanup.
+	 */
+	getAllByProjectId(projectId: string): MessageSnapshot[] {
+		const db = getDatabase();
+		return db.prepare(`
+			SELECT * FROM message_snapshots WHERE project_id = ?
+			ORDER BY created_at ASC
+		`).all(projectId) as MessageSnapshot[];
+	},
+
+	/**
+	 * Delete all snapshots for a session.
+	 * Returns the deleted snapshots so callers can clean up blob store.
+	 */
+	deleteBySessionId(sessionId: string): MessageSnapshot[] {
+		const db = getDatabase();
+		const snapshots = db.prepare(`
+			SELECT * FROM message_snapshots WHERE session_id = ?
+		`).all(sessionId) as MessageSnapshot[];
+
+		if (snapshots.length > 0) {
+			db.prepare('DELETE FROM message_snapshots WHERE session_id = ?').run(sessionId);
+		}
+
+		return snapshots;
+	},
+
+	/**
+	 * Delete all snapshots for a project.
+	 * Returns the deleted snapshots so callers can clean up blob store.
+	 */
+	deleteByProjectId(projectId: string): MessageSnapshot[] {
+		const db = getDatabase();
+		const snapshots = db.prepare(`
+			SELECT * FROM message_snapshots WHERE project_id = ?
+		`).all(projectId) as MessageSnapshot[];
+
+		if (snapshots.length > 0) {
+			db.prepare('DELETE FROM message_snapshots WHERE project_id = ?').run(projectId);
+		}
+
+		return snapshots;
+	},
+
+	/**
+	 * Delete session relationships by session ID (as parent or child).
+	 */
+	deleteRelationshipsBySessionId(sessionId: string): void {
+		const db = getDatabase();
+		db.prepare('DELETE FROM session_relationships WHERE parent_session_id = ? OR child_session_id = ?')
+			.run(sessionId, sessionId);
+	},
+
+	/**
+	 * Delete all session relationships for a project.
+	 */
+	deleteRelationshipsByProjectId(projectId: string): void {
+		const db = getDatabase();
+		db.prepare(`
+			DELETE FROM session_relationships
+			WHERE parent_session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)
+			   OR child_session_id IN (SELECT id FROM chat_sessions WHERE project_id = ?)
+		`).run(projectId, projectId);
+	},
+
+	/**
+	 * Collect all blob hashes referenced by the given snapshots.
+	 * Extracts oldHash and newHash from session_changes.
+	 */
+	collectBlobHashes(snapshots: MessageSnapshot[]): Set<string> {
+		const hashes = new Set<string>();
+		for (const snap of snapshots) {
+			if (!snap.session_changes) continue;
+			try {
+				const changes = JSON.parse(snap.session_changes as string) as Record<string, { oldHash: string; newHash: string }>;
+				for (const change of Object.values(changes)) {
+					if (change.oldHash) hashes.add(change.oldHash);
+					if (change.newHash) hashes.add(change.newHash);
+				}
+			} catch { /* skip malformed */ }
+		}
+		return hashes;
+	},
+
+	/**
+	 * Get all blob hashes still referenced by remaining snapshots in the database.
+	 * Used to determine which blobs are safe to delete (orphan detection).
+	 */
+	getAllReferencedBlobHashes(): Set<string> {
+		const db = getDatabase();
+		const rows = db.prepare(`
+			SELECT session_changes FROM message_snapshots
+			WHERE session_changes IS NOT NULL
+		`).all() as { session_changes: string }[];
+
+		const hashes = new Set<string>();
+		for (const row of rows) {
+			try {
+				const changes = JSON.parse(row.session_changes) as Record<string, { oldHash: string; newHash: string }>;
+				for (const change of Object.values(changes)) {
+					if (change.oldHash) hashes.add(change.oldHash);
+					if (change.newHash) hashes.add(change.newHash);
+				}
+			} catch { /* skip malformed */ }
+		}
+		return hashes;
 	}
 };

package/backend/database/utils/connection.ts

@@ -117,23 +117,29 @@ export class DatabaseManager {
 
 	async resetDatabase(): Promise<void> {
 		debug.log('database', '⚠️ Resetting database (dropping all tables)...');
-		
+
 		if (!this.db) {
 			throw new Error('Database not connected');
 		}
 
-		// Drop all tables
-		const tables = this.db.prepare(`
-			SELECT name FROM sqlite_master 
-			WHERE type='table' AND name NOT LIKE 'sqlite_%'
-		`).all() as { name: string }[];
+		// Disable foreign key checks to allow dropping in any order
+		this.db.exec('PRAGMA foreign_keys = OFF');
 
-		for (const table of tables) {
-			debug.log('database', `🗑️ Dropping table: ${table.name}`);
-			this.db.exec(`DROP TABLE IF EXISTS ${table.name}`);
-		}
+		try {
+			const tables = this.db.prepare(`
+				SELECT name FROM sqlite_master
+				WHERE type='table' AND name NOT LIKE 'sqlite_%'
+			`).all() as { name: string }[];
+
+			for (const table of tables) {
+				debug.log('database', `🗑️ Dropping table: ${table.name}`);
+				this.db.exec(`DROP TABLE IF EXISTS ${table.name}`);
+			}
 
-		debug.log('database', '✅ Database reset completed');
+			debug.log('database', '✅ Database reset completed');
+		} finally {
+			this.db.exec('PRAGMA foreign_keys = ON');
+		}
 	}
 
 	async vacuum(): Promise<void> {

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

@@ -22,6 +22,7 @@ import { debug } from '$shared/utils/logger';
 /** Pending AskUserQuestion resolver — stored while SDK is blocked waiting for user input */
 interface PendingUserAnswer {
   resolve: (result: PermissionResult) => void;
+  removeAbortListener: () => void;
   input: Record<string, unknown>;
 }
 
@@ -130,6 +131,9 @@ export class ClaudeCodeEngine implements AIEngine {
                   options.signal.removeEventListener('abort', onAbort);
                   resolve(result);
                 },
+                removeAbortListener: () => {
+                  options.signal.removeEventListener('abort', onAbort);
+                },
                 input
               });
             });
@@ -180,9 +184,15 @@ export class ClaudeCodeEngine implements AIEngine {
    * Cancel active query
    */
   async cancel(): Promise<void> {
-    // Resolve all pending AskUserQuestion promises before terminating.
+    // Remove abort listeners from pending AskUserQuestion promises WITHOUT
+    // resolving them. Resolving causes the SDK to call handleControlRequest →
+    // write() to send the permission result to the subprocess. If close() has
+    // already killed the subprocess, this write throws "Operation aborted" as
+    // an unhandled error, crashing the server. By removing listeners and not
+    // resolving, the promises are safely abandoned when close() terminates the
+    // process and the async generator completes.
     for (const [, pending] of this.pendingUserAnswers) {
-      pending.resolve({ behavior: 'deny', message: 'Cancelled' });
+      pending.removeAbortListener();
     }
     this.pendingUserAnswers.clear();