mstro-app 0.1.57 → 0.2.0

package/server/services/websocket/handler.ts

@@ -22,8 +22,9 @@ import {
   renameFile, 
   writeFile
 } from '../files.js';
+import { validatePathWithinWorkingDir } from '../pathUtils.js';
 import { captureException } from '../sentry.js';
-import { getModel, getSettings, setModel } from '../settings.js';
+import { getModel, getPrBaseBranch, getSettings, setModel, setPrBaseBranch } from '../settings.js';
 import { getPTYManager } from '../terminal/pty-manager.js';
 import { AutocompleteService } from './autocomplete.js';
 import { readFileContent } from './file-utils.js';
@@ -38,24 +39,31 @@ export interface UsageReport {
 
 export type UsageReporter = (report: UsageReport) => void;
 
+/** Convert tool history entries into OutputLine-compatible lines */
+function convertToolHistoryToLines(tools: any[], ts: number): any[] {
+  const lines: any[] = [];
+  for (const tool of tools) {
+    lines.push({ type: 'tool-call', text: '', toolName: tool.toolName, toolInput: tool.toolInput || {}, timestamp: ts });
+    if (tool.result !== undefined) {
+      lines.push({ type: 'tool-result', text: '', toolResult: tool.result || 'No output', toolStatus: tool.isError ? 'error' : 'success', timestamp: ts });
+    }
+  }
+  return lines;
+}
+
 /** Convert a single movement record into OutputLine-compatible entries */
-function convertMovementToLines(movement: { userPrompt: string; timestamp: string; thinkingOutput?: string; toolUseHistory?: any[]; assistantResponse?: string; errorOutput?: string; tokensUsed: number }): any[] {
+function convertMovementToLines(movement: { userPrompt: string; timestamp: string; thinkingOutput?: string; toolUseHistory?: any[]; assistantResponse?: string; errorOutput?: string; tokensUsed: number; durationMs?: number }): any[] {
   const lines: any[] = [];
   const ts = new Date(movement.timestamp).getTime();
 
-  lines.push({ type: 'user', text: `> ${movement.userPrompt}`, timestamp: ts });
+  lines.push({ type: 'user', text: movement.userPrompt, timestamp: ts });
 
   if (movement.thinkingOutput) {
     lines.push({ type: 'thinking', text: '', thinking: movement.thinkingOutput, timestamp: ts });
   }
 
   if (movement.toolUseHistory) {
-    for (const tool of movement.toolUseHistory) {
-      lines.push({ type: 'tool-call', text: '', toolName: tool.toolName, toolInput: tool.toolInput || {}, timestamp: ts });
-      if (tool.result !== undefined) {
-        lines.push({ type: 'tool-result', text: '', toolResult: tool.result || 'No output', toolStatus: tool.isError ? 'error' : 'success', timestamp: ts });
-      }
-    }
+    lines.push(...convertToolHistoryToLines(movement.toolUseHistory, ts));
   }
 
   if (movement.assistantResponse) {
@@ -66,10 +74,20 @@ function convertMovementToLines(movement: { userPrompt: string; timestamp: strin
     lines.push({ type: 'error', text: `Error: ${movement.errorOutput}`, timestamp: ts });
   }
 
-  lines.push({ type: 'system', text: `Command completed (tokens: ${movement.tokensUsed.toLocaleString()})`, timestamp: ts });
+  const durationText = movement.durationMs
+    ? `Completed in ${(movement.durationMs / 1000).toFixed(2)}s`
+    : 'Completed';
+  lines.push({ type: 'system', text: durationText, timestamp: ts });
   return lines;
 }
 
+/** Detect git provider from remote URL */
+function detectGitProvider(remoteUrl: string): 'github' | 'gitlab' | 'unknown' {
+  if (remoteUrl.includes('github.com')) return 'github';
+  if (remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab')) return 'gitlab';
+  return 'unknown';
+}
+
 export class WebSocketImproviseHandler {
   private sessions: Map<string, ImprovisationSessionManager> = new Map();
   private connections: Map<WSContext, Map<string, string>> = new Map();
@@ -163,8 +181,11 @@ export class WebSocketImproviseHandler {
     try {
       const msg: WebSocketMessage = JSON.parse(message);
       const tabId = msg.tabId || 'default';
+      // Extract sandbox permission injected by server relay (for sandboxed shared users)
+      const permission = msg._permission;
+      delete msg._permission;
 
-      await this.dispatchMessage(ws, msg, tabId, workingDir);
+      await this.dispatchMessage(ws, msg, tabId, workingDir, permission);
     } catch (error: any) {
       console.error('[WebSocketImproviseHandler] Error handling message:', error);
       captureException(error, { context: 'websocket.handleMessage' });
@@ -178,7 +199,7 @@ export class WebSocketImproviseHandler {
   /**
    * Dispatch a parsed message to the appropriate handler
    */
-  private async dispatchMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  private async dispatchMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'control' | 'view'): Promise<void> {
     switch (msg.type) {
       case 'ping':
         this.send(ws, { type: 'pong', tabId });
@@ -194,7 +215,7 @@ export class WebSocketImproviseHandler {
       case 'new':
       case 'approve':
       case 'reject':
-        return this.handleSessionMessage(ws, msg, tabId);
+        return this.handleSessionMessage(ws, msg, tabId, permission);
       case 'getSessions':
       case 'getSessionsCount':
       case 'getSessionById':
@@ -206,16 +227,14 @@ export class WebSocketImproviseHandler {
       case 'readFile':
       case 'recordSelection':
       case 'requestNotificationSummary':
-        return this.handleFileMessage(ws, msg, tabId, workingDir);
+        return this.handleFileMessage(ws, msg, tabId, workingDir, permission);
       case 'terminalInit':
       case 'terminalReconnect':
       case 'terminalList':
-      case 'terminalInitPersistent':
-      case 'terminalListPersistent':
       case 'terminalInput':
       case 'terminalResize':
       case 'terminalClose':
-        return this.handleTerminalMessage(ws, msg, tabId, workingDir);
+        return this.handleTerminalMessage(ws, msg, tabId, workingDir, permission);
       case 'listDirectory':
       case 'writeFile':
       case 'createFile':
@@ -223,7 +242,7 @@ export class WebSocketImproviseHandler {
       case 'deleteFile':
       case 'renameFile':
       case 'notifyFileOpened':
-        return this.handleFileExplorerMessage(ws, msg, tabId, workingDir);
+        return this.handleFileExplorerMessage(ws, msg, tabId, workingDir, permission);
       case 'gitStatus':
       case 'gitStage':
       case 'gitUnstage':
@@ -233,6 +252,9 @@ export class WebSocketImproviseHandler {
       case 'gitLog':
       case 'gitDiscoverRepos':
       case 'gitSetDirectory':
+      case 'gitGetRemoteInfo':
+      case 'gitCreatePR':
+      case 'gitGeneratePRDescription':
         return this.handleGitMessage(ws, msg, tabId, workingDir);
       // Session sync messages
       case 'getActiveTabs':
@@ -262,18 +284,18 @@ export class WebSocketImproviseHandler {
   /**
    * Handle session-related messages (execute, cancel, history, new, approve, reject)
    */
-  private handleSessionMessage(ws: WSContext, msg: WebSocketMessage, tabId: string): void {
+  private handleSessionMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, permission?: 'control' | 'view'): void {
     switch (msg.type) {
       case 'execute': {
         if (!msg.data?.prompt) throw new Error('Prompt is required');
         const session = this.requireSession(ws, tabId);
-        session.executePrompt(msg.data.prompt, msg.data.attachments);
+        const sandboxed = permission === 'control' || permission === 'view';
+        session.executePrompt(msg.data.prompt, msg.data.attachments, { sandboxed });
         break;
       }
       case 'cancel': {
         const session = this.requireSession(ws, tabId);
         session.cancel();
-        this.send(ws, { type: 'output', tabId, data: { text: '\n⚠️  Operation cancelled\n' } });
         break;
       }
       case 'getHistory': {
@@ -347,15 +369,14 @@ export class WebSocketImproviseHandler {
   /**
    * Handle file-related messages (autocomplete, readFile, recordSelection, notifications)
    */
-  private handleFileMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+  private handleFileMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'control' | 'view'): void {
     switch (msg.type) {
       case 'autocomplete':
         if (!msg.data?.partialPath) throw new Error('Partial path is required');
         this.send(ws, { type: 'autocomplete', tabId, data: { completions: this.autocompleteService.getFileCompletions(msg.data.partialPath, workingDir) } });
         break;
       case 'readFile':
-        if (!msg.data?.filePath) throw new Error('File path is required');
-        this.send(ws, { type: 'fileContent', tabId, data: readFileContent(msg.data.filePath, workingDir) });
+        this.handleReadFile(ws, msg, tabId, workingDir, permission);
         break;
       case 'recordSelection':
         if (msg.data?.filePath) this.recordFileSelection(msg.data.filePath);
@@ -367,14 +388,27 @@ export class WebSocketImproviseHandler {
     }
   }
 
+  private handleReadFile(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'control' | 'view'): void {
+    if (!msg.data?.filePath) throw new Error('File path is required');
+    const isSandboxed = permission === 'control' || permission === 'view';
+    if (isSandboxed) {
+      const validation = validatePathWithinWorkingDir(msg.data.filePath, workingDir);
+      if (!validation.valid) {
+        this.send(ws, { type: 'fileContent', tabId, data: { path: msg.data.filePath, fileName: msg.data.filePath.split('/').pop() || '', content: '', error: 'Sandboxed: path outside project directory' } });
+        return;
+      }
+    }
+    this.send(ws, { type: 'fileContent', tabId, data: readFileContent(msg.data.filePath, workingDir) });
+  }
+
   /**
    * Handle terminal messages
    */
-  private handleTerminalMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+  private handleTerminalMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'control' | 'view'): void {
     const termId = msg.terminalId || tabId;
     switch (msg.type) {
       case 'terminalInit':
-        this.handleTerminalInit(ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows);
+        this.handleTerminalInit(ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows, permission);
         break;
       case 'terminalReconnect':
         this.handleTerminalReconnect(ws, termId);
@@ -382,12 +416,6 @@ export class WebSocketImproviseHandler {
       case 'terminalList':
         this.handleTerminalList(ws);
         break;
-      case 'terminalInitPersistent':
-        this.handleTerminalInitPersistent(ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows);
-        break;
-      case 'terminalListPersistent':
-        this.handleTerminalListPersistent(ws);
-        break;
       case 'terminalInput':
         this.handleTerminalInput(ws, termId, msg.data?.input);
         break;
@@ -496,9 +524,20 @@ export class WebSocketImproviseHandler {
     }
   }
 
-  private handleFileExplorerMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+  private handleFileExplorerMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'control' | 'view'): void {
+    const isSandboxed = permission === 'control' || permission === 'view';
     const handlers: Record<string, () => void> = {
-      listDirectory: () => this.handleListDirectory(ws, msg, tabId, workingDir),
+      listDirectory: () => {
+        // Sandboxed users can only list directories within the project
+        if (isSandboxed && msg.data?.dirPath) {
+          const validation = validatePathWithinWorkingDir(msg.data.dirPath, workingDir);
+          if (!validation.valid) {
+            this.send(ws, { type: 'directoryListing', tabId, data: { success: false, path: msg.data.dirPath, error: 'Sandboxed: path outside project directory' } });
+            return;
+          }
+        }
+        this.handleListDirectory(ws, msg, tabId, workingDir);
+      },
       writeFile: () => this.handleWriteFile(ws, msg, tabId, workingDir),
       createFile: () => this.handleCreateFile(ws, msg, tabId, workingDir),
       createDirectory: () => this.handleCreateDirectory(ws, msg, tabId, workingDir),
@@ -534,10 +573,10 @@ export class WebSocketImproviseHandler {
     });
 
     session.on('onMovementStart', (sequenceNumber: number, prompt: string) => {
-      this.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now() } });
+      this.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp } });
       // Broadcast execution state to ALL clients so tab indicators update
       // even if per-tab event subscriptions aren't ready yet (e.g., newly discovered tabs)
-      this.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true } });
+      this.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true, executionStartTimestamp: session.executionStartTimestamp } });
     });
 
     session.on('onMovementComplete', (movement: any) => {
@@ -755,6 +794,7 @@ export class WebSocketImproviseHandler {
         outputHistory,
         isExecuting: session.isExecuting,
         executionEvents,
+        ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
       }
     });
   }
@@ -851,14 +891,14 @@ export class WebSocketImproviseHandler {
    * Get count of all historical sessions without reading file contents
    */
   private getSessionsCount(workingDir: string): number {
-    const sessionsDir = join(workingDir, '.mstro', 'improvise');
+    const sessionsDir = join(workingDir, '.mstro', 'history');
 
     if (!existsSync(sessionsDir)) {
       return 0;
     }
 
     return readdirSync(sessionsDir)
-      .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'))
+      .filter((name: string) => name.endsWith('.json'))
       .length;
   }
 
@@ -867,7 +907,7 @@ export class WebSocketImproviseHandler {
    * Returns minimal metadata - movements are stripped to just userPrompt preview
    */
   private getSessionsList(workingDir: string, limit: number = 20, offset: number = 0): { sessions: any[]; total: number; hasMore: boolean } {
-    const sessionsDir = join(workingDir, '.mstro', 'improvise');
+    const sessionsDir = join(workingDir, '.mstro', 'history');
 
     if (!existsSync(sessionsDir)) {
       return { sessions: [], total: 0, hasMore: false };
@@ -875,10 +915,10 @@ export class WebSocketImproviseHandler {
 
     // Get sorted file list (newest first) without reading contents
     const historyFiles = readdirSync(sessionsDir)
-      .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'))
+      .filter((name: string) => name.endsWith('.json'))
       .sort((a: string, b: string) => {
-        const timestampA = parseInt(a.replace('history-', '').replace('.json', ''), 10);
-        const timestampB = parseInt(b.replace('history-', '').replace('.json', ''), 10);
+        const timestampA = parseInt(a.replace('.json', ''), 10);
+        const timestampB = parseInt(b.replace('.json', ''), 10);
         return timestampB - timestampA;
       });
 
@@ -923,14 +963,14 @@ export class WebSocketImproviseHandler {
    * Get a full session by ID (includes all movement data)
    */
   private getSessionById(workingDir: string, sessionId: string): any {
-    const sessionsDir = join(workingDir, '.mstro', 'improvise');
+    const sessionsDir = join(workingDir, '.mstro', 'history');
 
     if (!existsSync(sessionsDir)) {
       return null;
     }
 
     const historyFiles = readdirSync(sessionsDir)
-      .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'));
+      .filter((name: string) => name.endsWith('.json'));
 
     for (const filename of historyFiles) {
       const historyPath = join(sessionsDir, filename);
@@ -960,7 +1000,7 @@ export class WebSocketImproviseHandler {
    * Delete a single session from disk
    */
   private deleteSession(workingDir: string, sessionId: string): { sessionId: string; success: boolean } {
-    const sessionsDir = join(workingDir, '.mstro', 'improvise');
+    const sessionsDir = join(workingDir, '.mstro', 'history');
 
     if (!existsSync(sessionsDir)) {
       return { sessionId, success: false };
@@ -968,7 +1008,7 @@ export class WebSocketImproviseHandler {
 
     try {
       const historyFiles = readdirSync(sessionsDir)
-        .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'));
+        .filter((name: string) => name.endsWith('.json'));
 
       for (const filename of historyFiles) {
         const historyPath = join(sessionsDir, filename);
@@ -994,7 +1034,7 @@ export class WebSocketImproviseHandler {
    * Clear all sessions from disk
    */
   private clearAllSessions(workingDir: string): { success: boolean; deletedCount: number } {
-    const sessionsDir = join(workingDir, '.mstro', 'improvise');
+    const sessionsDir = join(workingDir, '.mstro', 'history');
 
     if (!existsSync(sessionsDir)) {
       return { success: true, deletedCount: 0 };
@@ -1002,7 +1042,7 @@ export class WebSocketImproviseHandler {
 
     try {
       const historyFiles = readdirSync(sessionsDir)
-        .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'));
+        .filter((name: string) => name.endsWith('.json'));
 
       let deletedCount = 0;
       for (const filename of historyFiles) {
@@ -1053,7 +1093,7 @@ export class WebSocketImproviseHandler {
   }
 
   private searchSessions(workingDir: string, query: string, limit: number = 20, offset: number = 0): { sessions: any[]; total: number; hasMore: boolean } {
-    const sessionsDir = join(workingDir, '.mstro', 'improvise');
+    const sessionsDir = join(workingDir, '.mstro', 'history');
 
     if (!existsSync(sessionsDir)) {
       return { sessions: [], total: 0, hasMore: false };
@@ -1063,10 +1103,10 @@ export class WebSocketImproviseHandler {
 
     try {
       const historyFiles = readdirSync(sessionsDir)
-        .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'))
+        .filter((name: string) => name.endsWith('.json'))
         .sort((a: string, b: string) => {
-          const timestampA = parseInt(a.replace('history-', '').replace('.json', ''), 10);
-          const timestampB = parseInt(b.replace('history-', '').replace('.json', ''), 10);
+          const timestampA = parseInt(a.replace('.json', ''), 10);
+          const timestampB = parseInt(b.replace('.json', ''), 10);
           return timestampB - timestampA;
         });
 
@@ -1133,6 +1173,7 @@ export class WebSocketImproviseHandler {
           isExecuting: session.isExecuting,
           outputHistory: this.buildOutputHistory(session),
           executionEvents: session.isExecuting ? session.getExecutionEventLog() : undefined,
+          ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
         };
       } else {
         // Session not in memory — try to provide basic info from registry
@@ -1466,6 +1507,9 @@ Respond with ONLY the summary text, nothing else.`;
       gitLog: () => this.handleGitLog(ws, msg, tabId, gitDir),
       gitDiscoverRepos: () => this.handleGitDiscoverRepos(ws, tabId, workingDir),
       gitSetDirectory: () => this.handleGitSetDirectory(ws, msg, tabId, workingDir),
+      gitGetRemoteInfo: () => this.handleGitGetRemoteInfo(ws, tabId, gitDir),
+      gitCreatePR: () => this.handleGitCreatePR(ws, msg, tabId, gitDir),
+      gitGeneratePRDescription: () => this.handleGitGeneratePRDescription(ws, msg, tabId, gitDir),
     };
     handlers[msg.type]?.();
   }
@@ -1636,14 +1680,22 @@ Respond with ONLY the summary text, nothing else.`;
       const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
       const branch = branchResult.stdout.trim() || 'HEAD';
 
-      // Get ahead/behind counts
+      // Get ahead/behind counts and upstream tracking info
       let ahead = 0;
       let behind = 0;
+      let hasUpstream = false;
       const trackingResult = await this.executeGitCommand(['rev-list', '--left-right', '--count', `${branch}...@{u}`], workingDir);
       if (trackingResult.exitCode === 0) {
+        hasUpstream = true;
         const parts = trackingResult.stdout.trim().split(/\s+/);
         ahead = parseInt(parts[0], 10) || 0;
         behind = parseInt(parts[1], 10) || 0;
+      } else {
+        // No upstream - count local commits as ahead
+        const localResult = await this.executeGitCommand(['rev-list', '--count', 'HEAD'], workingDir);
+        if (localResult.exitCode === 0) {
+          ahead = parseInt(localResult.stdout.trim(), 10) || 0;
+        }
       }
 
       const { staged, unstaged, untracked } = this.parseGitStatus(statusResult.stdout);
@@ -1656,6 +1708,7 @@ Respond with ONLY the summary text, nothing else.`;
         untracked,
         ahead,
         behind,
+        hasUpstream,
       };
 
       this.send(ws, { type: 'gitStatus', tabId, data: response });
@@ -1744,6 +1797,8 @@ Respond with ONLY the summary text, nothing else.`;
       const hash = hashResult.stdout.trim();
 
       this.send(ws, { type: 'gitCommitted', tabId, data: { hash, message } });
+      // Proactively send updated status so the UI reflects new ahead/behind counts
+      this.handleGitStatus(ws, tabId, workingDir);
     } catch (error: any) {
       this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
     }
@@ -1869,6 +1924,8 @@ Respond with ONLY the commit message, nothing else.`;
           const hash = hashResult.stdout.trim();
 
           this.send(ws, { type: 'gitCommitted', tabId, data: { hash, message: commitMessage } });
+          // Proactively send updated status so the UI reflects new ahead/behind counts
+          this.handleGitStatus(ws, tabId, workingDir);
         }
       });
 
@@ -1902,7 +1959,7 @@ Respond with ONLY the commit message, nothing else.`;
     for (const pattern of patterns) {
       const match = output.match(pattern);
       if (match?.[1]) {
-        return match[1].trim();
+        return this.stripCoauthorLines(match[1].trim());
       }
     }
 
@@ -1911,7 +1968,7 @@ Respond with ONLY the commit message, nothing else.`;
 
     // If only one paragraph, return it as-is
     if (paragraphs.length <= 1) {
-      return output.trim();
+      return this.stripCoauthorLines(output.trim());
     }
 
     const firstParagraph = paragraphs[0].trim();
@@ -1938,7 +1995,7 @@ Respond with ONLY the commit message, nothing else.`;
       // Validate the extracted message has a reasonable first line
       const extractedFirstLine = commitMessage.split('\n')[0].trim();
       if (extractedFirstLine.length > 0 && extractedFirstLine.length <= 100) {
-        return commitMessage;
+        return this.stripCoauthorLines(commitMessage);
       }
     }
 
@@ -1953,12 +2010,37 @@ Respond with ONLY the commit message, nothing else.`;
           /^[A-Z][a-z]/.test(secondFirstLine) &&
           !secondFirstLine.endsWith('.')) {
         // Return from second paragraph onwards
-        return paragraphs.slice(1).join('\n\n').trim();
+        return this.stripCoauthorLines(paragraphs.slice(1).join('\n\n').trim());
       }
     }
 
     // Fall back to original output if we can't identify a better message
-    return output.trim();
+    return this.stripCoauthorLines(output.trim());
+  }
+
+  /**
+   * Strip injected coauthor/attribution lines from a commit message.
+   * The Claude Code CLI appends "Co-Authored-By" lines to LLM output.
+   * We detect and remove them by matching known marker strings.
+   */
+  private stripCoauthorLines(message: string): string {
+    const lines = message.split('\n');
+    const markers = ['co-authored', 'authored-by', 'haiku', 'noreply@anthropic.com'];
+    const result: string[] = [];
+    for (let i = 0; i < lines.length; i++) {
+      const lower = lines[i].toLowerCase();
+      if (markers.some(m => lower.includes(m))) {
+        // Also remove a blank line immediately before this one
+        if (result.length > 0 && result[result.length - 1].trim() === '') {
+          result.pop();
+        }
+        continue;
+      }
+      result.push(lines[i]);
+    }
+    // Don't return empty - keep at least the first line of the original
+    if (result.length === 0) return lines[0]?.trim() || message;
+    return result.join('\n').trimEnd();
   }
 
   /**
@@ -1966,7 +2048,15 @@ Respond with ONLY the commit message, nothing else.`;
    */
   private async handleGitPush(ws: WSContext, tabId: string, workingDir: string): Promise<void> {
     try {
-      const result = await this.executeGitCommand(['push'], workingDir);
+      // Check if branch has an upstream, if not use --set-upstream
+      const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+      const branch = branchResult.stdout.trim();
+
+      const upstreamCheck = await this.executeGitCommand(['rev-parse', '--abbrev-ref', `${branch}@{u}`], workingDir);
+      const hasUpstream = upstreamCheck.exitCode === 0;
+
+      const pushArgs = hasUpstream ? ['push'] : ['push', '-u', 'origin', branch];
+      const result = await this.executeGitCommand(pushArgs, workingDir);
       if (result.exitCode !== 0) {
         this.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || result.stdout || 'Failed to push' } });
         return;
@@ -2117,6 +2207,356 @@ Respond with ONLY the commit message, nothing else.`;
     }
   }
 
+  /**
+   * Get remote info for PR creation (remote URL, provider, default branch)
+   */
+  private async handleGitGetRemoteInfo(ws: WSContext, tabId: string, workingDir: string): Promise<void> {
+    try {
+      const remoteResult = await this.executeGitCommand(['remote', 'get-url', 'origin'], workingDir);
+      if (remoteResult.exitCode !== 0) {
+        this.send(ws, { type: 'gitRemoteInfo', tabId, data: { hasRemote: false } });
+        return;
+      }
+
+      const remoteUrl = remoteResult.stdout.trim();
+      const provider = detectGitProvider(remoteUrl);
+      const defaultBranch = await this.getDefaultBranch(workingDir);
+      const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+      const currentBranch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : '';
+      const cliStatus = await this.checkGitCliStatus(provider);
+      const remoteBranches = await this.listRemoteBranches(workingDir);
+      const preferredBaseBranch = getPrBaseBranch(remoteUrl) ?? undefined;
+
+      this.send(ws, {
+        type: 'gitRemoteInfo',
+        tabId,
+        data: {
+          hasRemote: true,
+          remoteUrl,
+          provider,
+          defaultBranch,
+          currentBranch,
+          ...cliStatus,
+          remoteBranches,
+          preferredBaseBranch,
+        },
+      });
+    } catch (error: any) {
+      this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
+    }
+  }
+
+  private async getDefaultBranch(workingDir: string): Promise<string> {
+    const result = await this.executeGitCommand(
+      ['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'],
+      workingDir
+    );
+    return result.exitCode === 0 ? result.stdout.trim().replace('origin/', '') : 'main';
+  }
+
+  private async checkGitCliStatus(provider: 'github' | 'gitlab' | 'unknown'): Promise<{ hasGhCli: boolean; ghCliAuthenticated: boolean; ghCliBinary?: 'gh' | 'glab' }> {
+    const cliBin = provider === 'github' ? 'gh' : provider === 'gitlab' ? 'glab' : null;
+    if (!cliBin) return { hasGhCli: false, ghCliAuthenticated: false };
+
+    const installed = await this.spawnCheck(cliBin, ['--version']);
+    if (!installed) return { hasGhCli: false, ghCliAuthenticated: false };
+
+    const authenticated = await this.spawnCheck(cliBin, ['auth', 'status']);
+    return { hasGhCli: true, ghCliAuthenticated: authenticated, ghCliBinary: cliBin };
+  }
+
+  private async listRemoteBranches(workingDir: string): Promise<string[]> {
+    const result = await this.executeGitCommand(['branch', '-r', '--list', 'origin/*'], workingDir);
+    if (result.exitCode !== 0) return [];
+
+    return result.stdout.split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.includes('->'))
+      .map(line => line.replace('origin/', ''))
+      .filter(Boolean)
+      .sort();
+  }
+
+  /** Check if a binary runs successfully (exit code 0) */
+  private spawnCheck(bin: string, args: string[]): Promise<boolean> {
+    return new Promise((resolve) => {
+      const proc = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('close', (code) => resolve(code === 0));
+      proc.on('error', () => resolve(false));
+    });
+  }
+
+  /** Detect which CLI binary to use for PR creation based on remote URL */
+  private detectPRCliBin(remoteUrl: string): { cliBin: 'gh' | 'glab' | null; isGitHub: boolean; isGitLab: boolean } {
+    const isGitHub = remoteUrl.includes('github.com');
+    const isGitLab = remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab');
+    const cliBin = isGitHub ? 'gh' as const : isGitLab ? 'glab' as const : null;
+    return { cliBin, isGitHub, isGitLab };
+  }
+
+  /** Send PR success and optionally persist base branch */
+  private sendPRCreated(
+    ws: WSContext, tabId: string, url: string, method: string,
+    remoteUrl: string, baseBranch?: string,
+  ): void {
+    if (baseBranch) setPrBaseBranch(remoteUrl, baseBranch);
+    this.send(ws, { type: 'gitPRCreated', tabId, data: { url, method } });
+  }
+
+  /**
+   * Create a pull/merge request using gh CLI (GitHub) or open browser URL (fallback)
+   */
+  private async handleGitCreatePR(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+    const { title, body, baseBranch, draft } = msg.data ?? {};
+
+    if (!title) {
+      this.send(ws, { type: 'gitError', tabId, data: { error: 'PR title is required' } });
+      return;
+    }
+
+    try {
+      const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+      if (branchResult.exitCode !== 0) {
+        this.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to detect current branch' } });
+        return;
+      }
+
+      const remoteResult = await this.executeGitCommand(['remote', 'get-url', 'origin'], workingDir);
+      if (remoteResult.exitCode !== 0) {
+        this.send(ws, { type: 'gitError', tabId, data: { error: 'No remote origin configured' } });
+        return;
+      }
+
+      const headBranch = branchResult.stdout.trim();
+      const remoteUrl = remoteResult.stdout.trim();
+      const { cliBin, isGitHub, isGitLab } = this.detectPRCliBin(remoteUrl);
+
+      const cliResult = await this.tryCliPRCreate(cliBin, { title, body, baseBranch, draft, headBranch }, workingDir);
+
+      if (cliResult.created) {
+        this.sendPRCreated(ws, tabId, cliResult.url!, isGitHub ? 'gh' : 'glab', remoteUrl, baseBranch);
+        return;
+      }
+      if (cliResult.error) {
+        this.send(ws, { type: 'gitError', tabId, data: { error: cliResult.error } });
+        return;
+      }
+
+      const prUrl = this.buildBrowserPRUrl(remoteUrl, headBranch, baseBranch, title, body, isGitHub, isGitLab);
+      if (prUrl) {
+        this.sendPRCreated(ws, tabId, prUrl, 'browser', remoteUrl, baseBranch);
+      } else {
+        this.send(ws, { type: 'gitError', tabId, data: { error: 'Could not determine remote URL format for PR creation' } });
+      }
+    } catch (error: any) {
+      this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
+    }
+  }
+
+  /** Attempt to create a PR/MR via CLI. Returns { created, url, error } */
+  private async tryCliPRCreate(
+    cliBin: 'gh' | 'glab' | null,
+    opts: { title: string; body?: string; baseBranch?: string; draft?: boolean; headBranch: string },
+    workingDir: string,
+  ): Promise<{ created: boolean; url?: string; error?: string }> {
+    if (!cliBin) return { created: false }; // No CLI for this provider
+
+    // Check if CLI is installed
+    const installed = await this.spawnCheck(cliBin, ['--version']);
+    if (!installed) return { created: false }; // Not installed, fall through to browser
+
+    // Build CLI args
+    const args = cliBin === 'gh'
+      ? ['pr', 'create', '--title', opts.title]
+      : ['mr', 'create', '--title', opts.title, '--yes']; // glab mr create
+
+    if (opts.body) args.push('--body', opts.body);
+    if (opts.baseBranch) {
+      args.push(cliBin === 'gh' ? '--base' : '--target-branch', opts.baseBranch);
+    }
+    if (opts.draft) args.push('--draft');
+
+    const result = await this.spawnWithOutput(cliBin, args, workingDir);
+
+    if (result.exitCode === 0) {
+      const urlMatch = result.stdout.match(/https?:\/\/\S+/);
+      return { created: true, url: urlMatch ? urlMatch[0] : result.stdout.trim() };
+    }
+
+    return { created: false, error: this.classifyCliPRError(cliBin, result, opts.headBranch) };
+  }
+
+  /** Classify a CLI PR creation error into a user-facing message */
+  private classifyCliPRError(
+    cliBin: string,
+    result: { stdout: string; stderr: string },
+    headBranch: string,
+  ): string {
+    const combined = result.stderr + result.stdout;
+    const lower = combined.toLowerCase();
+
+    if (lower.includes('already exists')) {
+      const existingUrl = combined.match(/https?:\/\/\S+/);
+      return existingUrl
+        ? `A pull request already exists for ${headBranch}: ${existingUrl[0]}`
+        : `A pull request already exists for ${headBranch}`;
+    }
+
+    if (lower.includes('auth') || lower.includes('401') || lower.includes('token') || lower.includes('log in')) {
+      return `${cliBin} is not authenticated. Run: ${cliBin} auth login`;
+    }
+
+    if (lower.includes('must first push') || lower.includes('failed to push') || lower.includes('no upstream')) {
+      return `Branch "${headBranch}" has not been pushed to remote. Push first, then create the PR.`;
+    }
+
+    return `${cliBin} failed: ${(result.stderr || result.stdout).trim()}`;
+  }
+
+  /** Spawn a process and capture stdout/stderr */
+  private spawnWithOutput(bin: string, args: string[], cwd: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    return new Promise((resolve) => {
+      const proc = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+      let stdout = '';
+      let stderr = '';
+      proc.stdout?.on('data', (d: Buffer) => { stdout += d.toString(); });
+      proc.stderr?.on('data', (d: Buffer) => { stderr += d.toString(); });
+      proc.on('close', (code) => resolve({ stdout, stderr, exitCode: code ?? 1 }));
+      proc.on('error', (err: Error) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
+    });
+  }
+
+  /** Build a browser URL for PR creation (fallback when no CLI) */
+  private buildBrowserPRUrl(
+    remoteUrl: string, headBranch: string, baseBranch: string | undefined,
+    title: string, body: string | undefined, isGitHub: boolean, isGitLab: boolean,
+  ): string {
+    const sshMatch = remoteUrl.match(/[:/]([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (!sshMatch) return '';
+
+    const [, owner, repo] = sshMatch;
+    const base = baseBranch || 'main';
+
+    if (isGitHub) {
+      return `https://github.com/${owner}/${repo}/compare/${base}...${headBranch}?expand=1&title=${encodeURIComponent(title)}${body ? `&body=${encodeURIComponent(body)}` : ''}`;
+    }
+    if (isGitLab) {
+      return `https://gitlab.com/${owner}/${repo}/-/merge_requests/new?merge_request[source_branch]=${headBranch}&merge_request[target_branch]=${base}&merge_request[title]=${encodeURIComponent(title)}`;
+    }
+    return '';
+  }
+
+  /**
+   * Generate a PR title and description using Haiku, based on the diff against the base branch.
+   */
+  private async handleGitGeneratePRDescription(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+    const baseBranch = msg.data?.baseBranch || 'main';
+
+    try {
+      // Get commit list for context
+      const logResult = await this.executeGitCommand(['log', `${baseBranch}..HEAD`, '--oneline'], workingDir);
+      const commits = logResult.exitCode === 0 ? logResult.stdout.trim() : '';
+
+      if (!commits) {
+        this.send(ws, { type: 'gitError', tabId, data: { error: `No commits found between ${baseBranch} and HEAD` } });
+        return;
+      }
+
+      // Get diff against base
+      const diffResult = await this.executeGitCommand(['diff', `${baseBranch}...HEAD`], workingDir);
+      const diff = diffResult.exitCode === 0 ? diffResult.stdout : '';
+
+      // Get changed files summary
+      const statResult = await this.executeGitCommand(['diff', `${baseBranch}...HEAD`, '--stat'], workingDir);
+      const stat = statResult.exitCode === 0 ? statResult.stdout.trim() : '';
+
+      // Truncate diff if too long (same pattern as commit message generation)
+      let truncatedDiff = diff;
+      if (diff.length > 8000) {
+        truncatedDiff = `${diff.slice(0, 4000)}\n\n... [diff truncated] ...\n\n${diff.slice(-3500)}`;
+      }
+
+      // Build prompt
+      const tempDir = join(workingDir, '.mstro', 'tmp');
+      if (!existsSync(tempDir)) {
+        mkdirSync(tempDir, { recursive: true });
+      }
+
+      const prompt = `You are generating a pull request title and description for the following changes.
+
+COMMITS (${baseBranch}..HEAD):
+${commits}
+
+FILES CHANGED:
+${stat}
+
+DIFF:
+${truncatedDiff}
+
+Generate a pull request title and description following these rules:
+1. TITLE: First line must be the PR title — imperative mood, under 70 characters
+2. Leave a blank line after the title
+3. BODY: Write a concise description in markdown with:
+   - A "## Summary" section with 1-3 bullet points explaining what changed and why
+   - Optionally a "## Details" section if the changes are complex
+4. Focus on the "why" not just the "what"
+5. No emojis
+
+Respond with ONLY the title and description, nothing else.`;
+
+      const promptFile = join(tempDir, `pr-desc-${Date.now()}.txt`);
+      writeFileSync(promptFile, prompt);
+
+      const systemPrompt = 'You are a pull request description assistant. Respond with only the PR title and description, no preamble or explanation.';
+
+      const args = [
+        '--print',
+        '--model', 'haiku',
+        '--system-prompt', systemPrompt,
+        promptFile
+      ];
+
+      const claude = spawn('claude', args, {
+        cwd: workingDir,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      claude.stdout?.on('data', (data: Buffer) => { stdout += data.toString(); });
+      claude.stderr?.on('data', (data: Buffer) => { stderr += data.toString(); });
+
+      claude.on('close', (code: number | null) => {
+        try { unlinkSync(promptFile); } catch { /* ignore */ }
+
+        if (code !== 0 || !stdout.trim()) {
+          console.error('[WebSocketImproviseHandler] Claude PR description error:', stderr || 'No output');
+          this.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to generate PR description' } });
+          return;
+        }
+
+        // Parse: first line = title, rest = body
+        const output = this.stripCoauthorLines(stdout.trim());
+        const lines = output.split('\n');
+        const title = lines[0].trim();
+        const body = lines.slice(1).join('\n').trim();
+
+        this.send(ws, { type: 'gitPRDescription', tabId, data: { title, body } });
+      });
+
+      claude.on('error', (err: Error) => {
+        console.error('[WebSocketImproviseHandler] Failed to spawn Claude for PR description:', err);
+        this.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to generate PR description' } });
+      });
+
+      setTimeout(() => { claude.kill(); }, 30000);
+
+    } catch (error: any) {
+      this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
+    }
+  }
+
   // ============================================
   // Terminal handling methods
   // ============================================
@@ -2130,7 +2570,8 @@ Respond with ONLY the commit message, nothing else.`;
     workingDir: string,
     requestedShell?: string,
     cols?: number,
-    rows?: number
+    rows?: number,
+    permission?: 'control' | 'view'
   ): void {
 
     const ptyManager = getPTYManager();
@@ -2156,29 +2597,21 @@ Respond with ONLY the commit message, nothing else.`;
 
     try {
       // Create or reconnect to the PTY process
+      // Both 'control' and 'view' users get sandboxed terminals
       const { shell, cwd, isReconnect } = ptyManager.create(
         terminalId,
         workingDir,
         cols || 80,
         rows || 24,
-        requestedShell
+        requestedShell,
+        { sandboxed: permission === 'control' || permission === 'view' }
       );
 
-      // If reconnecting, send scrollback buffer to THIS client only
-      if (isReconnect) {
-        const scrollback = ptyManager.getScrollback(terminalId);
-        if (scrollback.length > 0) {
-          this.send(ws, {
-            type: 'terminalScrollback',
-            terminalId,
-            data: { lines: scrollback }
-          });
-        }
-      } else {
+      if (!isReconnect) {
         // New terminal — broadcast to other clients so they can create matching tabs
         this.broadcastToOthers(ws, {
           type: 'terminalCreated',
-          data: { terminalId, shell, cwd, persistent: false }
+          data: { terminalId, shell, cwd }
         });
       }
 
@@ -2227,16 +2660,6 @@ Respond with ONLY the commit message, nothing else.`;
     // Set up broadcast listeners (idempotent — only creates once per terminal)
     this.setupTerminalBroadcastListeners(terminalId);
 
-    // Send scrollback buffer to THIS client only
-    const scrollback = ptyManager.getScrollback(terminalId);
-    if (scrollback.length > 0) {
-      this.send(ws, {
-        type: 'terminalScrollback',
-        terminalId,
-        data: { lines: scrollback }
-      });
-    }
-
     // Send ready message indicating reconnection
     this.send(ws, {
       type: 'terminalReady',
@@ -2282,14 +2705,6 @@ Respond with ONLY the commit message, nothing else.`;
       return;
     }
 
-    // Check if this is a persistent terminal first
-    const persistentHandler = this.persistentHandlers.get(terminalId);
-    if (persistentHandler) {
-      persistentHandler.write(input);
-      return;
-    }
-
-    // Otherwise use regular PTY
     const ptyManager = getPTYManager();
     const success = ptyManager.write(terminalId, input);
 
@@ -2315,14 +2730,6 @@ Respond with ONLY the commit message, nothing else.`;
       return;
     }
 
-    // Check if this is a persistent terminal first
-    const persistentHandler = this.persistentHandlers.get(terminalId);
-    if (persistentHandler) {
-      persistentHandler.resize(cols, rows);
-      return;
-    }
-
-    // Otherwise use regular PTY
     const ptyManager = getPTYManager();
     ptyManager.resize(terminalId, cols, rows);
   }
@@ -2333,27 +2740,17 @@ Respond with ONLY the commit message, nothing else.`;
   private handleTerminalClose(ws: WSContext, terminalId: string): void {
     trackEvent(AnalyticsEvents.TERMINAL_SESSION_CLOSED);
 
-    // Check if this is a persistent terminal first
-    const persistentHandler = this.persistentHandlers.get(terminalId);
-    if (persistentHandler) {
-      persistentHandler.detach();
-      this.persistentHandlers.delete(terminalId);
-      // For persistent terminals, close actually kills the tmux session
-      const ptyManager = getPTYManager();
-      ptyManager.closePersistent(terminalId);
-    } else {
-      // Clean up event listeners
-      const listenerCleanup = this.terminalListenerCleanups.get(terminalId);
-      if (listenerCleanup) {
-        listenerCleanup();
-        this.terminalListenerCleanups.delete(terminalId);
-      }
-
-      // Close regular PTY
-      const ptyManager = getPTYManager();
-      ptyManager.close(terminalId);
+    // Clean up event listeners
+    const listenerCleanup = this.terminalListenerCleanups.get(terminalId);
+    if (listenerCleanup) {
+      listenerCleanup();
+      this.terminalListenerCleanups.delete(terminalId);
     }
 
+    // Close PTY
+    const ptyManager = getPTYManager();
+    ptyManager.close(terminalId);
+
     // Clean up subscribers
     this.terminalSubscribers.delete(terminalId);
 
@@ -2364,9 +2761,6 @@ Respond with ONLY the commit message, nothing else.`;
     });
   }
 
-  // Persistent terminal handlers for tmux-backed sessions
-  private persistentHandlers: Map<string, { write: (data: string) => void; resize: (cols: number, rows: number) => void; detach: () => void }> = new Map();
-
   // Track PTY event listener cleanup functions per terminal to prevent duplicate listeners
   private terminalListenerCleanups: Map<string, () => void> = new Map();
 
@@ -2401,36 +2795,6 @@ Respond with ONLY the commit message, nothing else.`;
     }
   }
 
-  /**
-   * Attach persistent (tmux) terminal handlers for output/exit broadcasting.
-   */
-  private attachPersistentHandlers(terminalId: string, ptyManager: ReturnType<typeof getPTYManager>): void {
-    const handlers = ptyManager.attachPersistent(
-      terminalId,
-      (output: string) => {
-        const subs = this.terminalSubscribers.get(terminalId);
-        if (subs) {
-          for (const sub of subs) {
-            this.send(sub, { type: 'terminalOutput', terminalId, data: { output } });
-          }
-        }
-      },
-      (exitCode: number) => {
-        const subs = this.terminalSubscribers.get(terminalId);
-        if (subs) {
-          for (const sub of subs) {
-            this.send(sub, { type: 'terminalExit', terminalId, data: { exitCode } });
-          }
-        }
-        this.persistentHandlers.delete(terminalId);
-        this.terminalSubscribers.delete(terminalId);
-      }
-    );
-    if (handlers) {
-      this.persistentHandlers.set(terminalId, handlers);
-    }
-  }
-
   /**
    * Set up PTY event listeners that broadcast to all subscribers.
    * Only creates listeners once per terminal (idempotent).
@@ -2491,104 +2855,4 @@ Respond with ONLY the commit message, nothing else.`;
     });
   }
 
-  /**
-   * Initialize a persistent (tmux-backed) terminal session
-   * These sessions survive server restarts.
-   * Uses subscriber pattern for multi-client output broadcasting.
-   */
-  private handleTerminalInitPersistent(
-    ws: WSContext,
-    terminalId: string,
-    workingDir: string,
-    requestedShell?: string,
-    cols?: number,
-    rows?: number
-  ): void {
-
-    const ptyManager = getPTYManager();
-
-    // Check if tmux is available
-    if (!ptyManager.isTmuxAvailable()) {
-      this.send(ws, {
-        type: 'terminalError',
-        terminalId,
-        data: { error: 'Persistent terminals require tmux, which is not installed' }
-      });
-      return;
-    }
-
-    // Add this WS as a subscriber for this terminal's output
-    this.addTerminalSubscriber(terminalId, ws);
-
-    try {
-      // Create or reconnect to the persistent session
-      const { shell, cwd, isReconnect } = ptyManager.createPersistent(
-        terminalId,
-        workingDir,
-        cols || 80,
-        rows || 24,
-        requestedShell
-      );
-
-      // Only attach if we don't already have handlers (first subscriber)
-      if (!this.persistentHandlers.has(terminalId)) {
-        this.attachPersistentHandlers(terminalId, ptyManager);
-      }
-
-      // If reconnecting, send scrollback buffer to THIS client only
-      if (isReconnect) {
-        const scrollback = ptyManager.getPersistentScrollback(terminalId);
-        if (scrollback.length > 0) {
-          this.send(ws, {
-            type: 'terminalScrollback',
-            terminalId,
-            data: { lines: scrollback }
-          });
-        }
-      } else {
-        // New terminal — broadcast to other clients so they can create matching tabs
-        this.broadcastToOthers(ws, {
-          type: 'terminalCreated',
-          data: { terminalId, shell, cwd, persistent: true }
-        });
-      }
-
-      // Send ready message to THIS client
-      this.send(ws, {
-        type: 'terminalReady',
-        terminalId,
-        data: { shell, cwd, isReconnect, persistent: true }
-      });
-    } catch (error: any) {
-      console.error(`[WebSocketImproviseHandler] Failed to create persistent terminal:`, error);
-      this.send(ws, {
-        type: 'terminalError',
-        terminalId,
-        data: { error: error.message || 'Failed to create persistent terminal' }
-      });
-      this.removeTerminalSubscriber(terminalId, ws);
-    }
-  }
-
-  /**
-   * List all persistent terminal sessions (including those from previous server runs)
-   */
-  private handleTerminalListPersistent(ws: WSContext): void {
-    const ptyManager = getPTYManager();
-    const sessions = ptyManager.getPersistentSessions();
-
-    this.send(ws, {
-      type: 'terminalListPersistent',
-      data: {
-        available: ptyManager.isTmuxAvailable(),
-        terminals: sessions.map(s => ({
-          id: s.terminalId,
-          shell: s.shell,
-          cwd: s.cwd,
-          createdAt: s.createdAt,
-          lastAttachedAt: s.lastAttachedAt,
-        }))
-      }
-    });
-  }
 }