@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/chat/browser/unifiedWorkspacePickerConfiguration.js

@@ -0,0 +1,17 @@
+
+import { UNIFIED_WORKSPACE_PICKER_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/common/constants';
+
+const LEGACY_UNIFIED_WORKSPACE_PICKER_SETTING = 'chat.agentSessions.consolidatedRemoteWorkspaces';
+const unifiedWorkspacePickerConfigurationMigration = {
+    key: LEGACY_UNIFIED_WORKSPACE_PICKER_SETTING,
+    includeApplication: true,
+    migrateFn: (value, accessor) => {
+        const pairs = [[LEGACY_UNIFIED_WORKSPACE_PICKER_SETTING, { value: undefined }]];
+        if (accessor(UNIFIED_WORKSPACE_PICKER_SETTING) === undefined) {
+            pairs.push([UNIFIED_WORKSPACE_PICKER_SETTING, { value }]);
+        }
+        return pairs;
+    },
+};
+
+export { LEGACY_UNIFIED_WORKSPACE_PICKER_SETTING, unifiedWorkspacePickerConfigurationMigration };

package/vscode/src/vs/sessions/contrib/chat/browser/voiceBridge.contribution.d.ts

@@ -0,0 +1,14 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { VoiceNewSessionPreparationResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController";
+import { IVoiceSessionController } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { INewChatVoiceTargetService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatVoice.service";
+export declare function prepareNewVoiceSession(text: string, sessionsService: ISessionsService, sessionsManagementService: ISessionsManagementService, voiceSessionController: IVoiceSessionController, hasActiveComposer: () => boolean, beginVoiceTransition: () => IDisposable, logService: ILogService): Promise<VoiceNewSessionPreparationResult>;
+/** Ends voice when a different welcome composer becomes active; routing in-session composers are exempt. */
+export declare class SessionsVoiceNewComposerContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "sessions.voiceNewComposer";
+    constructor(voiceSessionController: IVoiceSessionController, newChatVoiceTargetService: INewChatVoiceTargetService);
+}

package/vscode/src/vs/sessions/contrib/chat/browser/voiceBridge.contribution.js

@@ -0,0 +1,381 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IVoiceSessionController } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service';
+import { combineVoiceInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceInputUtils';
+import { resolveVoiceModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { inheritableSessionTarget } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { NEW_CHAT_VOICE_SENTINEL } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatVoice';
+import { INewChatVoiceTargetService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatVoice.service';
+import { INewSessionComposerService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newSessionComposerService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+async function prepareNewVoiceSession(
+    text,
+    sessionsService,
+    sessionsManagementService,
+    voiceSessionController,
+    hasActiveComposer,
+    beginVoiceTransition,
+    logService
+) {
+    const activeSession = sessionsService.activeSession.get();
+    const isQuickChat = activeSession?.isQuickChat?.get() ?? false;
+    const folderUri = isQuickChat ? undefined : activeSession?.workspace.get()?.uri;
+    const previousTarget = voiceSessionController.targetSession.get();
+    const previousHadDraftTarget = voiceSessionController.hasDraftTarget.get();
+    const restoreVoiceTarget = () => previousHadDraftTarget ? voiceSessionController.setDraftTarget() : voiceSessionController.setTargetSession(previousTarget);
+    const fail = () => {
+        restoreVoiceTarget();
+        return "failed";
+    };
+    voiceSessionController.setDraftTarget();
+    const transition = beginVoiceTransition();
+    try {
+        const result = await sessionsService.openNewSession({
+            folderUri,
+            ...inheritableSessionTarget(sessionsManagementService, activeSession, folderUri)
+        });
+        if (folderUri) {
+            if (!result.session) {
+                return fail();
+            }
+            if (text.trim()) {
+                await sessionsManagementService.sendNewChatRequest(result.session, {
+                    query: text
+                });
+                return "sent";
+            }
+            return "prepared";
+        }
+        return sessionsService.activeSession.get() === undefined && hasActiveComposer() ? "prepared" : fail();
+    } catch (error) {
+        logService.error("Failed to prepare a new session for Voice Mode:", error);
+        return fail();
+    } finally {
+        transition.dispose();
+    }
+}
+let SessionsVoiceBridgeContribution = class SessionsVoiceBridgeContribution extends Disposable {
+    static {
+        this.ID = "sessions.voiceBridge";
+    }
+    constructor(
+        configurationService,
+        chatWidgetService,
+        sessionsService,
+        sessionsManagementService,
+        newChatVoiceTargetService,
+        voiceSessionController,
+        newSessionComposerService,
+        logService
+    ) {
+        super();
+        this.configurationService = configurationService;
+        this.chatWidgetService = chatWidgetService;
+        this.sessionsService = sessionsService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.newChatVoiceTargetService = newChatVoiceTargetService;
+        this.voiceSessionController = voiceSessionController;
+        this.newSessionComposerService = newSessionComposerService;
+        this.logService = logService;
+        this._commandDisposables = this._register(( new DisposableStore()));
+        this._updateCommands();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("agents.voice.enabled")) {
+                this._updateCommands();
+            }
+        }));
+    }
+    _updateCommands() {
+        this._commandDisposables.clear();
+        if (this.configurationService.getValue("agents.voice.enabled") !== true) {
+            return;
+        }
+        this._commandDisposables.add(
+            CommandsRegistry.registerCommand("_chat.voice.acceptInput", (_accessor, text) => {
+                if (!text) {
+                    return;
+                }
+                const composer = this._activeComposerTarget();
+                if (composer) {
+                    composer.sendQuery(text);
+                    return;
+                }
+                const widget = this._activeSessionWidget() ?? this.chatWidgetService.lastFocusedWidget;
+                if (widget?.viewModel) {
+                    if (widget.viewModel.editing) {
+                        widget.input.setValue(text, false);
+                    } else {
+                        widget.acceptInput(combineVoiceInput(widget.getInput(), text), {
+                            preserveFocus: true
+                        });
+                    }
+                }
+            })
+        );
+        this._commandDisposables.add(CommandsRegistry.registerCommand("_chat.voice.getCurrentSession", () => {
+            if (this._activeComposerTarget()) {
+                return ( NEW_CHAT_VOICE_SENTINEL.toString());
+            }
+            const activeChat = this._createdActiveChatResource();
+            if (activeChat) {
+                return ( activeChat.toString());
+            }
+            return this.chatWidgetService.lastFocusedWidget?.viewModel?.sessionResource?.toString();
+        }));
+        this._commandDisposables.add(
+            CommandsRegistry.registerCommand("_chat.voice.prepareNewSession", (_accessor, text) => {
+                this.newSessionComposerService.notifyUserNavigation();
+                return prepareNewVoiceSession(
+                    text,
+                    this.sessionsService,
+                    this.sessionsManagementService,
+                    this.voiceSessionController,
+                    () => !!this._activeComposerTarget(),
+                    () => this.newChatVoiceTargetService.beginVoiceTransition(),
+                    this.logService
+                );
+            })
+        );
+        this._commandDisposables.add(
+            CommandsRegistry.registerCommand("_chat.voice.selectModel", (_accessor, requestedModel) => {
+                const composer = this._activeComposerTarget();
+                const widget = composer ? undefined : this._activeSessionWidget() ?? this.chatWidgetService.lastFocusedWidget;
+                const models = composer?.getVoiceModels() ?? widget?.inputPart.availableLanguageModels;
+                if (!models) {
+                    return {
+                        ok: false,
+                        reason: "no_input"
+                    };
+                }
+                const resolved = resolveVoiceModel(models, requestedModel);
+                if (!resolved.ok || !resolved.identifier) {
+                    return resolved;
+                }
+                const selected = composer ? composer.selectVoiceModel(resolved.identifier) : widget.inputPart.switchModelByIdentifier(resolved.identifier, true, true);
+                return selected ? resolved : {
+                    ok: false,
+                    reason: "selection_failed",
+                    available_models: resolved.available_models
+                };
+            })
+        );
+        this._commandDisposables.add(
+            CommandsRegistry.registerCommand("_chat.voice.switchToSession", async (_accessor, resourceStr) => {
+                if (!resourceStr) {
+                    return false;
+                }
+                if (resourceStr === ( NEW_CHAT_VOICE_SENTINEL.toString())) {
+                    const composer = this._activeComposerTarget();
+                    composer?.focus();
+                    return !!composer;
+                }
+                let resource;
+                try {
+                    resource = ( URI.parse(resourceStr));
+                } catch {
+                    return false;
+                }
+                const owner = this.sessionsManagementService.getSessionForChatResource(resource);
+                if (owner) {
+                    await this.sessionsService.openSession(owner.session.resource, {
+                        preserveFocus: true,
+                        source: "voice"
+                    });
+                    if (!isEqual(owner.chat.resource, owner.session.resource)) {
+                        await this.sessionsService.openChat(owner.session, owner.chat.resource);
+                    }
+                    return true;
+                }
+                const session = this.sessionsManagementService.getSession(resource);
+                if (session) {
+                    await this.sessionsService.openSession(session.resource, {
+                        preserveFocus: true,
+                        source: "voice"
+                    });
+                    return true;
+                }
+                try {
+                    await this.sessionsService.openSession(resource, {
+                        preserveFocus: true,
+                        source: "voice"
+                    });
+                    return true;
+                } catch {
+                    return false;
+                }
+            })
+        );
+        this._commandDisposables.add(
+            CommandsRegistry.registerCommand("_chat.voice.activateSession", (_accessor, resourceStr) => {
+                if (!resourceStr || resourceStr === ( NEW_CHAT_VOICE_SENTINEL.toString())) {
+                    return false;
+                }
+                let resource;
+                try {
+                    resource = ( URI.parse(resourceStr));
+                } catch {
+                    return false;
+                }
+                this.voiceSessionController.activateSession(resource);
+                return true;
+            })
+        );
+    }
+    _createdActiveChatResource() {
+        const active = this.sessionsService.activeSession.get();
+        return active?.isCreated.get() ? active.activeChat.get()?.resource : undefined;
+    }
+    _activeSessionWidget() {
+        const resource = this._createdActiveChatResource();
+        return resource ? this.chatWidgetService.getWidgetBySessionResource(resource) : undefined;
+    }
+    _activeComposerTarget() {
+        const composer = this.newChatVoiceTargetService.activeComposer.get();
+        if (!composer) {
+            return undefined;
+        }
+        if (composer.routesWhileSessionActive || !this._createdActiveChatResource()) {
+            return composer;
+        }
+        return undefined;
+    }
+};
+SessionsVoiceBridgeContribution = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IChatWidgetService)), ( __param(2, ISessionsService)), ( __param(3, ISessionsManagementService)), ( __param(4, INewChatVoiceTargetService)), ( __param(5, IVoiceSessionController)), ( __param(6, INewSessionComposerService)), ( __param(7, ILogService))], SessionsVoiceBridgeContribution));
+registerWorkbenchContribution2(
+    SessionsVoiceBridgeContribution.ID,
+    SessionsVoiceBridgeContribution,
+    WorkbenchPhase.AfterRestored
+);
+let SessionsVoiceActiveSessionContribution = class SessionsVoiceActiveSessionContribution extends Disposable {
+    static {
+        this.ID = "sessions.voiceActiveSession";
+    }
+    constructor(voiceSessionController, sessionsService) {
+        super();
+        this.voiceSessionController = voiceSessionController;
+        this.sessionsService = sessionsService;
+        let voiceDraftSession;
+        this._register(autorun(reader => {
+            const active = this.sessionsService.activeSession.read(reader);
+            const hasDraftTarget = this.voiceSessionController.hasDraftTarget.read(reader);
+            if (!hasDraftTarget) {
+                voiceDraftSession = undefined;
+            } else if (!voiceDraftSession && active && !active.isCreated.read(reader)) {
+                voiceDraftSession = active;
+            }
+            if (voiceDraftSession?.isCreated.read(reader)) {
+                this.voiceSessionController.promoteDraftTarget(voiceDraftSession.activeChat.read(reader).resource);
+                voiceDraftSession = undefined;
+            }
+            if (!active) {
+                this.voiceSessionController.setActiveSessionShown(undefined);
+                return;
+            }
+            if (!active.isCreated.read(reader)) {
+                this.voiceSessionController.setActiveSessionShown(null);
+                return;
+            }
+            this.voiceSessionController.setActiveSessionShown(active.activeChat.read(reader)?.resource);
+        }));
+    }
+};
+SessionsVoiceActiveSessionContribution = ( __decorate([( __param(0, IVoiceSessionController)), ( __param(1, ISessionsService))], SessionsVoiceActiveSessionContribution));
+registerWorkbenchContribution2(
+    SessionsVoiceActiveSessionContribution.ID,
+    SessionsVoiceActiveSessionContribution,
+    WorkbenchPhase.AfterRestored
+);
+let SessionsVoiceListeningContribution = class SessionsVoiceListeningContribution extends Disposable {
+    static {
+        this.ID = "sessions.voiceListening";
+    }
+    constructor(voiceSessionController, sessionsService) {
+        super();
+        let listeningSession;
+        this._register(autorun(reader => {
+            const connected = voiceSessionController.isConnected.read(reader);
+            const voiceState = voiceSessionController.voiceState.read(reader);
+            const targetSession = voiceSessionController.targetSession.read(reader);
+            const turns = voiceSessionController.transcriptTurns.read(reader);
+            const activeSession = sessionsService.activeSession.read(reader);
+            const currentSession = activeSession?.activeChat.read(reader)?.resource;
+            if (!connected) {
+                listeningSession = undefined;
+                return;
+            }
+            if (voiceState !== "listening") {
+                listeningSession = undefined;
+                return;
+            }
+            if (!listeningSession) {
+                listeningSession = targetSession ?? currentSession;
+            } else if (!targetSession && currentSession && !isEqual(currentSession, listeningSession)) {
+                const dictationSession = listeningSession;
+                const activelyDictating = ( turns.some(t => t.speaker === "user" && t.isPartial && t.text.trim().length > 0));
+                if (activelyDictating) {
+                    voiceSessionController.finishListeningAndSubmitTo(dictationSession);
+                } else {
+                    voiceSessionController.discardListening();
+                }
+                listeningSession = undefined;
+            }
+        }));
+    }
+};
+SessionsVoiceListeningContribution = ( __decorate([( __param(0, IVoiceSessionController)), ( __param(1, ISessionsService))], SessionsVoiceListeningContribution));
+registerWorkbenchContribution2(
+    SessionsVoiceListeningContribution.ID,
+    SessionsVoiceListeningContribution,
+    WorkbenchPhase.Eventually
+);
+let SessionsVoiceNewComposerContribution = class SessionsVoiceNewComposerContribution extends Disposable {
+    static {
+        this.ID = "sessions.voiceNewComposer";
+    }
+    constructor(voiceSessionController, newChatVoiceTargetService) {
+        super();
+        let voiceComposer;
+        let voiceComposerCaptured = false;
+        this._register(autorun(reader => {
+            const connected = voiceSessionController.isConnected.read(reader) || voiceSessionController.isConnecting.read(reader);
+            const activeComposer = newChatVoiceTargetService.activeComposer.read(reader);
+            if (!connected) {
+                voiceComposer = activeComposer;
+                voiceComposerCaptured = false;
+                return;
+            }
+            if (!voiceComposerCaptured) {
+                voiceComposer = activeComposer;
+                voiceComposerCaptured = true;
+                return;
+            }
+            if (activeComposer && activeComposer !== voiceComposer) {
+                if (newChatVoiceTargetService.consumeVoiceTransition()) {
+                    voiceComposer = activeComposer;
+                } else if (!activeComposer.routesWhileSessionActive) {
+                    voiceSessionController.disconnect("internal");
+                }
+            }
+        }));
+    }
+};
+SessionsVoiceNewComposerContribution = ( __decorate([( __param(0, IVoiceSessionController)), ( __param(1, INewChatVoiceTargetService))], SessionsVoiceNewComposerContribution));
+registerWorkbenchContribution2(
+    SessionsVoiceNewComposerContribution.ID,
+    SessionsVoiceNewComposerContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { SessionsVoiceNewComposerContribution, prepareNewVoiceSession };

package/vscode/src/vs/sessions/contrib/chat/browser/workbenchSessionTaskRunner.d.ts

@@ -0,0 +1,23 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionTaskRunner } from "@codingame/monaco-vscode-workbench-service-override/vscode/vs/sessions/contrib/chat/browser/sessionTaskRunner";
+import { ITaskEntry } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService";
+/**
+ * Default task runner that delegates to the workbench `ITaskService`. Used
+ * for sessions whose workspace is a real local folder loaded into the
+ * workbench (so the Tasks extension can run them). Acts as the lowest-priority
+ * fallback when no specialized runner (e.g. for an agent host) claims the
+ * session.
+ */
+export declare class WorkbenchSessionTaskRunner implements ISessionTaskRunner {
+    private readonly _taskService;
+    private readonly _workspaceContextService;
+    readonly id = "workbench";
+    readonly priority = 0;
+    constructor(_taskService: ITaskService, _workspaceContextService: IWorkspaceContextService);
+    canRun(session: ISession): boolean;
+    runTask(task: ITaskEntry, session: ISession): Promise<IDisposable | undefined>;
+    private _getCwd;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/workbenchSessionTaskRunner.js

@@ -0,0 +1,48 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { TaskRunSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks';
+import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
+
+let WorkbenchSessionTaskRunner = class WorkbenchSessionTaskRunner {
+    constructor(_taskService, _workspaceContextService) {
+        this._taskService = _taskService;
+        this._workspaceContextService = _workspaceContextService;
+        this.id = "workbench";
+        this.priority = 0;
+    }
+    canRun(session) {
+        const cwd = this._getCwd(session);
+        if (!cwd || cwd.scheme !== Schemas.file) {
+            return false;
+        }
+        return !!this._workspaceContextService.getWorkspaceFolder(cwd);
+    }
+    async runTask(task, session) {
+        const cwd = this._getCwd(session);
+        if (!cwd) {
+            return undefined;
+        }
+        const workspaceFolder = this._workspaceContextService.getWorkspaceFolder(cwd);
+        if (!workspaceFolder) {
+            return undefined;
+        }
+        const resolved = await this._taskService.getTask(workspaceFolder, task.label);
+        if (!resolved) {
+            return undefined;
+        }
+        await this._taskService.run(resolved, undefined, TaskRunSource.User);
+        return toDisposable(() => {
+            this._taskService.terminate(resolved);
+        });
+    }
+    _getCwd(session) {
+        const repo = session.workspace.get()?.folders[0];
+        return repo?.workingDirectory ?? repo?.root;
+    }
+};
+WorkbenchSessionTaskRunner = ( __decorate([( __param(0, ITaskService)), ( __param(1, IWorkspaceContextService))], WorkbenchSessionTaskRunner));
+
+export { WorkbenchSessionTaskRunner };

package/vscode/src/vs/sessions/contrib/chat/browser/worktreeCreatedTaskDispatcher.d.ts

@@ -0,0 +1,40 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsTasksService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService.service";
+/**
+ * Setting that controls whether `runOptions.runOn === 'worktreeCreated'`
+ * tasks are auto-dispatched for agent host sessions when a new worktree is
+ * created. Defaults to `true`. Manual `Run Task` invocations are unaffected.
+ */
+export declare const AGENT_HOST_RUN_WORKTREE_CREATED_TASKS_SETTING = "chat.agentHost.runWorktreeCreatedTasks";
+/**
+ * Workbench contribution that runs all tasks tagged with
+ * `runOptions.runOn === 'worktreeCreated'` once per newly-created session,
+ * when the session first reports an actual git worktree.
+ *
+ * Sessions whose runtime already runs these tasks server-side (signalled via
+ * {@link ISessionCapabilities.runsWorktreeCreatedTasks}) are skipped to avoid
+ * double-execution.
+ *
+ * The stop handles returned by the dispatched tasks are tracked per session and
+ * disposed when the session is marked done (archived) or removed, so the
+ * long-running setup/build processes don't leak. See #321021.
+ *
+ * We deliberately ignore sessions that predate this contribution so restored
+ * sessions don't re-run setup tasks when the agents window opens.
+ */
+export declare class WorktreeCreatedTaskDispatcher extends Disposable implements IWorkbenchContribution {
+    private readonly _sessionsManagementService;
+    private readonly _sessionsTasksService;
+    private readonly _configurationService;
+    private readonly _logService;
+    static readonly ID = "workbench.contrib.sessions.worktreeCreatedTaskDispatcher";
+    private readonly _sessionDisposables;
+    constructor(_sessionsManagementService: ISessionsManagementService, _sessionsTasksService: ISessionsTasksService, _configurationService: IConfigurationService, _logService: ILogService);
+    private _onDidRemoveSessions;
+    private _trackSession;
+    private _dispatchWorktreeCreatedTasks;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/worktreeCreatedTaskDispatcher.js

@@ -0,0 +1,116 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isAgentHostProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsTasksService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService.service';
+import { registerAutorunSelfDisposable, autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const LOG_PREFIX = "[WorktreeCreatedTaskDispatcher]";
+const AGENT_HOST_RUN_WORKTREE_CREATED_TASKS_SETTING = "chat.agentHost.runWorktreeCreatedTasks";
+let WorktreeCreatedTaskDispatcher = class WorktreeCreatedTaskDispatcher extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.worktreeCreatedTaskDispatcher";
+    }
+    constructor(
+        _sessionsManagementService,
+        _sessionsTasksService,
+        _configurationService,
+        _logService
+    ) {
+        super();
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsTasksService = _sessionsTasksService;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this._sessionDisposables = this._register(( new DisposableMap()));
+        this._register(
+            this._sessionsManagementService.onDidStartSession(session => this._trackSession(session))
+        );
+        this._register(
+            this._sessionsManagementService.onDidChangeSessions(e => this._onDidRemoveSessions(e.removed))
+        );
+    }
+    _onDidRemoveSessions(removed) {
+        for (const session of removed) {
+            this._sessionDisposables.deleteAndDispose(session.sessionId);
+        }
+    }
+    _trackSession(session) {
+        if (session.capabilities.get().runsWorktreeCreatedTasks) {
+            return;
+        }
+        if (this._sessionDisposables.get(session.sessionId)) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        this._sessionDisposables.set(session.sessionId, store);
+        const taskHandles = store.add(( new DisposableStore()));
+        registerAutorunSelfDisposable(store, reader => {
+            if (session.loading.read(reader)) {
+                return;
+            }
+            if (session.status.read(reader) === SessionStatus.Untitled) {
+                return;
+            }
+            if (!session.workspace.read(reader)?.folders.some(folder => !!folder.gitRepository?.workTreeUri)) {
+                return;
+            }
+            reader.dispose();
+            this._dispatchWorktreeCreatedTasks(session, taskHandles);
+        });
+        store.add(autorun(reader => {
+            if (session.isArchived.read(reader)) {
+                taskHandles.clear();
+            }
+        }));
+    }
+    async _dispatchWorktreeCreatedTasks(session, taskHandles) {
+        if (isAgentHostProviderId(session.providerId) && !this._configurationService.getValue(AGENT_HOST_RUN_WORKTREE_CREATED_TASKS_SETTING)) {
+            this._logService.trace(
+                `${LOG_PREFIX} Skipping worktreeCreated tasks for agent host session '${session.sessionId}' — '${AGENT_HOST_RUN_WORKTREE_CREATED_TASKS_SETTING}' is disabled.`
+            );
+            return;
+        }
+        let tasks;
+        try {
+            tasks = await this._sessionsTasksService.getSessionTasksOnce(session);
+        } catch (err) {
+            this._logService.warn(
+                `${LOG_PREFIX} Failed to read tasks for session '${session.sessionId}': ${err}`
+            );
+            return;
+        }
+        for (const {
+            task
+        } of tasks) {
+            if (task.runOptions?.runOn !== "worktreeCreated") {
+                continue;
+            }
+            this._logService.trace(
+                `${LOG_PREFIX} Running worktreeCreated task '${task.label}' for session '${session.sessionId}'`
+            );
+            try {
+                const handle = await this._sessionsTasksService.runTask(task, session);
+                if (handle) {
+                    if (session.isArchived.get()) {
+                        handle.dispose();
+                    } else {
+                        taskHandles.add(handle);
+                    }
+                }
+            } catch (err) {
+                this._logService.warn(
+                    `${LOG_PREFIX} Failed to run task '${task.label}' for session '${session.sessionId}': ${err}`
+                );
+            }
+        }
+    }
+};
+WorktreeCreatedTaskDispatcher = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsTasksService)), ( __param(2, IConfigurationService)), ( __param(3, ILogService))], WorktreeCreatedTaskDispatcher));
+
+export { AGENT_HOST_RUN_WORKTREE_CREATED_TASKS_SETTING, WorktreeCreatedTaskDispatcher };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostAgentPicker.d.ts

@@ -0,0 +1 @@
+export {};