mstro-app 0.4.52 → 0.5.1

package/server/services/websocket/session-handlers.ts

@@ -1,11 +1,12 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
-// Licensed under the MIT License. See LICENSE file for details.
 
-import type { FileAttachment, ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { type FileAttachment, ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import { getEffortLevel, getModel } from '../settings.js';
 import type { HandlerContext } from './handler-context.js';
 import { runQualityScan } from './quality-service.js';
+import type { SessionRegistry } from './session-registry.js';
 import { resolveSkillPrompt } from './skill-handlers.js';
+import { broadcastTabEvent } from './tab-broadcast.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
 // Re-export from extracted modules for backward compatibility
@@ -43,6 +44,17 @@ function convertToolHistoryToLines(tools: Array<{ toolName: string; toolInput?:
   return lines;
 }
 
+function formatElapsedDuration(totalSeconds: number): string {
+  const seconds = Math.floor(totalSeconds) % 60;
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  const hours = Math.floor(totalSeconds / 3600) % 24;
+  const days = Math.floor(totalSeconds / 86400);
+  if (days > 0) return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+
 /** Convert a single movement record into OutputLine-compatible entries */
 function convertMovementToLines(movement: { userPrompt: string; timestamp: string; thinkingOutput?: string; toolUseHistory?: Array<{ toolName: string; toolInput?: Record<string, unknown>; result?: string; isError?: boolean }>; assistantResponse?: string; errorOutput?: string; tokensUsed: number; durationMs?: number }): Array<Record<string, unknown>> {
   const lines: Array<Record<string, unknown>> = [];
@@ -67,26 +79,105 @@ function convertMovementToLines(movement: { userPrompt: string; timestamp: strin
   }
 
   const durationText = movement.durationMs
-    ? `Completed in ${(movement.durationMs / 1000).toFixed(2)}s`
+    ? `Completed in ${formatElapsedDuration(movement.durationMs / 1000)}`
     : 'Completed';
   lines.push({ type: 'system', text: durationText, timestamp: ts });
   return lines;
 }
 
 function requireSession(ctx: HandlerContext, ws: WSContext, tabId: string): ImprovisationSessionManager {
-  const session = getSession(ctx, ws, tabId);
+  const session = resolveTabSession(ctx, ws, tabId);
   if (!session) throw new Error(`No session found for tab ${tabId}`);
   return session;
 }
 
-function getSession(ctx: HandlerContext, ws: WSContext, tabId: string): ImprovisationSessionManager | null {
+/**
+ * Canonical tab → session resolver.
+ *
+ * Returns the `ImprovisationSessionManager` for `tabId`, attaching it to `ws`
+ * if needed. Contract: after a successful return, the session is mapped in
+ * `ctx.connections.get(ws)` and its event listeners are wired to this `ws`.
+ *
+ * Resolution order (cheapest first, each step caches for subsequent calls):
+ *   1. Per-connection `tabMap` — the session is already attached to this `ws`.
+ *   2. Registry + in-memory — another connection has the session loaded;
+ *      re-attach listeners to this `ws` without re-reading disk.
+ *   3. Registry + disk — session is persisted but not in memory (e.g. after
+ *      a CLI restart); construct the manager from history and cache it.
+ *
+ * Returns `null` only when the tab is truly unknown (no registry entry AND
+ * no history file). That is the only case where handlers should surface an
+ * error to the caller — everything else self-heals so session ops never
+ * race the `initTab` handshake.
+ *
+ * Also restores worktree bindings from the registry on miss so git/file ops
+ * against this tab route to the correct directory even without initTab.
+ */
+export function resolveTabSession(ctx: HandlerContext, ws: WSContext, tabId: string): ImprovisationSessionManager | null {
   const tabMap = ctx.connections.get(ws);
-  if (!tabMap) return null;
 
-  const sessionId = tabMap.get(tabId);
-  if (!sessionId) return null;
+  const mappedSessionId = tabMap?.get(tabId);
+  if (mappedSessionId) {
+    const session = ctx.sessions.get(mappedSessionId);
+    if (session) return session;
+  }
+
+  const workingDir = ws._workingDir;
+  if (!workingDir) return null;
+
+  const registry = ctx.getRegistry(workingDir);
+  const registrySessionId = registry.getTabSession(tabId);
+  if (!registrySessionId) return null;
+
+  const inMemorySession = ctx.sessions.get(registrySessionId);
+  if (inMemorySession) {
+    return attachSessionToConnection(ctx, ws, tabId, inMemorySession, registry);
+  }
+
+  try {
+    const diskSession = ImprovisationSessionManager.resumeFromHistory(workingDir, registrySessionId);
+    ctx.sessions.set(diskSession.getSessionInfo().sessionId, diskSession);
+    registry.markTabPersisted(tabId);
+    return attachSessionToConnection(ctx, ws, tabId, diskSession, registry);
+  } catch {
+    // History file doesn't exist — either the tab has never had a first
+    // prompt (lazy persistence) or the file was deleted and the registry
+    // hasn't been swept yet. Either way, construct a fresh session bound to
+    // the registered sessionId so the tab keeps its identity.
+    const freshSession = new ImprovisationSessionManager({
+      workingDir,
+      sessionId: registrySessionId,
+      model: getModel(),
+      effortLevel: getEffortLevel(),
+    });
+    ctx.sessions.set(freshSession.getSessionInfo().sessionId, freshSession);
+    return attachSessionToConnection(ctx, ws, tabId, freshSession, registry);
+  }
+}
+
+/** Wire listeners + update caches when a resolved session first attaches to this ws. */
+function attachSessionToConnection(
+  ctx: HandlerContext,
+  ws: WSContext,
+  tabId: string,
+  session: ImprovisationSessionManager,
+  registry: SessionRegistry,
+): ImprovisationSessionManager {
+  setupSessionListeners(ctx, session, ws, tabId);
+  const tabMap = ctx.connections.get(ws);
+  if (tabMap) tabMap.set(tabId, session.getSessionInfo().sessionId);
+  registry.touchTab(tabId);
+  restoreWorktreeFromRegistry(ctx, registry, tabId);
+  return session;
+}
 
-  return ctx.sessions.get(sessionId) || null;
+/** Copy worktree bindings from the persistent registry into the live context. */
+export function restoreWorktreeFromRegistry(ctx: HandlerContext, registry: SessionRegistry, tabId: string): void {
+  if (ctx.gitDirectories.has(tabId)) return;
+  const regTab = registry.getTab(tabId);
+  if (!regTab?.worktreePath) return;
+  ctx.gitDirectories.set(tabId, regTab.worktreePath);
+  if (regTab.worktreeBranch) ctx.gitBranches.set(tabId, regTab.worktreeBranch);
 }
 
 export function buildOutputHistory(session: ImprovisationSessionManager): Array<Record<string, unknown>> {
@@ -100,24 +191,49 @@ export function buildOutputHistory(session: ImprovisationSessionManager): Array<
     .flatMap(convertMovementToLines);
 }
 
-export function setupSessionListeners(ctx: HandlerContext, session: ImprovisationSessionManager, ws: WSContext, tabId: string): void {
+/**
+ * Wire session events to the WebSocket fan-out.
+ *
+ * All session-driven messages broadcast to `allConnections` rather than the
+ * `ws` that called `initTab`/`execute`. The CLI has exactly one live socket
+ * at a time (the platform relay), and `allConnections` is maintained by
+ * `handleConnection`/`handleClose` — so a broadcast always lands on the
+ * *current* relay socket, even after a reconnect, and is fanned out to every
+ * paired web client by the platform.
+ *
+ * Sending to the captured `ws` was the prior shape and silently dropped
+ * streaming output for any tab whose `setupSessionListeners` hadn't been
+ * re-run after a relay reconnect (i.e. background tabs the user wasn't
+ * actively viewing). The `tabStateChanged` events still fired — they were
+ * already broadcast — so the tab's executing dot showed up but the actual
+ * stream content (`output`/`thinking`/`toolUse`/...) went nowhere.
+ *
+ * `ws` is retained in the signature for symmetry with other handlers and to
+ * keep the call sites unchanged.
+ */
+export function setupSessionListeners(ctx: HandlerContext, session: ImprovisationSessionManager, _ws: WSContext, tabId: string): void {
   session.removeAllListeners();
 
+  session.on('onHistoryPersisted', () => {
+    const registry = ctx.getRegistry('');
+    try { registry.markTabPersisted(tabId); } catch { /* ignore */ }
+  });
+
   session.on('onOutput', (text: string) => {
-    ctx.send(ws, { type: 'output', tabId, data: { text, timestamp: Date.now() } });
+    broadcastTabEvent(ctx, tabId, 'output', { text, timestamp: Date.now() });
   });
 
   session.on('onThinking', (text: string) => {
-    ctx.send(ws, { type: 'thinking', tabId, data: { text } });
+    broadcastTabEvent(ctx, tabId, 'thinking', { text });
   });
 
   session.on('onMovementStart', (sequenceNumber: number, prompt: string, isAutoContinue?: boolean) => {
-    ctx.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp, isAutoContinue } });
+    broadcastTabEvent(ctx, tabId, 'movementStart', { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp, isAutoContinue });
     ctx.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true, executionStartTimestamp: session.executionStartTimestamp } });
   });
 
   session.on('onMovementComplete', (movement: Record<string, unknown>) => {
-    ctx.send(ws, { type: 'movementComplete', tabId, data: movement });
+    broadcastTabEvent(ctx, tabId, 'movementComplete', movement);
 
     const registry = ctx.getRegistry('');
     // Use a try/catch since getRegistry may not have been initialized with the right workingDir
@@ -141,24 +257,24 @@ export function setupSessionListeners(ctx: HandlerContext, session: Improvisatio
   });
 
   session.on('onMovementError', (error: Error) => {
-    ctx.send(ws, { type: 'movementError', tabId, data: { message: error.message } });
+    broadcastTabEvent(ctx, tabId, 'movementError', { message: error.message });
     ctx.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: false } });
   });
 
   session.on('onSessionUpdate', (history: Record<string, unknown>) => {
-    ctx.send(ws, { type: 'sessionUpdate', tabId, data: history });
+    broadcastTabEvent(ctx, tabId, 'sessionUpdate', history);
   });
 
   session.on('onPlanNeedsConfirmation', (plan: Record<string, unknown>) => {
-    ctx.send(ws, { type: 'approvalRequired', tabId, data: plan });
+    broadcastTabEvent(ctx, tabId, 'approvalRequired', plan);
   });
 
   session.on('onToolUse', (event: Record<string, unknown>) => {
-    ctx.send(ws, { type: 'toolUse', tabId, data: { ...event, timestamp: Date.now() } });
+    broadcastTabEvent(ctx, tabId, 'toolUse', { ...event, timestamp: Date.now() });
   });
 
   session.on('onTokenUsage', (usage: { inputTokens: number; outputTokens: number }) => {
-    ctx.send(ws, { type: 'streamingTokens', tabId, data: usage });
+    broadcastTabEvent(ctx, tabId, 'streamingTokens', usage);
   });
 }
 
@@ -187,46 +303,87 @@ export function mergePreUploadedAttachments(ctx: HandlerContext, tabId: string,
 
 const WRITE_OPS = new Set(['execute', 'cancel', 'new', 'approve', 'reject']);
 
+function emitExecuteAck(ctx: HandlerContext, tabId: string, sessionId: string, msgId: string, duplicate = false): void {
+  ctx.broadcastToAll({
+    type: 'executeAck',
+    tabId,
+    data: duplicate ? { msgId, sessionId, duplicate: true } : { msgId, sessionId },
+  });
+}
+
+/**
+ * Handle an `execute` request: validate, dedupe on msgId, run the prompt,
+ * and ack every paired web so their outbox drains.
+ *
+ * Extracted from `handleSessionMessage` to keep its cyclomatic complexity
+ * within the biome threshold; the switch-body pattern was pushing past 15.
+ */
+function handleExecuteMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string): void {
+  if (!msg.data?.prompt) throw new Error('Prompt is required');
+  const session = requireSession(ctx, ws, tabId);
+  const { sessionId } = session.getSessionInfo();
+  const msgId = typeof msg.data.msgId === 'string' ? msg.data.msgId as string : undefined;
+
+  // Idempotency: a web reconnect may replay the same msgId. Re-ack so its
+  // outbox drains, but don't run the prompt a second time.
+  if (msgId && !ctx.msgIdTracker.recordIfFirst(tabId, msgId)) {
+    console.log(`[session] execute duplicate msgId=${msgId} tabId=${tabId} — re-acking without re-run`);
+    emitExecuteAck(ctx, tabId, sessionId, msgId, /* duplicate */ true);
+    return;
+  }
+
+  if (msgId) {
+    console.log(`[session] execute accepted msgId=${msgId} tabId=${tabId} sessionId=${sessionId}`);
+  }
+
+  const worktreeDir = ctx.gitDirectories.get(tabId);
+  const attachments = mergePreUploadedAttachments(ctx, tabId, msg.data.attachments);
+
+  // Resolve slash commands (e.g. "/code-review") to their SKILL.md content.
+  // Claude Code's -p headless mode doesn't support skills natively, so we
+  // load the skill's instructions and pass them as the actual prompt.
+  const rawPrompt = msg.data.prompt as string;
+  const effectiveDir = worktreeDir || session.getSessionInfo().workingDir;
+  const resolved = resolveSkillPrompt(rawPrompt, effectiveDir);
+
+  session.executePrompt(
+    resolved ? resolved.prompt : rawPrompt,
+    attachments,
+    {
+      workingDir: worktreeDir,
+      displayPrompt: resolved ? rawPrompt : undefined,
+    },
+  );
+
+  // Ack AFTER enqueue so the web knows the CLI accepted the work.
+  if (msgId) emitExecuteAck(ctx, tabId, sessionId, msgId);
+}
+
+function handleNewSessionMessage(ctx: HandlerContext, ws: WSContext, tabId: string): void {
+  const oldSession = requireSession(ctx, ws, tabId);
+  const oldSessionId = oldSession.getSessionInfo().sessionId;
+  const newSession = oldSession.startNewSession({ model: getModel(), effortLevel: getEffortLevel() });
+  oldSession.destroy();
+  ctx.sessions.delete(oldSessionId);
+  setupSessionListeners(ctx, newSession, ws, tabId);
+  const newSessionId = newSession.getSessionInfo().sessionId;
+  ctx.sessions.set(newSessionId, newSession);
+  const tabMap = ctx.connections.get(ws);
+  if (tabMap) tabMap.set(tabId, newSessionId);
+  const registry = ctx.getRegistry('');
+  try { registry.updateTabSession(tabId, newSessionId); } catch { /* ignore */ }
+  ctx.send(ws, { type: 'newSession', tabId, data: newSession.getSessionInfo() });
+}
+
 export function handleSessionMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, permission?: 'view'): void {
   if (permission === 'view' && WRITE_OPS.has(msg.type)) {
     throw new Error('View-only users cannot perform write operations');
   }
 
   switch (msg.type) {
-    case 'execute': {
-      if (!msg.data?.prompt) throw new Error('Prompt is required');
-      const session = requireSession(ctx, ws, tabId);
-      const worktreeDir = ctx.gitDirectories.get(tabId);
-      const attachments = mergePreUploadedAttachments(ctx, tabId, msg.data.attachments);
-
-      // Resolve slash commands (e.g. "/code-review") to their SKILL.md prompt content.
-      // Claude Code's -p headless mode doesn't support skills natively, so we load
-      // the skill's instructions and pass them as the actual prompt.
-      const rawPrompt = msg.data.prompt as string;
-      const effectiveDir = worktreeDir || session.getSessionInfo().workingDir;
-      const resolved = resolveSkillPrompt(rawPrompt, effectiveDir);
-
-      // Authoritative prompt-input clear for all connected devices. The
-      // submitter already cleared locally; this guarantees other devices
-      // clear even if the submitter's debounced syncPromptText never fires
-      // (e.g. mobile tab suspended after Send). Clients suppress this via
-      // locallyEditingTabs if the user is actively typing a new prompt.
-      ctx.broadcastToAll({
-        type: 'promptTextSync',
-        tabId,
-        data: { tabId, text: '' },
-      });
-
-      session.executePrompt(
-        resolved ? resolved.prompt : rawPrompt,
-        attachments,
-        {
-          workingDir: worktreeDir,
-          displayPrompt: resolved ? rawPrompt : undefined,
-        },
-      );
+    case 'execute':
+      handleExecuteMessage(ctx, ws, msg, tabId);
       break;
-    }
     case 'cancel': {
       const session = requireSession(ctx, ws, tabId);
       session.cancel();
@@ -237,32 +394,19 @@ export function handleSessionMessage(ctx: HandlerContext, ws: WSContext, msg: We
       ctx.send(ws, { type: 'history', tabId, data: session.getHistory() });
       break;
     }
-    case 'new': {
-      const oldSession = requireSession(ctx, ws, tabId);
-      const oldSessionId = oldSession.getSessionInfo().sessionId;
-      const newSession = oldSession.startNewSession({ model: getModel(), effortLevel: getEffortLevel() });
-      oldSession.destroy();
-      ctx.sessions.delete(oldSessionId);
-      setupSessionListeners(ctx, newSession, ws, tabId);
-      const newSessionId = newSession.getSessionInfo().sessionId;
-      ctx.sessions.set(newSessionId, newSession);
-      const tabMap = ctx.connections.get(ws);
-      if (tabMap) tabMap.set(tabId, newSessionId);
-      const registry = ctx.getRegistry('');
-      try { registry.updateTabSession(tabId, newSessionId); } catch { /* ignore */ }
-      ctx.send(ws, { type: 'newSession', tabId, data: newSession.getSessionInfo() });
+    case 'new':
+      handleNewSessionMessage(ctx, ws, tabId);
       break;
-    }
     case 'approve': {
       const session = requireSession(ctx, ws, tabId);
       session.respondToApproval(true);
-      ctx.send(ws, { type: 'output', tabId, data: { text: '\n✅ Approved - proceeding with operation\n' } });
+      broadcastTabEvent(ctx, tabId, 'output', { text: '\n✅ Approved - proceeding with operation\n' });
       break;
     }
     case 'reject': {
       const session = requireSession(ctx, ws, tabId);
       session.respondToApproval(false);
-      ctx.send(ws, { type: 'output', tabId, data: { text: '\n🚫 Rejected - operation cancelled\n' } });
+      broadcastTabEvent(ctx, tabId, 'output', { text: '\n🚫 Rejected - operation cancelled\n' });
       break;
     }
   }

package/server/services/websocket/session-history.ts

@@ -1,5 +1,4 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
-// Licensed under the MIT License. See LICENSE file for details.
 
 import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';

package/server/services/websocket/session-initialization.ts

@@ -1,13 +1,27 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
-// Licensed under the MIT License. See LICENSE file for details.
 
 import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import { getEffortLevel, getModel } from '../settings.js';
 import type { HandlerContext } from './handler-context.js';
 import { buildOutputHistory, setupSessionListeners } from './session-handlers.js';
 import type { SessionRegistry } from './session-registry.js';
+import { replayTabEventsSince } from './tab-event-replay.js';
 import type { WSContext } from './types.js';
 
+/**
+ * Extract `lastSeenSeq` from an initTab/resumeSession data payload.
+ *
+ * Keeps the narrow-typing scoped to the initialization module instead of
+ * leaking into the broader `HandlerContext`. Returns `undefined` for first
+ * init (no replay needed) or malformed payloads (treated as first init —
+ * safer than surfacing an error the user can't act on).
+ */
+function extractLastSeenSeq(data: unknown): number | undefined {
+  if (!data || typeof data !== 'object') return undefined;
+  const candidate = (data as { lastSeenSeq?: unknown }).lastSeenSeq;
+  return typeof candidate === 'number' && Number.isFinite(candidate) ? candidate : undefined;
+}
+
 function tryResumeFromDisk(
   ctx: HandlerContext,
   ws: WSContext,
@@ -15,7 +29,8 @@ function tryResumeFromDisk(
   workingDir: string,
   registrySessionId: string,
   tabMap: Map<string, string> | undefined,
-  registry: SessionRegistry
+  registry: SessionRegistry,
+  lastSeenSeq: number | undefined,
 ): boolean {
   try {
     const diskSession = ImprovisationSessionManager.resumeFromHistory(workingDir, registrySessionId);
@@ -24,6 +39,7 @@ function tryResumeFromDisk(
     ctx.sessions.set(diskSessionId, diskSession);
     if (tabMap) tabMap.set(tabId, diskSessionId);
     registry.touchTab(tabId);
+    registry.markTabPersisted(tabId);
 
     // Restore worktree state from registry
     const regTab = registry.getTab(tabId);
@@ -34,12 +50,18 @@ function tryResumeFromDisk(
     const worktreePath = ctx.gitDirectories.get(tabId);
     const worktreeBranch = ctx.gitBranches.get(tabId);
 
+    // Replay any tab-scoped events the web missed during the transport gap
+    // BEFORE tabInitialized so they arrive in the right order. Web-side
+    // handlers append; `tabInitialized` does NOT reset when `resumedFromSeq`
+    // is set, preserving the replayed additions.
+    replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+
     ctx.send(ws, {
       type: 'tabInitialized',
       tabId,
       data: {
         ...diskSession.getSessionInfo(),
-        outputHistory: buildOutputHistory(diskSession),
+        ...(lastSeenSeq === undefined ? { outputHistory: buildOutputHistory(diskSession) } : { resumedFromSeq: true }),
         ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
       }
     });
@@ -49,16 +71,17 @@ function tryResumeFromDisk(
   }
 }
 
-export async function initializeTab(ctx: HandlerContext, ws: WSContext, tabId: string, workingDir: string, tabName?: string): Promise<void> {
+export async function initializeTab(ctx: HandlerContext, ws: WSContext, tabId: string, workingDir: string, tabName?: string, rawData?: unknown): Promise<void> {
   const tabMap = ctx.connections.get(ws);
   const registry = ctx.getRegistry(workingDir);
+  const lastSeenSeq = extractLastSeenSeq(rawData);
 
   // 1. Check per-connection map (same WS reconnect)
   const existingSessionId = tabMap?.get(tabId);
   if (existingSessionId) {
     const existingSession = ctx.sessions.get(existingSessionId);
     if (existingSession) {
-      reattachSession(ctx, existingSession, ws, tabId, registry);
+      reattachSession(ctx, existingSession, ws, tabId, registry, lastSeenSeq);
       return;
     }
   }
@@ -68,17 +91,25 @@ export async function initializeTab(ctx: HandlerContext, ws: WSContext, tabId: s
   if (registrySessionId) {
     const inMemorySession = ctx.sessions.get(registrySessionId);
     if (inMemorySession) {
-      reattachSession(ctx, inMemorySession, ws, tabId, registry);
+      reattachSession(ctx, inMemorySession, ws, tabId, registry, lastSeenSeq);
       return;
     }
 
-    if (tryResumeFromDisk(ctx, ws, tabId, workingDir, registrySessionId, tabMap, registry)) {
+    if (tryResumeFromDisk(ctx, ws, tabId, workingDir, registrySessionId, tabMap, registry, lastSeenSeq)) {
       return;
     }
   }
 
-  // 3. Create new session
-  const session = new ImprovisationSessionManager({ workingDir, model: getModel(), effortLevel: getEffortLevel() });
+  // 3. Create new session. If the tab is already registered (no file on
+  // disk — tab is pending first prompt or file was deleted), reuse its
+  // sessionId so the tab keeps its identity across restarts.
+  const existingTab = registry.getTab(tabId);
+  const session = new ImprovisationSessionManager({
+    workingDir,
+    ...(registrySessionId ? { sessionId: registrySessionId } : {}),
+    model: getModel(),
+    effortLevel: getEffortLevel(),
+  });
   setupSessionListeners(ctx, session, ws, tabId);
 
   const sessionId = session.getSessionInfo().sessionId;
@@ -88,17 +119,24 @@ export async function initializeTab(ctx: HandlerContext, ws: WSContext, tabId: s
     tabMap.set(tabId, sessionId);
   }
 
-  registry.registerTab(tabId, sessionId, tabName);
+  registry.registerTab(tabId, sessionId, tabName || existingTab?.tabName);
   const registeredTab = registry.getTab(tabId);
   ctx.broadcastToAll({
     type: 'tabCreated',
     data: { tabId, tabName: registeredTab?.tabName || 'Chat', createdAt: registeredTab?.createdAt, order: registeredTab?.order, sessionInfo: session.getSessionInfo() }
   });
 
+  // Fresh session (no disk/memory predecessor) has nothing to replay,
+  // but we still pass lastSeenSeq through so the web flag is consistent.
+  replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+
   ctx.send(ws, {
     type: 'tabInitialized',
     tabId,
-    data: session.getSessionInfo()
+    data: {
+      ...session.getSessionInfo(),
+      ...(lastSeenSeq !== undefined ? { resumedFromSeq: true } : {}),
+    }
   });
 }
 
@@ -107,16 +145,18 @@ export async function resumeHistoricalSession(
   ws: WSContext,
   tabId: string,
   workingDir: string,
-  historicalSessionId: string
+  historicalSessionId: string,
+  rawData?: unknown,
 ): Promise<void> {
   const tabMap = ctx.connections.get(ws);
   const registry = ctx.getRegistry(workingDir);
+  const lastSeenSeq = extractLastSeenSeq(rawData);
 
   const existingSessionId = tabMap?.get(tabId);
   if (existingSessionId) {
     const existingSession = ctx.sessions.get(existingSessionId);
     if (existingSession) {
-      reattachSession(ctx, existingSession, ws, tabId, registry);
+      reattachSession(ctx, existingSession, ws, tabId, registry, lastSeenSeq);
       return;
     }
   }
@@ -125,7 +165,7 @@ export async function resumeHistoricalSession(
   if (registrySessionId) {
     const inMemorySession = ctx.sessions.get(registrySessionId);
     if (inMemorySession) {
-      reattachSession(ctx, inMemorySession, ws, tabId, registry);
+      reattachSession(ctx, inMemorySession, ws, tabId, registry, lastSeenSeq);
       return;
     }
   }
@@ -152,12 +192,14 @@ export async function resumeHistoricalSession(
 
   registry.registerTab(tabId, sessionId);
 
+  replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+
   ctx.send(ws, {
     type: 'tabInitialized',
     tabId,
     data: {
       ...session.getSessionInfo(),
-      outputHistory: buildOutputHistory(session),
+      ...(lastSeenSeq === undefined ? { outputHistory: buildOutputHistory(session) } : { resumedFromSeq: true }),
       resumeFailed: isNewSession,
       originalSessionId: isNewSession ? historicalSessionId : undefined
     }
@@ -169,7 +211,8 @@ function reattachSession(
   session: ImprovisationSessionManager,
   ws: WSContext,
   tabId: string,
-  registry: SessionRegistry
+  registry: SessionRegistry,
+  lastSeenSeq: number | undefined,
 ): void {
   setupSessionListeners(ctx, session, ws, tabId);
 
@@ -185,15 +228,35 @@ function reattachSession(
     if (regTab.worktreeBranch) ctx.gitBranches.set(tabId, regTab.worktreeBranch);
   }
 
-  const outputHistory = buildOutputHistory(session);
+  const worktreePath = ctx.gitDirectories.get(tabId);
+  const worktreeBranch = ctx.gitBranches.get(tabId);
 
+  // Fast path: the web already has local state (via Zustand), so just replay
+  // anything newer than `lastSeenSeq` and tell the client to skip the
+  // destructive reset in its tabInitialized handler.
+  if (lastSeenSeq !== undefined) {
+    replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+    ctx.send(ws, {
+      type: 'tabInitialized',
+      tabId,
+      data: {
+        ...session.getSessionInfo(),
+        resumedFromSeq: true,
+        isExecuting: session.isExecuting,
+        ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
+        ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
+      }
+    });
+    return;
+  }
+
+  // Cold-start reattach (no prior seq): send the full snapshot so the web
+  // can rebuild from scratch.
+  const outputHistory = buildOutputHistory(session);
   const executionEvents = session.isExecuting
     ? session.getExecutionEventLog()
     : undefined;
 
-  const worktreePath = ctx.gitDirectories.get(tabId);
-  const worktreeBranch = ctx.gitBranches.get(tabId);
-
   ctx.send(ws, {
     type: 'tabInitialized',
     tabId,