@myrialabs/clopen 0.0.7 → 0.1.1

package/frontend/lib/services/chat/chat.service.ts

@@ -11,7 +11,8 @@
  * - Proper presence synchronization
  */
 
-import { appState } from '$frontend/lib/stores/core/app.svelte';
+import { appState, updateSessionProcessState } from '$frontend/lib/stores/core/app.svelte';
+import type { SessionProcessState } from '$frontend/lib/stores/core/app.svelte';
 import { chatModelState } from '$frontend/lib/stores/ui/chat-model.svelte';
 import { projectState } from '$frontend/lib/stores/core/projects.svelte';
 import { sessionState, setCurrentSession, createSession, updateSession } from '$frontend/lib/stores/core/sessions.svelte';
@@ -23,6 +24,14 @@ import { buildMetadataFromTransport } from '$shared/utils/message-formatter';
 import { debug } from '$shared/utils/logger';
 import ws from '$frontend/lib/utils/ws';
 
+/**
+ * Tools that block the SDK waiting for user interaction.
+ * When these tools appear in an assistant message without a result,
+ * and the stream is active, the chat status switches to "waiting for input".
+ * Extend this list for future interactive tools.
+ */
+const INTERACTIVE_TOOLS = new Set(['AskUserQuestion']);
+
 class ChatService {
   private activeProcessId: string | null = null;
   private streamCompleted: boolean = false;
@@ -58,6 +67,30 @@ class ChatService {
     this.setupWebSocketHandlers();
   }
 
+  /**
+   * Update process state for a session.
+   * Writes to both the per-session map (for multi-session support)
+   * and global convenience flags (for backward-compatible single-session components).
+   *
+   * @param update - Partial state to merge
+   * @param sessionId - Override session ID (defaults to this.currentSessionId or current session)
+   */
+  private setProcessState(
+    update: Partial<SessionProcessState>,
+    sessionId?: string | null
+  ): void {
+    const resolvedId = sessionId ?? this.currentSessionId ?? sessionState.currentSession?.id;
+    if (resolvedId) {
+      updateSessionProcessState(resolvedId, update);
+    }
+    // Always sync to global convenience flags
+    if ('isLoading' in update) appState.isLoading = update.isLoading!;
+    if ('isWaitingInput' in update) appState.isWaitingInput = update.isWaitingInput!;
+    if ('isCancelling' in update) appState.isCancelling = update.isCancelling!;
+    if ('isRestoring' in update) appState.isRestoring = update.isRestoring!;
+    if ('error' in update && update.error !== undefined) appState.error = update.error;
+  }
+
   /**
    * Check if event should be skipped (sequence-based deduplication)
    */
@@ -137,8 +170,10 @@ class ChatService {
 
       this.streamCompleted = true;
       this.reconnected = false;
-      appState.isLoading = false;
-      appState.isCancelling = false;
+      this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: false });
+
+      // Mark any tool_use blocks that never got a tool_result
+      this.markInterruptedTools();
 
       // Stream completed successfully — all old cancelled streams' events
       // have definitely been delivered by now, so clear the blacklist.
@@ -161,8 +196,10 @@ class ChatService {
       this.streamCompleted = true;
       this.reconnected = false;
       this.activeProcessId = null;
-      appState.isLoading = false;
-      appState.isCancelling = false;
+      this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: false });
+
+      // Mark any tool_use blocks that never got a tool_result
+      this.markInterruptedTools();
 
       // Notifications handled by GlobalStreamMonitor via chat:stream-finished
     });
@@ -178,8 +215,10 @@ class ChatService {
       // (e.g. from multiple subscriptions or late-arriving events with different processId/seq)
       this.streamCompleted = true;
       this.reconnected = false;
-      appState.isLoading = false;
-      appState.isCancelling = false;
+      this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: false });
+
+      // Mark any tool_use blocks that never got a tool_result
+      this.markInterruptedTools();
 
       // Don't show notification for cancel-triggered errors
       if (data.error === 'Stream cancelled') return;
@@ -277,11 +316,10 @@ class ChatService {
     }
 
     // Set loading state
-    appState.isLoading = true;
-    appState.isCancelling = false;
     this.streamCompleted = false;
     this.reconnected = false;
     this.currentSessionId = sessionState.currentSession.id;
+    this.setProcessState({ isLoading: true, isWaitingInput: false, isCancelling: false });
     // DON'T clear cancelledProcessIds — late events from previously cancelled
     // streams must still be blocked. The set is cleared on stream complete.
     // Clear sequence tracking for new stream
@@ -432,9 +470,9 @@ class ChatService {
     this.currentSessionId = null;
     this.streamCompleted = true;
     this.reconnected = false;
-    appState.isLoading = false;
-    // Prevent presence effect from re-enabling loading before server confirms cancel
-    appState.isCancelling = true;
+    // Update per-session map with captured ID (before it was nulled above)
+    // and global flags — cancel sets isCancelling=true to prevent presence re-enabling
+    this.setProcessState({ isLoading: false, isWaitingInput: false, isCancelling: true }, chatSessionId);
 
     // Clean up stale stream_events from the cancelled stream.
     // Without this, stale stream_events remain in the messages array and cause
@@ -465,6 +503,7 @@ class ChatService {
     this.reconnected = false;
     this.lastEventSeq.clear();
     appState.isLoading = false;
+    appState.isWaitingInput = false;
     appState.isCancelling = false;
   }
 
@@ -549,6 +588,27 @@ class ChatService {
       })
     };
 
+    // Detect interactive tool_use blocks (e.g., AskUserQuestion) and set waiting status.
+    // When the SDK is blocked on canUseTool, partial events stop and the user must interact.
+    if (sdkMessage.type === 'assistant' && sdkMessage.message?.content) {
+      const content = Array.isArray(sdkMessage.message.content) ? sdkMessage.message.content : [];
+      const hasInteractiveTool = content.some(
+        (item: any) => item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name)
+      );
+      if (hasInteractiveTool) {
+        this.setProcessState({ isWaitingInput: true });
+      }
+    }
+
+    // When a user message with tool_result arrives, the SDK is unblocked — clear waiting status
+    if (sdkMessage.type === 'user' && sdkMessage.message?.content) {
+      const content = Array.isArray(sdkMessage.message.content) ? sdkMessage.message.content : [];
+      const hasToolResult = content.some((item: any) => item.type === 'tool_result');
+      if (hasToolResult && appState.isWaitingInput) {
+        this.setProcessState({ isWaitingInput: false });
+      }
+    }
+
     // For reasoning messages that couldn't find a matching stream_event,
     // insert BEFORE trailing non-reasoning assistant messages (tools/text)
     // to preserve reasoning-before-tool ordering within the same turn.
@@ -671,6 +731,80 @@ class ChatService {
     }
   }
 
+  /**
+   * Detect whether any interactive tool (e.g. AskUserQuestion) is pending in the current messages.
+   * Used after browser refresh / catchup to restore the isWaitingInput state.
+   */
+  detectPendingInteractiveTools(): void {
+    if (!appState.isLoading) return;
+
+    // Collect all tool_use IDs that have a matching tool_result
+    const answeredToolIds = new Set<string>();
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'user' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+      for (const item of content) {
+        if (item.type === 'tool_result' && item.tool_use_id) {
+          answeredToolIds.add(item.tool_use_id);
+        }
+      }
+    }
+
+    // Check if any interactive tool is unanswered
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'assistant' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+      const hasPendingInteractive = content.some(
+        (item: any) => item.type === 'tool_use' && INTERACTIVE_TOOLS.has(item.name) && item.id && !answeredToolIds.has(item.id)
+      );
+      if (hasPendingInteractive) {
+        this.setProcessState({ isWaitingInput: true });
+        return;
+      }
+    }
+  }
+
+  /**
+   * Mark assistant messages with unanswered tool_use blocks as interrupted.
+   * Sets metadata.interrupted at the MESSAGE level (not tool_use content level).
+   * Called when stream ends (complete/error/cancel) for immediate in-memory update.
+   * The backend persists this to DB via stream:lifecycle for durability.
+   */
+  private markInterruptedTools(): void {
+    // Collect all tool_use IDs that have a matching tool_result
+    const answeredToolIds = new Set<string>();
+
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'user' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+
+      for (const item of content) {
+        if (item.type === 'tool_result' && item.tool_use_id) {
+          answeredToolIds.add(item.tool_use_id);
+        }
+      }
+    }
+
+    // Mark messages with unanswered tool_use blocks as interrupted (message-level metadata)
+    for (const msg of sessionState.messages) {
+      const msgAny = msg as any;
+      if (msgAny.type !== 'assistant' || !msgAny.message?.content) continue;
+      const content = Array.isArray(msgAny.message.content) ? msgAny.message.content : [];
+
+      const hasUnansweredTool = content.some(
+        (item: any) => item.type === 'tool_use' && item.id && !answeredToolIds.has(item.id)
+      );
+
+      if (hasUnansweredTool && !msgAny.metadata?.interrupted) {
+        if (!msgAny.metadata) msgAny.metadata = {};
+        msgAny.metadata.interrupted = true;
+      }
+    }
+  }
+
   /**
    * Handle general errors
    */

package/frontend/lib/services/terminal/project.service.ts

@@ -98,28 +98,83 @@ class TerminalProjectManager {
 
 	/**
 	 * Create initial terminal sessions for a project
+	 * First checks backend for existing PTY sessions (e.g., after browser refresh)
 	 */
 	private async createProjectTerminalSessions(projectId: string, projectPath: string): Promise<void> {
-		// Creating terminal session for project
-		
 		const context = this.getOrCreateProjectContext(projectId, projectPath);
-		
-		// Create only 1 terminal session by default with correct project path and projectId
+
+		// Check backend for existing PTY sessions (survives browser refresh)
+		const existingBackendSessions = await terminalService.listProjectSessions(projectId);
+
+		if (existingBackendSessions.length > 0) {
+			debug.log('terminal', `Found ${existingBackendSessions.length} existing PTY sessions for project ${projectId}`);
+
+			// Sort by sessionId to maintain consistent order (terminal-1, terminal-2, etc.)
+			existingBackendSessions.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+
+			// Restore all existing sessions as tabs
+			for (const backendSession of existingBackendSessions) {
+				const sessionParts = backendSession.sessionId.split('-');
+				const terminalNumber = sessionParts[sessionParts.length - 1] || '1';
+
+				const terminalSession: TerminalSession = {
+					id: backendSession.sessionId,
+					name: `Terminal ${terminalNumber}`,
+					directory: backendSession.cwd || projectPath,
+					lines: [],
+					commandHistory: [],
+					isActive: false,
+					createdAt: new Date(backendSession.createdAt),
+					lastUsedAt: new Date(backendSession.lastActivityAt),
+					shellType: 'Unknown',
+					terminalBuffer: undefined,
+					projectId: projectId,
+					projectPath: projectPath
+				};
+
+				terminalStore.addSession(terminalSession);
+				terminalSessionManager.createSession(backendSession.sessionId, projectId, projectPath, backendSession.cwd || projectPath);
+				context.sessionIds.push(backendSession.sessionId);
+
+				// Update nextSessionId to avoid ID conflicts
+				const match = backendSession.sessionId.match(/terminal-(\d+)/);
+				if (match) {
+					terminalStore.updateNextSessionId(parseInt(match[1], 10) + 1);
+				}
+			}
+
+			// Restore previously active session from sessionStorage, or default to first
+			let activeSessionId = existingBackendSessions[0].sessionId;
+			if (typeof sessionStorage !== 'undefined') {
+				try {
+					const savedActiveId = sessionStorage.getItem(`terminal-active-session-${projectId}`);
+					if (savedActiveId && context.sessionIds.includes(savedActiveId)) {
+						activeSessionId = savedActiveId;
+					}
+				} catch {
+					// sessionStorage not available
+				}
+			}
+			context.activeSessionId = activeSessionId;
+			terminalStore.switchToSession(context.activeSessionId);
+			this.persistContexts();
+			return;
+		}
+
+		// No existing backend sessions, create 1 new terminal session
 		const sessionId = terminalStore.createNewSession(projectPath, projectPath, projectId);
-		
-		// Update the session's directory to ensure it's correct
+
 		const session = terminalStore.getSession(sessionId);
 		if (session) {
 			session.directory = projectPath;
 		}
-		
-		// Create a fresh session in terminalSessionManager with correct project association
+
 		terminalSessionManager.createSession(sessionId, projectId, projectPath, projectPath);
-		
+
 		context.sessionIds.push(sessionId);
 		context.activeSessionId = sessionId;
 		terminalStore.switchToSession(sessionId);
-		
+
 		this.persistContexts();
 	}
 

package/frontend/lib/services/terminal/terminal.service.ts

@@ -339,6 +339,25 @@ export class TerminalService {
 		}
 	}
 
+	/**
+	 * List active PTY sessions for a project on the backend
+	 * Used after browser refresh to discover existing sessions
+	 */
+	async listProjectSessions(projectId: string): Promise<Array<{
+		sessionId: string;
+		pid: number;
+		cwd: string;
+		createdAt: string;
+		lastActivityAt: string;
+	}>> {
+		try {
+			const data = await ws.http('terminal:list-sessions', { projectId }, 5000);
+			return data.sessions || [];
+		} catch {
+			return [];
+		}
+	}
+
 	/**
 	 * Cleanup listeners for a session
 	 */

package/frontend/lib/stores/core/app.svelte.ts

@@ -15,14 +15,41 @@ interface PageInfo {
 	actions?: import('svelte').Snippet;
 }
 
+/**
+ * Per-session process state.
+ * Tracks loading/waiting/cancelling state for each chat session independently,
+ * enabling correct multi-session and multi-project support.
+ */
+export interface SessionProcessState {
+	isLoading: boolean;
+	isWaitingInput: boolean;
+	isRestoring: boolean;
+	isCancelling: boolean;
+	error: string | null;
+}
+
+const DEFAULT_SESSION_STATE: SessionProcessState = {
+	isLoading: false,
+	isWaitingInput: false,
+	isRestoring: false,
+	isCancelling: false,
+	error: null,
+};
+
 interface AppState {
 	// UI Navigation
 	currentView: string;
+
+	// Current session process state (convenience — synced from sessionStates for the active session)
 	isLoading: boolean;
+	isWaitingInput: boolean;
 	isRestoring: boolean;
 	isCancelling: boolean;
 	error: string | null;
 
+	// Per-session process states (source of truth for multi-session support)
+	sessionStates: Record<string, SessionProcessState>;
+
 	// Page Information
 	pageInfo: PageInfo;
 
@@ -36,10 +63,14 @@ export const appState = $state<AppState>({
 	// UI Navigation
 	currentView: 'chat',
 	isLoading: false,
+	isWaitingInput: false,
 	isRestoring: false,
 	isCancelling: false,
 	error: null,
 
+	// Per-session process states
+	sessionStates: {},
+
 	// Page Information
 	pageInfo: {
 		title: 'Claude Code',
@@ -52,6 +83,52 @@ export const appState = $state<AppState>({
 	isAppInitialized: false
 });
 
+// ========================================
+// PER-SESSION PROCESS STATE MANAGEMENT
+// ========================================
+
+/**
+ * Get the process state for a specific session.
+ * Returns default (idle) state if the session has no entry.
+ */
+export function getSessionProcessState(sessionId: string): SessionProcessState {
+	return appState.sessionStates[sessionId] ?? DEFAULT_SESSION_STATE;
+}
+
+/**
+ * Update process state for a specific session in the per-session map.
+ * Does NOT touch global convenience flags — caller is responsible for that.
+ */
+export function updateSessionProcessState(
+	sessionId: string,
+	update: Partial<SessionProcessState>
+): void {
+	if (!appState.sessionStates[sessionId]) {
+		appState.sessionStates[sessionId] = { ...DEFAULT_SESSION_STATE };
+	}
+	Object.assign(appState.sessionStates[sessionId], update);
+}
+
+/**
+ * Sync global convenience flags from a session's per-session state.
+ * Call when switching sessions to derive global state from the new session.
+ */
+export function syncGlobalStateFromSession(sessionId: string): void {
+	const state = appState.sessionStates[sessionId] ?? DEFAULT_SESSION_STATE;
+	appState.isLoading = state.isLoading;
+	appState.isWaitingInput = state.isWaitingInput;
+	appState.isRestoring = state.isRestoring;
+	appState.isCancelling = state.isCancelling;
+	appState.error = state.error;
+}
+
+/**
+ * Remove a session's process state entry (e.g. when deleting a session).
+ */
+export function clearSessionProcessState(sessionId: string): void {
+	delete appState.sessionStates[sessionId];
+}
+
 // ========================================
 // UI STATE MANAGEMENT
 // ========================================

package/frontend/lib/stores/features/terminal.svelte.ts

@@ -138,6 +138,16 @@ export const terminalStore = {
 		}));
 
 		terminalState.activeSessionId = sessionId;
+
+		// Persist active session ID for restoration after browser refresh
+		const session = terminalState.sessions.find(s => s.id === sessionId);
+		if (session?.projectId && typeof sessionStorage !== 'undefined') {
+			try {
+				sessionStorage.setItem(`terminal-active-session-${session.projectId}`, sessionId);
+			} catch {
+				// sessionStorage not available
+			}
+		}
 	},
 
 	async closeSession(sessionId: string): Promise<boolean> {

package/frontend/lib/utils/chat/message-grouper.ts

@@ -2,7 +2,9 @@ import type { SDKMessageFormatter } from '$shared/types/database/schema';
 import {
   shouldFilterMessage,
   extractToolUses,
-  extractToolResults
+  extractToolResults,
+  isCompactBoundaryMessage,
+  isSyntheticUserMessage
 } from './message-processor';
 import { processToolMessage } from './tool-handler';
 
@@ -21,13 +23,50 @@ export interface BackgroundBashData {
 // Processed message type
 export type ProcessedMessage = SDKMessageFormatter;
 
+// Module-level map for compact summary lookup (rebuilt each groupMessages call)
+let _compactSummaryMap = new WeakMap<SDKMessageFormatter, string>();
+
+// Lookup compact summary for a given compact_boundary message
+export function getCompactSummary(message: SDKMessageFormatter): string | undefined {
+  return _compactSummaryMap.get(message);
+}
+
+// Extract text content from a user message
+function extractUserTextContent(message: SDKMessageFormatter): string {
+  if (!('message' in message) || !message.message?.content) return '';
+  const content = message.message.content;
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((item: any) => typeof item === 'object' && item?.type === 'text')
+      .map((item: any) => item.text)
+      .join('\n');
+  }
+  return '';
+}
+
+// Get parent_tool_use_id from any message type
+function getParentToolUseId(message: SDKMessageFormatter): string | null {
+  if ('parent_tool_use_id' in message) {
+    return (message as any).parent_tool_use_id ?? null;
+  }
+  return null;
+}
+
 // Group tool_use and tool_result messages together
 export function groupMessages(messages: SDKMessageFormatter[]): {
   groups: ProcessedMessage[],
-  toolUseMap: Map<string, ToolGroup>
+  toolUseMap: Map<string, ToolGroup>,
+  subAgentMap: Map<string, SDKMessageFormatter[]>
 } {
   const groups: ProcessedMessage[] = [];
   const toolUseMap = new Map<string, ToolGroup>();
+  const agentToolUseIds = new Set<string>();
+  const subAgentMap = new Map<string, SDKMessageFormatter[]>();
+  let lastCompactBoundaryIdx = -1;
+
+  // Rebuild compact summary map each call
+  _compactSummaryMap = new WeakMap<SDKMessageFormatter, string>();
 
   messages.forEach(message => {
     // Skip messages that should be filtered
@@ -35,8 +74,30 @@ export function groupMessages(messages: SDKMessageFormatter[]): {
       return;
     }
 
+    // Intercept ALL sub-agent messages (any parent_tool_use_id !== null)
+    // before normal processing — these belong to Agent tool sub-conversations
+    const parentToolId = getParentToolUseId(message);
+    if (parentToolId) {
+      if (agentToolUseIds.has(parentToolId)) {
+        if (!subAgentMap.has(parentToolId)) {
+          subAgentMap.set(parentToolId, []);
+        }
+        subAgentMap.get(parentToolId)!.push(message);
+      }
+      // Don't add any sub-agent message to main groups
+      return;
+    }
+
+    // Handle compact boundary messages — track for synthetic user embedding
+    if (isCompactBoundaryMessage(message)) {
+      lastCompactBoundaryIdx = groups.length;
+      groups.push(message as ProcessedMessage);
+      return;
+    }
+
     // Handle assistant messages with tool_use
     if (message.type === 'assistant' && 'message' in message && message.message?.content) {
+      lastCompactBoundaryIdx = -1;
       const toolUses = extractToolUses(message.message.content);
 
       if (toolUses.length > 0) {
@@ -47,17 +108,35 @@ export function groupMessages(messages: SDKMessageFormatter[]): {
               toolUseMessage: message,
               toolResultMessage: null
             });
+            // Track Agent tool IDs for sub-agent message collection
+            if (toolUse.name === 'Agent') {
+              agentToolUseIds.add(toolUse.id);
+            }
           }
         });
         groups.push(message as ProcessedMessage);
       } else {
         groups.push(message as ProcessedMessage);
       }
+      return;
     }
-    // Handle user messages with tool_result
-    else if (message.type === 'user' && 'message' in message && message.message?.content) {
-      const toolResults = extractToolResults(message.message.content);
 
+    // Handle user messages
+    if (message.type === 'user' && 'message' in message && message.message?.content) {
+      // Synthetic user messages (after compaction): store summary in WeakMap keyed by compact boundary message
+      if (isSyntheticUserMessage(message) && lastCompactBoundaryIdx >= 0) {
+        const compactMsg = groups[lastCompactBoundaryIdx];
+        const summaryText = extractUserTextContent(message);
+        if (summaryText) {
+          _compactSummaryMap.set(compactMsg, summaryText);
+        }
+        lastCompactBoundaryIdx = -1;
+        return;
+      }
+
+      lastCompactBoundaryIdx = -1;
+
+      const toolResults = extractToolResults(message.message.content);
       if (toolResults.length > 0) {
         // Group tool_result with corresponding tool_use
         toolResults.forEach((toolResult: any) => {
@@ -73,20 +152,22 @@ export function groupMessages(messages: SDKMessageFormatter[]): {
         // Regular user message
         groups.push(message as ProcessedMessage);
       }
+      return;
     }
+
     // Include stream_event and other messages
-    else {
-      groups.push(message as ProcessedMessage);
-    }
+    lastCompactBoundaryIdx = -1;
+    groups.push(message as ProcessedMessage);
   });
 
-  return { groups, toolUseMap };
+  return { groups, toolUseMap, subAgentMap };
 }
 
 // Add tool results to messages
 export function embedToolResults(
   groups: ProcessedMessage[],
-  toolUseMap: Map<string, ToolGroup>
+  toolUseMap: Map<string, ToolGroup>,
+  subAgentMap: Map<string, SDKMessageFormatter[]>
 ): ProcessedMessage[] {
   // Track background bash sessions
   const backgroundBashMap = trackBackgroundBashSessions(groups, toolUseMap);
@@ -100,7 +181,8 @@ export function embedToolResults(
         const processedMessage = processToolMessage(
           message,
           toolUseMap,
-          backgroundBashMap
+          backgroundBashMap,
+          subAgentMap
         );
         return processedMessage;
       }
@@ -216,4 +298,4 @@ function trackBashOutput(
       bashData.bashOutputs.push(toolResult);
     }
   }
-}
+}