termdock 1.4.313 → 1.4.315

package/dist/server/agent/sessionManagement.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { CollaborationError } from './collaborationProtocol.js';
+const fail = (code, message) => { throw new CollaborationError(code, message, 409); };
+/** Read the live foreground process instance, not a historical PID. */
+export async function foregroundProcessInstance(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return fail('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Foreground process is unavailable');
+    try {
+        if (process.platform === 'linux') {
+            const stat = await fs.readFile(`/proc/${pid}/stat`, 'utf8');
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            if (fields[0] === 'Z' || Number(fields[2]) <= 0 || fields[2] !== fields[5] || !/^\d+$/.test(fields[19]))
+                throw new Error();
+            return `linux:${fields[19]}`;
+        }
+        if (process.platform === 'darwin') {
+            const { stdout } = await promisify(execFile)('ps', ['-p', String(pid), '-o', 'pgid=,tpgid=,stat=,lstart='], { timeout: 2000 });
+            const match = stdout.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+            if (!match || Number(match[1]) < 1 || match[1] !== match[2] || match[3].startsWith('Z'))
+                throw new Error();
+            return `darwin:${match[4]}`;
+        }
+    }
+    catch { /* Never fall back to PID existence. */ }
+    return fail('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Current foreground process instance cannot be verified');
+}
+/** A missing PID is absence; inaccessible identity remains an error. */
+export async function processStartIdentity(pid) {
+    if (process.platform === 'linux') {
+        try {
+            const stat = await fs.readFile(`/proc/${pid}/stat`, 'utf8');
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            if (fields[0] === 'Z')
+                return null;
+            if (!/^\d+$/.test(fields[19]))
+                throw new Error();
+            return `linux:${fields[19]}`;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+        }
+    }
+    else if (process.platform === 'darwin') {
+        try {
+            const { stdout } = await promisify(execFile)('ps', ['-p', String(pid), '-o', 'stat=,lstart='], { timeout: 2000 });
+            const match = stdout.trim().match(/^(\S+)\s+(.+)$/);
+            if (match)
+                return match[1].startsWith('Z') ? null : `darwin:${match[2]}`;
+        }
+        catch {
+            try {
+                process.kill(pid, 0);
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    return null;
+            }
+        }
+    }
+    return fail('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Process disappearance cannot be verified');
+}
+/** Restart reconciliation never issues termination. External tmux/process
+ * changes are outside the service lock; final fresh checks reduce, not erase,
+ * that race. The exact tmux session ID is used for teardown. */
+export async function closeSessionRuntime(adapter, target, reconcile) {
+    await adapter.barrier(async () => {
+        if (adapter.pendingMessages())
+            fail('SESSION_PENDING_MESSAGES', 'Pending messages must be resolved before closing');
+        if (await adapter.exists()) {
+            if (reconcile)
+                fail('OPERATION_OUTCOME_UNCONFIRMED', 'Runtime still exists; reconciliation will not terminate a process');
+            if (!target || JSON.stringify(await adapter.observe()) !== JSON.stringify(target))
+                fail('SESSION_CLOSE_TARGET_CHANGED', 'Runtime or process instance changed after close intent');
+            await adapter.destroy(target);
+            const deadline = Date.now() + 2000;
+            // Observe actual disappearance; do not issue repeated termination.
+            while (await adapter.exists() && Date.now() < deadline)
+                await new Promise(resolve => setTimeout(resolve, 50));
+        }
+        if (await adapter.exists())
+            fail('OPERATION_OUTCOME_UNCONFIRMED', 'Runtime absence cannot be confirmed');
+        await adapter.forgetRuntime();
+    });
+}

package/dist/server/agent/terminalInput.js

@@ -14,11 +14,19 @@ function serializeInQueue(store, target, action) {
     store.set(target, operation);
     return operation;
 }
+export class TerminalInputTargetChangedError extends Error {
+    evidence;
+    code = 'TERMINAL_INPUT_TARGET_CHANGED';
+    constructor(evidence) {
+        super('TERMINAL_INPUT_TARGET_CHANGED');
+        this.evidence = evidence;
+    }
+}
 /** Clearing a one-time launch check does not change the runtime generation. */
 export function captureTerminalInputGuard(current, expected = current()) {
     return () => {
         if (current() !== expected)
-            throw new Error('TERMINAL_INPUT_TARGET_CHANGED');
+            throw new TerminalInputTargetChangedError();
     };
 }
 /** Await the actual write instead of leaving detached timers after reporting success. */

package/dist/server/routes/terminal.js

@@ -2,6 +2,7 @@ import { collaborationSessionDisplayName } from '../utils/sessionDisplayName.js'
 import { integrationError } from '../agent/integrationStore.js';
 import { assertNativeResumeAvailable, collectNativeResumeOwnerCandidates } from '../agent/nativeResumeOwner.js';
 import { readNativeProcessIdentity } from '../agent/nativeProcessIdentity.js';
+import { closeSessionRuntime, foregroundProcessInstance, processStartIdentity } from '../agent/sessionManagement.js';
 import { releaseSessionRuntime } from '../agent/sessionLifecycle.js';
 import { resumeConfigurationFingerprint } from '../agent/sessionResumeConfiguration.js';
 import { integrationLaunchCommand } from '../agent/integrationSessions.js';
@@ -50,7 +51,7 @@ import { archiveTaskWorkspace, restoreTaskWorkspace, snapshotTaskWorkspace } fro
 import { isTmuxRecoveryCandidate } from '../utils/tmuxRecoveryCandidate.js';
 import { AutomationStore, normalizeAutomationSchedule } from '../agent/automationStore.js';
 import { writeBracketedPrompt, canDeliverPromptToAgent } from '../agent/promptDelivery.js';
-import { captureTerminalInputGuard, waitAndWriteTerminalInput } from '../agent/terminalInput.js';
+import { captureTerminalInputGuard, waitAndWriteTerminalInput, TerminalInputTargetChangedError } from '../agent/terminalInput.js';
 import { agentLaunchBlockReason, normalizeAgentLaunchCheck } from '../agent/agentLaunchCheck.js';
 import { prepareSupervisionEnable } from '../utils/enableSupervision.js';
 import { buildServerHealthState, dismissServerHealth } from '../utils/serverHealth.js';
@@ -629,7 +630,7 @@ function schedulePersistGlobalState() {
         }
     }, 200);
 }
-async function persistGlobalStateNow() {
+async function persistGlobalStateNow(strict = false) {
     if (persistGlobalStateTimer) {
         clearTimeout(persistGlobalStateTimer);
         persistGlobalStateTimer = null;
@@ -639,6 +640,8 @@ async function persistGlobalStateNow() {
     }
     catch (error) {
         console.warn('[session-persist] Failed to persist global state:', getErrorMessage(error));
+        if (strict)
+            throw error;
     }
 }
 // 进程退出前立即刷盘，避免 tsx watch 重启导致状态丢失
@@ -1479,21 +1482,21 @@ async function observeAgentLaunchCheck(record, observed) {
 function terminalInputGuard(record) {
     const frontendSessionId = record.sessionId;
     const backendSessionId = record.backendSessionId;
-    const generation = captureTerminalInputGuard(() => globalSessionState.sessions
-        .find(candidate => candidate.sessionId === frontendSessionId)?.agentLaunchGeneration ?? null, record.agentLaunchGeneration ?? null);
+    const launchId = record.agentLaunchGeneration ?? null;
     const backend = backendSessionId ? terminalSessions.get(backendSessionId) : undefined;
     return () => {
         const latest = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
         if (!latest)
             throw new Error('SESSION_REMOVED');
-        generation();
-        if (latest.backendSessionId !== backendSessionId
-            || backendSessionId && terminalSessions.get(backendSessionId) !== backend)
-            throw new Error('TERMINAL_INPUT_TARGET_CHANGED');
+        const instanceMatches = !backendSessionId || terminalSessions.get(backendSessionId) === backend;
+        if ((latest.agentLaunchGeneration ?? null) !== launchId || latest.backendSessionId !== backendSessionId || !instanceMatches) {
+            throw new TerminalInputTargetChangedError({ expected_backend_session_id: backendSessionId, current_backend_session_id: latest.backendSessionId,
+                expected_launch_id: launchId, current_launch_id: latest.agentLaunchGeneration ?? null, backend_instance_matches: instanceMatches });
+        }
     };
 }
 /** tmux input always uses the pane queue, including automation and launch commands. */
-async function automaticTerminalInput(record, assertCurrent = terminalInputGuard(record)) {
+async function automaticTerminalInput(record, assertCurrent = terminalInputGuard(record), progress) {
     assertCurrent();
     if (record.mode === 'tmux') {
         const binding = collaborationRouting.get(record.sessionId) ?? {
@@ -1505,18 +1508,18 @@ async function automaticTerminalInput(record, assertCurrent = terminalInputGuard
         if (inspected.state !== 'ready' || !inspected.pane)
             throw new Error(inspected.reason ?? 'TMUX_PANE_UNAVAILABLE');
         const pane = inspected.pane;
-        return (prompt) => writeCollaborationTmuxPane(runTmux, pane, prompt, runTmuxStdin, assertCurrent);
+        return (prompt) => writeCollaborationTmuxPane(runTmux, pane, prompt, runTmuxStdin, assertCurrent, progress);
     }
     const backend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
     if (!backend)
         throw new Error('SHELL_BACKEND_NOT_RUNNING');
-    return (prompt) => writeBracketedPrompt(backend.ptyProcess, prompt, assertCurrent);
+    return (prompt) => writeBracketedPrompt(backend.ptyProcess, prompt, assertCurrent, progress);
 }
-async function writeAutomaticTerminalPrompt(frontendSessionId, prompt) {
+async function writeAutomaticTerminalPrompt(frontendSessionId, prompt, progress) {
     const record = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
     if (!record)
         throw new Error('SESSION_REMOVED');
-    const write = await automaticTerminalInput(record);
+    const write = await automaticTerminalInput(record, terminalInputGuard(record), progress);
     await write(prompt);
 }
 async function deliverAutomationPromptWhenReady(backendSessionId, prompt) {
@@ -1980,11 +1983,131 @@ async function integrationTmuxPresent(record) {
         throw error;
     }
 }
+async function verifyIntegrationRuntimeOwnership(record) {
+    await integrationSessionAdapter.prepareRelease(record);
+    const terminal = integrationTerminalRecord(record);
+    if (terminal && globalSessionState.sessions.some(other => other.sessionId !== record.session_id
+        && (other.tmuxSessionName === terminal.tmuxSessionName || terminal.backendSessionId && other.backendSessionId === terminal.backendSessionId))) {
+        integrationError('SESSION_IDENTITY_MISMATCH', 'Runtime has another logical owner', 409);
+    }
+}
+async function forgetIntegrationRuntime(record) {
+    if (await integrationTmuxPresent(record))
+        integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Owned tmux still exists', 409);
+    await verifyIntegrationRuntimeOwnership(record);
+    for (const [id, backend] of terminalSessions)
+        if (backend.mode === 'tmux' && backend.tmuxSessionName === `wt-integration-${record.session_id}`)
+            cleanupSession(id, { killProcess: true });
+    removeGlobalSessionRecord(record.session_id);
+    collaborationStore.archiveSession(record.session_id);
+    collaborationRouting.remove(record.session_id);
+    await persistGlobalStateNow(true);
+    broadcastClientState();
+}
+async function observeIntegrationCloseTarget(record) {
+    await verifyIntegrationRuntimeOwnership(record);
+    const terminal = integrationTerminalRecord(record);
+    if (!terminal || !record.terminal_binding)
+        integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Original runtime binding is unavailable', 409);
+    const inspected = await inspectCollaborationTmux({ sessionId: record.session_id, backendSessionId: terminal.backendSessionId,
+        mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: record.agent_slug,
+        nativeSessionId: record.agent_native_session_id, pane: record.terminal_binding }, undefined, false, true);
+    if (inspected.state !== 'ready' || !inspected.pane)
+        integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Original pinned pane cannot be verified', 409);
+    const layout = await getTmuxLayout(terminal.tmuxSessionName);
+    const panes = layout.windows.flatMap(window => window.panes);
+    if (panes.length !== 1 || layout.activePaneId !== record.terminal_binding.paneId)
+        integrationError('SESSION_IDENTITY_MISMATCH', 'Only the single original owned pane can be closed', 409);
+    const pane = panes[0];
+    const paneOwners = (await runTmux(['list-panes', '-a', '-F', '#{session_id} #{pane_id}'])).trim().split('\n');
+    if (paneOwners.some(line => { const [owner, id] = line.trim().split(/\s+/); return id === pane.id && owner !== record.terminal_binding.sessionId; }))
+        integrationError('SESSION_SCOPE_CONFLICT', 'Owned pane is linked into another tmux session', 409);
+    if (process.platform === 'linux')
+        await getProcessSnapshot(true);
+    const program = await resolveTmuxPaneProgram(pane, true, true);
+    const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
+    let kind, pid, nativeId = null;
+    if (agent) {
+        if (!record.agent_native_session_id || agent.slug !== record.agent_slug || program?.source !== 'tmux-tty' || !program.processPid) {
+            integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'A running Agent requires a live exact native identity', 409);
+        }
+        const identity = await observeProgramNativeIdentity(agent, program);
+        if (identity.failure || identity.nativeId !== record.agent_native_session_id)
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Current Agent native identity differs from the owned record', 409);
+        kind = 'agent';
+        pid = program.processPid;
+        nativeId = identity.nativeId;
+    }
+    else {
+        if (!await integrationPaneIsIdleShell(inspected.pane))
+            integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Current runtime is not a verified foreground shell', 409);
+        kind = 'shell';
+        pid = pane.pid;
+    }
+    const serverStart = await processStartIdentity(record.terminal_binding.serverPid);
+    if (!serverStart)
+        integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Current tmux server instance is unavailable', 409);
+    return { binding: { ...record.terminal_binding }, tmux_server_start_id: serverStart, kind, process_pid: pid,
+        process_start_id: await foregroundProcessInstance(pid), native_id: nativeId };
+}
 export const integrationSessionAdapter = {
     subscribe(listener) { integrationSessionObservers.add(listener); return () => { integrationSessionObservers.delete(listener); }; },
     registerDeliveryGuard(guard) { integrationDeliveryGuard = guard; return () => { if (integrationDeliveryGuard === guard)
         integrationDeliveryGuard = undefined; }; },
+    async prepareRename(record) {
+        await verifyIntegrationRuntimeOwnership(record);
+        if (!integrationTerminalRecord(record) && await integrationTmuxPresent(record))
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Live tmux lacks its owned terminal registration', 409);
+    },
+    async rename(record) {
+        await integrationSessionAdapter.prepareRename(record);
+        const terminal = integrationTerminalRecord(record);
+        if (!terminal)
+            return; // Metadata survives released/closed; never recreate a runtime.
+        if (!record.name)
+            integrationError('INVALID_NAME', 'Missing persistent display name');
+        if (await integrationTmuxPresent(record))
+            await setTmuxOption(terminal.tmuxSessionName, '@termdock-friendly-name', record.name);
+        upsertGlobalSessionRecord({ ...terminal, name: record.name, customName: true, autoTitle: null });
+        await persistGlobalStateNow(true);
+        await getSessionInventorySnapshot({ refresh: true });
+        broadcastClientState();
+    },
+    async prepareClose(record) {
+        if (collaborationStore.pendingCount(record.session_id))
+            integrationError('SESSION_PENDING_MESSAGES', 'Pending messages must be resolved before closing', 409);
+        await verifyIntegrationRuntimeOwnership(record);
+        return await integrationTmuxPresent(record) ? observeIntegrationCloseTarget(record) : null;
+    },
+    async closeRuntime(record, reconcile) {
+        await closeSessionRuntime({
+            barrier: action => collaborationDeliveryWorker.reconfigure(record.session_id, action),
+            async exists() {
+                if (await integrationTmuxPresent(record))
+                    return true;
+                const target = record.close_intent?.target;
+                return !!target && await processStartIdentity(target.process_pid) === target.process_start_id;
+            },
+            pendingMessages: () => collaborationStore.pendingCount(record.session_id),
+            observe: () => observeIntegrationCloseTarget(record),
+            async destroy(target) {
+                // Kill by immutable tmux session ID, not by a potentially reused name.
+                // No process-group kill or application prompt is sent.
+                if (JSON.stringify(await observeIntegrationCloseTarget(record)) !== JSON.stringify(target))
+                    integrationError('SESSION_CLOSE_TARGET_CHANGED', 'Close target changed before teardown', 409);
+                intentionallyDeletingTmuxSessions.add(`wt-integration-${record.session_id}`);
+                try {
+                    await runTmux(['kill-session', '-t', target.binding.sessionId]);
+                }
+                finally {
+                    intentionallyDeletingTmuxSessions.delete(`wt-integration-${record.session_id}`);
+                }
+            },
+            forgetRuntime: () => forgetIntegrationRuntime(record),
+        }, record.close_intent?.target ?? null, reconcile);
+    },
     pendingMessages(id) { return collaborationStore.pendingCount(id); },
+    messageHistory(id) { return collaborationStore.hasTerminalMessageHistory(id); },
     async prepareRelease(record) {
         if (collaborationStore.groupsForSession(record.session_id).some(group => group.id !== record.group_id))
             integrationError('SESSION_SCOPE_CONFLICT', 'Runtime belongs to another collaboration group; administrator must resolve its membership first', 409);
@@ -2076,21 +2199,28 @@ export const integrationSessionAdapter = {
             collaborationRouting.bind({ ...route, nativeSessionId: nativeId, pane: { ...route.pane, nativeSessionId: nativeId } });
         return { exists: true, running: Boolean(pane.agentSlug), shell: await integrationPaneIsIdleShell(pane), agentSlug: pane.agentSlug || null, nativeId };
     },
-    async create(record, prepared) {
+    async create(record, prepared, progress) {
         await listDetectedAgentLaunchers();
         if (!agentBySlug(record.agent_slug))
             integrationError('COLLAB_AGENT_UNAVAILABLE', 'Configured agent plugin is not installed');
         if (integrationTerminalRecord(record))
             integrationError('SESSION_CREATE_OUTCOME_UNKNOWN', 'Creation intent already has a terminal; inspect it instead of relaunching', 409);
-        await launchIntegrationTerminal(record, false, prepared);
+        await launchIntegrationTerminal(record, false, prepared, progress);
     },
-    async restore(record, prepared) {
+    async restore(record, prepared, progress) {
         await listDetectedAgentLaunchers();
         const agent = agentBySlug(record.agent_slug);
         if (!record.agent_native_session_id || !agent || !buildResumeCommand(agent, record.agent_native_session_id, null))
             integrationError('EXACT_RESUME_UNSUPPORTED', 'Agent plugin must support exact native resume');
+        progress?.('native_owner_check');
         await assertIntegrationNativeResumeAvailable(record);
-        await launchIntegrationTerminal(record, true, prepared);
+        await launchIntegrationTerminal(record, true, prepared, progress);
+    },
+    async retryCold(record, prepared, progress) {
+        await listDetectedAgentLaunchers();
+        if (!agentBySlug(record.agent_slug))
+            integrationError('COLLAB_AGENT_UNAVAILABLE', 'Configured agent plugin is not installed');
+        await launchIntegrationTerminal(record, false, prepared, progress, true);
     },
 };
 async function assertIntegrationNativeResumeAvailable(record) {
@@ -2141,12 +2271,28 @@ async function assertIntegrationNativeResumeAvailable(record) {
                 program: program?.command ?? null, processSource: program?.source, argumentsObserved: !!program?.rawArgs }];
     });
 }
-async function launchIntegrationTerminal(record, restoring, prepared) {
+async function launchIntegrationTerminal(record, restoring, prepared, progress, retryCold = false) {
     await collaborationDeliveryWorker.reconfigure(record.session_id, async () => {
+        progress?.('runtime_prepare');
         const group = collaborationStore.getGroup(record.group_id);
         if (!group || group.deleted)
             integrationError('TASK_GROUP_NOT_FOUND', 'Integration group no longer exists', 404);
         const original = await integrationSessionAdapter.inspect(record);
+        if (retryCold) {
+            await integrationSessionAdapter.prepareRelease(record);
+            const owned = integrationTerminalRecord(record);
+            if (!owned || globalSessionState.sessions.some(other => other.sessionId !== record.session_id
+                && (other.tmuxSessionName === owned.tmuxSessionName || owned.backendSessionId && other.backendSessionId === owned.backendSessionId))) {
+                integrationError('SESSION_IDENTITY_MISMATCH', 'Cold retry runtime lacks unique logical ownership', 409);
+            }
+            const history = collaborationStore.hasTerminalMessageHistory(record.session_id);
+            if (history === null)
+                integrationError('SESSION_MESSAGE_HISTORY_UNCONFIRMED', 'Message history cannot be verified', 409);
+            if (history || collaborationStore.pendingCount(record.session_id))
+                integrationError('SESSION_MESSAGE_HISTORY_PRESENT', 'TD message history appeared before retry', 409);
+            if (!record.terminal_binding || !original.exists || original.running || !original.shell || original.nativeId)
+                integrationError('SESSION_COLD_RETRY_RUNTIME_UNCONFIRMED', 'Original shell could not be confirmed before retry', 409);
+        }
         if (!original.exists) {
             let tmuxExists = false;
             try {
@@ -2162,7 +2308,7 @@ async function launchIntegrationTerminal(record, restoring, prepared) {
         }
         const opened = await openInventorySession({}, { preferredFrontendSessionId: record.session_id,
             mode: 'tmux', tmuxSessionName: `wt-integration-${record.session_id}`, cwd: record.cwd,
-            name: `${record.agent_slug} · ${group.name}`, customName: true });
+            name: record.name ?? `${record.agent_slug} · ${group.name}`, customName: true });
         if (opened.session.sessionId !== record.session_id)
             integrationError('SESSION_IDENTITY_MISMATCH', 'Terminal id changed', 409);
         const terminal = integrationTerminalRecord(record);
@@ -2178,6 +2324,7 @@ async function launchIntegrationTerminal(record, restoring, prepared) {
         const pane = inspected.pane;
         const pinned = { serverPid: pane.serverPid, sessionId: pane.sessionId,
             paneId: pane.paneId, panePid: pane.panePid, agentSlug: record.agent_slug, nativeSessionId: record.agent_native_session_id };
+        progress?.('binding_persist');
         prepared(pinned); // Must persist before the command enters the terminal.
         collaborationRouting.bind({ sessionId: record.session_id, backendSessionId: opened.terminalSession.sessionId,
             mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: record.agent_slug, nativeSessionId: record.agent_native_session_id, pane: pinned });
@@ -2195,8 +2342,11 @@ async function launchIntegrationTerminal(record, restoring, prepared) {
         // use an active-pane target which might have changed during preparation.
         if (record.resume_configuration_fingerprint && record.resume_configuration_fingerprint !== await resumeConfigurationFingerprint(record, integrationSessionAdapter))
             integrationError('RESUME_CONFIGURATION_CHANGED', 'Recovery configuration changed before terminal input', 409);
-        if (restoring)
+        if (restoring) {
+            progress?.('native_owner_check');
             await assertIntegrationNativeResumeAvailable(record);
+        }
+        progress?.('runtime_verify');
         const shell = await inspectCollaborationTmux({ sessionId: record.session_id, backendSessionId: opened.terminalSession.sessionId,
             mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: null, nativeSessionId: null, pane: pinned });
         if (shell.state !== 'ready' || !shell.pane || !await integrationPaneIsIdleShell(shell.pane))
@@ -2206,8 +2356,9 @@ async function launchIntegrationTerminal(record, restoring, prepared) {
         backend.agentSession = null;
         backend.agent = null;
         backend.agentResumeRecovered = false;
+        progress?.('launch_intent');
         await beginAgentLaunchCheck(record.session_id, record.agent_slug, restoring ? record.agent_native_session_id : null);
-        await writeAutomaticTerminalPrompt(record.session_id, integrationLaunchCommand(record, restoring));
+        await writeAutomaticTerminalPrompt(record.session_id, integrationLaunchCommand(record, restoring), progress);
         broadcastClientState();
     });
 }