@codingame/monaco-vscode-xterm-common 36.2.7 → 37.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-xterm-common",
-  "version": "36.2.7",
+  "version": "37.2.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package depending on xterm",
   "keywords": [],
@@ -15,9 +15,9 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "36.2.7",
-    "@codingame/monaco-vscode-xterm-addons-common": "36.2.7",
-    "@xterm/xterm": "6.1.0-beta.288"
+    "@codingame/monaco-vscode-api": "37.2.0",
+    "@codingame/monaco-vscode-xterm-addons-common": "37.2.0",
+    "@xterm/xterm": "6.1.0-beta.304"
   },
   "exports": {
     ".": {

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostOutputChannel.d.ts

@@ -0,0 +1,22 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import type { IChatTerminalOutputSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+/**
+ * Read-only view of an AHP output channel. Unlike {@link AgentHostPty}, this
+ * does not create a terminal process or an {@code ITerminalInstance}; chat
+ * renders the accumulated plain-text state in its own detached xterm.
+ */
+export declare class AgentHostOutputChannel extends Disposable implements IChatTerminalOutputSource {
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    private _output;
+    get output(): string;
+    private _hasExited;
+    get hasExited(): boolean;
+    private _exitCode;
+    get exitCode(): number | undefined;
+    constructor(connection: IAgentConnection, terminalUri: URI);
+    private _acceptState;
+}

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostOutputChannel.js

@@ -0,0 +1,48 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import { TerminalLifecycleStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+
+class AgentHostOutputChannel extends Disposable {
+    get output() {
+        return this._output;
+    }
+    get hasExited() {
+        return this._hasExited;
+    }
+    get exitCode() {
+        return this._exitCode;
+    }
+    constructor(connection, terminalUri) {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._output = "";
+        this._hasExited = false;
+        const subscriptionRef = this._register(
+            connection.getSubscription(StateComponents.Terminal, terminalUri, "AgentHostOutputChannel")
+        );
+        const subscription = subscriptionRef.object;
+        if (subscription.value && !(subscription.value instanceof Error)) {
+            this._acceptState(subscription.value);
+        }
+        this._register(subscription.onDidChange(state => this._acceptState(state)));
+    }
+    _acceptState(state) {
+        this._output = ( state.content.map(part => part.type === "command" ? part.output : part.value)).join("").replace(/\r?\n/g, "\r\n");
+        const lifecycle = state.lifecycle;
+        this._hasExited = lifecycle.status === TerminalLifecycleStatus.Exited;
+        this._exitCode = lifecycle.status === TerminalLifecycleStatus.Exited ? lifecycle.exitCode : undefined;
+        this._onDidChange.fire();
+    }
+}
+
+export { AgentHostOutputChannel };

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostPty.d.ts

@@ -1,7 +1,8 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IProcessPropertyMap, ITerminalChildProcess, ITerminalLaunchError, ITerminalLaunchResult, ProcessPropertyType } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
-import { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
 import { BasePty } from "../common/basePty.js";
 /**
  * Options for creating a new terminal on an agent host.
@@ -56,11 +57,14 @@ export declare function getAhpCommandMarkId(commandId: string, kind: AhpCommandM
 export declare class AgentHostPty extends BasePty implements ITerminalChildProcess {
     private _connection;
     private readonly _terminalUri;
-    private readonly _options?;
+    private readonly _options;
+    private readonly _logService;
     private readonly _startBarrier;
-    private readonly _subscriptionDisposables;
-    private _subscriptionRef;
+    private readonly _lifetime;
+    private readonly _subscription;
+    private _terminalCreation;
     private _initialCwd;
+    private _didSignalReady;
     private readonly _onCommandExecuted;
     readonly onCommandExecuted: Event<IAgentHostPtyCommandExecutedEvent>;
     private readonly _onCommandFinished;
@@ -76,8 +80,10 @@ export declare class AgentHostPty extends BasePty implements ITerminalChildProce
      * echo as a real command — we filter those out here.
      */
     private readonly _suppressedCommandIds;
-    constructor(id: number, _connection: IAgentConnection, _terminalUri: URI, _options?: IAgentHostPtyOptions | undefined);
+    constructor(id: number, _connection: IAgentConnection, _terminalUri: URI, _options: IAgentHostPtyOptions | undefined, _logService: ITerminalLogService);
     start(): Promise<ITerminalLaunchError | ITerminalLaunchResult | undefined>;
+    private _clearTerminalCreation;
+    private _signalReady;
     private _handleAction;
     /**
      * Replays structured terminal content parts from the initial state snapshot.
@@ -90,9 +96,15 @@ export declare class AgentHostPty extends BasePty implements ITerminalChildProce
      * are unwrapped to their original URI via {@link fromAgentHostUri}.
      */
     private _resolveCwdForProtocol;
+    private _createSubscription;
+    private _waitForHydration;
     input(data: string): void;
     resize(cols: number, rows: number): void;
     shutdown(_immediate: boolean): void;
+    private _requestHostTerminalDisposal;
+    private _disposeHostTerminal;
+    private _logHostDisposalError;
+    private _exitAndDispose;
     getInitialCwd(): Promise<string>;
     getCwd(): Promise<string>;
     clearBuffer(): Promise<void>;

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostPty.js

@@ -1,17 +1,20 @@
 
-import { Barrier } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Barrier, raceCancellation, DeferredPromise, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ProcessPropertyType } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
 import { AGENT_HOST_SCHEME, fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
-import '../../../../platform/agentHost/common/state/protocol/common/notifications.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import { TerminalClaimKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
 import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import { BasePty } from '../common/basePty.js';
 
@@ -34,14 +37,17 @@ class AgentHostPty extends BasePty {
     get supportsCommandDetection() {
         return this._supportsCommandDetection;
     }
-    constructor(id, _connection, _terminalUri, _options) {
+    constructor(id, _connection, _terminalUri, _options, _logService) {
         super(id,  false);
         this._connection = _connection;
         this._terminalUri = _terminalUri;
         this._options = _options;
+        this._logService = _logService;
         this._startBarrier = ( new Barrier());
-        this._subscriptionDisposables = this._register(( new DisposableStore()));
+        this._lifetime = this._register(( new CancellationTokenSource()));
+        this._subscription = this._register(( new MutableDisposable()));
         this._initialCwd = "";
+        this._didSignalReady = false;
         this._onCommandExecuted = this._register(( new Emitter()));
         this.onCommandExecuted = this._onCommandExecuted.event;
         this._onCommandFinished = this._register(( new Emitter()));
@@ -52,30 +58,45 @@ class AgentHostPty extends BasePty {
         this._suppressedCommandIds = ( new Set());
     }
     async start() {
+        const connection = this._connection;
         try {
+            if (this._lifetime.token.isCancellationRequested) {
+                return undefined;
+            }
             if (!this._options?.attachOnly) {
-                await this._connection.createTerminal({
+                const terminalCreation = connection.createTerminal({
                     channel: ( this._terminalUri.toString()),
                     claim: {
                         kind: TerminalClaimKind.Client,
-                        clientId: this._connection.clientId
+                        clientId: connection.clientId
                     },
                     name: this._options?.name,
                     cwd: this._resolveCwdForProtocol(this._options?.cwd),
                     cols: this._lastDimensions.cols > 0 ? this._lastDimensions.cols : undefined,
                     rows: this._lastDimensions.rows > 0 ? this._lastDimensions.rows : undefined
                 });
+                this._terminalCreation = terminalCreation;
+                terminalCreation.then(
+                    () => this._clearTerminalCreation(terminalCreation),
+                    () => this._clearTerminalCreation(terminalCreation)
+                );
+                const created = await raceCancellation(terminalCreation.then(() => true), this._lifetime.token, false);
+                if (!created) {
+                    return undefined;
+                }
             }
-            this._subscriptionRef = this._connection.getSubscription(StateComponents.Terminal, this._terminalUri, "AgentHostPty");
-            const subscription = this._subscriptionRef.object;
-            if (subscription.value === undefined) {
-                await ( new Promise(resolve => {
-                    const listener = subscription.onDidChange(() => {
-                        listener.dispose();
-                        resolve();
-                    });
-                    this._subscriptionDisposables.add(listener);
-                }));
+            if (this._lifetime.token.isCancellationRequested || this._connection !== connection) {
+                return undefined;
+            }
+            const {
+                subscription,
+                store
+            } = this._createSubscription(this._connection);
+            if (!(await this._waitForHydration(subscription, store))) {
+                return undefined;
+            }
+            if (this._lifetime.token.isCancellationRequested || this._subscription.value !== store) {
+                return undefined;
             }
             const state = subscription.value;
             if (state.supportsCommandDetection) {
@@ -89,31 +110,49 @@ class AgentHostPty extends BasePty {
             if (state.title) {
                 this._properties.title = state.title;
             }
-            this._subscriptionDisposables.add(subscription.onDidApplyAction(envelope => {
+            this._signalReady();
+            store.add(subscription.onDidApplyAction(envelope => {
                 this._handleAction(envelope);
             }));
-            this._startBarrier.open();
-            this.handleReady({
-                pid: -1,
-                cwd: this._initialCwd,
-                windowsPty: undefined
-            });
             return undefined;
         } catch (err) {
-            this._startBarrier.open();
+            if (this._lifetime.token.isCancellationRequested || this._connection !== connection) {
+                return undefined;
+            }
             return {
                 message: err instanceof Error ? err.message : String(err)
             };
+        } finally {
+            this._startBarrier.open();
         }
     }
+    _clearTerminalCreation(terminalCreation) {
+        if (this._terminalCreation === terminalCreation) {
+            this._terminalCreation = undefined;
+        }
+    }
+    _signalReady() {
+        if (this._didSignalReady || this._lifetime.token.isCancellationRequested) {
+            return;
+        }
+        this._didSignalReady = true;
+        this.handleReady({
+            pid: -1,
+            cwd: this._initialCwd,
+            windowsPty: undefined
+        });
+    }
     _handleAction(envelope) {
+        if (this._lifetime.token.isCancellationRequested) {
+            return;
+        }
         const action = envelope.action;
         switch (action.type) {
         case ActionType.TerminalData:
             this.handleData(action.data);
             break;
         case ActionType.TerminalExited:
-            this.handleExit(action.exitCode);
+            this._exitAndDispose(action.exitCode);
             break;
         case ActionType.TerminalCwdChanged:
             this._properties.cwd = ( action.cwd.toString());
@@ -211,11 +250,43 @@ class AgentHostPty extends BasePty {
         }
         return ( cwd.toString());
     }
+    _createSubscription(connection) {
+        const store = ( new DisposableStore());
+        try {
+            const subscription = store.add(
+                connection.getSubscription(StateComponents.Terminal, this._terminalUri, "AgentHostPty")
+            ).object;
+            this._subscription.value = store;
+            return {
+                subscription,
+                store
+            };
+        } catch (error) {
+            store.dispose();
+            throw error;
+        }
+    }
+    async _waitForHydration(subscription, store, timeoutMs) {
+        if (subscription.value !== undefined) {
+            return true;
+        }
+        const hydration = ( new DeferredPromise());
+        const timeout = timeoutMs === undefined ? undefined : disposableTimeout(() => hydration.error(( new Error("Reconnect hydration timed out"))), timeoutMs, store);
+        store.add(toDisposable(() => hydration.complete(false)));
+        store.add(Event.once(subscription.onDidChange)(() => {
+            timeout?.dispose();
+            hydration.complete(true);
+        }));
+        return raceCancellation(hydration.p, this._lifetime.token, false);
+    }
     input(data) {
-        if (this._inReplay) {
+        if (this._inReplay || this._lifetime.token.isCancellationRequested) {
             return;
         }
         this._startBarrier.wait().then(() => {
+            if (this._lifetime.token.isCancellationRequested) {
+                return;
+            }
             this._connection.dispatch(( this._terminalUri.toString()), {
                 type: ActionType.TerminalInput,
                 data
@@ -223,12 +294,15 @@ class AgentHostPty extends BasePty {
         });
     }
     resize(cols, rows) {
-        if (this._inReplay || (this._lastDimensions.cols === cols && this._lastDimensions.rows === rows)) {
+        if (this._lifetime.token.isCancellationRequested || this._inReplay || (this._lastDimensions.cols === cols && this._lastDimensions.rows === rows)) {
             return;
         }
         this._lastDimensions.cols = cols;
         this._lastDimensions.rows = rows;
         this._startBarrier.wait().then(() => {
+            if (this._lifetime.token.isCancellationRequested) {
+                return;
+            }
             this._connection.dispatch(( this._terminalUri.toString()), {
                 type: ActionType.TerminalResized,
                 cols,
@@ -237,14 +311,43 @@ class AgentHostPty extends BasePty {
         });
     }
     shutdown(_immediate) {
-        this._startBarrier.wait().then(() => {
-            if (!this._options?.attachOnly) {
-                this._connection.disposeTerminal(this._terminalUri);
-            }
-            this._subscriptionRef?.dispose();
-            this._subscriptionRef = undefined;
-            this._subscriptionDisposables.clear();
-            this.handleExit(undefined);
+        if (this._lifetime.token.isCancellationRequested) {
+            return;
+        }
+        this._requestHostTerminalDisposal();
+        this._exitAndDispose(undefined);
+    }
+    _requestHostTerminalDisposal() {
+        if (this._options?.attachOnly) {
+            return;
+        }
+        this._disposeHostTerminal();
+        if (this._terminalCreation) {
+            void this._terminalCreation.then(() => this._disposeHostTerminal(), () => this._disposeHostTerminal());
+        }
+    }
+    _disposeHostTerminal() {
+        try {
+            void this._connection.disposeTerminal(this._terminalUri).catch(err => this._logHostDisposalError(err));
+        } catch (err) {
+            this._logHostDisposalError(err);
+        }
+    }
+    _logHostDisposalError(err) {
+        this._logService.warn(
+            `[AgentHostPty] Failed to dispose host terminal: ${err instanceof Error ? err.message : String(err)}`
+        );
+    }
+    _exitAndDispose(exitCode) {
+        if (this._lifetime.token.isCancellationRequested) {
+            return;
+        }
+        this._lifetime.cancel();
+        this._subscription.clear();
+        this._startBarrier.open();
+        queueMicrotask(() => {
+            this.handleExit(exitCode);
+            this.dispose();
         });
     }
     async getInitialCwd() {
@@ -254,6 +357,9 @@ class AgentHostPty extends BasePty {
         return this._properties.cwd || this._initialCwd;
     }
     async clearBuffer() {
+        if (this._lifetime.token.isCancellationRequested) {
+            return;
+        }
         this._connection.dispatch(( this._terminalUri.toString()), {
             type: ActionType.TerminalCleared
         });
@@ -269,27 +375,22 @@ class AgentHostPty extends BasePty {
     }
     async updateProperty(_type, _value) {}
     async reconnect(newConnection) {
-        this._subscriptionDisposables.clear();
-        this._subscriptionRef?.dispose();
-        this._subscriptionRef = undefined;
+        if (this._lifetime.token.isCancellationRequested) {
+            return false;
+        }
+        this._subscription.clear();
         this._connection = newConnection;
+        let subscriptionStore;
         try {
-            this._subscriptionRef = this._connection.getSubscription(StateComponents.Terminal, this._terminalUri, "AgentHostPty");
-            const subscription = this._subscriptionRef.object;
-            if (subscription.value === undefined) {
-                const RECONNECT_HYDRATE_TIMEOUT_MS = 10_000;
-                await ( new Promise((resolve, reject) => {
-                    const timer = setTimeout(() => {
-                        listener.dispose();
-                        reject(( new Error("Reconnect hydration timed out")));
-                    }, RECONNECT_HYDRATE_TIMEOUT_MS);
-                    const listener = subscription.onDidChange(() => {
-                        clearTimeout(timer);
-                        listener.dispose();
-                        resolve();
-                    });
-                    this._subscriptionDisposables.add(listener);
-                }));
+            const result = this._createSubscription(this._connection);
+            const subscription = result.subscription;
+            subscriptionStore = result.store;
+            const RECONNECT_HYDRATE_TIMEOUT_MS = 10_000;
+            if (!(await this._waitForHydration(subscription, subscriptionStore, RECONNECT_HYDRATE_TIMEOUT_MS))) {
+                return false;
+            }
+            if (this._lifetime.token.isCancellationRequested || this._subscription.value !== subscriptionStore) {
+                return false;
             }
             const state = subscription.value;
             if (state.supportsCommandDetection && !this._supportsCommandDetection) {
@@ -304,15 +405,24 @@ class AgentHostPty extends BasePty {
             if (state.title) {
                 this._properties.title = state.title;
             }
-            this._subscriptionDisposables.add(subscription.onDidApplyAction(envelope => {
+            this._signalReady();
+            subscriptionStore.add(subscription.onDidApplyAction(envelope => {
                 this._handleAction(envelope);
             }));
             return true;
         } catch (err) {
-            console.warn(
-                "[AgentHostPty] Reconnection failed:",
-                err instanceof Error ? err.message : String(err)
-            );
+            if (!this._lifetime.token.isCancellationRequested) {
+                this._logService.warn(
+                    `[AgentHostPty] Reconnection failed: ${err instanceof Error ? err.message : String(err)}`
+                );
+            }
+            if (subscriptionStore && this._subscription.value === subscriptionStore) {
+                this._subscription.clear();
+            }
+            if (!this._didSignalReady && !this._lifetime.token.isCancellationRequested) {
+                this._requestHostTerminalDisposal();
+                this._exitAndDispose(undefined);
+            }
             return false;
         }
     }
@@ -320,8 +430,8 @@ class AgentHostPty extends BasePty {
         return this._terminalUri;
     }
     dispose() {
-        this._subscriptionRef?.dispose();
-        this._subscriptionRef = undefined;
+        this._lifetime.cancel();
+        this._subscription.clear();
         super.dispose();
     }
 }

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostTerminalService.d.ts

@@ -1,8 +1,9 @@
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
 import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import { ITerminalInstance, ITerminalLocationOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
 import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
@@ -35,6 +36,7 @@ export declare class AgentHostTerminalService extends Disposable implements IAge
     private readonly _terminalChatService;
     private readonly _terminalProfileService;
     private readonly _quickInputService;
+    private readonly _logService;
     readonly _serviceBrand: undefined;
     private readonly _entries;
     private readonly _usedHosts;
@@ -49,8 +51,8 @@ export declare class AgentHostTerminalService extends Disposable implements IAge
      * keyed by terminal URI string. Used for reconnection scoping.
      */
     private readonly _activePtys;
-    private readonly _reviveSequencer;
-    constructor(_terminalService: ITerminalService, _terminalChatService: ITerminalChatService, _terminalProfileService: ITerminalProfileService, _quickInputService: IQuickInputService);
+    private readonly _pendingRevives;
+    constructor(_terminalService: ITerminalService, _terminalChatService: ITerminalChatService, _terminalProfileService: ITerminalProfileService, _quickInputService: IQuickInputService, _logService: ITerminalLogService);
     registerEntry(entry: IAgentHostEntry): IDisposable;
     getProfileForConnection(address: string): IAgentHostTerminalProfileInfo | undefined;
     setDefaultCwd(cwd: URI | undefined): void;
@@ -59,7 +61,15 @@ export declare class AgentHostTerminalService extends Disposable implements IAge
     createTerminalForEntry(address: string, options?: IAgentHostTerminalCreateOptions): Promise<ITerminalInstance | undefined>;
     createTerminal(connection: IAgentConnection, options?: IAgentHostTerminalCreateOptions): Promise<ITerminalInstance>;
     reviveTerminal(connection: IAgentConnection, terminalUri: URI, terminalToolSessionId: string): Promise<ITerminalInstance>;
+    attachOutputTerminal(connection: IAgentConnection, terminalUri: URI, terminalToolSessionId: string): IDisposable;
     private _doReviveTerminal;
+    /** Creates the registration that owns the pty produced for {@link key}. */
+    private _createPtyRegistration;
+    /**
+     * Ties the registration's lifetime to the terminal instance so the local
+     * pty is disposed even on paths that never call `shutdown()`.
+     */
+    private _registerInstancePtyCleanup;
     reconnectTerminals(newConnection: IAgentConnection, oldClientId: string): Promise<{
         recovered: number;
         total: number;