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

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

@@ -0,0 +1,294 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.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 { waitForState } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utilsCancellation';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+let AutomationRunner = class AutomationRunner {
+    constructor(
+        automationService,
+        sessionsManagementService,
+        logService,
+        notificationService
+    ) {
+        this.automationService = automationService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.logService = logService;
+        this.notificationService = notificationService;
+    }
+    runOnce(automation, trigger, leaderWindowId, token = CancellationToken.None) {
+        const dispatched = ( new DeferredPromise());
+        return {
+            whenDispatched: dispatched.p,
+            whenCompleted: this._runOnce(automation, trigger, leaderWindowId, token, dispatched)
+        };
+    }
+    async _runOnce(automation, trigger, leaderWindowId, token, dispatched) {
+        try {
+            await this._runOnceInner(automation, trigger, leaderWindowId, token, dispatched);
+        } catch (err) {
+            this.logService.error(`[AutomationRunner] unexpected error in runOnce for ${automation.id}`, err);
+        } finally {
+            await dispatched.complete({
+                kind: "notStarted",
+                reason: "error"
+            });
+        }
+    }
+    async _runOnceInner(automation, trigger, leaderWindowId, token, dispatched) {
+        let runId;
+        try {
+            if (!this.automationService.getAutomation(automation.id)) {
+                this.logService.trace(`[AutomationRunner] skipping ${automation.id}: automation was deleted.`);
+                await dispatched.complete({
+                    kind: "notStarted",
+                    reason: "deleted"
+                });
+                return;
+            }
+            const target = automation.target;
+            const isolationMode = target.kind === "workspace" ? target.isolation.kind === "folder" ? "workspace" : target.isolation.kind === "worktree" ? "worktree" : undefined : undefined;
+            const branch = target.kind === "workspace" && target.isolation.kind === "worktree" ? target.isolation.branch : undefined;
+            const automationConfiguration = automation.sessionTemplate ? {
+                sessionTemplate: automation.sessionTemplate
+            } : automation.modelId !== undefined || automation.mode !== undefined || automation.permissionLevel !== undefined ? {
+                modelId: automation.modelId,
+                mode: automation.mode,
+                permissionLevel: automation.permissionLevel
+            } : undefined;
+            const createOptions = target.providerId !== undefined || target.sessionTypeId !== undefined || automationConfiguration !== undefined || isolationMode !== undefined || branch !== undefined ? {
+                providerId: target.providerId,
+                sessionTypeId: target.sessionTypeId,
+                ...(automationConfiguration ? {
+                    sessionTemplate: automation.sessionTemplate,
+                    automationConfiguration
+                } : {}),
+                ...((automation.sessionTemplate?.modelId ?? automation.modelId) ? {
+                    modelId: automation.sessionTemplate?.modelId ?? automation.modelId
+                } : {}),
+                ...(!automation.sessionTemplate && automation.mode ? {
+                    modeId: automation.mode
+                } : {}),
+                ...(!automation.sessionTemplate && automation.permissionLevel ? {
+                    permissionLevel: automation.permissionLevel
+                } : {}),
+                isolationMode,
+                branch
+            } : undefined;
+            const targetAvailable = target.kind === "quickChat" ? this.sessionsManagementService.isQuickChatTargetAvailable(createOptions) : this.sessionsManagementService.isNewSessionTargetAvailable(target.folderUri, createOptions);
+            if (!targetAvailable) {
+                this.logService.trace(
+                    `[AutomationRunner] deferring ${automation.id}: target is not yet advertised.`
+                );
+                if (trigger === "manual") {
+                    this.notificationService.info(( localize(
+                        3335,
+                        "Automation '{0}' cannot start until its agent becomes available.",
+                        automation.name
+                    )));
+                }
+                await dispatched.complete({
+                    kind: "notStarted",
+                    reason: "targetUnavailable"
+                });
+                return;
+            }
+            const claim = await this.automationService.recordRunStart(automation.id, trigger, leaderWindowId);
+            if (!claim.claimed) {
+                if (claim.externalDispatch) {
+                    let cancellationForwarded = false;
+                    const forwardCancellation = () => {
+                        if (!cancellationForwarded) {
+                            cancellationForwarded = true;
+                            try {
+                                claim.externalDispatch?.cancel?.();
+                            } catch (error) {
+                                this.logService.error(
+                                    `[AutomationRunner] Failed to forward cancellation for ${automation.id}`,
+                                    error
+                                );
+                            }
+                        }
+                    };
+                    const cancellationListener = claim.externalDispatch.cancel ? token.onCancellationRequested(forwardCancellation) : undefined;
+                    const sessionResource = claim.externalDispatch.sessionResource;
+                    try {
+                        if (sessionResource) {
+                            await dispatched.complete({
+                                kind: "started",
+                                run: claim.run,
+                                sessionResource
+                            });
+                        } else {
+                            await dispatched.complete({
+                                kind: "notStarted",
+                                reason: "error",
+                                run: claim.run
+                            });
+                        }
+                        if (token.isCancellationRequested) {
+                            forwardCancellation();
+                        }
+                        await claim.externalDispatch.whenCompleted;
+                    } finally {
+                        cancellationListener?.dispose();
+                    }
+                    return;
+                }
+                this.logService.trace(`[AutomationRunner] skipping ${automation.id}: active run already exists.`);
+                await dispatched.complete({
+                    kind: "alreadyRunning",
+                    activeRun: claim.run
+                });
+                return;
+            }
+            runId = claim.run.id;
+            const run = (await this.automationService.updateRun(runId, {
+                status: "running"
+            })) ?? claim.run;
+            this.logService.info(
+                `[AutomationRunner] claimed run ${runId} for automation ${automation.id}: trigger=${trigger}, leaderWindowId=${leaderWindowId}.`
+            );
+            if (token.isCancellationRequested) {
+                await dispatched.complete({
+                    kind: "notStarted",
+                    reason: "cancelled",
+                    run
+                });
+                await this._markCancelled(runId, automation);
+                return;
+            }
+            const options = {
+                query: automation.prompt,
+                background: true,
+                title: automation.name?.substring(0, 100)
+            };
+            this.logService.trace(
+                `[AutomationRunner] running ${automation.id}: target=${target.kind}, provider=${createOptions?.providerId ?? "(default)"}, sessionType=${createOptions?.sessionTypeId ?? "(default)"}, model=${automationConfiguration?.modelId ?? "(default)"}, mode=${automationConfiguration?.mode ?? "(default)"}, permissionLevel=${automationConfiguration?.permissionLevel ?? "(default)"}`
+            );
+            this.logService.info(
+                `[AutomationRunner] creating a session for run ${runId} (automation ${automation.id}).`
+            );
+            let session;
+            if (target.kind === "quickChat") {
+                session = await this.sessionsManagementService.createAndSendQuickChatRequest(options, createOptions, token);
+            } else {
+                session = await this.sessionsManagementService.createAndSendNewChatRequest(target.folderUri, options, createOptions, token);
+            }
+            if (session) {
+                const sessionResource = session.resource;
+                let updatedRun;
+                try {
+                    updatedRun = await this.automationService.updateRun(runId, {
+                        sessionResource
+                    });
+                } catch (err) {
+                    this.logService.warn(`[AutomationRunner] session ${( sessionResource.toString())} was created for run ${runId} (automation ${automation.id}), but persisting the session link failed.`, err);
+                    throw err;
+                }
+                if (updatedRun) {
+                    this.logService.info(
+                        `[AutomationRunner] linked run ${runId} for automation ${automation.id} to session ${( sessionResource.toString())}.`
+                    );
+                } else {
+                    this.logService.warn(`[AutomationRunner] session ${( sessionResource.toString())} was created for run ${runId} (automation ${automation.id}), but the run no longer exists and the session link was not persisted.`);
+                }
+                const dispatchedRun = updatedRun ?? run;
+                await dispatched.complete({
+                    kind: "started",
+                    run: dispatchedRun,
+                    sessionResource
+                });
+            } else {
+                this.logService.warn(
+                    `[AutomationRunner] session creation returned no session for run ${runId} (automation ${automation.id}): cancelled=${token.isCancellationRequested}.`
+                );
+                await dispatched.complete({
+                    kind: "notStarted",
+                    reason: token.isCancellationRequested ? "cancelled" : "error",
+                    run
+                });
+            }
+            if (token.isCancellationRequested) {
+                await this._markCancelled(runId, automation);
+                return;
+            }
+            const terminalStatus = session ? await waitForState(
+                derived(reader => session.mainChat.read(reader).status.read(reader)),
+                status => status === SessionStatus.Completed || status === SessionStatus.Error,
+                undefined,
+                token
+            ) : SessionStatus.Completed;
+            if (token.isCancellationRequested) {
+                await this._markCancelled(runId, automation);
+                return;
+            }
+            if (terminalStatus === SessionStatus.Error) {
+                throw ( new Error(( localize(3336, "Agent session failed."))));
+            }
+            await this.automationService.updateRun(runId, {
+                status: "completed",
+                completedAt: ( new Date()).toISOString()
+            });
+        } catch (err) {
+            if (runId && token.isCancellationRequested) {
+                await dispatched.complete({
+                    kind: "notStarted",
+                    reason: "cancelled"
+                });
+                await this._markCancelled(runId, automation);
+                return;
+            }
+            this.logService.error(`[AutomationRunner] run for ${automation.id} failed`, err);
+            try {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                this.notificationService.error(( localize(3337, "Automation '{0}' failed: {1}", automation.name, errorMessage)));
+                let failedRun;
+                if (runId) {
+                    failedRun = await this.automationService.updateRun(runId, {
+                        status: "failed",
+                        completedAt: ( new Date()).toISOString(),
+                        errorMessage
+                    });
+                }
+                await dispatched.complete({
+                    kind: "notStarted",
+                    reason: "error",
+                    run: failedRun
+                });
+            } catch (innerErr) {
+                this.logService.error(
+                    `[AutomationRunner] error recording failure for ${automation.id}`,
+                    innerErr
+                );
+            }
+        }
+    }
+    async _markCancelled(runId, automation) {
+        try {
+            if (this.automationService.getActiveRunFor(automation.id)?.id === runId) {
+                await this.automationService.updateRun(runId, {
+                    status: "failed",
+                    completedAt: ( new Date()).toISOString(),
+                    errorMessage: ( localize(3338, "Cancelled"))
+                });
+            }
+        } catch (err) {
+            this.logService.error(
+                `[AutomationRunner] error recording cancellation for ${automation.id}`,
+                err
+            );
+        }
+    }
+};
+AutomationRunner = ( __decorate([( __param(0, IAutomationService)), ( __param(1, ISessionsManagementService)), ( __param(2, ILogService)), ( __param(3, INotificationService))], AutomationRunner));
+
+export { AutomationRunner };

package/vscode/src/vs/sessions/contrib/automations/browser/automationScheduler.d.ts

@@ -0,0 +1,59 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IAutomationRunner } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner.service";
+import { IAutomationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { IAutomationLeaderElection } from "./automationLeaderElection.js";
+export declare const DEFAULT_SCHEDULER_TICK_MS = 60000;
+export declare const CRASH_RECOVERY_REASON: string;
+export declare const RUN_TIMEOUT_REASON_PREFIX = "Timed out after";
+export interface IAutomationSchedulerCoreOptions {
+    readonly tickIntervalMs?: number;
+    readonly now?: () => Date;
+    readonly leaderElection?: IAutomationLeaderElection;
+    readonly disableAutoTick?: boolean;
+    readonly isFeatureEnabled?: () => boolean;
+    readonly getRunTimeoutMs?: () => number;
+    readonly onDidChangeTargetAvailability?: Event<void>;
+}
+export declare class AutomationSchedulerCore extends Disposable {
+    private readonly automationService;
+    private readonly runner;
+    private readonly logService;
+    private readonly _leader;
+    private readonly _tickIntervalMs;
+    private readonly _now;
+    private readonly _isFeatureEnabled;
+    private readonly _getRunTimeoutMs;
+    private readonly _timer;
+    private readonly _runCts;
+    private _didStartupForCurrentLeadership;
+    private _pendingRuns;
+    constructor(automationService: IAutomationService, runner: IAutomationRunner, storageService: IStorageService, logService: ILogService, options?: IAutomationSchedulerCoreOptions);
+    /** Test-only: run a single tick and await it. */
+    tickForTesting(): Promise<void>;
+    /** Test-only: await in-flight runs. */
+    waitForPendingRuns(): Promise<void>;
+    private kickoffPendingRuns;
+    private tickOnce;
+    private dispatchDue;
+    private runOneWithTimeout;
+    dispose(): void;
+}
+export declare class AutomationScheduler extends Disposable implements IWorkbenchContribution {
+    private readonly _automationService;
+    private readonly _runner;
+    private readonly _storageService;
+    private readonly _logService;
+    private readonly _configurationService;
+    private readonly _sessionsManagementService;
+    static readonly ID = "workbench.contrib.automationScheduler";
+    private readonly _core;
+    constructor(_automationService: IAutomationService, _runner: IAutomationRunner, _storageService: IStorageService, _logService: ILogService, _configurationService: IConfigurationService, _sessionsManagementService: ISessionsManagementService);
+    private _isEnabled;
+    private _createCore;
+}

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

@@ -0,0 +1,232 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IntervalTimer, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { stringHash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable, MutableDisposable } 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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IAutomationRunner } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner.service';
+import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service';
+import { DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES, CHAT_AUTOMATIONS_ENABLED_SETTING, CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { AutomationLeaderElection } from './automationLeaderElection.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const DEFAULT_SCHEDULER_TICK_MS = 60_000;
+const CRASH_RECOVERY_REASON = ( localize(3339, "Interrupted by app shutdown"));
+class AutomationSchedulerCore extends Disposable {
+    constructor(automationService, runner, storageService, logService, options = {}) {
+        super();
+        this.automationService = automationService;
+        this.runner = runner;
+        this.logService = logService;
+        this._timer = this._register(( new IntervalTimer()));
+        this._runCts = this._register(( new CancellationTokenSource()));
+        this._didStartupForCurrentLeadership = false;
+        this._pendingRuns = Promise.resolve();
+        this._tickIntervalMs = options.tickIntervalMs ?? DEFAULT_SCHEDULER_TICK_MS;
+        this._now = options.now ?? (() => ( new Date()));
+        this._isFeatureEnabled = options.isFeatureEnabled ?? (() => true);
+        this._getRunTimeoutMs = options.getRunTimeoutMs ?? (() => DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES * 60_000);
+        this._leader = options.leaderElection ?? this._register(( new AutomationLeaderElection(storageService, logService)));
+        this._register(autorun(reader => {
+            const isLeader = this._leader.isLeader.read(reader);
+            if (!isLeader) {
+                this._didStartupForCurrentLeadership = false;
+                this.automationService.stopStaleRunRecovery();
+                return;
+            }
+            this.kickoffPendingRuns(() => this.tickOnce(true));
+        }));
+        if (!options.disableAutoTick) {
+            this._timer.cancelAndSet(() => {
+                this.kickoffPendingRuns(() => this.tickOnce(false));
+            }, this._tickIntervalMs);
+        }
+        if (options.onDidChangeTargetAvailability) {
+            this._register(options.onDidChangeTargetAvailability(() => {
+                this.kickoffPendingRuns(() => this.tickOnce(false));
+            }));
+        }
+    }
+    async tickForTesting() {
+        this.kickoffPendingRuns(() => this.tickOnce(false));
+        await this._pendingRuns;
+    }
+    async waitForPendingRuns() {
+        await this._pendingRuns;
+    }
+    kickoffPendingRuns(task) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this._pendingRuns = this._pendingRuns.then(task).catch(err => {
+            this.logService.error("[AutomationScheduler] tick failed", err);
+        });
+    }
+    async tickOnce(isLeadershipTransition) {
+        if (!this._leader.isLeader.get()) {
+            return;
+        }
+        if (!this._isFeatureEnabled()) {
+            return;
+        }
+        if (!this._didStartupForCurrentLeadership) {
+            this._didStartupForCurrentLeadership = true;
+            await this.automationService.startStaleRunRecovery(CRASH_RECOVERY_REASON);
+            await this.dispatchDue("catch_up");
+            if (isLeadershipTransition) {
+                return;
+            }
+        }
+        await this.dispatchDue("schedule");
+    }
+    async dispatchDue(trigger) {
+        const now = this._now();
+        const due = this.automationService.automations.get().filter(
+            automation => this.automationService.isSchedulingOwnedByHost?.(automation.id) !== true && isDue(automation, now)
+        );
+        if (due.length === 0) {
+            return;
+        }
+        const leaderWindowId = stringHash(this._leader.instanceId, 0);
+        for (const automation of due) {
+            try {
+                await this.runOneWithTimeout(automation, trigger, leaderWindowId);
+            } catch (err) {
+                this.logService.error("[AutomationScheduler] dispatch failed for automation", automation.id, err);
+            }
+        }
+    }
+    async runOneWithTimeout(automation, trigger, leaderWindowId) {
+        const timeoutMs = this._getRunTimeoutMs();
+        const perRunCts = ( new CancellationTokenSource(this._runCts.token));
+        try {
+            if (timeoutMs <= 0) {
+                await this.runner.runOnce(automation, trigger, leaderWindowId, perRunCts.token).whenCompleted;
+                return;
+            }
+            let timedOut = false;
+            await raceTimeout(
+                this.runner.runOnce(automation, trigger, leaderWindowId, perRunCts.token).whenCompleted,
+                timeoutMs,
+                () => {
+                    timedOut = true;
+                }
+            );
+            if (!timedOut) {
+                return;
+            }
+            try {
+                const active = this.automationService.getActiveRunFor(automation.id);
+                if (active) {
+                    const updated = await this.automationService.updateRun(active.id, {
+                        status: "failed",
+                        errorMessage: ( localize(3340, "Timed out after {0} minute(s).", Math.round(timeoutMs / 60_000))),
+                        completedAt: this._now().toISOString()
+                    });
+                    if (updated) {
+                        this.logService.warn(
+                            `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms; marked run ${active.id} failed (previousStatus=${active.status}, session=${updated.sessionResource?.toString() ?? "(none)"}).`
+                        );
+                    } else {
+                        this.logService.warn(
+                            `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms, but active run ${active.id} disappeared before it could be marked failed (previousStatus=${active.status}, session=${active.sessionResource?.toString() ?? "(none)"}).`
+                        );
+                    }
+                } else {
+                    this.logService.warn(
+                        `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms with no active run recorded.`
+                    );
+                }
+            } catch (err) {
+                this.logService.warn(
+                    `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms and failed to mark its active run as failed.`,
+                    err
+                );
+            }
+            perRunCts.cancel();
+        } finally {
+            perRunCts.dispose();
+        }
+    }
+    dispose() {
+        this.automationService.stopStaleRunRecovery();
+        this._runCts.cancel();
+        super.dispose();
+    }
+}
+let AutomationScheduler = class AutomationScheduler extends Disposable {
+    static {
+        this.ID = "workbench.contrib.automationScheduler";
+    }
+    constructor(
+        _automationService,
+        _runner,
+        _storageService,
+        _logService,
+        _configurationService,
+        _sessionsManagementService
+    ) {
+        super();
+        this._automationService = _automationService;
+        this._runner = _runner;
+        this._storageService = _storageService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._core = this._register(( new MutableDisposable()));
+        if (this._isEnabled()) {
+            this._createCore();
+        }
+        this._register(_configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(CHAT_AUTOMATIONS_ENABLED_SETTING)) {
+                if (this._isEnabled()) {
+                    this._createCore();
+                } else {
+                    this._core.clear();
+                }
+            }
+        }));
+    }
+    _isEnabled() {
+        return this._configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+    }
+    _createCore() {
+        if (this._core.value) {
+            return;
+        }
+        this._core.value = ( new AutomationSchedulerCore(
+            this._automationService,
+            this._runner,
+            this._storageService,
+            this._logService,
+            {
+                isFeatureEnabled: () => this._isEnabled(),
+                getRunTimeoutMs: () => {
+                    const minutes = this._configurationService.getValue(CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING);
+                    const sane = typeof minutes === "number" && Number.isFinite(minutes) && minutes >= 1 ? minutes : DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES;
+                    return sane * 60_000;
+                },
+                onDidChangeTargetAvailability: this._sessionsManagementService.onDidChangeSessionTypes
+            }
+        ));
+    }
+};
+AutomationScheduler = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IAutomationRunner)), ( __param(2, IStorageService)), ( __param(3, ILogService)), ( __param(4, IConfigurationService)), ( __param(5, ISessionsManagementService))], AutomationScheduler));
+function isDue(automation, now) {
+    if (!automation.enabled || !automation.nextRunAt) {
+        return false;
+    }
+    const next = Date.parse(automation.nextRunAt);
+    if (Number.isNaN(next)) {
+        return false;
+    }
+    return next <= now.getTime();
+}
+
+export { AutomationScheduler, AutomationSchedulerCore, CRASH_RECOVERY_REASON, DEFAULT_SCHEDULER_TICK_MS };

package/vscode/src/vs/sessions/contrib/automations/browser/automationStorageService.d.ts

@@ -0,0 +1,13 @@
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IAutomationStorageCompareAndSwapResult } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/common/automationStorageService";
+import { IAutomationStorageService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/common/automationStorageService.service";
+/**
+ * Uses an IndexedDB transaction so automation writes remain atomic across browser tabs.
+ */
+export declare class BrowserAutomationStorageService implements IAutomationStorageService {
+    readonly _serviceBrand: undefined;
+    private readonly storageService;
+    constructor(storageService: IStorageService);
+    read(key: string): Promise<string | undefined>;
+    compareAndSwap(key: string, expectedValue: string | undefined, newValue: string): Promise<IAutomationStorageCompareAndSwapResult>;
+}

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

@@ -0,0 +1,22 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { BrowserStorageService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/storage/browser/storageService';
+
+let BrowserAutomationStorageService = class BrowserAutomationStorageService {
+    constructor(storageService) {
+        if (!(storageService instanceof BrowserStorageService)) {
+            throw ( new Error("Browser automation storage requires BrowserStorageService."));
+        }
+        this.storageService = storageService;
+    }
+    async read(key) {
+        return this.storageService.getApplicationStorageValue(key);
+    }
+    async compareAndSwap(key, expectedValue, newValue) {
+        return this.storageService.compareAndSwapApplicationStorage(key, expectedValue, newValue);
+    }
+};
+BrowserAutomationStorageService = ( __decorate([( __param(0, IStorageService))], BrowserAutomationStorageService));
+
+export { BrowserAutomationStorageService };