nterminal 1.3.25 → 1.3.26

package/dist/server/terminal/TerminalManager.js

@@ -45,6 +45,7 @@ const BUSY_OUTPUT_WINDOW_MS = 2_500;
 // which is fast enough to feel responsive without spamming polls.
 const STATUS_POLL_INTERVAL_MS = 2_000;
 const RESTORE_RETRY_INTERVAL_MS = 2_000;
+const RESTORE_RETRY_MAX_INTERVAL_MS = 30_000;
 const TRANSCRIPT_POLL_CONCURRENCY = 2;
 const TRANSCRIPT_SOURCE_MISS_GRACE_MS = 10_000;
 const TRANSCRIPT_SLOW_WARNING_MS = 3_000;
@@ -54,6 +55,8 @@ const HISTORY_PAGE_LINES = 1000;
 const HISTORY_PAGE_MAX_LINES = 5000;
 const MAX_PENDING_CONTROL_OPERATIONS = 256;
 const MAX_PENDING_CONTROL_BYTES = 16 * 1024 * 1024;
+const RECOVERY_CHECKPOINT_INTERVAL_MS = 10_000;
+const RECOVERY_SAVE_DELAY_MS = 1_000;
 export class TerminalManager {
     config;
     ptyAdapter;
@@ -92,6 +95,7 @@ export class TerminalManager {
     completionStates = new Map();
     statusPollTimer = null;
     restoreRetryTimer = null;
+    restoreRetryDelayMs = RESTORE_RETRY_INTERVAL_MS;
     restoreInflight = null;
     statusPollInflight = false;
     activeTranscriptWorkers = 0;
@@ -104,9 +108,18 @@ export class TerminalManager {
     terminalMutationGeneration = 0;
     shutdownRequested = false;
     disposed = false;
+    sessionStore;
+    recoveryReady = false;
+    recoveryTimer = null;
+    recoveryWriteTimer = null;
+    recoveryCheckpoint = null;
+    pendingSessionRestores = new Map();
+    creatingSessionIds = new Set();
+    pendingDeletionCancellations = new Map();
     constructor(config, ptyAdapter, options = {}) {
         this.config = config;
         this.ptyAdapter = ptyAdapter;
+        this.sessionStore = options.sessionStore;
         this.transcriptStore = new TranscriptStore(path.join(path.dirname(config.statePath), 'transcript-cache'));
         this.resolveCwd = options.resolveCwd ?? resolveProcessCwd;
         this.now = options.now ?? (() => new Date());
@@ -125,6 +138,14 @@ export class TerminalManager {
         if (typeof this.ptyAdapter.pollSessions === 'function') {
             this.startStatusPoller();
         }
+        if (this.sessionStore) {
+            this.recoveryTimer = setInterval(() => {
+                if (this.recoveryReady && !this.shutdownRequested && !this.disposed) {
+                    void this.checkpointRecovery().catch(error => this.reportDiagnostic({ event: 'terminal.recovery_save_failed', error }));
+                }
+            }, RECOVERY_CHECKPOINT_INTERVAL_MS);
+            this.recoveryTimer.unref?.();
+        }
     }
     startStatusPoller() {
         if (this.statusPollTimer)
@@ -393,6 +414,11 @@ export class TerminalManager {
             this.statusPollTimer = null;
         }
         this.clearRestoreRetryTimer();
+        if (this.recoveryTimer)
+            clearInterval(this.recoveryTimer);
+        if (this.recoveryWriteTimer)
+            clearTimeout(this.recoveryWriteTimer);
+        this.recoveryTimer = this.recoveryWriteTimer = null;
         this.transcriptQueue.length = 0;
         for (const record of this.terminals.values()) {
             record.transcriptRerun = false;
@@ -402,6 +428,7 @@ export class TerminalManager {
         }
     }
     async createTerminal(options = {}) {
+        this.assertRecoveryReady();
         if (this.shutdownRequested || this.terminalResetBlockers > 0) {
             throw new Error('terminal manager is not accepting new terminals');
         }
@@ -421,33 +448,57 @@ export class TerminalManager {
         const id = randomUUID();
         const timestamp = this.timestamp();
         const initialTitle = this.createTitle(cwd);
-        const pty = await this.ptyAdapter.spawn({
-            sessionId: id,
-            shell: this.config.shell,
-            cwd,
-            cols,
-            rows,
-            env: terminalEnv(),
-            // Pass the initial title in so persistent adapters (tmux) name the
-            // session with it from the start — otherwise an immediate restart
-            // before the operator interacted would show a placeholder pill.
-            title: initialTitle
-        });
-        const record = {
-            summary: {
-                id,
-                title: initialTitle,
-                cwd,
-                pid: pty.pid,
-                cols,
-                rows,
-                createdAt: timestamp,
-                updatedAt: timestamp,
-                status: 'running',
-                exitCode: null,
-                ...(this.terminalCapabilities ? { capabilities: this.terminalCapabilities } : {})
-            },
-            pty,
+        const summary = {
+            id, title: initialTitle, cwd, pid: null, cols, rows,
+            createdAt: timestamp, updatedAt: timestamp,
+            status: 'running', exitCode: null,
+            ...(this.terminalCapabilities ? { capabilities: this.terminalCapabilities } : {})
+        };
+        this.creatingSessionIds.add(id);
+        try {
+            // An incomplete creation may be adopted if still alive, but must never
+            // recreate a missing shell after a failed spawn or an interrupted request.
+            await this.sessionStore?.prepareCreation(summary);
+            let pty;
+            try {
+                pty = await this.ptyAdapter.spawn({
+                    sessionId: id, shell: this.config.shell, cwd, cols, rows,
+                    env: terminalEnv(), title: initialTitle
+                });
+            }
+            catch (error) {
+                await this.forgetRecoverySession(id);
+                throw error;
+            }
+            const record = this.createRecord(summary);
+            this.wireUpPty(record, pty);
+            this.terminals.set(id, record);
+            try {
+                await this.sessionStore?.save([record.summary]);
+            }
+            catch (error) {
+                // Keep the real shell discoverable if its final checkpoint fails.
+                // Background persistence retries it; never replace or kill that shell.
+                this.reportDiagnostic({ event: 'terminal.recovery_save_failed', terminalId: id, error });
+                this.scheduleRestoreRetry();
+                throw error;
+            }
+            return cloneSummary(record.summary);
+        }
+        catch (error) {
+            // prepareCreation may have renamed its file before a later fsync failed.
+            if (this.sessionStore)
+                this.scheduleRestoreRetry();
+            throw error;
+        }
+        finally {
+            this.creatingSessionIds.delete(id);
+        }
+    }
+    createRecord(summary) {
+        return {
+            summary,
+            pty: null,
             output: new OutputBuffer(),
             subscribers: new Set(),
             dataDisposable: { dispose: () => undefined },
@@ -469,9 +520,6 @@ export class TerminalManager {
             closePromise: null,
             closing: false
         };
-        this.wireUpPty(record, pty);
-        this.terminals.set(id, record);
-        return cloneSummary(record.summary);
     }
     // Repopulate the in-memory record map with any persistent sessions the
     // adapter is already holding for us — used at process start so that after
@@ -491,7 +539,7 @@ export class TerminalManager {
             return;
         }
         if (this.restoreInflight) {
-            await this.restoreInflight;
+            await this.restoreInflight.catch(() => undefined);
             return;
         }
         const initialization = this.restoreSessionsUntracked();
@@ -501,6 +549,9 @@ export class TerminalManager {
         try {
             restored = await initialization;
         }
+        catch (error) {
+            this.reportDiagnostic({ event: 'terminal.restore_failed', error });
+        }
         finally {
             this.pendingInitializations.delete(initialization);
             if (this.restoreInflight === initialization) {
@@ -509,6 +560,7 @@ export class TerminalManager {
         }
         if (restored) {
             this.clearRestoreRetryTimer();
+            this.restoreRetryDelayMs = RESTORE_RETRY_INTERVAL_MS;
         }
         else {
             this.scheduleRestoreRetry();
@@ -527,62 +579,180 @@ export class TerminalManager {
         // A close/reset that completed while listExisting() was in flight makes
         // that catalog stale. Retry from a fresh adapter snapshot instead of
         // resurrecting a session the operator just deleted.
-        if (restoreGeneration !== this.terminalMutationGeneration) {
+        if (restoreGeneration !== this.terminalMutationGeneration || this.shutdownRequested || this.disposed) {
             return false;
         }
+        const saved = new Map(this.sessionStore?.list().map(entry => [entry.id, entry]) ?? []);
+        const live = new Map(existing.map(session => [session.sessionId, session]));
         const now = this.timestamp();
         for (const session of existing) {
             const sessionId = session.sessionId;
-            if (this.terminals.has(sessionId))
+            if (this.terminals.has(sessionId) || this.creatingSessionIds.has(sessionId))
                 continue;
+            const recovery = saved.get(sessionId);
             // Use the adapter-provided title (tmux's window name) when the
             // operator had renamed the tab in a previous run — that's how a
             // human-readable label survives NTerminal restarts. Fall back to a
             // distinguishable placeholder when no name was set.
-            const restoredTitle = normalizeTerminalTitle(session.title?.trim() || `Terminal ${sessionId.slice(0, 6)}`);
-            this.terminals.set(sessionId, {
-                summary: {
-                    id: sessionId,
-                    title: restoredTitle,
-                    cwd: session.cwd || this.config.workspaceRoot,
-                    pid: null,
-                    cols: 80,
-                    rows: 24,
-                    createdAt: now,
-                    updatedAt: now,
-                    status: 'running',
-                    exitCode: null,
+            const restoredTitle = normalizeTerminalTitle(session.title?.trim() || recovery?.title || `Terminal ${sessionId.slice(0, 6)}`);
+            this.terminals.set(sessionId, this.createRecord({
+                id: sessionId,
+                title: restoredTitle,
+                cwd: session.cwd || recovery?.cwd || this.config.workspaceRoot,
+                pid: null,
+                cols: recovery?.cols ?? 80,
+                rows: recovery?.rows ?? 24,
+                createdAt: recovery?.createdAt ?? now,
+                updatedAt: now,
+                status: 'running',
+                exitCode: null,
+                ...(this.terminalCapabilities ? { capabilities: this.terminalCapabilities } : {})
+            }));
+            // A failed deletion may have left its cancellation unwritten. Never
+            // destroy a surviving shell merely because an old intent is on disk.
+            if (recovery?.deleting)
+                this.pendingDeletionCancellations.set(sessionId, Symbol());
+        }
+        // Only startup-missing panes are eligible for creation. Keep placeholders
+        // and their subscribers across retries; ordinary exited shells stay exited.
+        if (!this.recoveryReady) {
+            for (const entry of saved.values()) {
+                if (entry.deleting || entry.creating || this.terminals.has(entry.id))
+                    continue;
+                const record = this.createRecord({
+                    id: entry.id, title: entry.title, cwd: entry.cwd, cols: entry.cols, rows: entry.rows,
+                    createdAt: entry.createdAt, updatedAt: now, status: 'exited', exitCode: null, pid: null,
                     ...(this.terminalCapabilities ? { capabilities: this.terminalCapabilities } : {})
-                },
-                pty: null, // null = persisted but no local client attached yet
-                output: new OutputBuffer(),
-                subscribers: new Set(),
-                dataDisposable: { dispose: () => undefined },
-                exitDisposable: { dispose: () => undefined },
-                pauseCount: 0,
-                lastOutputAt: 0,
-                history: null,
-                lastKernelBusy: false,
-                transcriptGeneration: 0,
-                transcriptRefreshState: 'idle',
-                transcriptRerun: false,
-                transcriptSourceMissingSince: null,
-                cwdRefreshGeneration: 0,
-                resizeGeneration: 0,
-                controlTail: Promise.resolve(),
-                pendingControlOperations: 0,
-                pendingControlBytes: 0,
-                pendingScroll: null,
-                closePromise: null,
-                closing: false
+                });
+                this.terminals.set(entry.id, record);
+                this.pendingSessionRestores.set(entry.id, record);
+            }
+        }
+        // The inventory is authoritative now, including every recoverable missing
+        // pane. Slow cwd/spawn/disk operations must not block healthy panes or HTTP.
+        this.recoveryReady = true;
+        let savedSuccessfully = true;
+        for (const entry of saved.values()) {
+            if (restoreGeneration !== this.terminalMutationGeneration)
+                return false;
+            if ((!entry.deleting && !entry.creating) || live.has(entry.id) || this.terminals.has(entry.id) ||
+                this.creatingSessionIds.has(entry.id))
+                continue;
+            if (!await this.forgetRecoverySession(entry.id))
+                savedSuccessfully = false;
+        }
+        await mapWithConcurrency([...this.pendingSessionRestores.values()], 4, record => this.retrySessionRestore(record, live.get(record.summary.id), restoreGeneration));
+        if (restoreGeneration !== this.terminalMutationGeneration)
+            return false;
+        try {
+            await this.saveRecoveryMetadata();
+        }
+        catch (error) {
+            savedSuccessfully = false;
+            this.reportDiagnostic({ event: 'terminal.recovery_save_failed', error });
+        }
+        if (restoreGeneration !== this.terminalMutationGeneration)
+            return false;
+        return savedSuccessfully && this.pendingSessionRestores.size === 0 && this.pendingDeletionCancellations.size === 0;
+    }
+    hasCompleteInventory() {
+        return this.recoveryReady && !this.shutdownRequested && !this.disposed;
+    }
+    isRecoveryPending() {
+        return Boolean(this.sessionStore || this.ptyAdapter.listExisting) && !this.recoveryReady;
+    }
+    async retrySessionRestore(record, live, generation) {
+        const id = record.summary.id;
+        const canRestore = () => !this.shutdownRequested && !this.disposed && !this.terminalResetBlockers &&
+            generation === this.terminalMutationGeneration && !record.closing &&
+            this.terminals.get(id) === record && this.pendingSessionRestores.get(id) === record;
+        try {
+            await this.enqueueControl(record, async () => {
+                if (!canRestore())
+                    return;
+                if (live) {
+                    record.summary.status = 'running';
+                    record.summary.exitCode = null;
+                    record.summary.cwd = live.cwd || record.summary.cwd;
+                    record.summary.updatedAt = this.timestamp();
+                    this.pendingSessionRestores.delete(id);
+                    if (record.subscribers.size > 0)
+                        await this.ensureAttachedAsync(record);
+                }
+                else {
+                    if (!(await statFile(record.summary.cwd)).isDirectory())
+                        throw new Error('Saved terminal cwd is not a directory');
+                    if (!canRestore())
+                        return;
+                    const pty = await this.ptyAdapter.spawn({
+                        sessionId: id, shell: this.config.shell, cwd: record.summary.cwd,
+                        cols: record.summary.cols, rows: record.summary.rows,
+                        env: terminalEnv(), title: record.summary.title
+                    });
+                    this.pendingSessionRestores.delete(id);
+                    if (this.disposed) {
+                        pty.kill();
+                        return;
+                    }
+                    // Close is serialized behind this spawn. If requested while it was
+                    // pending, leave the new PTY on the same record for close to dispose.
+                    this.wireUpPty(record, pty);
+                }
+                if (!record.closing)
+                    this.publish(record, { type: 'terminal_updated', terminal: cloneSummary(record.summary) });
             });
         }
-        return true;
+        catch (error) {
+            this.reportDiagnostic({ event: 'terminal.restore_failed', terminalId: id, error });
+        }
+    }
+    assertRecoveryReady() {
+        if (this.isRecoveryPending()) {
+            throw Object.assign(new Error('terminal_recovery_pending'), { statusCode: 503 });
+        }
+    }
+    async saveRecoveryMetadata() {
+        for (const [id, token] of this.pendingDeletionCancellations) {
+            await this.retryDeletionCancellation(id, token);
+        }
+        await this.sessionStore?.save([...this.terminals.values()].filter(record => !record.closing).map(record => record.summary));
+    }
+    scheduleRecoverySave() {
+        if (!this.sessionStore || !this.recoveryReady || this.recoveryWriteTimer || this.shutdownRequested || this.disposed)
+            return;
+        const timer = setTimeout(() => {
+            void this.saveRecoveryMetadata()
+                .catch(error => this.reportDiagnostic({ event: 'terminal.recovery_save_failed', error }))
+                .finally(() => { if (this.recoveryWriteTimer === timer)
+                this.recoveryWriteTimer = null; });
+        }, RECOVERY_SAVE_DELAY_MS);
+        this.recoveryWriteTimer = timer;
+        timer.unref?.();
+    }
+    async checkpointRecovery() {
+        if (!this.sessionStore)
+            return;
+        if (this.recoveryCheckpoint)
+            return await this.recoveryCheckpoint;
+        const operation = (async () => {
+            await mapWithConcurrency([...this.terminals.values()], 4, record => this.refreshCwd(record));
+            await this.saveRecoveryMetadata();
+        })();
+        this.recoveryCheckpoint = operation;
+        try {
+            await operation;
+        }
+        finally {
+            if (this.recoveryCheckpoint === operation)
+                this.recoveryCheckpoint = null;
+        }
     }
     scheduleRestoreRetry() {
         if (this.restoreRetryTimer || this.shutdownRequested || this.disposed) {
             return;
         }
+        const delayMs = this.restoreRetryDelayMs;
+        this.restoreRetryDelayMs = Math.min(delayMs * 2, RESTORE_RETRY_MAX_INTERVAL_MS);
         this.restoreRetryTimer = setTimeout(() => {
             this.restoreRetryTimer = null;
             if (this.shutdownRequested || this.disposed) {
@@ -593,7 +763,7 @@ export class TerminalManager {
                 return;
             }
             void this.restoreSessions();
-        }, RESTORE_RETRY_INTERVAL_MS);
+        }, delayMs);
         this.restoreRetryTimer.unref?.();
     }
     clearRestoreRetryTimer() {
@@ -613,6 +783,11 @@ export class TerminalManager {
         record.summary.status = 'running';
         record.summary.exitCode = null;
         record.summary.updatedAt = this.timestamp();
+        record.summary.capabilities = {
+            ...record.summary.capabilities,
+            screenRedraw: typeof pty.redrawScreen === 'function',
+            screenRestore: typeof pty.redrawScreen === 'function' && typeof this.ptyAdapter.cancelScrollbackMode === 'function'
+        };
         record.dataDisposable = pty.onData((data) => {
             record.output.push(data);
             record.lastOutputAt = Date.now();
@@ -730,6 +905,7 @@ export class TerminalManager {
         this.wireUpPty(record, pty);
     }
     listTerminals() {
+        this.assertRecoveryReady();
         return [...this.terminals.values()].map((record) => cloneSummary(record.summary));
     }
     subscribeActivity(listener) {
@@ -1183,6 +1359,7 @@ export class TerminalManager {
             ? resolution : null;
     }
     getTerminal(id) {
+        this.assertRecoveryReady();
         const record = this.terminals.get(id);
         return record ? cloneSummary(record.summary) : null;
     }
@@ -1409,6 +1586,7 @@ export class TerminalManager {
     // name). The adapter write and in-memory update share the terminal's control
     // queue so rename, input, scrollback, and close cannot overtake each other.
     async renameTerminal(id, title) {
+        this.assertRecoveryReady();
         const record = this.terminals.get(id);
         if (!record)
             return { status: 'not_found' };
@@ -1443,6 +1621,14 @@ export class TerminalManager {
             // close later fails, memory and tmux must not diverge.
             record.summary.title = normalizedTitle;
             record.summary.updatedAt = this.timestamp();
+            try {
+                await this.sessionStore?.save([record.summary]);
+            }
+            catch (error) {
+                // tmux already accepted the rename. Keep memory/UI consistent and
+                // retry its recovery checkpoint rather than reporting a false rollback.
+                this.reportDiagnostic({ event: 'terminal.recovery_save_failed', terminalId: id, error });
+            }
             const terminal = cloneSummary(record.summary);
             this.publish(record, { type: 'terminal_updated', terminal });
             return { status: 'renamed', terminal };
@@ -1459,6 +1645,7 @@ export class TerminalManager {
             : null;
     }
     attachTerminal(id, subscriber, options = {}) {
+        this.assertRecoveryReady();
         const record = this.terminals.get(id);
         if (!record || record.closing) {
             return null;
@@ -1474,6 +1661,7 @@ export class TerminalManager {
         return this.createAttachment(record, subscriber, options);
     }
     async attachTerminalAsync(id, subscriber, options = {}) {
+        this.assertRecoveryReady();
         const record = this.terminals.get(id);
         if (!record || record.closing) {
             return null;
@@ -1737,6 +1925,7 @@ export class TerminalManager {
         return true;
     }
     async closeTerminal(id) {
+        this.assertRecoveryReady();
         const record = this.terminals.get(id);
         if (!record) {
             return false;
@@ -1750,6 +1939,16 @@ export class TerminalManager {
         const queuedClose = this.enqueueControl(record, async () => {
             if (this.terminals.get(id) !== record)
                 return false;
+            try {
+                await this.sessionStore?.setDeleting(id, true);
+            }
+            catch (error) {
+                // Even an already-missing shell must keep its recovery entry if the
+                // deletion intent could not be committed.
+                await this.cancelFailedClose(record);
+                this.reportDiagnostic({ event: 'terminal.close_failed', terminalId: id, error });
+                return false;
+            }
             if (this.ptyAdapter.destroySession) {
                 let destroyed = false;
                 try {
@@ -1764,7 +1963,10 @@ export class TerminalManager {
             }
             this.disposeRecord(record);
             this.terminals.delete(id);
+            this.terminalMutationGeneration += 1;
+            this.pendingSessionRestores.delete(id);
             this.publishRemovedActivity(record);
+            await this.forgetRecoverySession(id);
             return true;
         }, 0, true);
         const close = queuedClose.catch(async (error) => {
@@ -1790,6 +1992,7 @@ export class TerminalManager {
         if (record.closing)
             return;
         record.closing = true;
+        this.pendingDeletionCancellations.delete(record.summary.id);
         this.terminalMutationGeneration += 1;
         record.transcriptGeneration += 1;
         this.sealPendingScroll(record);
@@ -1797,28 +2000,70 @@ export class TerminalManager {
         this.cancelQueuedTranscriptRefresh(record);
     }
     async recoverOrFinalizeFailedClose(record) {
-        record.closing = false;
         if (record.pty) {
+            await this.cancelFailedClose(record);
             return false;
         }
         const persistentState = await this.persistentSessionState(record.summary.id);
         if (persistentState === false) {
             this.disposeRecord(record);
             this.terminals.delete(record.summary.id);
+            this.terminalMutationGeneration += 1;
+            this.pendingSessionRestores.delete(record.summary.id);
             this.publishRemovedActivity(record);
+            await this.forgetRecoverySession(record.summary.id);
             return true;
         }
-        record.summary.status = 'running';
-        record.summary.exitCode = null;
+        if (!this.pendingSessionRestores.has(record.summary.id)) {
+            record.summary.status = 'running';
+            record.summary.exitCode = null;
+        }
+        await this.cancelFailedClose(record);
+        return false;
+    }
+    async cancelFailedClose(record) {
+        // Disk errors must not leave a surviving terminal permanently unwritable.
+        record.closing = false;
         record.summary.updatedAt = this.timestamp();
-        if (record.subscribers.size > 0) {
+        if (!record.pty && record.summary.status === 'running' && record.subscribers.size > 0) {
             void this.ensureAttachedAsync(record);
         }
         this.publish(record, {
             type: 'terminal_updated',
             terminal: cloneSummary(record.summary)
         });
-        return false;
+        if (this.sessionStore) {
+            const token = Symbol();
+            this.pendingDeletionCancellations.set(record.summary.id, token);
+            await this.retryDeletionCancellation(record.summary.id, token);
+        }
+    }
+    async retryDeletionCancellation(id, token) {
+        if (this.pendingDeletionCancellations.get(id) !== token || this.terminals.get(id)?.closing)
+            return;
+        try {
+            // The store serializes writes. A later explicit delete is enqueued after
+            // this cancellation, and invalidates its token before either can finish.
+            await this.sessionStore?.setDeleting(id, false);
+            if (this.pendingDeletionCancellations.get(id) === token)
+                this.pendingDeletionCancellations.delete(id);
+        }
+        catch (error) {
+            this.reportDiagnostic({ event: 'terminal.recovery_save_failed', terminalId: id, error });
+            this.scheduleRestoreRetry();
+        }
+    }
+    async forgetRecoverySession(id) {
+        try {
+            await this.sessionStore?.forget(id);
+            return true;
+        }
+        catch (error) {
+            // The durable deletion intent remains sufficient to prevent restoration.
+            this.reportDiagnostic({ event: 'terminal.recovery_save_failed', terminalId: id, error });
+            this.scheduleRestoreRetry();
+            return false;
+        }
     }
     async closeAll() {
         this.shutdownRequested = true;
@@ -1839,6 +2084,17 @@ export class TerminalManager {
             }
             await Promise.allSettled(pendingCloses);
         }
+        await this.checkpointRecovery().catch(error => this.reportDiagnostic({ event: 'terminal.recovery_save_failed', error }));
+        // Requests can still arrive while the checkpoint awaits disk/cwd I/O.
+        // Drain again, with no await between the last empty check and disposal.
+        while (true) {
+            const pendingCloses = [...this.terminals.values()]
+                .map(record => record.closePromise)
+                .filter((close) => close !== null);
+            if (pendingCloses.length === 0)
+                break;
+            await Promise.allSettled(pendingCloses);
+        }
         for (const record of this.terminals.values()) {
             this.disposeRecord(record);
         }
@@ -1975,11 +2231,14 @@ export class TerminalManager {
     }
     async refreshCwd(record) {
         const pty = record.pty;
-        if (!pty || record.summary.status !== 'running') {
+        if (record.closing || record.summary.status !== 'running') {
             return;
         }
         const refreshGeneration = ++record.cwdRefreshGeneration;
-        const cwd = await this.safeResolveCwd(pty.pid);
+        // Detached panes have no local tmux client. Read their backing shell PID
+        // without attaching a client, so cwd changes over SSH are checkpointed too.
+        const pid = pty?.pid ?? await this.ptyAdapter.getSessionPid?.(record.summary.id);
+        const cwd = pid ? await this.safeResolveCwd(pid) : null;
         if (!cwd ||
             this.terminals.get(record.summary.id) !== record ||
             record.closing ||
@@ -2026,6 +2285,8 @@ export class TerminalManager {
         }).catch(() => undefined);
     }
     publish(record, message) {
+        if (message.type === 'terminal_updated')
+            this.scheduleRecoverySave();
         for (const subscriber of record.subscribers) {
             subscriber(message);
         }