Replay persisted terminal scrollback on a cold app start

Scrollback was already being written to userData/terminal-history/<id>,
but getHistory() only read the in-memory map, and that map is seeded from
disk inside create(). On a cold start the renderer asks for history
before it spawns, so it got '' and skipped the replay — create() then
loaded the file into a buffer nobody ever displayed, which is why a
renderer reload showed scrollback but relaunching the app did not.

Both entry points now go through ensureHistoryBuffer, so the file is read
on first touch (at most once per id) whichever call arrives first.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: frenchie4111

src/main/pty-manager.test.ts

@@ -36,6 +36,7 @@ vi.mock('./persistence', () => ({
 
 import { PtyManager } from './pty-manager'
 import * as pty from 'node-pty'
+import { loadTerminalHistory } from './persistence'
 
 describe('PtyManager.create — eager spawn contract for createShell (#203)', () => {
   beforeEach(() => {
@@ -67,3 +68,43 @@ describe('PtyManager.create — eager spawn contract for createShell (#203)', ()
     expect(pty.spawn).not.toHaveBeenCalled()
   })
 })
+
+// On a cold app start the renderer asks for scrollback BEFORE it spawns, so
+// getHistory has to reach the persisted file itself — reading only the
+// in-memory map left restored tabs blank until something else seeded it.
+describe('PtyManager.getHistory — persisted scrollback across an app restart', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns the persisted scrollback when nothing is in memory yet', () => {
+    vi.mocked(loadTerminalHistory).mockReturnValueOnce('previous run output')
+    const mgr = new PtyManager()
+    expect(mgr.getHistory('shell-restored-1')).toBe('previous run output')
+  })
+
+  it('returns empty string when no history was persisted', () => {
+    const mgr = new PtyManager()
+    expect(mgr.getHistory('shell-restored-2')).toBe('')
+  })
+
+  it('reads the file once per id — the spawn that follows reuses the buffer', () => {
+    vi.mocked(loadTerminalHistory).mockReturnValueOnce('previous run output')
+    const mgr = new PtyManager()
+    const id = 'shell-restored-3'
+    mgr.getHistory(id)
+    mgr.create(id, tmpdir(), '', ['-il'], undefined, true)
+    expect(loadTerminalHistory).toHaveBeenCalledTimes(1)
+    expect(mgr.getHistory(id)).toBe('previous run output')
+  })
+
+  it('drops both the buffer and the file on forgetHistory so a closed tab does not resurrect', () => {
+    vi.mocked(loadTerminalHistory).mockReturnValue('previous run output')
+    const mgr = new PtyManager()
+    const id = 'shell-restored-4'
+    expect(mgr.getHistory(id)).toBe('previous run output')
+    vi.mocked(loadTerminalHistory).mockReturnValue(null)
+    mgr.forgetHistory(id)
+    expect(mgr.getHistory(id)).toBe('')
+  })
+})

src/main/pty-manager.ts

@@ -85,8 +85,8 @@ export class PtyManager {
   private store: Store | null = null
   private sendSignal: ((channel: string, ...args: unknown[]) => void) | null = null
   // Per-terminal raw-byte scrollback owned by main. Populated from disk on
-  // create() (if a history file exists), appended to from the PTY onData
-  // stream, and returned on getHistory(id). Persistence to
+  // first touch by either getHistory(id) or create() (whichever comes first),
+  // appended to from the PTY onData stream. Persistence to
   // userData/terminal-history/<id> happens on a throttled cadence and on
   // before-quit via flushAllHistory().
   private history = new Map<string, HistoryBuffer>()
@@ -209,20 +209,15 @@ export class PtyManager {
     }
 
     // Seed the history buffer from disk if a file exists. Renderer calls
-    // getHistory(id) right after createTerminal and writes the bytes into a
-    // fresh xterm instance before wiring up live data.
-    let buf = this.history.get(id)
-    if (!buf) {
-      buf = new HistoryBuffer()
-      const existing = loadTerminalHistory(id)
-      if (existing) buf.seed(existing)
-      this.history.set(id, buf)
-    }
+    // getHistory(id) right before createTerminal and writes the bytes into a
+    // fresh xterm instance before wiring up live data, so this usually finds
+    // the buffer already loaded and skips the read.
+    const buf = this.ensureHistoryBuffer(id)
 
     ptyProcess.onData((data: string) => {
       // Tee into the history ring buffer before forwarding, so a reload
       // right after output arrives still sees it.
-      buf!.append(data)
+      buf.append(data)
       this.historyDirty.add(id)
       this.ensureHistoryFlushTimer()
       this.perfMonitor?.recordTerminalBytes(id, data.length)
@@ -258,9 +253,25 @@ export class PtyManager {
     }
   }
 
-  /** Raw PTY scrollback for `id`, or empty string if none. */
+  /** Raw PTY scrollback for `id`, or empty string if none. Falls back to the
+   * persisted file when nothing is in memory yet: on a cold app start the
+   * renderer asks for history BEFORE it spawns, so reading only the in-memory
+   * map returned '' and the saved scrollback stayed invisible until a renderer
+   * reload happened to hit the buffer create() had since seeded. */
   getHistory(id: string): string {
-    return this.history.get(id)?.toString() || ''
+    return this.ensureHistoryBuffer(id).toString()
+  }
+
+  /** The buffer for `id`, seeded from disk on first touch. Both getHistory and
+   * create go through here so the file is read at most once per id. */
+  private ensureHistoryBuffer(id: string): HistoryBuffer {
+    const existing = this.history.get(id)
+    if (existing) return existing
+    const buf = new HistoryBuffer()
+    const persisted = loadTerminalHistory(id)
+    if (persisted) buf.seed(persisted)
+    this.history.set(id, buf)
+    return buf
   }
 
   /** Drop the in-memory buffer + delete the persisted file. Called on tab

src/renderer/components/XTerminal.tsx

@@ -699,11 +699,11 @@ export function XTerminal({ terminalId, cwd, type, agentKind, visible, sessionNa
         spawnPty()
         return
       }
-      // A non-empty history means main already has a live PTY for this id
-      // — the agent isn't "starting," we're attaching to a running one.
-      // Clear the loading overlay so the restored scrollback is visible
-      // without waiting for new bytes (which may never come if the agent
-      // is idle at its prompt).
+      // A non-empty history means this tab has run before — either main
+      // still holds a live PTY for it (we're attaching to a running one) or
+      // the scrollback came off disk from a previous app run. Clear the
+      // loading overlay so it's visible without waiting for new bytes
+      // (which may never come if the agent is idle at its prompt).
       setLoading(false)
       // Replay raw scrollback. Wait for xterm to finish parsing before
       // attaching onData, otherwise any response sequences xterm generates