@myrialabs/clopen 0.2.11 → 0.2.13

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)
@@ -494,6 +495,9 @@ class StreamManager extends EventEmitter {
 				includePartialMessages: true,
 				abortController: streamState.abortController,
 				...(claudeAccountId !== undefined && { claudeAccountId }),
+				...(projectId && chatSessionId && {
+					mcpContext: { projectId, chatSessionId, streamId: streamState.streamId }
+				}),
 			});
 
 			await projectContextService.runWithContextAsync(
@@ -707,10 +711,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 +840,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 +903,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 +1106,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 +1116,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 {
@@ -1172,7 +1226,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) {
@@ -1190,8 +1244,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
@@ -1376,6 +1438,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>;
 }
 
@@ -89,7 +90,8 @@ export class ClaudeCodeEngine implements AIEngine {
 
     try {
       // Get custom MCP servers and allowed tools
-      const mcpServers = getEnabledMcpServers();
+      // Pass mcpContext so tool handlers are bound to the correct project
+      const mcpServers = getEnabledMcpServers(options.mcpContext);
       const allowedMcpTools = getAllowedMcpTools();
 
       debug.log('mcp', '📦 Loading custom MCP servers...');
@@ -130,6 +132,9 @@ export class ClaudeCodeEngine implements AIEngine {
                   options.signal.removeEventListener('abort', onAbort);
                   resolve(result);
                 },
+                removeAbortListener: () => {
+                  options.signal.removeEventListener('abort', onAbort);
+                },
                 input
               });
             });
@@ -180,9 +185,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();
 

package/backend/engine/types.ts

@@ -11,6 +11,13 @@ import type { EngineType, EngineModel } from '$shared/types/engine';
 
 export type { EngineType, EngineModel };
 
+/** Execution context for MCP tool handlers (project isolation) */
+export interface McpExecutionContext {
+	projectId?: string;
+	chatSessionId?: string;
+	streamId?: string;
+}
+
 /** Options passed to engine.streamQuery() */
 export interface EngineQueryOptions {
 	projectPath: string;
@@ -22,6 +29,8 @@ export interface EngineQueryOptions {
 	includePartialMessages?: boolean;
 	abortController?: AbortController;
 	claudeAccountId?: number;
+	/** Context bound to MCP tool handlers for project isolation */
+	mcpContext?: McpExecutionContext;
 }
 
 /** Options for one-shot structured generation (no tools, no streaming) */

package/backend/index.ts

@@ -35,6 +35,7 @@ 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
@@ -165,22 +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/config.ts

@@ -5,10 +5,12 @@
  * to avoid duplication and make it easier to add new servers.
  */
 
-import type { McpSdkServerConfigWithInstance, McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import { createSdkMcpServer, tool, type McpSdkServerConfigWithInstance, type McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
 import type { McpRemoteConfig } from '@opencode-ai/sdk';
 import type { ServerConfig, ParsedMcpToolName, ServerName } from './types';
-import { serverRegistry, serverFactories } from './servers';
+import type { McpExecutionContext } from '../engine/types';
+import { serverRegistry, serverFactories, serverMetadata } from './servers';
+import { projectContextService } from './project-context';
 import { debug } from '$shared/utils/logger';
 import { SERVER_ENV } from '../utils/env';
 
@@ -87,15 +89,39 @@ export const mcpServers: Record<string, ServerConfig & { instance: McpSdkServerC
  *
  * Creates FRESH server instances each call so that concurrent streams
  * each get their own Protocol — avoids "Already connected to a transport" errors.
+ *
+ * When `context` is provided, tool handlers are wrapped to restore the
+ * AsyncLocalStorage execution context. This is required because the SDK
+ * invokes MCP tool handlers through IPC which breaks AsyncLocalStorage
+ * propagation — without this, background streams from Project A would
+ * resolve to Project B's preview browser when the user switches projects.
  */
-export function getEnabledMcpServers(): Record<string, McpServerConfig> {
+export function getEnabledMcpServers(context?: McpExecutionContext): Record<string, McpServerConfig> {
 	const enabledServers: Record<string, McpServerConfig> = {};
 
 	Object.entries(mcpServers).forEach(([serverName, serverConfig]) => {
 		if (serverConfig.enabled) {
-			const factory = serverFactories[serverName as ServerName];
-			enabledServers[serverName] = factory ? factory() : serverConfig.instance;
-			debug.log('mcp', `✓ Enabled MCP server: ${serverName}`);
+			if (context) {
+				// Create context-bound instance: wrap each tool handler so
+				// AsyncLocalStorage context is restored on invocation
+				const meta = serverMetadata[serverName as ServerName];
+				const sdkTools = (serverConfig.tools as readonly string[]).map(toolName => {
+					const def = meta.toolDefs[toolName];
+					const boundHandler = async (args: any) => {
+						return projectContextService.runWithContextAsync(context, () => def.handler(args));
+					};
+					return tool(toolName, def.description, def.schema, boundHandler as any);
+				});
+				enabledServers[serverName] = createSdkMcpServer({
+					name: meta.name,
+					version: '1.0.0',
+					tools: sdkTools
+				});
+			} else {
+				const factory = serverFactories[serverName as ServerName];
+				enabledServers[serverName] = factory ? factory() : serverConfig.instance;
+			}
+			debug.log('mcp', `✓ Enabled MCP server: ${serverName}${context ? ' (context-bound)' : ''}`);
 		} else {
 			debug.log('mcp', `✗ Disabled MCP server: ${serverName}`);
 		}