@codingame/monaco-vscode-workbench-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/automations/browser/automationDialog.js

@@ -0,0 +1,1589 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, isEditableElement, addDisposableListener, EventType, clearNode, append, getWindow, hide, DisposableResizeObserver, addStandardDisposableListener, show } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { raceCancellationError, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { InputBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { SelectBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/selectBox/selectBox';
+import { Checkbox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { DisposableStore, Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { EditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { SuggestController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/suggest/browser/suggestController';
+import { Context } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/suggest/browser/suggest';
+import { State } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/suggest/browser/suggestModel';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ActionListItemKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { KeybindingsRegistry, KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { defaultInputBoxStyles, defaultSelectBoxStyles, defaultCheckboxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { hasNativeContextMenu } from '@codingame/monaco-vscode-api/vscode/vs/platform/window/common/window';
+import { WorkspacePicker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionWorkspacePicker';
+import { BranchPicker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/branchPicker';
+import { MobileSessionTypePicker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/mobile/mobileSessionTypePicker';
+import { isMobilePickerSheetTarget } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobilePickerSheet';
+import { SESSION_WORKSPACE_GROUP_LOCAL } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { IGitService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/gitService.service';
+import { DAYS_OF_WEEK } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/schedule';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatInputPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputPart';
+import { ChatInputPickerResponsiveLayout } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputPickerResponsiveLayout';
+import { normalizeAutomationBranchNames, AutomationIsolationModel } from '../common/isolationGroupModel.js';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { shouldUseMobileWorkspacePickerSheet, showMobileWorkspacePickerSheet } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/mobile/mobileWorkspacePickerSheet';
+import { AutomationInputCompletions } from './automationInputCompletions.js';
+import { NewChatModelPickerService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatModelPicker';
+import { INewChatModelPickerService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newChatModelPicker.service';
+import { createNewSessionConfigToolbar, createNewSessionControlToolbar } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newSessionConfigToolbars';
+import { SessionModelSelection } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionModelSelection';
+import { ISessionModelSelection } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionModelSelection.service';
+import { SessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+import { VisibleSession } from '../../../services/sessions/browser/visibleSessions.js';
+import { setActiveSessionContextKeys } from '../../../services/sessions/common/sessionContextKeys.js';
+import { SessionUsesCombinedConfigPickerContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableValue, disposableObservableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+
+const $ = $$1;
+const INTERVALS = [{
+    value: "manual",
+    label: ( localize(3272, "Manual"))
+}, {
+    value: "hourly",
+    label: ( localize(3273, "Hourly"))
+}, {
+    value: "daily",
+    label: ( localize(3274, "Daily"))
+}, {
+    value: "weekly",
+    label: ( localize(3275, "Weekly"))
+}];
+function isAutomationDialogPopupTarget(relatedTarget) {
+    return isMobilePickerSheetTarget(relatedTarget) || !!relatedTarget.closest(
+        ".context-view, .quick-input-widget, .monaco-menu-container, .monaco-hover, .monaco-hover-content, .suggest-widget"
+    );
+}
+function shouldPassThroughAutomationDialogCommand(commandId, target) {
+    return commandId === "acceptSelectedSuggestion" || ((commandId === "undo" || commandId === "redo") && isEditableElement(target));
+}
+async function canSelectAutomationWorkspace(
+    folderUri,
+    preferredProviderId,
+    sessionsManagementService,
+    workspaceTrustRequestService
+) {
+    const resolved = sessionsManagementService.resolveWorkspace(folderUri, preferredProviderId);
+    if (!resolved) {
+        return false;
+    }
+    if (!resolved.workspace.requiresWorkspaceTrust) {
+        return true;
+    }
+    return !!(await workspaceTrustRequestService.requestResourcesTrust({
+        uri: folderUri,
+        message: ( localize(
+            3276,
+            "An agent session will be able to read files, run commands, and make changes in this folder."
+        ))
+    }));
+}
+function registerAutomationDialogKeyboardNavigation(
+    targetWindow,
+    getFocusableElements,
+    isPopupTarget,
+    acceptPromptSuggestion = () => false,
+    cancelPromptSuggestion = () => false
+) {
+    const store = ( new DisposableStore());
+    let suppressPopupEscapeKeyUp = false;
+    const visibleFocusableElements = () => getFocusableElements().filter(element => {
+        if (!element.isConnected || element.tabIndex < 0 || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") {
+            return false;
+        }
+        for (let current = element; current; current = current.parentElement) {
+            if (current.hidden || current.hasAttribute("inert") || current.getAttribute("aria-hidden") === "true") {
+                return false;
+            }
+            const style = targetWindow.getComputedStyle(current);
+            if (style.display === "none" || style.visibility === "hidden") {
+                return false;
+            }
+        }
+        return true;
+    });
+    store.add(addDisposableListener(targetWindow, EventType.KEY_DOWN, event => {
+        const target = event.target;
+        const isPopup = target instanceof targetWindow.HTMLElement && isPopupTarget(target);
+        if (event.key === "Escape" && !event.repeat) {
+            const promptSuggestionCancelled = !isPopup && !event.altKey && !event.ctrlKey && !event.metaKey && cancelPromptSuggestion();
+            suppressPopupEscapeKeyUp = isPopup || promptSuggestionCancelled;
+            if (promptSuggestionCancelled) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                return;
+            }
+        }
+        if (isPopup) {
+            return;
+        }
+        if (event.key !== "Tab") {
+            return;
+        }
+        if (!event.shiftKey && acceptPromptSuggestion()) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            return;
+        }
+        const focusableElements = visibleFocusableElements();
+        if (focusableElements.length === 0) {
+            return;
+        }
+        const activeElement = targetWindow.document.activeElement;
+        let focusedIndex = focusableElements.findIndex(element => element === activeElement);
+        if (focusedIndex < 0) {
+            focusedIndex = focusableElements.findIndex(element => !!activeElement && element.contains(activeElement));
+        }
+        if (focusedIndex < 0) {
+            focusedIndex = event.shiftKey ? 0 : -1;
+        }
+        const nextIndex = event.shiftKey ? (focusedIndex - 1 + focusableElements.length) % focusableElements.length : (focusedIndex + 1) % focusableElements.length;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        focusableElements[nextIndex].focus();
+    }, true));
+    store.add(addDisposableListener(targetWindow, EventType.KEY_UP, event => {
+        if (event.key === "Escape") {
+            if (suppressPopupEscapeKeyUp) {
+                event.stopImmediatePropagation();
+            }
+            suppressPopupEscapeKeyUp = false;
+        }
+    }, true));
+    return {
+        focusFirst: () => visibleFocusableElements()[0]?.focus(),
+        dispose: () => store.dispose()
+    };
+}
+const AUTOMATION_CONFIGURATION_CAPTURE_TIMEOUT_MS = 5_000;
+const AUTOMATION_CONFIGURATION_RETARGET_CAPTURE_TIMEOUT_MS = 1_000;
+class AutomationSessionDraftSynchronizer extends Disposable {
+    constructor(
+        sessionsManagementService,
+        canSelectWorkspace,
+        onError,
+        configurationCaptureTimeoutMs = AUTOMATION_CONFIGURATION_CAPTURE_TIMEOUT_MS,
+        retargetConfigurationCaptureTimeoutMs = AUTOMATION_CONFIGURATION_RETARGET_CAPTURE_TIMEOUT_MS
+    ) {
+        super();
+        this.sessionsManagementService = sessionsManagementService;
+        this.canSelectWorkspace = canSelectWorkspace;
+        this.onError = onError;
+        this.configurationCaptureTimeoutMs = configurationCaptureTimeoutMs;
+        this.retargetConfigurationCaptureTimeoutMs = retargetConfigurationCaptureTimeoutMs;
+        this.availability = observableValue(this, "idle");
+        this.configurationsByTarget = ( new Map());
+        this.generation = 0;
+        this.syncScheduled = false;
+        this.syncInProgress = false;
+        this.syncPromise = Promise.resolve();
+        this.disposed = false;
+    }
+    update(target) {
+        if (this.targetsEqual(this.requestedTarget, target) && (!target || this.syncScheduled || this.syncInProgress || !!this.session && this.sessionsManagementService.automationSession.get()?.sessionId === this.session.sessionId)) {
+            return;
+        }
+        if (target?.sessionConfiguration) {
+            const key = this.targetKey(target);
+            if (!( this.configurationsByTarget.has(key))) {
+                this.configurationsByTarget.set(key, target.sessionConfiguration);
+            }
+        }
+        this.requestedTarget = target;
+        this.generation++;
+        this.synchronizationError = undefined;
+        this.availability.set(target ? "pending" : "idle", undefined);
+        this.scheduleSync();
+    }
+    async waitForSync(token = CancellationToken.None) {
+        let pendingSync;
+        do {
+            pendingSync = this.syncPromise;
+            await raceCancellationError(pendingSync, token);
+        } while (pendingSync !== this.syncPromise);
+    }
+    async getSessionConfiguration(token = CancellationToken.None) {
+        const deadline = Date.now() + this.configurationCaptureTimeoutMs;
+        while (!this.disposed) {
+            const synchronized = await this.waitForResultBeforeDeadline(this.waitForSync(token), deadline, token);
+            if (!synchronized) {
+                return this.captureFailed(( new Error(
+                    `Timed out after ${this.configurationCaptureTimeoutMs}ms while synchronizing the Automation session configuration.`
+                )));
+            }
+            const generation = this.generation;
+            const session = this.session;
+            const target = this.requestedTarget;
+            if (!session || !target) {
+                if (this.synchronizationError) {
+                    return {
+                        kind: "failed",
+                        error: this.synchronizationError
+                    };
+                }
+                return {
+                    kind: "preserved",
+                    configuration: this.configurationForTarget(target)
+                };
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                return this.captureFailed(( new Error(
+                    `Timed out after ${this.configurationCaptureTimeoutMs}ms while capturing the Automation session configuration.`
+                )));
+            }
+            const captured = await this.captureSessionConfiguration(session, target, remaining, token);
+            if (generation !== this.generation || session !== this.session) {
+                continue;
+            }
+            return captured;
+        }
+        return {
+            kind: "preserved",
+            configuration: this.configurationForTarget(this.requestedTarget)
+        };
+    }
+    scheduleSync() {
+        this.syncScheduled = true;
+        if (this.syncInProgress) {
+            return;
+        }
+        this.syncInProgress = true;
+        this.syncPromise = (async () => {
+            try {
+                while (this.syncScheduled && !this.disposed) {
+                    this.syncScheduled = false;
+                    await this.sync(this.generation);
+                }
+            } finally {
+                this.syncInProgress = false;
+            }
+        })();
+    }
+    async sync(generation) {
+        const target = this.requestedTarget;
+        if (!target) {
+            this.discardSession();
+            this.availability.set("idle", undefined);
+            return;
+        }
+        if (this.matchesAppliedTarget(target)) {
+            this.availability.set("available", undefined);
+            return;
+        }
+        try {
+            if (target.kind === "workspace" && !(await this.canSelectWorkspace(target.folderUri, target.providerId))) {
+                if (generation === this.generation) {
+                    this.discardSession();
+                    this.availability.set("unavailable", undefined);
+                }
+                return;
+            }
+            if (this.disposed || generation !== this.generation) {
+                return;
+            }
+            if (this.session && this.appliedTarget) {
+                await this.captureSessionConfiguration(
+                    this.session,
+                    this.appliedTarget,
+                    this.retargetConfigurationCaptureTimeoutMs
+                );
+                if (this.disposed || generation !== this.generation) {
+                    return;
+                }
+            }
+            const targetAvailable = target.kind === "quickChat" ? this.sessionsManagementService.isQuickChatTargetAvailable({
+                providerId: target.providerId,
+                sessionTypeId: target.sessionTypeId
+            }) : this.sessionsManagementService.isNewSessionTargetAvailable(target.folderUri, {
+                providerId: target.providerId,
+                sessionTypeId: target.sessionTypeId
+            });
+            if (!targetAvailable) {
+                this.discardSession();
+                this.availability.set("unavailable", undefined);
+                return;
+            }
+            const sessionConfiguration = this.configurationForTarget(target);
+            this.session = target.kind === "quickChat" ? this.sessionsManagementService.createAutomationQuickChat({
+                providerId: target.providerId,
+                sessionTypeId: target.sessionTypeId,
+                sessionTemplate: sessionConfiguration?.sessionTemplate,
+                automationConfiguration: sessionConfiguration
+            }) : this.sessionsManagementService.createAutomationSession(target.folderUri, {
+                providerId: target.providerId,
+                sessionTypeId: target.sessionTypeId,
+                sessionTemplate: sessionConfiguration?.sessionTemplate,
+                automationConfiguration: sessionConfiguration
+            });
+            this.appliedTarget = target;
+            this.appliedConfiguration = sessionConfiguration;
+            this.availability.set(
+                this.sessionsManagementService.supportsAutomationSessionConfiguration(this.session) ? "available" : "unavailable",
+                undefined
+            );
+        } catch (error) {
+            if (!this.disposed && generation === this.generation) {
+                this.synchronizationError = error;
+                this.discardSession();
+                this.availability.set("unavailable", undefined);
+                this.onError(error);
+            }
+        }
+    }
+    matchesAppliedTarget(target) {
+        if (!this.session || !this.appliedTarget || this.sessionsManagementService.automationSession.get()?.sessionId !== this.session.sessionId || this.appliedTarget.kind !== target.kind || this.appliedTarget.providerId !== target.providerId || this.appliedTarget.sessionTypeId !== target.sessionTypeId || this.appliedConfiguration !== this.configurationForTarget(target)) {
+            return false;
+        }
+        return target.kind === "quickChat" || (this.appliedTarget.kind === "workspace" && isEqual(this.appliedTarget.folderUri, target.folderUri));
+    }
+    discardSession() {
+        if (this.session) {
+            this.sessionsManagementService.discardAutomationSession(this.session);
+        }
+        this.session = undefined;
+        this.appliedTarget = undefined;
+        this.appliedConfiguration = undefined;
+    }
+    async captureSessionConfiguration(session, target, timeoutMs, token = CancellationToken.None) {
+        try {
+            const result = await raceTimeout(raceCancellationError(
+                this.sessionsManagementService.getAutomationSessionConfiguration(session).then(configuration => ({
+                    configuration
+                })),
+                token
+            ), timeoutMs);
+            if (!result) {
+                throw ( new Error(
+                    `Timed out after ${timeoutMs}ms while capturing Automation session configuration.`
+                ));
+            }
+            if (result.configuration === null) {
+                return {
+                    kind: "preserved",
+                    configuration: this.configurationForTarget(target)
+                };
+            }
+            if (result.configuration === undefined) {
+                throw ( new Error(
+                    "The Automation session draft was replaced before its configuration could be captured."
+                ));
+            }
+            this.configurationsByTarget.set(this.targetKey(target), result.configuration);
+            return {
+                kind: "captured",
+                configuration: result.configuration
+            };
+        } catch (error) {
+            if (token.isCancellationRequested) {
+                throw error;
+            }
+            return this.captureFailed(error);
+        }
+    }
+    captureFailed(error) {
+        this.onError(error);
+        return {
+            kind: "failed",
+            error
+        };
+    }
+    async waitForResultBeforeDeadline(promise, deadline, token) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            return false;
+        }
+        return (await raceTimeout(raceCancellationError(promise.then(() => true), token), remaining)) ?? false;
+    }
+    configurationForTarget(target) {
+        return target ? this.configurationsByTarget.get(this.targetKey(target)) ?? target.sessionConfiguration : undefined;
+    }
+    targetsEqual(first, second) {
+        if (first === second) {
+            return true;
+        }
+        if (!first || !second || first.kind !== second.kind || first.providerId !== second.providerId || first.sessionTypeId !== second.sessionTypeId || first.sessionConfiguration !== second.sessionConfiguration) {
+            return false;
+        }
+        return first.kind === "quickChat" || (second.kind === "workspace" && isEqual(first.folderUri, second.folderUri));
+    }
+    targetKey(target) {
+        return target.kind === "quickChat" ? `quickChat:${target.providerId}:${target.sessionTypeId}` : `workspace:${( target.folderUri.toString())}:${target.providerId ?? ""}:${target.sessionTypeId}`;
+    }
+    dispose() {
+        this.disposed = true;
+        this.generation++;
+        this.discardSession();
+        super.dispose();
+    }
+}
+const AUTOMATIONS_HARNESS_CHIP_ACTION_ID = "workbench.action.chat.renderAutomationsHarnessChip";
+const AUTOMATIONS_WORKSPACE_PICKER_ACTION_ID = "workbench.action.chat.renderAutomationsWorkspacePicker";
+const AUTOMATIONS_ISOLATION_GROUP_ACTION_ID = "workbench.action.chat.renderAutomationsIsolationGroup";
+function setAutomationControlVisible(container, visible) {
+    container.style.display = visible ? "" : "none";
+    if (visible) {
+        container.removeAttribute("aria-hidden");
+    } else {
+        container.setAttribute("aria-hidden", "true");
+    }
+}
+function getAutomationToolbarResponsiveItems(toolbar, options = {}) {
+    const items = [];
+    for (let index = 0; index < toolbar.getItemsLength(); index++) {
+        const element = toolbar.getItemElement(index);
+        const action = toolbar.getItemAction(index);
+        if (!element || !action) {
+            continue;
+        }
+        items.push({
+            element,
+            canShrink: options.canShrink ?? true,
+            isCompact: () => element.classList.contains("compact-picker"),
+            setCompact: compact => {
+                element.classList.toggle("compact-picker", compact);
+                if (action.id === "sessions.modelPicker") {
+                    options.compactModelPicker?.set(compact, undefined);
+                }
+            }
+        });
+    }
+    return items;
+}
+let AutomationIsolationGroupActionViewItem = class AutomationIsolationGroupActionViewItem extends BaseActionViewItem {
+    constructor(
+        action,
+        state,
+        isolationModel,
+        workspaceFolder,
+        onDidChangeTarget,
+        revalidate,
+        options,
+        visible,
+        gitService,
+        sessionsManagementService,
+        pickerLogService,
+        instantiationService
+    ) {
+        super(undefined, action, options);
+        this.state = state;
+        this.isolationModel = isolationModel;
+        this.workspaceFolder = workspaceFolder;
+        this.onDidChangeTarget = onDidChangeTarget;
+        this.revalidate = revalidate;
+        this.visible = visible;
+        this.gitService = gitService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.pickerLogService = pickerLogService;
+        this.renderDisposables = this._register(( new DisposableStore()));
+        this.branchRepoDisposable = this._register(( new MutableDisposable()));
+        this.branchRequest = this._register(( new MutableDisposable()));
+        this.branchRequestId = 0;
+        this.branchLoadState = "noFolder";
+        this.branches = [];
+        this.worktreeCapabilityResolved = false;
+        this.branchPicker = this._register(instantiationService.createInstance(BranchPicker, {
+            user: "automationBranchPicker",
+            slotClassName: "automation-form-branch-picker-slot",
+            triggerClassName: "automation-form-branch-slot",
+            labelClassName: "automation-form-branch-name",
+            descriptionClassName: "automation-form-branch-description",
+            keepDisabledFocusable: true,
+            renderDisabledAsStatic: true,
+            ariaLive: "polite",
+            onSelectBranch: branch => {
+                this.isolationModel.selectBranch(branch);
+                this.renderBranchControl();
+            },
+            onRetry: () => {
+                void this.reloadRepository(this.isolationModel.folderUri);
+            },
+            isolation: {
+                label: ( localize(3277, "New Worktree")),
+                ariaLabel: ( localize(3278, "Worktree isolation")),
+                onToggle: checked => {
+                    this.isolationModel.selectIsolationMode(checked ? "worktree" : "workspace");
+                    this.renderBranchControl();
+                }
+            }
+        }));
+    }
+    render(container) {
+        this.renderDisposables.clear();
+        this.branchRepoDisposable.clear();
+        this.cancelBranchRequest();
+        clearNode(container);
+        container.style.marginLeft = "auto";
+        const visible = this.visible;
+        if (visible) {
+            this.renderDisposables.add(autorun(reader => {
+                setAutomationControlVisible(container, visible.read(reader));
+            }));
+        }
+        const isolationGroup = append(container, $("span.automation-form-isolation-group"));
+        this.branchPicker.render(isolationGroup);
+        this.refreshTargetCapability();
+        this.renderBranchControl();
+        this.renderDisposables.add(autorun(reader => {
+            const folderUri = this.workspaceFolder.read(reader);
+            this.refreshTargetAndRender();
+            void this.reloadRepository(folderUri);
+        }));
+        this.renderDisposables.add(this.onDidChangeTarget(() => {
+            this.refreshTargetAndRender();
+        }));
+        this.renderDisposables.add(
+            this.sessionsManagementService.onDidChangeSessionTypes(() => this.refreshTargetAndRender())
+        );
+        this.renderDisposables.add({
+            dispose: () => {
+                this.cancelBranchRequest();
+            }
+        });
+    }
+    showPicker(anchor) {
+        this.branchPicker.showPicker(anchor);
+    }
+    refreshTargetCapability() {
+        const folderUri = this.isolationModel.folderUri;
+        const sessionTypeId = this.state.sessionTypeId;
+        if (!folderUri || !sessionTypeId) {
+            this.worktreeCapabilityResolved = false;
+            this.isolationModel.setSupportsWorktreeConfiguration(false);
+            return;
+        }
+        const sessionType = this.sessionsManagementService.getSessionTypesForFolder(folderUri).find(
+            candidate => candidate.sessionType.id === sessionTypeId && (this.state.providerId === undefined || candidate.providerId === this.state.providerId)
+        )?.sessionType;
+        if (!sessionType) {
+            this.worktreeCapabilityResolved = false;
+            this.isolationModel.setSupportsWorktreeConfiguration(false);
+            return;
+        }
+        this.worktreeCapabilityResolved = true;
+        const supportsWorktreeConfiguration = sessionType.supportsWorktreeConfiguration === true;
+        this.isolationModel.setSupportsWorktreeConfiguration(supportsWorktreeConfiguration);
+        if (!supportsWorktreeConfiguration && this.isolationModel.isolationMode === "worktree") {
+            this.isolationModel.selectIsolationMode("workspace");
+        }
+    }
+    refreshTargetAndRender() {
+        this.refreshTargetCapability();
+        this.renderBranchControl();
+    }
+    renderBranchControl() {
+        const presentation = this.getBranchPresentation();
+        const canOpen = this.canOpenBranchPicker();
+        const selectedBranch = this.isolationModel.selectedBranch ?? this.isolationModel.headBranch;
+        const branches = this.branches.map(branch => ({
+            name: branch,
+            selected: branch === selectedBranch
+        }));
+        if (selectedBranch && !this.branches.includes(selectedBranch)) {
+            branches.unshift({
+                name: selectedBranch,
+                selected: true,
+                unavailable: true
+            });
+        }
+        const worktreeUnavailableReason = this.getWorktreeUnavailableReason();
+        const isolationState = worktreeUnavailableReason === undefined ? "enabled" : "disabled";
+        this.branchPicker.update({
+            label: presentation.label,
+            branches,
+            status: this.branchLoadState === "loadingRepository" || this.branchLoadState === "loadingBranches" ? "loading" : this.branchLoadState === "error" ? "error" : this.branchLoadState === "ready" ? "ready" : "empty",
+            canOpen,
+            disabledReason: presentation.reason,
+            missing: presentation.missing,
+            showChevron: this.isolationModel.branchPickerAvailable || this.branchLoadState === "error",
+            isolation: {
+                checked: this.isolationModel.isolationMode === "worktree",
+                state: isolationState,
+                disabledReason: worktreeUnavailableReason
+            }
+        });
+        this.revalidate();
+    }
+    getBranchPresentation() {
+        const displayBranch = this.isolationModel.displayBranch;
+        if (!this.isolationModel.folderUri) {
+            return {
+                label: ( localize(3279, "—")),
+                reason: ( localize(3280, "Select a folder to determine its Git branch.")),
+                missing: true
+            };
+        }
+        if (!this.worktreeCapabilityResolved) {
+            return {
+                label: displayBranch ?? ( localize(3279, "—")),
+                reason: ( localize(3281, "Session capabilities are loading.")),
+                missing: !displayBranch
+            };
+        }
+        if (!this.isolationModel.supportsWorktreeConfiguration) {
+            return {
+                label: displayBranch ?? ( localize(3279, "—")),
+                reason: ( localize(
+                    3282,
+                    "The selected session type does not support Worktree branch configuration."
+                )),
+                missing: !displayBranch
+            };
+        }
+        if (this.branchLoadState === "error") {
+            return {
+                label: displayBranch ?? ( localize(3283, "Unable to load branches")),
+                reason: ( localize(3284, "Open the branch picker to retry loading local branches.")),
+                missing: !displayBranch
+            };
+        }
+        if (this.isolationModel.isolationMode !== "worktree") {
+            return {
+                label: displayBranch ?? this.detachedCommit ?? ( localize(3279, "—")),
+                reason: ( localize(3285, "Select Worktree to choose a branch.")),
+                missing: !displayBranch && !this.detachedCommit
+            };
+        }
+        switch (this.branchLoadState) {
+        case "loadingRepository":
+        case "loadingBranches":
+            return {
+                label: displayBranch ?? ( localize(3286, "Loading branches…")),
+                reason: ( localize(3287, "Local branches are loading.")),
+                missing: !displayBranch
+            };
+        case "noRepository":
+            return {
+                label: displayBranch ?? ( localize(3288, "no git repo")),
+                reason: ( localize(3289, "No Git repository was found for the selected folder.")),
+                missing: !displayBranch
+            };
+        case "empty":
+            return {
+                label: displayBranch ?? ( localize(3290, "No local branches")),
+                reason: ( localize(3291, "No local branches were found in this repository.")),
+                missing: !displayBranch
+            };
+        case "ready":
+            return {
+                label: displayBranch ?? ( localize(3292, "Select branch")),
+                reason: ( localize(3293, "Choose the local branch to use as the Worktree base.")),
+                missing: !displayBranch
+            };
+        case "noFolder":
+            return {
+                label: ( localize(3279, "—")),
+                reason: ( localize(3280, "Select a folder to determine its Git branch.")),
+                missing: true
+            };
+        }
+    }
+    canOpenBranchPicker() {
+        if (this.branchLoadState === "error") {
+            return !!this.isolationModel.folderUri && this.worktreeCapabilityResolved && this.isolationModel.supportsWorktreeConfiguration;
+        }
+        return this.isolationModel.branchPickerAvailable && this.branchLoadState !== "noFolder" && this.branchLoadState !== "noRepository" && this.branchLoadState !== "loadingRepository" && this.branchLoadState !== "loadingBranches";
+    }
+    getWorktreeUnavailableReason() {
+        if (!this.isolationModel.folderUri) {
+            return localize(3294, "Select a folder to use Worktree isolation.");
+        }
+        if (!this.worktreeCapabilityResolved) {
+            return localize(3281, "Session capabilities are loading.");
+        }
+        if (!this.isolationModel.supportsWorktreeConfiguration) {
+            return localize(3295, "Not supported by the selected session type");
+        }
+        if (this.isolationModel.selectedBranch) {
+            return undefined;
+        }
+        switch (this.branchLoadState) {
+        case "loadingRepository":
+        case "loadingBranches":
+            return localize(3287, "Local branches are loading.");
+        case "noRepository":
+            return localize(3289, "No Git repository was found for the selected folder.");
+        case "error":
+            return localize(3284, "Open the branch picker to retry loading local branches.");
+        case "empty":
+            return localize(3291, "No local branches were found in this repository.");
+        case "ready":
+            return this.branches.length > 0 ? undefined : ( localize(3291, "No local branches were found in this repository."));
+        case "noFolder":
+            return localize(3294, "Select a folder to use Worktree isolation.");
+        }
+    }
+    cancelBranchRequest() {
+        this.branchRequest.value?.cancel();
+        this.branchRequest.clear();
+    }
+    async reloadRepository(folder) {
+        const requestId = ++this.branchRequestId;
+        this.cancelBranchRequest();
+        this.branchRepoDisposable.clear();
+        this.repository = undefined;
+        this.branches = [];
+        this.detachedCommit = undefined;
+        if (!folder) {
+            this.branchLoadState = "noFolder";
+            this.isolationModel.setHeadBranch(undefined);
+            this.renderBranchControl();
+            return;
+        }
+        this.branchLoadState = "loadingRepository";
+        this.renderBranchControl();
+        const cts = ( new CancellationTokenSource());
+        this.branchRequest.value = cts;
+        let repo;
+        try {
+            repo = await this.gitService.openRepository(folder);
+        } catch (error) {
+            if (requestId !== this.branchRequestId || cts.token.isCancellationRequested) {
+                return;
+            }
+            this.pickerLogService.error(
+                "[AutomationDialog] Failed to open Git repository for branch selection.",
+                error
+            );
+            this.branchLoadState = "error";
+            this.renderBranchControl();
+            return;
+        }
+        if (requestId !== this.branchRequestId || cts.token.isCancellationRequested) {
+            return;
+        }
+        if (!repo) {
+            this.branchLoadState = "noRepository";
+            this.renderBranchControl();
+            return;
+        }
+        this.repository = repo;
+        const watcher = ( new DisposableStore());
+        watcher.add(autorun(reader => {
+            const head = repo.state.read(reader).HEAD;
+            if (head?.commit && head.name) {
+                this.detachedCommit = undefined;
+                this.isolationModel.setHeadBranch(head.name);
+            } else if (head?.commit) {
+                this.detachedCommit = ( localize(3296, "({0})", head.commit.slice(0, 7)));
+                this.isolationModel.setHeadBranch(undefined);
+            } else {
+                this.detachedCommit = undefined;
+                this.isolationModel.setHeadBranch(undefined);
+            }
+            this.renderBranchControl();
+        }));
+        this.branchRepoDisposable.value = watcher;
+        this.branchLoadState = "loadingBranches";
+        this.renderBranchControl();
+        try {
+            const refs = await repo.getRefs({
+                pattern: "refs/heads"
+            }, cts.token);
+            if (requestId !== this.branchRequestId || cts.token.isCancellationRequested || this.repository !== repo) {
+                return;
+            }
+            this.branches = normalizeAutomationBranchNames(refs.map(ref => ref.name));
+            this.branchLoadState = this.branches.length > 0 ? "ready" : "empty";
+        } catch (error) {
+            if (requestId !== this.branchRequestId || cts.token.isCancellationRequested) {
+                return;
+            }
+            this.pickerLogService.error("[AutomationDialog] Failed to load local branches.", error);
+            this.branchLoadState = "error";
+        }
+        this.renderBranchControl();
+    }
+};
+AutomationIsolationGroupActionViewItem = ( __decorate([( __param(8, IGitService)), ( __param(9, ISessionsManagementService)), ( __param(10, ILogService)), ( __param(11, IInstantiationService))], AutomationIsolationGroupActionViewItem));
+class AutomationPickerActionViewItem extends BaseActionViewItem {
+    constructor(action, renderPicker, visible, options) {
+        super(undefined, action, options);
+        this.renderPicker = renderPicker;
+        this.visible = visible;
+        this.visibilityWatch = this._register(( new MutableDisposable()));
+    }
+    render(container) {
+        super.render(container);
+        clearNode(container);
+        this.renderPicker(container);
+        const visible = this.visible;
+        this.visibilityWatch.value = visible ? autorun(reader => {
+            setAutomationControlVisible(container, visible.read(reader));
+        }) : undefined;
+    }
+}
+registerAction2(class OpenAutomationsHarnessChipAction extends Action2 {
+    constructor() {
+        super({
+            id: AUTOMATIONS_HARNESS_CHIP_ACTION_ID,
+            title: ( localize2(3297, "Automations Harness Chip")),
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+            menu: [{
+                id: Menus.AutomationsDialogTargetToolbar,
+                group: "navigation",
+                order: -1,
+                when: ChatContextKeys.inAutomationsDialog
+            }]
+        });
+    }
+    async run() {}
+});
+registerAction2(class OpenAutomationsWorkspacePickerAction extends Action2 {
+    constructor() {
+        super({
+            id: AUTOMATIONS_WORKSPACE_PICKER_ACTION_ID,
+            title: ( localize2(3298, "Automations Workspace Picker")),
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+            menu: [{
+                id: Menus.AutomationsDialogTargetToolbar,
+                group: "navigation",
+                order: -2,
+                when: ChatContextKeys.inAutomationsDialog
+            }]
+        });
+    }
+    async run() {}
+});
+registerAction2(class OpenAutomationsIsolationGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: AUTOMATIONS_ISOLATION_GROUP_ACTION_ID,
+            title: ( localize2(3299, "Automations Isolation Group")),
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+            menu: [{
+                id: Menus.AutomationsDialogTargetToolbar,
+                group: "navigation",
+                order: 2,
+                when: ChatContextKeys.inAutomationsDialog
+            }]
+        });
+    }
+    async run() {}
+});
+function renderForm(
+    form,
+    state,
+    disposables,
+    validation,
+    revalidate,
+    instantiationService,
+    contextKeyService,
+    contextViewService,
+    configurationService,
+    layoutService,
+    logService,
+    sessionsManagementService,
+    workspaceTrustRequestService,
+    initialPrompt,
+    initialTarget,
+    initialSessionConfiguration
+) {
+    const formContent = append(form, $(".automation-form-content"));
+    const nameRow = append(formContent, $(".automation-form-row"));
+    append(nameRow, $("span.automation-form-label", undefined, ( localize(3300, "Name"))));
+    const nameInputContainer = append(nameRow, $(".automation-form-input-host"));
+    const nameInput = disposables.add(( new InputBox(nameInputContainer, contextViewService, {
+        inputBoxStyles: defaultInputBoxStyles,
+        placeholder: ( localize(3301, "e.g. Morning standup notes")),
+        ariaLabel: ( localize(3300, "Name"))
+    })));
+    nameInput.value = state.name;
+    disposables.add(nameInput.onDidChange(value => {
+        state.name = value;
+        revalidate();
+    }));
+    const scheduleRow = append(formContent, $(".automation-form-row.automation-form-schedule-row"));
+    const useCustomDrawn = !hasNativeContextMenu(configurationService);
+    const intervalGroup = append(scheduleRow, $(".automation-form-schedule-group"));
+    append(intervalGroup, $("span.automation-form-label", undefined, ( localize(3302, "Schedule"))));
+    const intervalOptions = INTERVALS.map(item => ({
+        text: item.label
+    }));
+    const intervalIndex = Math.max(0, INTERVALS.findIndex(item => item.value === state.interval));
+    const intervalSelect = disposables.add(( new SelectBox(
+        intervalOptions,
+        intervalIndex,
+        contextViewService,
+        defaultSelectBoxStyles,
+        {
+            ariaLabel: ( localize(3302, "Schedule")),
+            useCustomDrawn
+        }
+    )));
+    const intervalSelectContainer = append(intervalGroup, $(".automation-form-schedule-select-container"));
+    intervalSelect.render(intervalSelectContainer);
+    const timeGroup = append(
+        scheduleRow,
+        $(".automation-form-schedule-group.automation-form-time-group")
+    );
+    append(timeGroup, $("span.automation-form-label", undefined, ( localize(3303, "Time"))));
+    const timeOptions = buildTimeOptions();
+    const initialTimeIndex = nearestTimeOptionIndex(state.hour, state.minute);
+    state.hour = timeOptions[initialTimeIndex].hour;
+    state.minute = timeOptions[initialTimeIndex].minute;
+    const timeSelect = disposables.add(( new SelectBox(timeOptions.map(opt => ({
+        text: opt.label
+    })), initialTimeIndex, contextViewService, defaultSelectBoxStyles, {
+        ariaLabel: ( localize(3303, "Time")),
+        useCustomDrawn
+    })));
+    const timeSelectContainer = append(timeGroup, $(
+        ".automation-form-schedule-select-container.automation-form-time-select-container"
+    ));
+    timeSelect.render(timeSelectContainer);
+    disposables.add(timeSelect.onDidSelect(e => {
+        const opt = timeOptions[e.index];
+        state.hour = opt.hour;
+        state.minute = opt.minute;
+    }));
+    const dayGroup = append(
+        scheduleRow,
+        $(".automation-form-schedule-group.automation-form-day-group")
+    );
+    append(dayGroup, $("span.automation-form-label", undefined, ( localize(3304, "Day of week"))));
+    const dayOptions = DAYS_OF_WEEK.map(d => ({
+        text: d
+    }));
+    const daySelect = disposables.add(( new SelectBox(
+        dayOptions,
+        Math.min(Math.max(state.day, 0), DAYS_OF_WEEK.length - 1),
+        contextViewService,
+        defaultSelectBoxStyles,
+        {
+            ariaLabel: ( localize(3304, "Day of week")),
+            useCustomDrawn
+        }
+    )));
+    const daySelectContainer = append(dayGroup, $(".automation-form-schedule-select-container"));
+    daySelect.render(daySelectContainer);
+    disposables.add(daySelect.onDidSelect(e => {
+        state.day = e.index;
+    }));
+    const applyIntervalVisibility = () => {
+        const showTime = state.interval === "daily" || state.interval === "weekly";
+        const showDay = state.interval === "weekly";
+        timeGroup.style.display = showTime ? "" : "none";
+        dayGroup.style.display = showDay ? "" : "none";
+    };
+    applyIntervalVisibility();
+    disposables.add(intervalSelect.onDidSelect(e => {
+        state.interval = INTERVALS[e.index].value;
+        applyIntervalVisibility();
+    }));
+    const isolationModel = ( new AutomationIsolationModel(state));
+    const workspaceControlsVisible = derived(
+        reader => !isolationModel.isQuickChatObs.read(reader) && isolationModel.folderUriObs.read(reader) !== undefined
+    );
+    const sessionTypePicker = disposables.add(
+        instantiationService.createInstance(MobileSessionTypePicker, constObservable(undefined), {
+            persistSelection: false,
+            telemetrySource: "AutomationSessionTypePicker"
+        })
+    );
+    sessionTypePicker.setQuickChatSource(isolationModel.isQuickChatObs);
+    sessionTypePicker.setFolderSource(isolationModel.folderUriObs, {
+        initialPick: state.sessionTypeId ? {
+            providerId: state.providerId,
+            sessionTypeId: state.sessionTypeId
+        } : undefined,
+        preserveUnavailableInitialPick: true
+    });
+    const onDidChangeSessionType = disposables.add(( new Emitter()));
+    const onDidChangeSessionTarget = disposables.add(( new Emitter()));
+    const sessionTypeDelegate = {
+        getActiveSessionProvider: () => sessionTypePicker.modelTargetChatSessionType.get(),
+        onDidChangeActiveSessionProvider: onDidChangeSessionType.event
+    };
+    const syncStateFromPicker = () => {
+        const pick = sessionTypePicker.selectedPick;
+        state.providerId = pick?.providerId;
+        state.sessionTypeId = pick?.sessionTypeId;
+        onDidChangeSessionTarget.fire();
+    };
+    disposables.add(autorun(reader => {
+        const modelTarget = sessionTypePicker.modelTargetChatSessionType.read(reader);
+        if (modelTarget) {
+            onDidChangeSessionType.fire(modelTarget);
+        }
+    }));
+    syncStateFromPicker();
+    const workspacePicker = disposables.add(instantiationService.createInstance(MobileAutomationsWorkspacePicker, {
+        restoreFromSessions: false,
+        canRestoreWorkspace: () => false,
+        canSelectWorkspace: (folderUri, preferredProviderId) => canSelectAutomationWorkspace(
+            folderUri,
+            preferredProviderId,
+            sessionsManagementService,
+            workspaceTrustRequestService
+        )
+    }));
+    workspacePicker.setTargetModel(isolationModel);
+    workspacePicker.setLayoutService(layoutService);
+    const automationSessionDraftSynchronizer = disposables.add(( new AutomationSessionDraftSynchronizer(
+        sessionsManagementService,
+        (folderUri, preferredProviderId) => canSelectAutomationWorkspace(
+            folderUri,
+            preferredProviderId,
+            sessionsManagementService,
+            workspaceTrustRequestService
+        ),
+        error => logService.error(
+            "[AutomationDialog] Failed to synchronize the automation session draft.",
+            error
+        )
+    )));
+    let resolvedInitialProviderId = initialTarget?.providerId;
+    let resolvedInitialSessionTypeId = initialTarget?.sessionTypeId;
+    const getInitialSessionConfiguration = (folderUri, providerId, sessionTypeId, isQuickChat) => {
+        if (!initialTarget || !initialSessionConfiguration || initialTarget.kind !== (isQuickChat ? "quickChat" : "workspace")) {
+            return undefined;
+        }
+        if (initialTarget.kind === "workspace" && (!folderUri || !isEqual(initialTarget.folderUri, folderUri))) {
+            return undefined;
+        }
+        resolvedInitialProviderId ??= providerId;
+        resolvedInitialSessionTypeId ??= sessionTypeId;
+        if (resolvedInitialProviderId !== providerId || resolvedInitialSessionTypeId !== sessionTypeId) {
+            return undefined;
+        }
+        return initialSessionConfiguration;
+    };
+    const updateAutomationSessionTarget = () => {
+        const folderUri = isolationModel.folderUriObs.get();
+        const pick = sessionTypePicker.selectedPick;
+        const isQuickChat = isolationModel.isQuickChatObs.get();
+        if (!pick || (isQuickChat && !pick.providerId) || (!isQuickChat && !folderUri)) {
+            automationSessionDraftSynchronizer.update(undefined);
+            return;
+        }
+        if (isQuickChat) {
+            const providerId = pick.providerId;
+            if (providerId) {
+                automationSessionDraftSynchronizer.update({
+                    kind: "quickChat",
+                    providerId,
+                    sessionTypeId: pick.sessionTypeId,
+                    sessionConfiguration: getInitialSessionConfiguration(undefined, providerId, pick.sessionTypeId, true)
+                });
+            }
+        } else if (folderUri) {
+            automationSessionDraftSynchronizer.update({
+                kind: "workspace",
+                folderUri,
+                providerId: pick.providerId,
+                sessionTypeId: pick.sessionTypeId,
+                sessionConfiguration: getInitialSessionConfiguration(folderUri, pick.providerId, pick.sessionTypeId, false)
+            });
+        }
+    };
+    disposables.add(sessionTypePicker.onDidChangeSelectedPick(() => {
+        syncStateFromPicker();
+        updateAutomationSessionTarget();
+        revalidate();
+    }));
+    disposables.add(
+        sessionsManagementService.onDidChangeSessionTypes(() => updateAutomationSessionTarget())
+    );
+    if (state.folderUri) {
+        workspacePicker.setSelectedWorkspace(state.folderUri, {
+            fireEvent: false,
+            persist: false
+        });
+    }
+    disposables.add(workspacePicker.onDidSelectWorkspace(uri => {
+        if (isolationModel.setWorkspace(uri)) {
+            updateAutomationSessionTarget();
+            revalidate();
+        }
+    }));
+    disposables.add(autorun(reader => {
+        isolationModel.isQuickChatObs.read(reader);
+        updateAutomationSessionTarget();
+        revalidate();
+    }));
+    const sessionSection = append(formContent, $(".automation-session-section"));
+    const targetRow = append(sessionSection, $(".automation-form-row.automation-target-row"));
+    const targetLabel = append(targetRow, $("span.automation-form-label", {
+        id: "automation-target-label"
+    }, ( localize(3305, "Target"))));
+    const targetContainer = append(targetRow, $(".automation-target-toolbar", {
+        role: "group",
+        "aria-labelledby": targetLabel.id
+    }));
+    const promptSection = append(sessionSection, $(".automation-prompt-section"));
+    const promptRow = append(promptSection, $(".automation-form-row"));
+    append(promptRow, $("span.automation-form-label", undefined, ( localize(3306, "Prompt"))));
+    const promptHost = append(promptRow, $(".automation-form-prompt-host.interactive-session"));
+    const editorOverflowWidgetsDomNode = layoutService.getContainer(getWindow(promptHost)).appendChild($(".chat-editor-overflow.automation-dialog-editor-overflow.monaco-editor"));
+    disposables.add(toDisposable(() => editorOverflowWidgetsDomNode.remove()));
+    const activeAutomationSession = disposables.add(disposableObservableValue(form, undefined));
+    disposables.add(autorun(reader => {
+        const session = sessionsManagementService.automationSession.read(reader);
+        activeAutomationSession.set(session ? ( new VisibleSession(session, session.mainChat.read(reader))) : undefined, undefined);
+    }));
+    const scopedContextKeyService = disposables.add(contextKeyService.createScoped(sessionSection));
+    ChatContextKeys.location.bindTo(scopedContextKeyService).set(ChatAgentLocation.Chat);
+    ChatContextKeys.inChatSession.bindTo(scopedContextKeyService).set(true);
+    ChatContextKeys.inAutomationsDialog.bindTo(scopedContextKeyService).set(true);
+    const newChatModelPickerService = ( new NewChatModelPickerService());
+    const sessionModelSelection = disposables.add(
+        instantiationService.createInstance(SessionModelSelection, activeAutomationSession, {
+            modelConfiguration: true
+        })
+    );
+    const scopedInstantiationService = disposables.add(instantiationService.createChild(( new ServiceCollection(
+        [IContextKeyService, scopedContextKeyService],
+        [ISessionContext, ( new SessionContext(activeAutomationSession))],
+        [INewChatModelPickerService, newChatModelPickerService],
+        [ISessionModelSelection, sessionModelSelection]
+    ))));
+    const usesCombinedConfigPicker = SessionUsesCombinedConfigPickerContext.bindTo(scopedContextKeyService);
+    const sessionTypesChanged = observableSignalFromEvent(form, sessionsManagementService.onDidChangeSessionTypes);
+    disposables.add(autorun(reader => {
+        sessionTypesChanged.read(reader);
+        const session = activeAutomationSession.read(reader);
+        setActiveSessionContextKeys(session, scopedContextKeyService, reader);
+        usesCombinedConfigPicker.set(
+            !!session && sessionsManagementService.usesCombinedNewSessionConfigPicker(session)
+        );
+    }));
+    const targetToolbar = disposables.add(scopedInstantiationService.createInstance(
+        MenuWorkbenchToolBar,
+        targetContainer,
+        Menus.AutomationsDialogTargetToolbar,
+        {
+            ariaLabel: ( localize(3307, "Automation target options")),
+            telemetrySource: "automations.dialog",
+            hiddenItemStrategy: HiddenItemStrategy.NoHide,
+            responsiveBehavior: {
+                enabled: true,
+                kind: "all",
+                actionMinWidth: 22,
+                allowOverflow: false
+            },
+            actionViewItemProvider: (action, itemOptions) => {
+                if (action.id === AUTOMATIONS_HARNESS_CHIP_ACTION_ID) {
+                    return ( new AutomationPickerActionViewItem(
+                        action,
+                        container => sessionTypePicker.render(container),
+                        undefined,
+                        itemOptions
+                    ));
+                }
+                if (action.id === AUTOMATIONS_WORKSPACE_PICKER_ACTION_ID) {
+                    return ( new AutomationPickerActionViewItem(
+                        action,
+                        container => workspacePicker.render(container),
+                        undefined,
+                        itemOptions
+                    ));
+                }
+                if (action.id === AUTOMATIONS_ISOLATION_GROUP_ACTION_ID) {
+                    return instantiationService.createInstance(
+                        AutomationIsolationGroupActionViewItem,
+                        action,
+                        state,
+                        isolationModel,
+                        isolationModel.folderUriObs,
+                        onDidChangeSessionTarget.event,
+                        revalidate,
+                        itemOptions,
+                        workspaceControlsVisible
+                    );
+                }
+                return undefined;
+            }
+        }
+    ));
+    const targetLayout = disposables.add(( new ChatInputPickerResponsiveLayout("AutomationDialog.target", targetContainer, {
+        getItems: () => getAutomationToolbarResponsiveItems(targetToolbar, {
+            canShrink: false
+        }),
+        hasOverflow: () => targetToolbar.hasOverflow(),
+        relayout: () => targetToolbar.relayout()
+    })));
+    targetLayout.layout();
+    const chatInputStyles = {
+        overlayBackground: "var(--vscode-input-background)",
+        listForeground: "var(--vscode-foreground)",
+        listBackground: "var(--vscode-input-background)"
+    };
+    const chatInputOptions = {
+        renderFollowups: false,
+        renderInputToolbarBelowInput: false,
+        renderWorkingSet: false,
+        enableImplicitContext: false,
+        supportsChangingModes: false,
+        suppressModePreferredModel: true,
+        suppressModelPersistence: true,
+        menus: {
+            executeToolbar: MenuId.AutomationsDialogInput,
+            inputToolbar: Menus.AutomationsDialogInputToolbar,
+            telemetrySource: "automations.dialog"
+        },
+        widgetViewKindTag: "automations-dialog",
+        isTransientChat: true,
+        inputEditorMinLines: 3,
+        inputEditorQuickSuggestions: EditorOptions.quickSuggestions.defaultValue,
+        inputPartHorizontalPadding: 0,
+        editorOverflowWidgetsDomNode,
+        sessionTypePickerDelegate: sessionTypeDelegate
+    };
+    const stubWidget = {
+        onDidChangeViewModel: Event.None,
+        viewModel: undefined,
+        contribs: [],
+        location: ChatAgentLocation.Chat,
+        viewContext: {},
+        lockToCodingAgent: () => {},
+        unlockFromCodingAgent: () => {}
+    };
+    const chatInput = disposables.add(scopedInstantiationService.createInstance(
+        ChatInputPart,
+        ChatAgentLocation.Chat,
+        chatInputOptions,
+        chatInputStyles,
+        false
+    ));
+    chatInput.render(promptHost, initialPrompt, stubWidget);
+    chatInput.inputEditor.updateOptions({
+        placeholder: ( localize(3308, "Describe what you want to automate"))
+    });
+    disposables.add(
+        scopedInstantiationService.createInstance(AutomationInputCompletions, chatInput.inputEditor)
+    );
+    const sessionConfigurationRow = append(promptSection, $(".automation-form-row"));
+    const sessionConfigurationLabel = append(sessionConfigurationRow, $("span.automation-form-label", {
+        id: "automation-session-configuration-label"
+    }, ( localize(3309, "Session configuration"))));
+    const sessionConfiguration = append(sessionConfigurationRow, $(".automation-session-configuration", {
+        role: "group",
+        "aria-labelledby": sessionConfigurationLabel.id
+    }));
+    const sessionConfigContainer = append(
+        sessionConfiguration,
+        $(".automation-session-config.sessions-chat-config-toolbar")
+    );
+    const compactModelPicker = observableValue(sessionConfigContainer, false);
+    const sessionConfigToolbar = disposables.add(createNewSessionConfigToolbar(
+        sessionConfigContainer,
+        scopedInstantiationService,
+        compactModelPicker,
+        ( localize(3310, "Session configuration options"))
+    ));
+    const sessionControlsContainer = append(sessionConfiguration, $(".automation-session-controls"));
+    const sessionControlsToolbar = disposables.add(
+        createNewSessionControlToolbar(sessionControlsContainer, scopedInstantiationService, ( localize(3311, "Session controls")))
+    );
+    const sessionConfigLayout = disposables.add(( new ChatInputPickerResponsiveLayout("AutomationDialog.sessionConfig", sessionConfigContainer, {
+        getItems: () => getAutomationToolbarResponsiveItems(sessionConfigToolbar, {
+            compactModelPicker
+        }),
+        hasOverflow: () => sessionConfigToolbar.hasOverflow(),
+        relayout: () => sessionConfigToolbar.relayout()
+    })));
+    sessionConfigLayout.layout();
+    const sessionControlsLayout = disposables.add(( new ChatInputPickerResponsiveLayout("AutomationDialog.sessionControls", sessionControlsContainer, {
+        getItems: () => getAutomationToolbarResponsiveItems(sessionControlsToolbar),
+        hasOverflow: () => sessionControlsToolbar.hasOverflow(),
+        relayout: () => sessionControlsToolbar.relayout()
+    })));
+    sessionControlsLayout.layout();
+    const sessionConfigurationUnavailable = append(
+        sessionConfiguration,
+        $("span.automation-session-configuration-unavailable", {
+            role: "status",
+            "aria-atomic": "true"
+        })
+    );
+    const sessionConfigurationError = append(sessionConfiguration, $("span.automation-session-configuration-error", {
+        role: "alert",
+        tabindex: "-1"
+    }));
+    hide(sessionConfigurationError);
+    disposables.add(autorun(reader => {
+        const hasTarget = isolationModel.isQuickChatObs.read(reader) || isolationModel.folderUriObs.read(reader) !== undefined;
+        setAutomationControlVisible(sessionConfigurationRow, hasTarget);
+        const availability = automationSessionDraftSynchronizer.availability.read(reader);
+        const pending = availability === "pending";
+        const controlsUnavailable = availability !== "available";
+        sessionConfiguration.classList.toggle("controls-unavailable", controlsUnavailable);
+        for (const container of [sessionConfigContainer, sessionControlsContainer]) {
+            container.toggleAttribute("inert", controlsUnavailable);
+            container.setAttribute("aria-hidden", String(controlsUnavailable));
+            container.setAttribute("aria-busy", String(pending));
+        }
+        sessionConfigurationUnavailable.textContent = pending ? ( localize(3312, "Loading session configuration…")) : hasTarget && controlsUnavailable ? ( localize(3313, "Session configuration unavailable")) : "";
+    }));
+    disposables.add(chatInput.inputEditor.onDidChangeModelContent(() => {
+        revalidate();
+    }));
+    const layoutChatInput = () => {
+        const width = promptHost.getBoundingClientRect().width;
+        if (width > 0) {
+            chatInput.layout(width);
+        }
+    };
+    layoutChatInput();
+    queueMicrotask(() => {
+        if (!disposables.isDisposed) {
+            layoutChatInput();
+        }
+    });
+    const resizeObserver = disposables.add(
+        new DisposableResizeObserver("automationDialog.promptHost", entries => {
+            for (const entry of entries) {
+                const width = entry.contentRect.width;
+                if (width > 0) {
+                    chatInput.layout(width);
+                }
+            }
+        }, getWindow(promptHost))
+    );
+    disposables.add(resizeObserver.observe(promptHost));
+    const enabledRow = append(formContent, $(".automation-form-row.automation-form-checkbox-row"));
+    const enabledLabelText = ( localize(3314, "Enabled (the scheduler runs this automation when due)"));
+    const enabledCheckbox = disposables.add(( new Checkbox(enabledLabelText, state.enabled, defaultCheckboxStyles)));
+    append(enabledRow, enabledCheckbox.domNode);
+    const enabledLabel = append(
+        enabledRow,
+        $("span.automation-form-checkbox-label", undefined, enabledLabelText)
+    );
+    const setEnabled = value => {
+        if (enabledCheckbox.checked !== value) {
+            enabledCheckbox.checked = value;
+        }
+        state.enabled = value;
+    };
+    disposables.add(enabledCheckbox.onChange(() => {
+        state.enabled = enabledCheckbox.checked;
+    }));
+    disposables.add(addStandardDisposableListener(enabledLabel, "click", () => {
+        setEnabled(!enabledCheckbox.checked);
+    }));
+    const saveStatus = append(form, $("span.automation-form-save-status", {
+        role: "status",
+        "aria-atomic": "true"
+    }));
+    hide(saveStatus);
+    return {
+        getPrompt: () => chatInput.inputEditor.getValue(),
+        getSessionConfiguration: token => automationSessionDraftSynchronizer.getSessionConfiguration(token),
+        getBranch: () => isolationModel.persistedBranch,
+        waitForAutomationSessionSync: token => {
+            updateAutomationSessionTarget();
+            return automationSessionDraftSynchronizer.waitForSync(token);
+        },
+        setSaving: saving => {
+            formContent.toggleAttribute("inert", saving);
+            formContent.setAttribute("aria-busy", String(saving));
+            form.classList.toggle("saving", saving);
+            if (saving) {
+                show(saveStatus);
+                saveStatus.textContent = ( localize(3315, "Saving automation…"));
+            } else {
+                hide(saveStatus);
+                saveStatus.textContent = "";
+            }
+        },
+        showSessionConfigurationError: message => {
+            if (message) {
+                show(sessionConfigurationError);
+                sessionConfigurationError.textContent = message;
+            } else {
+                hide(sessionConfigurationError);
+                sessionConfigurationError.textContent = "";
+            }
+        },
+        focusSessionConfigurationError: () => sessionConfigurationError.focus(),
+        getFocusableElements: () => {
+            return Array.from(
+                form.querySelectorAll("input, select, textarea, button, a[href], [tabindex]")
+            );
+        },
+        acceptPromptSuggestion: () => {
+            const suggestController = SuggestController.get(chatInput.inputEditor);
+            if (!suggestController || suggestController.model.state === State.Idle || !suggestController.widget.value.getFocusedItem()) {
+                return false;
+            }
+            suggestController.acceptSelectedSuggestion(true, false);
+            return true;
+        },
+        cancelPromptSuggestion: () => {
+            const suggestController = SuggestController.get(chatInput.inputEditor);
+            if (!chatInput.inputEditor.hasTextFocus() || !suggestController || suggestController.model.state === State.Idle) {
+                return false;
+            }
+            suggestController.cancelSuggestWidget();
+            return true;
+        }
+    };
+}
+function buildTimeOptions() {
+    const options = [];
+    for (let hour = 0; hour < 24; hour++) {
+        for (let minute = 0; minute < 60; minute += 15) {
+            const period = hour < 12 ? "AM" : "PM";
+            const hour12 = hour === 0 ? 12 : (hour > 12 ? hour - 12 : hour);
+            const minuteText = ( minute.toString()).padStart(2, "0");
+            options.push({
+                hour,
+                minute,
+                label: `${hour12}:${minuteText} ${period}`
+            });
+        }
+    }
+    return options;
+}
+function nearestTimeOptionIndex(hour, minute) {
+    const safeHour = Math.max(0, Math.min(23, hour | 0));
+    const safeMinute = Math.max(0, Math.min(59, minute | 0));
+    const slot = Math.round(safeMinute / 15) % 4;
+    const carriedHour = safeMinute >= 53 && slot === 0 ? (safeHour + 1) % 24 : safeHour;
+    return carriedHour * 4 + slot;
+}
+function updateSaveButtonState(saveButton, state, validation, form, getPrompt, getBranch) {
+    validation.nameError = state.name.trim() === "" ? ( localize(3316, "Name is required.")) : undefined;
+    validation.promptError = getPrompt().trim() === "" ? ( localize(3317, "Prompt is required.")) : undefined;
+    validation.folderError = !state.folderUri && !state.isQuickChat ? ( localize(3318, "Workspace folder is required.")) : undefined;
+    validation.sessionTypeError = !state.sessionTypeId || (state.isQuickChat && !state.providerId) ? ( localize(3319, "Session type is required.")) : undefined;
+    validation.branchError = !state.isQuickChat && state.isolationMode === "worktree" && !getBranch() ? ( localize(3320, "A branch is required for Worktree isolation.")) : undefined;
+    const valid = !validation.nameError && !validation.promptError && !validation.folderError && !validation.sessionTypeError && !validation.branchError;
+    if (saveButton) {
+        saveButton.enabled = valid;
+    }
+    form.classList.toggle("automation-form-invalid", !valid);
+}
+class AutomationsWorkspacePicker extends WorkspacePicker {
+    constructor() {
+        super(...arguments);
+        this.targetModelWatch = this._register(( new MutableDisposable()));
+    }
+    setTargetModel(model) {
+        this.targetModel = model;
+        this.targetModelWatch.value = autorun(reader => {
+            model.isQuickChatObs.read(reader);
+            this._updateTriggerLabel();
+        });
+    }
+    _showTabs() {
+        return false;
+    }
+    _shouldPersistSelection() {
+        return false;
+    }
+    _buildItems() {
+        const items = super._buildItems();
+        const noWorkspace = {
+            kind: ActionListItemKind.Action,
+            label: ( localize(3321, "No workspace")),
+            description: ( localize(3322, "Run without a backing workspace")),
+            group: {
+                title: "",
+                icon: Codicon.commentDiscussion
+            },
+            item: {
+                checked: this.targetModel?.isQuickChat || undefined,
+                run: () => this.targetModel?.setQuickChat(true)
+            }
+        };
+        return items.length > 0 ? [noWorkspace, {
+            kind: ActionListItemKind.Separator,
+            label: ""
+        }, ...items] : [noWorkspace];
+    }
+    async _dispatchPickerItem(item) {
+        const applied = await super._dispatchPickerItem(item);
+        const selectedFolder = this.selectedFolderUri;
+        if (applied && selectedFolder && (item.folderUri || item.browseActionIndex !== undefined)) {
+            this.targetModel?.setQuickChat(false, selectedFolder);
+        }
+        return applied;
+    }
+    _isSelectedFolder(folderUri) {
+        return !this.targetModel?.isQuickChat && super._isSelectedFolder(folderUri);
+    }
+    _renderTriggerLabel(trigger) {
+        clearNode(trigger);
+        const workspace = this.selectedResolved?.workspace;
+        const noWorkspace = this.targetModel?.isQuickChat === true;
+        const label = noWorkspace ? ( localize(3321, "No workspace")) : workspace?.label ?? ( localize(3323, "Select workspace"));
+        const icon = noWorkspace ? Codicon.commentDiscussion : workspace?.icon ?? Codicon.project;
+        trigger.setAttribute("aria-label", workspace || noWorkspace ? ( localize(3324, "Automation target, {0}", label)) : ( localize(3325, "Pick a workspace for this automation")));
+        const renderedIcon = append(trigger, renderIcon(icon));
+        renderedIcon.setAttribute("aria-hidden", "true");
+        append(trigger, $("span.sessions-chat-dropdown-label", undefined, label));
+        const chevron = append(trigger, renderIcon(Codicon.chevronDownCompact));
+        chevron.classList.add("sessions-chat-dropdown-chevron");
+        chevron.setAttribute("aria-hidden", "true");
+    }
+    _getAllBrowseActions() {
+        return super._getAllBrowseActions().filter(a => a.group === SESSION_WORKSPACE_GROUP_LOCAL);
+    }
+}
+class MobileAutomationsWorkspacePicker extends AutomationsWorkspacePicker {
+    setLayoutService(layoutService) {
+        this.layoutService = layoutService;
+    }
+    showPicker(force = false, anchor) {
+        const triggerElement = anchor ?? this._triggerElement;
+        if (!triggerElement || !this.layoutService || !shouldUseMobileWorkspacePickerSheet(this.layoutService)) {
+            super.showPicker(force, anchor);
+            return;
+        }
+        void showMobileWorkspacePickerSheet(this.layoutService, triggerElement, this._buildItems(), item => {
+            void this._dispatchPickerItem(item);
+        }, this._getAllBrowseActions());
+    }
+}
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "workbench.action.chat.automationsDialog.insertNewline",
+    weight: KeybindingWeight.EditorContrib + 100,
+    when: ( ContextKeyExpr.and(
+        EditorContextKeys.textInputFocus,
+        ChatContextKeys.inAutomationsDialog,
+        ( Context.Visible.toNegated())
+    )),
+    primary: KeyCode.Enter,
+    handler: accessor => {
+        const editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+        editor?.trigger("keyboard", "type", {
+            text: "\n"
+        });
+    }
+});
+
+export { AutomationIsolationGroupActionViewItem, AutomationSessionDraftSynchronizer, AutomationsWorkspacePicker, MobileAutomationsWorkspacePicker, canSelectAutomationWorkspace, isAutomationDialogPopupTarget, registerAutomationDialogKeyboardNavigation, renderForm, shouldPassThroughAutomationDialogCommand, updateSaveButtonState };