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

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsTypedCharactersTracker.js

@@ -0,0 +1,99 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { isUserEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource';
+
+const TYPED_CHARACTERS_REPORT_DELAY = 5000;
+const MAX_TYPED_CHARACTERS_RETRIES = 3;
+let SessionsTypedCharactersTracker = class SessionsTypedCharactersTracker extends Disposable {
+    constructor(_getActiveSession, _report, modelService) {
+        super();
+        this._getActiveSession = _getActiveSession;
+        this._report = _report;
+        this._pending = ( new Map());
+        this._modelListeners = this._register(( new DisposableMap()));
+        this._register(toDisposable(() => this.flush()));
+        this._reportScheduler = this._register(( new RunOnceScheduler(() => this.flush(), TYPED_CHARACTERS_REPORT_DELAY)));
+        for (const model of modelService.getModels()) {
+            this._trackModel(model);
+        }
+        this._register(modelService.onModelAdded(model => this._trackModel(model)));
+        this._register(
+            modelService.onModelRemoved(model => this._modelListeners.deleteAndDispose(model))
+        );
+    }
+    flush() {
+        if (this._pending.size === 0) {
+            return;
+        }
+        const flushed = ( new Map(this._pending));
+        this._pending.clear();
+        for (const entry of this._report([...( flushed.values())])) {
+            const key = toKey(entry.session.sessionId, entry.resource);
+            const deferred = flushed.get(key);
+            if (!deferred || deferred.retries >= MAX_TYPED_CHARACTERS_RETRIES) {
+                continue;
+            }
+            deferred.retries++;
+            this._add(key, deferred);
+        }
+        if (this._pending.size > 0) {
+            this._reportScheduler.schedule();
+        }
+    }
+    _trackModel(model) {
+        this._modelListeners.set(model, model.onDidChangeContent(e => this._handleContentChange(model, e)));
+    }
+    _handleContentChange(model, e) {
+        const characters = countTypedCharacters(e);
+        if (characters === 0) {
+            return;
+        }
+        const session = this._getActiveSession();
+        if (!session) {
+            return;
+        }
+        this._add(toKey(session.sessionId, model.uri), {
+            session,
+            resource: model.uri,
+            characters,
+            retries: 0
+        });
+        if (!this._reportScheduler.isScheduled()) {
+            this._reportScheduler.schedule();
+        }
+    }
+    _add(key, entry) {
+        const existing = this._pending.get(key);
+        if (existing) {
+            existing.characters += entry.characters;
+        } else {
+            this._pending.set(key, entry);
+        }
+    }
+};
+SessionsTypedCharactersTracker = ( __decorate([( __param(2, IModelService))], SessionsTypedCharactersTracker));
+function toKey(sessionId, resource) {
+    return `${sessionId}\u0000${( resource.toString())}`;
+}
+function countTypedCharacters(e) {
+    if (e.isUndoing || e.isRedoing) {
+        return 0;
+    }
+    let characters = 0;
+    let changeIndex = 0;
+    for (let i = 0; i < e.detailedReasons.length; i++) {
+        const changeEnd = Math.min(changeIndex + e.detailedReasonsChangeLengths[i], e.changes.length);
+        if (isUserEdit(e.detailedReasons[i])) {
+            for (let j = changeIndex; j < changeEnd; j++) {
+                characters += e.changes[j].text.length;
+            }
+        }
+        changeIndex = changeEnd;
+    }
+    return characters;
+}
+
+export { MAX_TYPED_CHARACTERS_RETRIES, SessionsTypedCharactersTracker, TYPED_CHARACTERS_REPORT_DELAY, countTypedCharacters };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsWindowNotifier.d.ts

@@ -0,0 +1,37 @@
+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 { IWorkbenchContribution } 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 { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.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";
+export declare class SessionsWindowNotifier extends Disposable implements IWorkbenchContribution {
+    private readonly _sessionsManagementService;
+    private readonly _sessionsService;
+    private readonly _hostService;
+    private readonly _configurationService;
+    private readonly _chatService;
+    private readonly _chatWidgetService;
+    static readonly ID = "workbench.contrib.sessionsWindowNotifier";
+    private readonly _statusListeners;
+    private readonly _activeNotifications;
+    constructor(_sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _hostService: IHostService, _configurationService: IConfigurationService, _chatService: IChatService, _chatWidgetService: IChatWidgetService);
+    /**
+     * Delay before a completed session is announced, to swallow the brief idle
+     * gap between a turn ending and the next queued turn starting. A method
+     * rather than a field so tests can override it before `_trackSession` runs
+     * during construction.
+     */
+    protected _getCompletedNotificationDelay(): number;
+    /**
+     * Delay before any toast from this window, which by definition is not showing
+     * the session, so that a window showing it notifies first.
+     */
+    protected _getBackgroundNotificationDelay(): number;
+    private _trackSession;
+    private _notify;
+    private _getNotificationBody;
+    private _sanitizeOSToastText;
+    private _clearNotification;
+}

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsWindowNotifier.js

@@ -0,0 +1,160 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable, DisposableMap, DisposableResourceMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { FocusMode } from '@codingame/monaco-vscode-api/vscode/vs/platform/native/common/native';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { getChatNotificationDedupeKey, ChatNotificationKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatNotification';
+import { ChatConfiguration, ChatNotificationMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+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 { autorunDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let SessionsWindowNotifier = class SessionsWindowNotifier extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsWindowNotifier";
+    }
+    constructor(
+        _sessionsManagementService,
+        _sessionsService,
+        _hostService,
+        _configurationService,
+        _chatService,
+        _chatWidgetService
+    ) {
+        super();
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this._hostService = _hostService;
+        this._configurationService = _configurationService;
+        this._chatService = _chatService;
+        this._chatWidgetService = _chatWidgetService;
+        this._statusListeners = this._register(( new DisposableMap()));
+        this._activeNotifications = this._register(( new DisposableResourceMap()));
+        for (const session of this._sessionsManagementService.getSessions()) {
+            this._trackSession(session);
+        }
+        this._register(this._sessionsManagementService.onDidChangeSessions(event => {
+            for (const session of event.removed) {
+                this._statusListeners.deleteAndDispose(session.sessionId);
+                this._clearNotification(session);
+            }
+            for (const session of event.added) {
+                this._trackSession(session);
+            }
+        }));
+    }
+    _getCompletedNotificationDelay() {
+        return 1_500;
+    }
+    _getBackgroundNotificationDelay() {
+        return 250;
+    }
+    _trackSession(session) {
+        const store = ( new DisposableStore());
+        const completedNotificationScheduler = store.add(( new RunOnceScheduler(
+            () => void this._notify(session, SessionStatus.Completed),
+            this._getCompletedNotificationDelay()
+        )));
+        store.add(autorunDelta(session.status, (
+            {
+                lastValue,
+                newValue
+            }
+        ) => {
+            if (lastValue === undefined || lastValue === newValue) {
+                return;
+            }
+            this._clearNotification(session);
+            if (newValue === SessionStatus.Completed) {
+                completedNotificationScheduler.schedule();
+            } else {
+                completedNotificationScheduler.cancel();
+            }
+            if (newValue === SessionStatus.NeedsInput || newValue === SessionStatus.Error) {
+                void this._notify(session, newValue);
+            }
+        }));
+        this._statusListeners.set(session.sessionId, store);
+    }
+    async _notify(session, status) {
+        if (session.status.get() !== status) {
+            return;
+        }
+        if (this._chatService.getSession(session.resource) || this._chatWidgetService.getWidgetBySessionResource(session.resource)) {
+            return;
+        }
+        const setting = status === SessionStatus.NeedsInput ? ChatConfiguration.NotifyWindowOnConfirmation : ChatConfiguration.NotifyWindowOnResponseReceived;
+        const mode = this._configurationService.getValue(setting);
+        if (mode === ChatNotificationMode.Off || (mode !== ChatNotificationMode.Always && this._hostService.hasFocus)) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        this._activeNotifications.set(session.resource, toDisposable(() => cts.dispose(true)));
+        try {
+            await timeout(this._getBackgroundNotificationDelay());
+            if (cts.token.isCancellationRequested || session.status.get() !== status || this._chatService.getSession(session.resource) || this._chatWidgetService.getWidgetBySessionResource(session.resource)) {
+                return;
+            }
+            if (!this._hostService.hasFocus) {
+                await this._hostService.focus(mainWindow, {
+                    mode: FocusMode.Notify
+                });
+            }
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            const result = await this._hostService.showToast({
+                title: this._sanitizeOSToastText(( localize(4603, "Session: {0}", session.title.get()))),
+                body: this._sanitizeOSToastText(this._getNotificationBody(session, status)),
+                actions: [( localize(4604, "Open Session"))],
+                dedupeKey: getChatNotificationDedupeKey(
+                    session.resource,
+                    status === SessionStatus.NeedsInput ? ChatNotificationKind.NeedsInput : ChatNotificationKind.Idle
+                )
+            }, cts.token);
+            if (result.clicked || typeof result.actionIndex === "number") {
+                await this._hostService.focus(mainWindow, {
+                    mode: FocusMode.Force
+                });
+                await this._sessionsService.openSession(session.resource, {
+                    source: "notification"
+                });
+            }
+        } finally {
+            if (!cts.token.isCancellationRequested) {
+                this._clearNotification(session);
+            }
+        }
+    }
+    _getNotificationBody(session, status) {
+        const workspaceLabel = session.workspace.get()?.label;
+        switch (status) {
+        case SessionStatus.NeedsInput:
+            return workspaceLabel ? ( localize(4605, "Input needed in {0}.", workspaceLabel)) : ( localize(4606, "Input needed."));
+        case SessionStatus.Completed:
+            return workspaceLabel ? ( localize(4607, "Completed in {0}.", workspaceLabel)) : ( localize(4608, "Session completed."));
+        case SessionStatus.Error:
+            return workspaceLabel ? ( localize(4609, "Failed in {0}.", workspaceLabel)) : ( localize(4610, "Session failed."));
+        default:
+            return "";
+        }
+    }
+    _sanitizeOSToastText(text) {
+        return text.replace(/`/g, "'");
+    }
+    _clearNotification(session) {
+        this._activeNotifications.deleteAndDispose(session.resource);
+    }
+};
+SessionsWindowNotifier = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsService)), ( __param(2, IHostService)), ( __param(3, IConfigurationService)), ( __param(4, IChatService)), ( __param(5, IChatWidgetService))], SessionsWindowNotifier));
+
+export { SessionsWindowNotifier };

package/vscode/src/vs/sessions/contrib/sessions/browser/views/automationTemplates.d.ts

@@ -0,0 +1,19 @@
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import type { IAutomationSchedule } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation";
+import { IAgentPlugin } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService";
+export interface IAutomationTemplateSource {
+    readonly label: string;
+    readonly uri: URI;
+}
+export interface IAutomationTemplate {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly prompt: string;
+    readonly schedule: IAutomationSchedule;
+    readonly source?: IAutomationTemplateSource;
+    readonly enabled?: boolean;
+}
+export declare const AUTOMATION_TEMPLATES: readonly IAutomationTemplate[];
+export declare function readAutomationTemplates(plugins: readonly IAgentPlugin[], reader?: IReader): readonly IAutomationTemplate[];

package/vscode/src/vs/sessions/contrib/sessions/browser/views/automationTemplates.js

@@ -0,0 +1,74 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { isContributionEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
+
+const AUTOMATION_TEMPLATES = [{
+    id: "main-updates",
+    name: ( localize(4611, "Catch up on main")),
+    description: ( localize(4612, "Pull the latest main and summarize new commits.")),
+    prompt: ( localize(
+        4613,
+        "Pull the latest main and summarize the commits that were pulled.\n\nInspect this repository's current branch, working tree, and configured remotes. Resolve the remote for main from the repository configuration rather than assuming origin. Record HEAD, then pull that remote's main into the current checkout using --ff-only. Proceed only with a clean working tree and a fast-forward update. If the remote is ambiguous, main is missing, or the update is blocked, stop and explain why. Do not switch branches, stash or discard local changes, rebase, or force an update.\n\nCompare the starting and ending HEAD and summarize only newly pulled commits, grouped by theme. Highlight user-visible changes, bug fixes, breaking changes, and follow-up actions. Include commit links and related pull requests when available. If no commits were pulled, say so."
+    )),
+    schedule: {
+        interval: "daily",
+        scheduleHour: 9,
+        scheduleMinute: 0,
+        scheduleDay: 0
+    }
+}, {
+    id: "issue-triage",
+    name: ( localize(4614, "Issue triage")),
+    description: ( localize(4615, "Triage my GitHub repositories' issues using their precedents.")),
+    prompt: ( localize(
+        4616,
+        "Triage my GitHub repositories' issues using existing repository precedents.\n\nUse the authenticated GitHub account to find my repositories, prioritizing active repositories and new or untriaged issues. For each repository, read its contribution guidelines, issue templates, existing labels, and comparable issues with maintainer decisions. Learn each repository's conventions separately before making recommendations.\n\nProduce a report grouped by repository. Link to each issue, recommend existing labels, identify likely duplicates, and draft a reply when useful. Cite prior issues, pull requests, or maintainer comments supporting each recommendation. Flag uncertainty or missing precedent rather than inventing a rule. Do not apply labels, post comments, close issues, or make other GitHub changes. State which repositories and issues were reviewed and any access limitations."
+    )),
+    schedule: {
+        interval: "daily",
+        scheduleHour: 9,
+        scheduleMinute: 0,
+        scheduleDay: 0
+    }
+}, {
+    id: "find-bugs",
+    name: ( localize(4617, "Find bugs")),
+    description: ( localize(4618, "Explore the codebase and report verified, reproducible bugs.")),
+    prompt: ( localize(
+        4619,
+        "Explore this codebase and find concrete, reproducible bugs.\n\nRead the repository guidance and understand the architecture before choosing a focused area to investigate, such as recent changes, complex state transitions, or error handling. Trace suspected problems through callers and existing tests. Use the smallest relevant tests or a minimal reproduction to verify behavior, and distinguish confirmed bugs from hypotheses. Avoid style-only suggestions and speculative findings.\n\nReport high-confidence, actionable bugs with severity, file and line references, a triggering scenario, expected versus actual behavior, and supporting test or reproduction results. Suggest a focused fix for each finding without modifying repository files or committing changes. State what you explored, any validation limitations, and when no confirmed bugs were found."
+    )),
+    schedule: {
+        interval: "weekly",
+        scheduleHour: 9,
+        scheduleMinute: 0,
+        scheduleDay: 1
+    }
+}];
+function readAutomationTemplates(plugins, reader) {
+    const templates = [...AUTOMATION_TEMPLATES];
+    for (const plugin of plugins) {
+        const enablement = reader ? plugin.enablement.read(reader) : plugin.enablement.get();
+        if (!isContributionEnabled(enablement)) {
+            continue;
+        }
+        const automations = reader ? plugin.automations.read(reader) : plugin.automations.get();
+        for (const automation of automations) {
+            templates.push({
+                id: `${( plugin.uri.toString())}#automation=${automation.blueprint.id}`,
+                name: automation.blueprint.name,
+                description: automation.blueprint.description ?? ( localize(4620, "Provided by {0}.", plugin.label)),
+                prompt: automation.blueprint.prompt,
+                schedule: automation.blueprint.schedule,
+                source: {
+                    label: plugin.label,
+                    uri: automation.uri
+                },
+                enabled: false
+            });
+        }
+    }
+    return templates;
+}
+
+export { AUTOMATION_TEMPLATES, readAutomationTemplates };

package/vscode/src/vs/sessions/contrib/sessions/browser/views/automationsAccessibility.d.ts

@@ -0,0 +1,4 @@
+import { IAutomationDescriptor, IAutomationRun } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation";
+import { AutomationCatalogueState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService";
+import { IAutomationTemplate } from "./automationTemplates.js";
+export declare function buildAutomationsAccessibleContent(automations: readonly IAutomationDescriptor[], runs: readonly IAutomationRun[], catalogueState: AutomationCatalogueState, templates?: readonly IAutomationTemplate[]): string;

package/vscode/src/vs/sessions/contrib/sessions/browser/views/automationsAccessibility.js

@@ -0,0 +1,228 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getActiveElement, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { AccessibleViewType, AccessibleContentProvider, AccessibleViewProviderId } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
+import { AccessibleViewRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service';
+import { DAYS_OF_WEEK } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/schedule';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { AutomationsCustomViewFocusContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { readAutomationTemplates } from './automationTemplates.js';
+
+class AutomationsCustomViewAccessibilityHelp {
+    constructor() {
+        this.type = AccessibleViewType.Help;
+        this.priority = 106;
+        this.name = "sessions-automations-help";
+        this.when = AutomationsCustomViewFocusContext;
+    }
+    getProvider(accessor) {
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const automationService = accessor.get(IAutomationService);
+        const agentPluginService = accessor.get(IAgentPluginService);
+        const restoreFocus = createFocusRestorer(layoutService);
+        const templates = readAutomationTemplates(agentPluginService.plugins.get());
+        const hasSavedAutomations = automationService.automations.get().length > 0;
+        const builtInTemplatesVisible = ( templates.some(template => !template.source));
+        const pluginTemplatesVisible = ( templates.some(template => !!template.source));
+        const content = [( localize(
+            4621,
+            "You are in the Automations view. It contains available automation cards followed by run history. Loading, unavailable, and error messages indicate that the catalogue may be incomplete."
+        )), ...(builtInTemplatesVisible ? [hasSavedAutomations ? ( localize(
+            4622,
+            "The Built-in Templates section is collapsed by default because saved automations exist. Press Enter or Space on its disclosure control to expand it."
+        )) : ( localize(
+            4623,
+            "The Built-in Templates section is expanded by default while there are no saved automations. Tab to a template and press Enter or Space to open a New automation dialog with an editable name, prompt, and schedule."
+        ))] : []), ...(pluginTemplatesVisible ? [( localize(
+            4624,
+            "The Templates from Plugins section is available whenever enabled plugins provide templates. Press Enter or Space on its disclosure control to expand or collapse it. A blue marker indicates templates added since the section was last expanded. Plugin templates start disabled."
+        ))] : []), ( localize(
+            4625,
+            "Use Import Automation in the view header, or drop one .automation.md file anywhere in the view, to review a shared Automation blueprint. Imported Automations start disabled. Open a saved Automation's context menu and choose Export to save a portable blueprint."
+        )), ( localize(
+            4626,
+            "For saved automations, Tab to a card's Edit control and action buttons. Use Left Arrow and Right Arrow to move between Run now and Delete. Press Enter or Space to activate a control. Edit, or clicking anywhere else on the card, opens the automation dialog. Open a card's context menu{0} (for example Shift+F10). Duplicate opens a prefilled New automation dialog, Disable prevents scheduled runs, and Delete asks for confirmation. Run now starts a session immediately.",
+            "<keybinding:editor.action.showContextMenu>"
+        )), ( localize(
+            4627,
+            "Run history is grouped by date. While a run is waiting for its session, a lightweight row shows the automation name with a Working... description. Once the session is available, use Up Arrow and Down Arrow to navigate the Sessions list, Enter to open, and Tab to reach Stop, the configured Archive or Mark as Done action, or Delete when available. Open a row's context menu, for example with Shift+F10, to rename it, change its active or read state, or delete it. Delete permanently deletes the session and removes it from run history after confirmation."
+        )), ( localize(
+            4628,
+            "Completed and failed runs that have not been opened are announced as unread. Use Mark all as read to clear all available unread runs."
+        )), ( localize(
+            4629,
+            "Use Open Accessible View to read the current automations and run history as text."
+        ))].join("\n");
+        return ( new AccessibleContentProvider(AccessibleViewProviderId.Automations, {
+            type: AccessibleViewType.Help
+        }, () => content, restoreFocus, AccessibilityVerbositySettingId.Automations));
+    }
+}
+class AutomationsCustomViewAccessibleView {
+    constructor() {
+        this.type = AccessibleViewType.View;
+        this.priority = 106;
+        this.name = "sessions-automations-view";
+        this.when = AutomationsCustomViewFocusContext;
+    }
+    getProvider(accessor) {
+        const automationService = accessor.get(IAutomationService);
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const agentPluginService = accessor.get(IAgentPluginService);
+        const restoreFocus = createFocusRestorer(layoutService);
+        return ( new AccessibleContentProvider(AccessibleViewProviderId.Automations, {
+            type: AccessibleViewType.View
+        }, () => buildAutomationsAccessibleContent(automationService.automations.get(), automationService.runs.get().filter(
+            run => run.status === "pending" || run.status === "running" || (!!run.sessionResource && !!sessionsManagementService.getSession(run.sessionResource))
+        ), automationService.catalogueState.get(), readAutomationTemplates(agentPluginService.plugins.get())), restoreFocus, AccessibilityVerbositySettingId.Automations));
+    }
+}
+function createFocusRestorer(layoutService) {
+    const focusedElement = getActiveElement();
+    return () => {
+        if (isHTMLElement(focusedElement) && focusedElement.isConnected) {
+            focusedElement.focus();
+        } else {
+            layoutService.focusPart(Parts.CUSTOM_VIEW_GRID_PART);
+        }
+    };
+}
+function buildAutomationsAccessibleContent(automations, runs, catalogueState, templates = readAutomationTemplates([])) {
+    const lines = [( localize(4630, "Automations"))];
+    const builtInTemplates = templates.filter(template => !template.source);
+    const pluginTemplates = templates.filter(template => !!template.source);
+    if (automations.length > 0) {
+        if (catalogueState === "loading") {
+            lines.push(( localize(4631, "Additional automations are loading.")));
+        } else if (catalogueState === "unavailable") {
+            lines.push(( localize(4632, "Some automations are unavailable.")));
+        } else if (catalogueState === "error") {
+            lines.push(( localize(4633, "Some automations could not be loaded.")));
+        }
+        for (const automation of automations) {
+            lines.push("");
+            lines.push(automation.enabled ? ( localize(4634, "{0}, enabled", automation.name)) : ( localize(4635, "{0}, disabled", automation.name)));
+            lines.push(( localize(4636, "Schedule: {0}", formatSchedule(automation.schedule))));
+            lines.push(( localize(4637, "Prompt: {0}", automation.prompt)));
+        }
+    } else if (catalogueState === "loading") {
+        lines.push(( localize(4638, "Loading automations.")));
+    } else if (catalogueState === "unavailable") {
+        lines.push(( localize(
+            4639,
+            "Some automations are unavailable. One or more providers are disconnected, disabled, or do not support automations."
+        )));
+    } else if (catalogueState === "error") {
+        lines.push(( localize(4640, "Unable to load automations.")));
+    } else {
+        lines.push(( localize(4641, "No automations.")));
+    }
+    if (builtInTemplates.length > 0 || pluginTemplates.length > 0) {
+        lines.push("");
+        lines.push(( localize(4642, "Available templates")));
+        if (builtInTemplates.length > 0) {
+            lines.push(( localize(4643, "Built-in Templates")));
+            for (const template of builtInTemplates) {
+                lines.push(( localize(
+                    4644,
+                    "{0}, {1}. {2}",
+                    template.name,
+                    formatSchedule(template.schedule),
+                    template.description
+                )));
+            }
+        }
+        if (pluginTemplates.length > 0) {
+            lines.push(( localize(4645, "Templates from Plugins")));
+            for (const template of pluginTemplates) {
+                if (template.source) {
+                    lines.push(( localize(
+                        4646,
+                        "{0}, {1}. {2} From {3}.",
+                        template.name,
+                        formatSchedule(template.schedule),
+                        template.description,
+                        template.source.label
+                    )));
+                }
+            }
+        }
+    }
+    lines.push("");
+    lines.push(( localize(4647, "Run history")));
+    if (runs.length === 0) {
+        lines.push(( localize(4648, "No runs.")));
+    } else {
+        const automationNames = ( new Map(automations.map(automation => [automation.id, automation.name])));
+        for (const run of runs) {
+            lines.push(( localize(
+                4649,
+                "{0}, {1}, started {2}",
+                automationNames.get(run.automationId) ?? ( localize(4650, "Unknown automation")),
+                formatRunStatus(run),
+                ( new Date(run.startedAt)).toLocaleString()
+            )));
+            if (run.errorMessage) {
+                lines.push(( localize(4651, "Error: {0}", run.errorMessage)));
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function formatSchedule(schedule) {
+    switch (schedule.interval) {
+    case "manual":
+        return localize(4652, "Manual");
+    case "hourly":
+        return localize(4653, "Hourly");
+    case "daily":
+        return localize(
+            4654,
+            "Daily at {0}",
+            formatTime(schedule.scheduleHour, schedule.scheduleMinute)
+        );
+    case "weekly":
+        return localize(
+            4655,
+            "{0} at {1}",
+            DAYS_OF_WEEK[((schedule.scheduleDay % 7) + 7) % 7],
+            formatTime(schedule.scheduleHour, schedule.scheduleMinute)
+        );
+    }
+}
+function formatTime(hour, minute) {
+    const date = ( new Date(Date.UTC(
+        2000,
+        0,
+        1,
+        Math.max(0, Math.min(23, hour | 0)),
+        Math.max(0, Math.min(59, minute | 0))
+    )));
+    return date.toLocaleTimeString(undefined, {
+        hour: "numeric",
+        minute: "2-digit",
+        timeZone: "UTC"
+    });
+}
+function formatRunStatus(run) {
+    switch (run.status) {
+    case "pending":
+        return localize(4656, "Pending");
+    case "running":
+        return localize(4657, "Running");
+    case "completed":
+        return localize(4658, "Completed");
+    case "failed":
+        return localize(4659, "Failed");
+    }
+}
+AccessibleViewRegistry.register(( new AutomationsCustomViewAccessibilityHelp()));
+AccessibleViewRegistry.register(( new AutomationsCustomViewAccessibleView()));
+
+export { buildAutomationsAccessibleContent };