@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

package/vscode/src/vs/platform/agentHost/common/customAgents.js

@@ -0,0 +1,12 @@
+
+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-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';
+
+function agentHostAgentPickerStorageKey(resourceScheme) {
+    return `workbench.agentsession.agentHostAgentPicker.${resourceScheme}.selectedAgentUri`;
+}
+
+export { agentHostAgentPickerStorageKey };

package/vscode/src/vs/platform/agentHost/common/sandboxConfigSchema.d.ts

@@ -0,0 +1,81 @@
+import { AgentSandboxEnabledValue } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings";
+/**
+ * Top-level keys the agent host's root config bag exposes for sandboxing.
+ * All sandbox-related values live nested under {@link AgentHostSandboxConfigKey.Sandbox}
+ * — the persisted JSON has a single `"sandbox": { ... }` object rather than a
+ * dozen flat keys.
+ */
+export declare enum AgentHostSandboxConfigKey {
+    Sandbox = "sandbox"
+}
+/**
+ * Well-known sub-keys inside the agent host's `sandbox` object. These are
+ * intentionally a flat, prefix-free namespace owned by the agent host —
+ * distinct from the workbench's `chat.agent.sandbox.*` setting IDs. Hosts
+ * (today: the workbench client) translate from their setting IDs to these
+ * keys when forwarding values via a `RootConfigChanged` action.
+ */
+export declare enum AgentHostSandboxKey {
+    Enabled = "enabled",
+    WindowsEnabled = "enabled.windows",
+    AllowUnsandboxedCommands = "allowUnsandboxedCommands",
+    AutoApproveUnsandboxedCommands = "autoApproveUnsandboxedCommands",
+    LinuxFileSystem = "fileSystem.linux",
+    MacFileSystem = "fileSystem.mac",
+    WindowsFileSystem = "fileSystem.windows",
+    AdvancedRuntime = "advanced.runtime",
+    AllowedNetworkDomains = "allowedNetworkDomains",
+    DeniedNetworkDomains = "deniedNetworkDomains"
+}
+/** Shape of the persisted/forwarded `sandbox` object. */
+export type ISandboxConfigValue = Partial<{
+    [AgentHostSandboxKey.Enabled]: AgentSandboxEnabledValue;
+    [AgentHostSandboxKey.WindowsEnabled]: AgentSandboxEnabledValue;
+    [AgentHostSandboxKey.AllowUnsandboxedCommands]: boolean;
+    [AgentHostSandboxKey.AutoApproveUnsandboxedCommands]: boolean;
+    [AgentHostSandboxKey.LinuxFileSystem]: Record<string, unknown>;
+    [AgentHostSandboxKey.MacFileSystem]: Record<string, unknown>;
+    [AgentHostSandboxKey.WindowsFileSystem]: Record<string, unknown>;
+    [AgentHostSandboxKey.AdvancedRuntime]: Record<string, unknown>;
+    [AgentHostSandboxKey.AllowedNetworkDomains]: string[];
+    [AgentHostSandboxKey.DeniedNetworkDomains]: string[];
+}>;
+/**
+ * Schema for the subset of workbench sandbox settings that hosts (today: the
+ * workbench client) may forward into the agent host's root config bag.
+ *
+ * The agent host's terminal sandbox engine reads these values through
+ * {@link IAgentConfigurationService.getRootValue}. Only the modern,
+ * normalized form of each setting is declared here — the workbench is
+ * expected to:
+ *
+ *  - map the legacy boolean form of `chat.agent.sandbox.enabled` to the
+ *    `'on' | 'off' | 'allowNetwork'` enum, and
+ *  - migrate values from any deprecated setting IDs to their modern key
+ *
+ * before pushing a `RootConfigChanged` action. That keeps the agent-host
+ * schema (and validation) free of backward-compat baggage.
+ */
+export declare const sandboxConfigSchema: import("./agentHostSchema.js").ISchema<{
+    sandbox: import("./agentHostSchema.js").ISchemaProperty<Partial<{
+        enabled: AgentSandboxEnabledValue;
+        "enabled.windows": AgentSandboxEnabledValue;
+        allowUnsandboxedCommands: boolean;
+        autoApproveUnsandboxedCommands: boolean;
+        "fileSystem.linux": Record<string, unknown>;
+        "fileSystem.mac": Record<string, unknown>;
+        "fileSystem.windows": Record<string, unknown>;
+        "advanced.runtime": Record<string, unknown>;
+        allowedNetworkDomains: string[];
+        deniedNetworkDomains: string[];
+    }>>;
+}>;
+/**
+ * Maps modern workbench sandbox setting IDs (the ones the engine asks about)
+ * to the sub-keys inside the agent host's `sandbox` config object.
+ *
+ * Deprecated setting IDs are intentionally absent: hosts forwarding values
+ * into the agent host are expected to migrate deprecated → modern IDs
+ * before dispatching `RootConfigChanged`.
+ */
+export declare const sandboxSettingIdToAgentHostKey: Readonly<Record<string, AgentHostSandboxKey>>;

package/vscode/src/vs/platform/agentHost/common/sandboxConfigSchema.js

@@ -0,0 +1,103 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AgentNetworkDomainSettingId } from '../../networkFilter/common/settings.js';
+import { AgentSandboxEnabledValue, AgentSandboxSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { createSchema, schemaProperty } from './agentHostSchema.js';
+
+var AgentHostSandboxConfigKey;
+(function(AgentHostSandboxConfigKey) {
+    AgentHostSandboxConfigKey["Sandbox"] = "sandbox";
+})(AgentHostSandboxConfigKey || (AgentHostSandboxConfigKey = {}));
+var AgentHostSandboxKey;
+(function(AgentHostSandboxKey) {
+    AgentHostSandboxKey["Enabled"] = "enabled";
+    AgentHostSandboxKey["WindowsEnabled"] = "enabled.windows";
+    AgentHostSandboxKey["AllowUnsandboxedCommands"] = "allowUnsandboxedCommands";
+    AgentHostSandboxKey["AutoApproveUnsandboxedCommands"] = "autoApproveUnsandboxedCommands";
+    AgentHostSandboxKey["LinuxFileSystem"] = "fileSystem.linux";
+    AgentHostSandboxKey["MacFileSystem"] = "fileSystem.mac";
+    AgentHostSandboxKey["WindowsFileSystem"] = "fileSystem.windows";
+    AgentHostSandboxKey["AdvancedRuntime"] = "advanced.runtime";
+    AgentHostSandboxKey["AllowedNetworkDomains"] = "allowedNetworkDomains";
+    AgentHostSandboxKey["DeniedNetworkDomains"] = "deniedNetworkDomains";
+})(AgentHostSandboxKey || (AgentHostSandboxKey = {}));
+createSchema({
+    [AgentHostSandboxConfigKey.Sandbox]: schemaProperty({
+        type: "object",
+        title: ( localize(1858, "Agent Sandbox")),
+        properties: {
+            [AgentHostSandboxKey.Enabled]: {
+                type: "string",
+                title: ( localize(1859, "Sandbox Enabled")),
+                enum: [
+                    AgentSandboxEnabledValue.Off,
+                    AgentSandboxEnabledValue.On,
+                    AgentSandboxEnabledValue.AllowNetwork
+                ]
+            },
+            [AgentHostSandboxKey.WindowsEnabled]: {
+                type: "string",
+                title: ( localize(1860, "Sandbox Enabled (Windows)")),
+                enum: [
+                    AgentSandboxEnabledValue.Off,
+                    AgentSandboxEnabledValue.On,
+                    AgentSandboxEnabledValue.AllowNetwork
+                ]
+            },
+            [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
+                type: "boolean",
+                title: ( localize(1861, "Allow Unsandboxed Commands"))
+            },
+            [AgentHostSandboxKey.AutoApproveUnsandboxedCommands]: {
+                type: "boolean",
+                title: ( localize(1862, "Auto-Approve Unsandboxed Commands"))
+            },
+            [AgentHostSandboxKey.LinuxFileSystem]: {
+                type: "object",
+                title: ( localize(1863, "Linux Sandbox Filesystem"))
+            },
+            [AgentHostSandboxKey.MacFileSystem]: {
+                type: "object",
+                title: ( localize(1864, "macOS Sandbox Filesystem"))
+            },
+            [AgentHostSandboxKey.WindowsFileSystem]: {
+                type: "object",
+                title: ( localize(1865, "Windows Sandbox Filesystem"))
+            },
+            [AgentHostSandboxKey.AdvancedRuntime]: {
+                type: "object",
+                title: ( localize(1866, "Advanced Sandbox Runtime"))
+            },
+            [AgentHostSandboxKey.AllowedNetworkDomains]: {
+                type: "array",
+                title: ( localize(1867, "Allowed Network Domains")),
+                items: {
+                    type: "string",
+                    title: ( localize(1868, "Domain"))
+                }
+            },
+            [AgentHostSandboxKey.DeniedNetworkDomains]: {
+                type: "array",
+                title: ( localize(1869, "Denied Network Domains")),
+                items: {
+                    type: "string",
+                    title: ( localize(1870, "Domain"))
+                }
+            }
+        }
+    })
+});
+const sandboxSettingIdToAgentHostKey = {
+    [AgentSandboxSettingId.AgentSandboxEnabled]: AgentHostSandboxKey.Enabled,
+    [AgentSandboxSettingId.AgentSandboxWindowsEnabled]: AgentHostSandboxKey.WindowsEnabled,
+    [AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands]: AgentHostSandboxKey.AllowUnsandboxedCommands,
+    [AgentSandboxSettingId.AgentSandboxAutoApproveUnsandboxedCommands]: AgentHostSandboxKey.AutoApproveUnsandboxedCommands,
+    [AgentSandboxSettingId.AgentSandboxLinuxFileSystem]: AgentHostSandboxKey.LinuxFileSystem,
+    [AgentSandboxSettingId.AgentSandboxMacFileSystem]: AgentHostSandboxKey.MacFileSystem,
+    [AgentSandboxSettingId.AgentSandboxWindowsFileSystem]: AgentHostSandboxKey.WindowsFileSystem,
+    [AgentSandboxSettingId.AgentSandboxAdvancedRuntime]: AgentHostSandboxKey.AdvancedRuntime,
+    [AgentNetworkDomainSettingId.AllowedNetworkDomains]: AgentHostSandboxKey.AllowedNetworkDomains,
+    [AgentNetworkDomainSettingId.DeniedNetworkDomains]: AgentHostSandboxKey.DeniedNetworkDomains
+};
+
+export { AgentHostSandboxConfigKey, AgentHostSandboxKey, sandboxSettingIdToAgentHostKey };

package/vscode/src/vs/platform/agentHost/common/state/agentSubscription.d.ts

@@ -4,7 +4,7 @@ import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ActionEnvelope, IRootConfigChangedAction, SessionAction, StateAction } from "./sessionActions.js";
 import type { TerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
-import type { RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { ChangesetState, RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 import type { IStateSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
 import { StateComponents } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 /**
@@ -36,6 +36,36 @@ export interface IAgentSubscription<T> {
     /** Fires after a server-originated action is applied to this subscription's state. */
     readonly onDidApplyAction: Event<ActionEnvelope>;
 }
+/**
+ * Read-only snapshot describing a single active resource subscription. Used by
+ * inspection/debug surfaces that enumerate everything a connection is currently
+ * subscribed to. Does not include the always-live root state.
+ */
+export interface IActiveSubscriptionInfo {
+    /** The protocol resource URI subscribed to. */
+    readonly resource: URI;
+    /** Which state component this subscription tracks. */
+    readonly kind: StateComponents;
+    /** Number of outstanding {@link IReference} holders. */
+    readonly refCount: number;
+    /**
+     * The named owners currently holding a reference to this subscription,
+     * with how many references each holds. Names come from the `owner`
+     * argument passed to {@link AgentSubscriptionManager.getSubscription}.
+     */
+    readonly holders: readonly IActiveSubscriptionHolder[];
+    /**
+     * Lifecycle status derived from the subscription's value:
+     * `pending` before the first snapshot, `error` if it failed, otherwise
+     * `snapshot`.
+     */
+    readonly status: "pending" | "snapshot" | "error";
+}
+/** A named owner holding one or more references to a subscription. */
+export interface IActiveSubscriptionHolder {
+    readonly owner: string;
+    readonly count: number;
+}
 /**
  * Base class for agent subscriptions. Handles envelope reception, confirmed
  * state management, and action event emission.
@@ -68,13 +98,13 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
     setError(error: Error): void;
     /**
      * Process an incoming action envelope. The subscription determines
-     * whether the action is relevant via {@link _isRelevantAction}.
+     * whether the action is relevant via {@link _isRelevantEnvelope}.
      */
     receiveEnvelope(envelope: ActionEnvelope): void;
     /** Apply the reducer to confirmed state. Subclasses must implement. */
     protected abstract _applyReducer(state: T, action: StateAction): T;
-    /** Whether the given action targets this subscription. */
-    protected abstract _isRelevantAction(action: StateAction): boolean;
+    /** Whether the given envelope targets this subscription. */
+    protected abstract _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
     /** Return optimistic state if write-ahead is active, otherwise `undefined`. */
     protected _getOptimisticState(): T | undefined;
     /** Hook called after a snapshot is applied. Replays buffered actions. */
@@ -91,7 +121,7 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
  */
 export declare class RootStateSubscription extends BaseAgentSubscription<RootState> {
     protected _applyReducer(state: RootState, action: StateAction): RootState;
-    protected _isRelevantAction(action: StateAction): boolean;
+    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
 }
 interface IPendingAction {
     readonly clientSeq: number;
@@ -118,9 +148,10 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<Sess
     applyOptimistic(action: SessionAction): number;
     protected _getOptimisticState(): SessionState | undefined;
     protected _applyReducer(state: SessionState, action: StateAction): SessionState;
-    protected _isRelevantAction(action: StateAction): boolean;
+    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
     protected _onSnapshotApplied(fromSeq: number): void;
     protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
+    private _promotePendingTurnStartIfTerminal;
     private _confirmedApply;
     private _recomputeOptimistic;
     /**
@@ -150,7 +181,26 @@ export declare class TerminalStateSubscription extends BaseAgentSubscription<Ter
     private readonly _terminalUri;
     constructor(terminalUri: string, clientId: string, log: (msg: string) => void);
     protected _applyReducer(state: TerminalState, action: StateAction): TerminalState;
-    protected _isRelevantAction(action: StateAction): boolean;
+    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
+}
+/**
+ * Subscription to a changeset at an expanded changeset URI (e.g.
+ * `<sessionUri>/changeset/session`).
+ *
+ * Server-only mutations — no write-ahead. The subscription itself does NOT
+ * self-tear-down on lifecycle events; cleanup is driven externally:
+ * - Workbench-side: `BaseAgentHostSessionsProvider._handleSessionRemoved`
+ *   disposes the per-session subscription map, which releases this
+ *   subscription's `IReference` and triggers `_releaseSubscription` on
+ *   the manager.
+ * - Wire layer: {@link IAgentConnection} refcounts the underlying server
+ *   subscription so multiple consumers can share one wire-level subscribe.
+ */
+export declare class ChangesetStateSubscription extends BaseAgentSubscription<ChangesetState> {
+    private readonly _changesetUri;
+    constructor(changesetUri: string, clientId: string, log: (msg: string) => void);
+    protected _applyReducer(state: ChangesetState, action: StateAction): ChangesetState;
+    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
 }
 /**
  * Manages the lifecycle of resource subscriptions for an agent connection.
@@ -164,6 +214,7 @@ export declare class TerminalStateSubscription extends BaseAgentSubscription<Ter
  */
 export declare class AgentSubscriptionManager extends Disposable {
     private readonly _subscriptions;
+    private _referenceOwnerIds;
     private readonly _rootState;
     private readonly _clientId;
     private readonly _seqAllocator;
@@ -187,8 +238,22 @@ export declare class AgentSubscriptionManager extends Disposable {
      * Get or create a refcounted subscription to any resource. Disposing
      * the returned reference decrements the refcount; when it reaches zero
      * the subscription is torn down and the server is notified.
+     *
+     * `owner` names the caller holding the reference so inspection surfaces
+     * (see {@link getActiveSubscriptions}) can attribute who is retaining a
+     * subscription. Use a stable, human-readable identifier such as the
+     * acquiring class name.
      */
-    getSubscription<T>(kind: StateComponents, resource: URI): IReference<IAgentSubscription<T>>;
+    getSubscription<T>(kind: StateComponents, resource: URI, owner: string): IReference<IAgentSubscription<T>>;
+    /**
+     * Register `owner` as a holder of `entry` and return a reference whose
+     * disposal removes that holder and releases the subscription. The
+     * caller is responsible for the matching refcount increment (a fresh
+     * entry starts at 1; an existing entry is bumped before calling this).
+     */
+    private _acquireReference;
+    private _disposeSubscriptionEntry;
+    private _tryUnsubscribe;
     /**
      * Route an incoming action envelope to all active subscriptions.
      */
@@ -196,8 +261,11 @@ export declare class AgentSubscriptionManager extends Disposable {
     /**
      * Dispatch a client action. Applies optimistically to the relevant
      * subscription if applicable, then returns the clientSeq.
+     *
+     * `channel` is the protocol URI string identifying the channel the
+     * action targets (a session URI for session actions, etc.).
      */
-    dispatchOptimistic(action: SessionAction | TerminalAction | IRootConfigChangedAction): number;
+    dispatchOptimistic(channel: string, action: SessionAction | TerminalAction | IRootConfigChangedAction): number;
     /**
      * URIs currently subscribed to via {@link getSubscription}. Used to
      * build the `subscriptions` payload for a `reconnect` RPC so the
@@ -207,6 +275,14 @@ export declare class AgentSubscriptionManager extends Disposable {
      * client manages separately.
      */
     currentSubscriptionUris(): URI[];
+    /**
+     * Read-only descriptors of every active resource subscription, for
+     * inspection/debug surfaces. Does NOT include the always-live root
+     * state, which the connection exposes separately via {@link rootState}.
+     */
+    getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
+    /** Group an entry's holders by owner name, sorted by descending count. */
+    private _summarizeHolders;
     /**
      * Snapshot of every pending optimistic action across all session
      * subscriptions. Callers use this to replay actions after a transport
@@ -228,7 +304,7 @@ export declare class AgentSubscriptionManager extends Disposable {
      * subscription when {@link ROOT_STATE_URI} matches, otherwise reseats the
      * matching entry in {@link _subscriptions}. Unknown resources are ignored.
      */
-    applyReconnectSnapshot(resource: URI, state: unknown, fromSeq: number): void;
+    applyReconnectSnapshot(resource: string, state: unknown, fromSeq: number): void;
     /**
      * Mark a set of subscriptions as no longer resumable on the server
      * (reported via `ReconnectReplayResult.missing`). The subscriptions

package/vscode/src/vs/platform/agentHost/common/state/agentSubscription.js

@@ -1,12 +1,17 @@
 
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 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 { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { isSessionAction } from './sessionActions.js';
-import { rootReducer, sessionReducer, terminalReducer } from './protocol/reducers.js';
-import { ROOT_STATE_URI, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { isSessionAction, isChangesetAction } from './sessionActions.js';
+import { rootReducer } from './protocol/channels-root/reducer.js';
+import { sessionReducer } from './protocol/channels-session/reducer.js';
+import { terminalReducer } from './protocol/channels-terminal/reducer.js';
+import { changesetReducer } from './protocol/channels-changeset/reducer.js';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { isAhpRootChannel, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
 class BaseAgentSubscription extends Disposable {
     constructor(clientId, log) {
@@ -39,7 +44,7 @@ class BaseAgentSubscription extends Disposable {
         this._error = error;
     }
     receiveEnvelope(envelope) {
-        if (!this._isRelevantAction(envelope.action)) {
+        if (!this._isRelevantEnvelope(envelope)) {
             return;
         }
         if (this._confirmedState === undefined) {
@@ -78,8 +83,8 @@ class RootStateSubscription extends BaseAgentSubscription {
     _applyReducer(state, action) {
         return rootReducer(state, action, this._log);
     }
-    _isRelevantAction(action) {
-        return action.type.startsWith("root/");
+    _isRelevantEnvelope(envelope) {
+        return isAhpRootChannel(envelope.channel) && envelope.action.type.startsWith("root/");
     }
 }
 class SessionStateSubscription extends BaseAgentSubscription {
@@ -108,8 +113,8 @@ class SessionStateSubscription extends BaseAgentSubscription {
     _applyReducer(state, action) {
         return sessionReducer(state, action, this._log);
     }
-    _isRelevantAction(action) {
-        return isSessionAction(action) && action.session === this._sessionUri;
+    _isRelevantEnvelope(envelope) {
+        return isSessionAction(envelope.action) && envelope.channel === this._sessionUri;
     }
     _onSnapshotApplied(fromSeq) {
         super._onSnapshotApplied(fromSeq);
@@ -129,10 +134,31 @@ class SessionStateSubscription extends BaseAgentSubscription {
                 this._confirmedApply(envelope.action);
             }
         } else {
+            this._promotePendingTurnStartIfTerminal(envelope.action);
             this._confirmedApply(envelope.action);
         }
         this._recomputeOptimistic();
     }
+    _promotePendingTurnStartIfTerminal(action) {
+        if (!isSessionAction(action)) {
+            return;
+        }
+        if (action.type !== ActionType.SessionTurnComplete && action.type !== ActionType.SessionTurnCancelled && action.type !== ActionType.SessionError) {
+            return;
+        }
+        const index = this._pendingActions.findIndex(
+            p => p.action.type === ActionType.SessionTurnStarted && p.action.turnId === action.turnId
+        );
+        if (index === -1) {
+            return;
+        }
+        const [{
+            action: pendingAction
+        }] = this._pendingActions.splice(index, 1);
+        if (this._confirmedState && (!this._confirmedState.activeTurn || this._confirmedState.activeTurn.id !== action.turnId)) {
+            this._confirmedState = this._applyReducer(this._confirmedState, pendingAction);
+        }
+    }
     _confirmedApply(action) {
         if (this._confirmedState) {
             this._confirmedState = this._applyReducer(this._confirmedState, action);
@@ -184,14 +210,27 @@ class TerminalStateSubscription extends BaseAgentSubscription {
     _applyReducer(state, action) {
         return terminalReducer(state, action, this._log);
     }
-    _isRelevantAction(action) {
-        return action.type.startsWith("terminal/") && action.terminal === this._terminalUri;
+    _isRelevantEnvelope(envelope) {
+        return envelope.action.type.startsWith("terminal/") && envelope.channel === this._terminalUri;
+    }
+}
+class ChangesetStateSubscription extends BaseAgentSubscription {
+    constructor(changesetUri, clientId, log) {
+        super(clientId, log);
+        this._changesetUri = changesetUri;
+    }
+    _applyReducer(state, action) {
+        return changesetReducer(state, action, this._log);
+    }
+    _isRelevantEnvelope(envelope) {
+        return isChangesetAction(envelope.action) && envelope.channel === this._changesetUri;
     }
 }
 class AgentSubscriptionManager extends Disposable {
     constructor(clientId, seqAllocator, log, subscribe, unsubscribe) {
         super();
         this._subscriptions = ( new ResourceMap());
+        this._referenceOwnerIds = 0;
         this._clientId = clientId;
         this._seqAllocator = seqAllocator;
         this._log = log;
@@ -209,20 +248,24 @@ class AgentSubscriptionManager extends Disposable {
         const entry = this._subscriptions.get(resource);
         return entry?.sub;
     }
-    getSubscription(kind, resource) {
+    getSubscription(kind, resource, owner) {
         const existing = this._subscriptions.get(resource);
         if (existing) {
-            existing.refCount++;
-            return {
-                object: existing.sub,
-                dispose: () => this._releaseSubscription(resource)
-            };
+            if (existing.sub.value instanceof Error) {
+                this._subscriptions.delete(resource);
+                this._disposeSubscriptionEntry(resource, existing);
+            } else {
+                existing.refCount++;
+                return this._acquireReference(resource, existing, owner);
+            }
         }
         const key = ( resource.toString());
         const sub = this._createSubscription(kind, key);
         const entry = {
             sub,
-            refCount: 1
+            kind,
+            refCount: 1,
+            holders: ( new Map())
         };
         this._subscriptions.set(resource, entry);
         this._subscribe(resource).then(snapshot => {
@@ -234,11 +277,39 @@ class AgentSubscriptionManager extends Disposable {
                 sub.setError(err instanceof Error ? err : ( new Error(String(err))));
             }
         });
+        return this._acquireReference(resource, entry, owner);
+    }
+    _acquireReference(resource, entry, owner) {
+        const ownerId = ++this._referenceOwnerIds;
+        entry.holders.set(ownerId, owner);
+        let isDisposed = false;
         return {
-            object: sub,
-            dispose: () => this._releaseSubscription(resource)
+            object: entry.sub,
+            dispose: () => {
+                if (isDisposed) {
+                    return;
+                }
+                isDisposed = true;
+                entry.holders.delete(ownerId);
+                this._releaseSubscription(resource, entry);
+            }
         };
     }
+    _disposeSubscriptionEntry(resource, entry) {
+        this._tryUnsubscribe(resource);
+        if (entry.sub instanceof SessionStateSubscription) {
+            entry.sub.clearPending();
+        }
+        entry.sub.dispose();
+    }
+    _tryUnsubscribe(resource) {
+        try {
+            this._unsubscribe(resource);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this._log(`Failed to unsubscribe ${( resource.toString())}: ${message}`);
+        }
+    }
     receiveEnvelope(envelope) {
         this._rootState.receiveEnvelope(envelope);
         for (const {
@@ -247,9 +318,9 @@ class AgentSubscriptionManager extends Disposable {
             sub.receiveEnvelope(envelope);
         }
     }
-    dispatchOptimistic(action) {
+    dispatchOptimistic(channel, action) {
         if (isSessionAction(action)) {
-            const entry = this._subscriptions.get(( URI.parse(action.session)));
+            const entry = this._subscriptions.get(( URI.parse(channel)));
             if (entry?.sub instanceof SessionStateSubscription) {
                 return entry.sub.applyOptimistic(action);
             }
@@ -259,6 +330,31 @@ class AgentSubscriptionManager extends Disposable {
     currentSubscriptionUris() {
         return [...( this._subscriptions.keys())];
     }
+    getActiveSubscriptions() {
+        const out = [];
+        for (const [resource, entry] of this._subscriptions) {
+            const value = entry.sub.value;
+            const status = value === undefined ? "pending" : value instanceof Error ? "error" : "snapshot";
+            out.push({
+                resource,
+                kind: entry.kind,
+                refCount: entry.refCount,
+                holders: this._summarizeHolders(entry),
+                status
+            });
+        }
+        return out;
+    }
+    _summarizeHolders(entry) {
+        const counts = ( new Map());
+        for (const owner of ( entry.holders.values())) {
+            counts.set(owner, (counts.get(owner) ?? 0) + 1);
+        }
+        return ( [...counts.entries()].map(([owner, count]) => ({
+            owner,
+            count
+        }))).sort((a, b) => b.count - a.count);
+    }
     getPendingSessionActions() {
         const out = [];
         for (const {
@@ -277,11 +373,11 @@ class AgentSubscriptionManager extends Disposable {
         }
     }
     applyReconnectSnapshot(resource, state, fromSeq) {
-        if (( resource.toString()) === ROOT_STATE_URI) {
+        if (isAhpRootChannel(resource)) {
             this._rootState.handleSnapshot(state, fromSeq);
             return;
         }
-        const entry = this._subscriptions.get(resource);
+        const entry = this._subscriptions.get(( URI.parse(resource)));
         if (!entry) {
             return;
         }
@@ -307,32 +403,28 @@ class AgentSubscriptionManager extends Disposable {
             return ( new SessionStateSubscription(key, this._clientId, this._seqAllocator, this._log));
         case StateComponents.Terminal:
             return ( new TerminalStateSubscription(key, this._clientId, this._log));
+        case StateComponents.Changeset:
+            return ( new ChangesetStateSubscription(key, this._clientId, this._log));
+        case StateComponents.Root:
+            throw ( new Error("_createSubscription: root subscription is managed separately"));
         default:
-            return ( new TerminalStateSubscription(key, this._clientId, this._log));
+            assertNever(kind, `_createSubscription: unsupported StateComponents kind: ${kind}`);
         }
     }
-    _releaseSubscription(resource) {
+    _releaseSubscription(resource, expected) {
         const entry = this._subscriptions.get(resource);
-        if (!entry) {
+        if (!entry || (expected && entry !== expected)) {
             return;
         }
         entry.refCount--;
         if (entry.refCount <= 0) {
             this._subscriptions.delete(resource);
-            try {
-                this._unsubscribe(resource);
-            } catch {}
-            if (entry.sub instanceof SessionStateSubscription) {
-                entry.sub.clearPending();
-            }
-            entry.sub.dispose();
+            this._disposeSubscriptionEntry(resource, entry);
         }
     }
     dispose() {
         for (const [resource, entry] of this._subscriptions) {
-            try {
-                this._unsubscribe(resource);
-            } catch {}
+            this._tryUnsubscribe(resource);
             entry.sub.dispose();
         }
         this._subscriptions.clear();
@@ -340,4 +432,4 @@ class AgentSubscriptionManager extends Disposable {
     }
 }
 
-export { AgentSubscriptionManager, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription };
+export { AgentSubscriptionManager, ChangesetStateSubscription, RootStateSubscription, SessionStateSubscription, TerminalStateSubscription };