@codingame/monaco-vscode-api 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostAutomationStore.js

@@ -1,16 +1,20 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { disposableTimeout, timeout } from '../../../../../base/common/async.js';
-import { isCancellationError, CancellationError } from '../../../../../base/common/errors.js';
+import { raceCancellationError, disposableTimeout } from '../../../../../base/common/async.js';
+import { CancellationToken } from '../../../../../base/common/cancellation.js';
+import { CancellationError } from '../../../../../base/common/errors.js';
 import { Event } from '../../../../../base/common/event.js';
 import { Disposable, DisposableMap, DisposableStore, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { stableStringify } from '../../../../../base/common/objects.js';
 import '../../../../../base/common/observableInternal/index.js';
+import { basename, isEqual, isEqualOrParent, relativePath, joinPath } from '../../../../../base/common/resources.js';
 import { hasKey } from '../../../../../base/common/types.js';
 import { URI } from '../../../../../base/common/uri.js';
+import { AgentSession } from '../../../../../platform/agentHost/common/agent.js';
 import { generateUuid } from '../../../../../base/common/uuid.js';
 import { localize } from '../../../../../nls.js';
-import { AGENT_HOST_AUTOMATION_MIGRATION_CONFIG_KEY, applyLegacyAutomationSessionConfig, migrateLegacyAutomationSessionConfig, AGENT_HOST_LEGACY_AUTOMATION_IMPORT_META_KEY, AGENT_HOST_LEGACY_AUTOMATION_IMPORT_PENDING_META_KEY } from '../../../../../platform/agentHost/common/automationMigration.js';
-import { isAgentHostAutomationCatalogMigrated, isAgentHostLegacyAutomationImportPending, isAgentHostLegacyAutomationImport } from '../../../../../platform/agentHost/common/meta/automationMeta.js';
+import { applyLegacyAutomationSessionConfig } from '../../../../../platform/agentHost/common/automationConfig.js';
+import { isCustomizationEnabled } from '../../../../../platform/agentHost/common/customizationEnablement.js';
 import { SessionConfigKey, omitAutomationSessionTemplateConfigValues, pickAutomationDefinitionOwnedConfigValues } from '../../../../../platform/agentHost/common/sessionConfigKeys.js';
 import { ActionType } from '../../../../../platform/agentHost/common/state/protocol/common/actions.js';
 import '../../../../../platform/agentHost/common/state/protocol/common/notifications.js';
@@ -22,54 +26,49 @@ import '../../../../../platform/agentHost/common/state/protocol/channels-changes
 import '../../../../../platform/agentHost/common/state/protocol/channels-resource-watch/state.js';
 import { AutomationOperation, AutomationTriggerKind, AutomationMisfirePolicy } from '../../../../../platform/agentHost/common/state/protocol/channels-automation/state.js';
 import { AutomationRunStatus, AutomationRunOriginKind } from '../../../../../platform/agentHost/common/state/protocol/channels-automation-run/state.js';
-import { StateComponents, AUTOMATION_CATALOG_URI, ROOT_STATE_URI, isAhpAutomationCatalogChannel } from '../../../../../platform/agentHost/common/state/sessionState.js';
+import { StateComponents, AUTOMATION_CATALOG_URI, isAhpAutomationCatalogChannel } from '../../../../../platform/agentHost/common/state/sessionState.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { StorageScope } from '../../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { IAgentHostActiveClientService } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service.js';
+import '../../../../../workbench/services/agentHost/common/agentHostFileSystemService.js';
 import { assertAutomationSessionTemplate } from '../../../../../workbench/contrib/chat/common/automations/automation.js';
-import { combineAutomationCatalogueStates, serializeAutomationEditableState, AutomationActiveRunError, isAutomationActiveRunError, assertAutomationSessionTemplateAuthority } from '../../../../../workbench/contrib/chat/common/automations/automationService.js';
-import { IAutomationStorageService } from '../../../automations/common/automationStorageService.service.js';
+import { AutomationUnavailableError, serializeAutomationEditableState, assertAutomationSessionTemplateAuthority } from '../../../../../workbench/contrib/chat/common/automations/automationService.js';
+import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
 import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
-import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
-import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { SYNCED_CUSTOMIZATION_SCHEME } from '../../../../../platform/agentHost/common/agentHostFileSystemService.js';
 
 const MUTATION_TIMEOUT_MS = 30_000;
-const MIGRATION_POLL_INTERVAL_MS = 50;
 const LEGACY_RUN_ARCHIVE_VERSION = 1;
-const LEGACY_RUN_ARCHIVE_WRITE_ATTEMPTS = 10;
 let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable {
     constructor(
         _providerId,
         _connection,
-        _legacySource,
         _boundaryMapper,
         _logService,
         _storageService,
-        _automationStorageService
+        _activeClientService
     ) {
         super();
         this._providerId = _providerId;
         this._connection = _connection;
-        this._legacySource = _legacySource;
         this._boundaryMapper = _boundaryMapper;
         this._logService = _logService;
         this._storageService = _storageService;
-        this._automationStorageService = _automationStorageService;
-        this.preservesImportedRunHistory = true;
-        this._ready = observableValue(this, false);
+        this._activeClientService = _activeClientService;
         this._runsForCache = ( new Map());
         this._pendingWaits = this._register(( new DisposableMap()));
         this._pendingWaitIds = 0;
+        this.canCreateAutomation = derived(
+            this,
+            reader => this.catalogueState.read(reader) === "ready" && !!this._connection.initializeResult.read(reader)?.automations?.create
+        );
         this._archiveKey = `agentHostAutomation.legacyRunArchive.${_providerId}`;
-        const archive = this._loadArchivedRuns();
-        this._archivedRuns = observableValue(this, archive.runs);
-        this._persistRepairedArchivedRuns(archive);
+        this._archivedRuns = observableValue(this, this._loadArchivedRuns());
         this._register(
             this._storageService.onDidChangeValue(StorageScope.APPLICATION, this._archiveKey, this._store)(() => {
-                const archive = this._loadArchivedRuns();
-                this._archivedRuns.set(archive.runs, undefined);
-                this._persistRepairedArchivedRuns(archive);
+                this._archivedRuns.set(this._loadArchivedRuns(), undefined);
             })
         );
         this._catalogReference = this._register(
@@ -78,63 +77,35 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         this._catalog = this._catalogReference.object;
         this._catalogChanged = observableSignalFromEvent(this, this._catalog.onDidChange);
         this._catalogError = observableSignalFromEvent(this, this._catalog.onDidError ?? Event.None);
+        const sessionResolutionChanged = observableSignalFromEvent(this, _boundaryMapper?.onDidChangeSessionResolution ?? Event.None);
         this.catalogueState = derived(this, reader => {
             this._catalogChanged.read(reader);
             this._catalogError.read(reader);
-            const hostState = this._catalog.value instanceof Error ? "error" : this._catalog.verifiedValue ? "ready" : "loading";
-            const legacyState = this._ready.read(reader) ? "ready" : this._legacySource?.catalogueState.read(reader) ?? "ready";
-            return combineAutomationCatalogueStates([hostState, legacyState]);
+            return this._catalog.value instanceof Error ? "error" : this._catalog.verifiedValue ? "ready" : "loading";
         });
         if (this._catalog.onDidError) {
             this._register(this._catalog.onDidError(error => this._logService.error(
                 `[AgentHostAutomationStore] Catalogue subscription failed: ${error.message}`
             )));
         }
-        this._register(autorun(reader => {
-            this._catalogChanged.read(reader);
-            const catalog = this._catalog.value;
-            if (catalog && !(catalog instanceof Error) && (isAgentHostAutomationCatalogMigrated(catalog) || ( catalog.entries.some(automation => automation.operations.includes(AutomationOperation.Run)))) && !( catalog.entries.some(
-                automation => isAgentHostLegacyAutomationImportPending(automation.definition)
-            )) && (!this._legacySource || (this._legacySource.catalogueState.read(reader) === "ready" && this._legacySource.canCompleteMigration?.() !== false && this._legacySource.automations.read(reader).length === 0)) && !this._migrationPromise && !this._ready.read(reader)) {
-                this._ready.set(true, undefined);
-            }
-        }));
         this.automations = derived(this, reader => {
             this._catalogChanged.read(reader);
-            if (!this._ready.read(reader)) {
-                return distinctById([
-                    ...(this._legacySource?.automations.read(reader) ?? []),
-                    ...this._projectAutomations()
-                ]);
-            }
             return this._projectAutomations();
         });
         this.runs = derived(this, reader => {
             this._catalogChanged.read(reader);
-            if (!this._ready.read(reader)) {
-                return distinctById([
-                    ...(this._legacySource?.runs.read(reader) ?? []),
-                    ...this._archivedRuns.read(reader)
-                ]).sort((first, second) => second.startedAt.localeCompare(first.startedAt));
-            }
+            sessionResolutionChanged.read(reader);
             return distinctById([...this._projectRuns(), ...this._archivedRuns.read(reader)]).sort((first, second) => second.startedAt.localeCompare(first.startedAt));
         });
     }
     getAutomation(id) {
-        return this._ready.get() ? this._projectAutomation(this._findAutomationEntry(id)) : this._legacySource?.getAutomation(id) ?? this._projectAutomation(this._findAutomationEntry(id));
-    }
-    isSchedulingOwnedByHost(automationId) {
-        if (!this._ready.get()) {
-            return false;
-        }
-        const state = this._findAutomationEntry(automationId);
-        return state !== undefined && !isAgentHostLegacyAutomationImportPending(state.definition) && state.operations.includes(AutomationOperation.Run);
+        return this._projectAutomation(this._findAutomationEntry(id));
     }
     canRunAutomation(automationId) {
         return this._operationAvailable(automationId, AutomationOperation.Run);
     }
     canUpdateAutomation(automationId) {
-        return this._operationAvailable(automationId, AutomationOperation.Update);
+        return this._operationAvailable(automationId, AutomationOperation.Update) && !this.getAutomation(automationId)?.readOnlyReason;
     }
     canDeleteAutomation(automationId) {
         return this._operationAvailable(automationId, AutomationOperation.Remove);
@@ -151,14 +122,13 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         return result;
     }
     async createAutomation(options, mutationGuard) {
-        await this._waitForMigrationBeforeMutation();
-        if (!this._ready.get() && this._legacySource) {
-            return this._legacySource.createAutomation(options, mutationGuard);
+        if (this._store.isDisposed || !this.canCreateAutomation.get()) {
+            throw ( new AutomationUnavailableError(( localize(4831, "The Agent Host is not ready to create automations."))));
         }
-        mutationGuard?.();
         const now = ( new Date());
+        const resource = automationResource(generateUuid());
         const descriptor = {
-            id: generateUuid(),
+            id: this._resourceId(resource),
             name: options.name,
             prompt: options.prompt,
             schedule: options.schedule,
@@ -171,26 +141,25 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
             createdAt: now.toISOString(),
             updatedAt: now.toISOString()
         };
-        const state = await this._createDescriptor(descriptor);
+        const state = await this._createDescriptor(resource, descriptor, mutationGuard, options.customizationIds);
         return this._requireProjectedAutomation(state);
     }
-    async updateAutomation(id, patch) {
-        await this._waitForMigrationBeforeMutation();
-        if (!this._ready.get() && this._legacySource?.getAutomation(id)) {
-            return this._legacySource.updateAutomation(id, patch);
-        }
+    async updateAutomation(id, patch, mutationGuard) {
         this._requireOperation(id, AutomationOperation.Update);
         const current = this._requireAutomation(id);
+        if (current.readOnlyReason) {
+            throw ( new Error(current.readOnlyReason));
+        }
         const updated = this._applyPatch(current, patch);
-        const state = await this._replaceDescriptor(updated, false, undefined, patch.sessionTemplate === null);
+        const state = await this._replaceDescriptor(
+            updated,
+            patch.sessionTemplate === null,
+            mutationGuard,
+            patch.customizationIds
+        );
         return this._requireProjectedAutomation(state);
     }
     async updateAutomationIfUnchanged(id, patch, expected, mutationGuard) {
-        await this._waitForMigrationBeforeMutation();
-        if (!this._ready.get() && this._legacySource?.getAutomation(id)) {
-            return this._legacySource.updateAutomationIfUnchanged(id, patch, expected, mutationGuard);
-        }
-        mutationGuard?.();
         const current = this.getAutomation(id);
         if (!current || serializeAutomationEditableState(current) !== serializeAutomationEditableState(expected)) {
             return {
@@ -200,390 +169,135 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         }
         return {
             kind: "updated",
-            automation: await this.updateAutomation(id, patch)
+            automation: await this.updateAutomation(id, patch, mutationGuard)
         };
     }
-    async deleteAutomation(id, mutationGuard) {
-        await this._waitForMigrationBeforeMutation();
-        if (!this._ready.get() && this._legacySource?.getAutomation(id)) {
-            return this._legacySource.deleteAutomation(id, mutationGuard);
+    async getCustomizationChoices(target, existingId, token) {
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
         }
-        this._requireOperation(id, AutomationOperation.Remove);
-        mutationGuard?.();
-        const resource = automationResource(id);
-        if (!this._findAutomationEntry(id)) {
-            return;
+        const existing = existingId ? this._findAutomationEntry(existingId)?.definition : undefined;
+        const scope = this._acquireCustomizationScope(target, target.sessionTypeId ?? existing?.session.provider);
+        if (!scope) {
+            return undefined;
         }
-        await this._dispatchAndWait({
-            type: ActionType.AutomationRemoved,
-            resource
-        }, catalog => !( catalog.entries.some(automation => automation.resource === resource)));
-        this._runsForCache.delete(id);
-    }
-    async importAutomationSnapshot(snapshot) {
-        return this._importAutomationSnapshot(snapshot, true);
-    }
-    async _importAutomationSnapshot(snapshot, importPending) {
-        assertTerminalRunHistory(snapshot.runs);
-        const existing = this._findAutomationEntry(snapshot.automation.id);
-        if (existing) {
-            const current = this._requireProjectedAutomation(existing);
-            const expected = this._canonicalDescriptor(snapshot.automation, existing);
-            if (serializeAutomationEditableState(current) !== serializeAutomationEditableState(expected)) {
-                if (isAgentHostLegacyAutomationImport(existing.definition)) {
-                    await this._replaceDescriptor(snapshot.automation, true, importPending);
-                    await this._archiveRuns(snapshot.runs);
-                    return {
-                        kind: "alreadyPresent"
-                    };
-                }
-                return {
-                    kind: "conflict",
-                    current: {
-                        automation: current,
-                        runs: this._projectRunsFor(existing.resource)
-                    }
-                };
-            }
-            if (importPending && !isAgentHostLegacyAutomationImportPending(existing.definition)) {
-                await this._replaceDescriptor(snapshot.automation, true, importPending);
+        try {
+            await raceCancellationError(scope.whenResolved(), token);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
             }
-            await this._archiveRuns(snapshot.runs);
-            return {
-                kind: "alreadyPresent"
-            };
-        }
-        await this._createDescriptor(snapshot.automation, true, importPending);
-        await this._archiveRuns(snapshot.runs);
-        this._logService.info(
-            `[AgentHostAutomationStore] Migrated Automation definition: resource=${automationResource(snapshot.automation.id)}, legacyRunsRetained=${snapshot.runs.length}.`
-        );
-        return {
-            kind: "inserted"
-        };
-    }
-    async upsertAutomationSnapshot(snapshot) {
-        assertTerminalRunHistory(snapshot.runs);
-        if (this._findAutomationEntry(snapshot.automation.id)) {
-            await this._replaceDescriptor(snapshot.automation, true, true);
-        } else {
-            await this._createDescriptor(snapshot.automation, true, true);
+            const current = scope.customizations.get().filter(isCustomizationEnabled);
+            const saved = ( new Map(existing?.session.customizations?.map(plugin => [plugin.id, plugin])));
+            const sameTarget = existing !== undefined && this._isCustomizationTargetUnchanged(target, existing, target.sessionTypeId ?? existing.session.provider, true);
+            const currentIds = ( new Set(current.map(plugin => plugin.id)));
+            return [...current.map(plugin => ({
+                id: plugin.id,
+                label: this._customizationLabel(plugin),
+                description: ( URI.parse(plugin.uri)).scheme === SYNCED_CUSTOMIZATION_SCHEME ? ( localize(4832, "Customizations synced from VS Code.")) : plugin.version ? ( localize(4833, "Version {0}", plugin.version)) : undefined,
+                selected: !sameTarget || ( saved.has(plugin.id)),
+                outdated: sameTarget && ( saved.has(plugin.id)) && (saved.get(plugin.id).nonce !== plugin.nonce || saved.get(plugin.id).uri !== plugin.uri)
+            })), ...[...( saved.values())].filter(plugin => !( currentIds.has(plugin.id))).map(plugin => ({
+                id: plugin.id,
+                label: this._customizationLabel(plugin),
+                description: ( localize(4834, "Not available locally. The saved copy is kept.")),
+                selected: true,
+                outdated: false
+            }))];
+        } finally {
+            scope.dispose();
         }
-        await this._archiveRuns(snapshot.runs);
     }
-    async removeAutomationSnapshotIfUnchanged(expected) {
-        const current = this._findAutomationEntry(expected.automation.id);
-        if (!current) {
-            return {
-                kind: "missing"
-            };
-        }
-        const projected = this._requireProjectedAutomation(current);
-        const canonicalExpected = this._canonicalDescriptor(expected.automation, current);
-        if (serializeAutomationEditableState(projected) !== serializeAutomationEditableState(canonicalExpected)) {
-            return {
-                kind: "conflict",
-                current: {
-                    automation: projected,
-                    runs: this._projectRunsFor(current.resource)
-                }
-            };
-        }
-        await this.deleteAutomation(expected.automation.id);
-        return {
-            kind: "removed"
-        };
+    _customizationLabel(plugin) {
+        const uri = ( URI.parse(plugin.uri));
+        return uri.scheme === SYNCED_CUSTOMIZATION_SCHEME ? ( localize(4835, "VS Code Customizations")) : plugin.name || basename(uri);
     }
-    async acknowledgeAutomationSnapshotImported(snapshot) {
-        const current = this._findAutomationEntry(snapshot.automation.id);
-        if (!current || !isAgentHostLegacyAutomationImportPending(current.definition)) {
-            return;
-        }
-        await this._clearImportPending(snapshot.automation.id);
+    async deleteAutomation(id, mutationGuard) {
+        const {
+            resource
+        } = this._requireOperation(id, AutomationOperation.Remove);
+        await this._dispatchAndWait({
+            type: ActionType.AutomationRemoved,
+            resource
+        }, catalog => !( catalog.entries.some(automation => automation.resource === resource)), mutationGuard);
+        this._runsForCache.delete(id);
     }
-    async recordRunStart(automationId, trigger, _leaderWindowId) {
-        if (!this._ready.get() && this._legacySource?.getAutomation(automationId)) {
-            return this._legacySource.recordRunStart(automationId, trigger, _leaderWindowId);
-        }
-        if (trigger !== "manual") {
-            throw ( new Error("Scheduled Automation execution is owned by the Agent Host."));
+    async runAutomation(automationId, token = CancellationToken.None) {
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
         }
-        this._requireOperation(automationId, AutomationOperation.Run);
+        const automation = this._requireOperation(automationId, AutomationOperation.Run);
         const activeRun = this.getActiveRunFor(automationId);
         if (activeRun) {
             return {
-                claimed: false,
+                kind: "alreadyRunning",
                 run: activeRun
             };
         }
         const result = await this._connection.runAutomation({
             channel: AUTOMATION_CATALOG_URI,
-            automation: automationResource(automationId),
+            automation: automation.resource,
             requestId: generateUuid()
         });
-        const catalog = await this._waitForCatalog(state => ( state.entries.some(automation => ( automation.runs.some(
-            run => run.resource === result.resource && (run.primarySession !== undefined || isTerminalRun(run))
-        )))));
-        const run = catalog.entries.flatMap(automation => automation.runs).find(candidate => candidate.resource === result.resource);
-        if (!run) {
-            throw ( new Error(
-                `Automation run did not appear in the authoritative catalogue: ${result.resource}`
-            ));
-        }
-        const projectedRun = this._projectRun(run);
-        return {
-            claimed: false,
-            run: projectedRun,
-            externalDispatch: {
-                sessionResource: projectedRun.sessionResource,
+        let cancellationForwarded = false;
+        const cancel = this._connection.initializeResult.get()?.automations?.runCancellation ? () => {
+            if (cancellationForwarded) {
+                return;
+            }
+            cancellationForwarded = true;
+            this._connection.dispatch(result.resource, {
+                type: ActionType.AutomationRunCancelRequested
+            });
+        } : undefined;
+        const dispatchDisposables = ( new DisposableStore());
+        try {
+            if (cancel) {
+                dispatchDisposables.add(token.onCancellationRequested(cancel));
+                if (token.isCancellationRequested) {
+                    cancel();
+                }
+            }
+            const catalog = await this._waitForCatalog(state => ( state.entries.some(automation => ( automation.runs.some(
+                run => run.resource === result.resource && (run.primarySession !== undefined || isTerminalRun(run))
+            )))), undefined, null);
+            const run = catalog.entries.flatMap(automation => automation.runs).find(candidate => candidate.resource === result.resource);
+            if (!run) {
+                throw ( new Error(
+                    `Automation run did not appear in the authoritative catalogue: ${result.resource}`
+                ));
+            }
+            return {
+                kind: "dispatched",
+                run: this._projectRun(run),
                 whenCompleted: this._waitForCatalog(state => ( state.entries.some(automation => ( automation.runs.some(
                     candidate => candidate.resource === result.resource && isTerminalRun(candidate)
                 )))), undefined, null).then(() => undefined),
-                ...(this._connection.initializeResult.get()?.automations?.runCancellation ? {
-                    cancel: () => this._connection.dispatch(result.resource, {
-                        type: ActionType.AutomationRunCancelRequested
-                    })
+                ...(cancel ? {
+                    cancel
                 } : {})
-            }
-        };
+            };
+        } finally {
+            dispatchDisposables.dispose();
+        }
     }
     _projectSessionResource(resource) {
         const session = ( URI.parse(resource));
-        const provider = this._boundaryMapper?.providerForSessionScheme?.(session.scheme) ?? session.scheme;
+        if (this._boundaryMapper?.sessionResource) {
+            return this._boundaryMapper.sessionResource(session);
+        }
+        const provider = this._boundaryMapper?.providerForSessionScheme?.(session.scheme) ?? AgentSession.provider(session);
+        if (!provider) {
+            return undefined;
+        }
         const resourceScheme = this._boundaryMapper?.resourceSchemeForProvider(provider);
         return resourceScheme ? session.with({
             scheme: resourceScheme
         }) : session;
     }
-    async updateRun(runId, _patch) {
-        if (!this._ready.get() && this._legacySource?.runs.get().some(run => run.id === runId)) {
-            return this._legacySource.updateRun(runId, _patch);
-        }
-        return this.runs.get().find(run => run.id === runId);
-    }
-    async deleteRun(runId) {
-        if (!this._ready.get() && this._legacySource?.runs.get().some(run => run.id === runId)) {
-            return this._legacySource.deleteRun(runId);
-        }
-        throw ( new Error("Automation run history is owned by the Agent Host."));
-    }
     getActiveRunFor(automationId) {
-        if (!this._ready.get() && this._legacySource?.getAutomation(automationId)) {
-            return this._legacySource.getActiveRunFor(automationId);
-        }
         return this.runs.get().find(
             run => run.automationId === automationId && (run.status === "pending" || run.status === "running")
         );
     }
-    async markStaleRunsFailed(reason) {
-        if (!this._ready.get() && this._legacySource) {
-            return this._legacySource.markStaleRunsFailed(reason);
-        }
-    }
-    async completeMigration() {
-        if (this._ready.get()) {
-            return;
-        }
-        if (this._migrationPromise) {
-            return this._migrationPromise;
-        }
-        const migration = this._completeMigration();
-        this._migrationPromise = migration;
-        try {
-            await migration;
-        } finally {
-            if (this._migrationPromise === migration) {
-                this._migrationPromise = undefined;
-            }
-        }
-    }
-    async _completeMigration() {
-        const startedAt = Date.now();
-        const source = this._legacySource;
-        const discovered = source ? [...source.automations.get()] : [];
-        const activeRuns = source ? discovered.flatMap(automation => source.runsFor(automation.id).get().filter(isNonTerminalRun)) : [];
-        if (activeRuns.length > 0) {
-            this._logService.info(
-                `[AgentHostAutomationStore] Automation migration deferred: activeRuns=${activeRuns.length}.`
-            );
-            throw ( new AutomationActiveRunError(activeRuns[0].automationId, activeRuns[0].id));
-        }
-        this._logService.info(
-            `[AgentHostAutomationStore] Automation migration started: discovered=${discovered.length}.`
-        );
-        let migratedCount = 0;
-        let failedCount = 0;
-        try {
-            this._requireLegacySourceReadable();
-            const failures = [];
-            for (const automation of discovered) {
-                try {
-                    await this._migrateLegacySourceAutomation(automation);
-                    migratedCount++;
-                } catch (error) {
-                    if (isCancellationError(error) || this._store.isDisposed) {
-                        throw ( new CancellationError());
-                    }
-                    const failure = error instanceof Error ? error : ( new Error(String(error)));
-                    failures.push(failure);
-                    failedCount++;
-                    if (isAutomationActiveRunError(error)) {
-                        this._logService.info(
-                            `[AgentHostAutomationStore] Automation migration item deferred while a run is active: resource=${automationResource(automation.id)}.`
-                        );
-                    } else {
-                        this._logService.error(
-                            `[AgentHostAutomationStore] Automation migration item failed: resource=${automationResource(automation.id)}, error=${failure.message}`
-                        );
-                    }
-                }
-            }
-            if (failures.length > 0) {
-                throw ( new AggregateError(
-                    failures,
-                    `Failed to migrate ${failures.length} Agent Host Automation definition(s).`
-                ));
-            }
-            this._requireLegacySourceDrained();
-            await this._waitForCatalog(() => true);
-            this._requireLegacySourceDrained();
-            const resources = discovered.map(automation => automationResource(automation.id));
-            this._connection.dispatch(ROOT_STATE_URI, {
-                type: ActionType.RootConfigChanged,
-                config: {
-                    [AGENT_HOST_AUTOMATION_MIGRATION_CONFIG_KEY]: {
-                        version: 1,
-                        status: "complete",
-                        resources
-                    }
-                }
-            });
-            await this._waitForMigrationCompletion();
-            this._requireLegacySourceDrained();
-            await this._drainPendingImports();
-            this._requireLegacySourceDrained();
-            this._ready.set(true, undefined);
-            const durationMs = Date.now() - startedAt;
-            this._logService.info(
-                `[AgentHostAutomationStore] Automation migration completed: discovered=${discovered.length}, migrated=${resources.length}, failed=0, durationMs=${durationMs}.`
-            );
-        } catch (error) {
-            if (isCancellationError(error)) {
-                throw error;
-            }
-            const durationMs = Date.now() - startedAt;
-            if (isAutomationActiveRunError(error)) {
-                this._logService.info(
-                    `[AgentHostAutomationStore] Automation migration deferred after ${migratedCount} item(s) while a run became active.`
-                );
-                throw error;
-            }
-            if (error instanceof AggregateError) {
-                failedCount = Math.max(failedCount, error.errors.length);
-            }
-            this._logService.error(
-                `[AgentHostAutomationStore] Automation migration failed: discovered=${discovered.length}, migrated=${migratedCount}, failed=${failedCount}, durationMs=${durationMs}, error=${error instanceof Error ? error.message : String(error)}.`
-            );
-            throw error;
-        }
-    }
-    async _waitForMigrationBeforeMutation() {
-        const migration = this._migrationPromise;
-        if (migration) {
-            await migration;
-        }
-    }
-    _requireLegacySourceReadable() {
-        if (this._legacySource && (this._legacySource.catalogueState.get() !== "ready" || this._legacySource.canCompleteMigration?.() === false)) {
-            throw ( new Error("Legacy Automation storage cannot be migrated safely by this version."));
-        }
-    }
-    _requireLegacySourceDrained() {
-        this._requireLegacySourceReadable();
-        const remaining = this._legacySource?.automations.get().length ?? 0;
-        if (remaining > 0) {
-            throw ( new Error(
-                `Automation migration source changed during migration; ${remaining} definition(s) remain.`
-            ));
-        }
-    }
-    async _migrateLegacySourceAutomation(initialAutomation) {
-        const source = this._legacySource;
-        if (!source) {
-            return;
-        }
-        let snapshot = {
-            automation: initialAutomation,
-            runs: source.runsFor(initialAutomation.id).get()
-        };
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const result = await this._importAutomationSnapshot(snapshot, true);
-            if (result.kind === "conflict") {
-                throw ( new Error(
-                    `Automation conflicts with the Agent Host catalogue: ${automationResource(initialAutomation.id)}`
-                ));
-            }
-            const removal = await source.removeAutomationSnapshotIfUnchanged(snapshot);
-            if (removal.kind === "removed" || removal.kind === "missing") {
-                await this._clearImportPending(initialAutomation.id);
-                return;
-            }
-            snapshot = removal.current;
-        }
-        throw ( new Error(
-            `Automation kept changing while migrating: ${automationResource(initialAutomation.id)}`
-        ));
-    }
-    async _clearImportPending(automationId) {
-        const current = this._findAutomationEntry(automationId);
-        if (!current || !isAgentHostLegacyAutomationImportPending(current.definition)) {
-            return;
-        }
-        const projected = this._projectAutomation(current);
-        if (!projected) {
-            return;
-        }
-        await this._replaceDescriptor(projected, isAgentHostLegacyAutomationImport(current.definition), false);
-    }
-    async _drainPendingImports() {
-        const catalog = this._catalog.value;
-        if (!catalog || catalog instanceof Error) {
-            return;
-        }
-        const failures = [];
-        const pending = catalog.entries.filter(
-            automation => isAgentHostLegacyAutomationImportPending(automation.definition)
-        );
-        for (const automation of pending) {
-            if (this._store.isDisposed) {
-                throw ( new CancellationError());
-            }
-            const id = automationId(automation.resource);
-            const legacyEntry = this._legacySource?.getAutomation(id);
-            try {
-                if (legacyEntry) {
-                    await this._migrateLegacySourceAutomation(legacyEntry);
-                } else {
-                    await this._clearImportPending(id);
-                }
-            } catch (error) {
-                if (isCancellationError(error) || this._store.isDisposed) {
-                    throw ( new CancellationError());
-                }
-                const failure = error instanceof Error ? error : ( new Error(String(error)));
-                failures.push(failure);
-                this._logService.error(
-                    `[AgentHostAutomationStore] Failed to drain pending Automation import: id=${id}, error=${failure.message}`
-                );
-            }
-        }
-        if (failures.length > 0) {
-            throw ( new AggregateError(
-                failures,
-                `Failed to drain ${failures.length} pending Agent Host Automation import(s).`
-            ));
-        }
-    }
     _projectAutomations() {
         const catalog = this._catalog.value;
         if (!catalog || catalog instanceof Error) {
@@ -598,9 +312,6 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         }
         return catalog.entries.flatMap(automation => automation.runs).map(run => this._projectRun(run)).sort((first, second) => second.startedAt.localeCompare(first.startedAt));
     }
-    _projectRunsFor(resource) {
-        return this._findAutomationEntryByResource(resource)?.runs.map(run => this._projectRun(run)) ?? [];
-    }
     _projectAutomation(state) {
         if (!state) {
             return undefined;
@@ -614,11 +325,15 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         }
         const modelId = this._projectModelId(state.definition.session.model?.id, state.definition.session.provider);
         const newestRun = state.runs[0];
+        const schedule = projectSchedule(state.definition.triggers);
         return {
-            id: automationId(state.resource),
+            id: this._resourceId(state.resource),
             name: state.definition.title,
             prompt: state.definition.message.text,
-            schedule: projectSchedule(state.definition.triggers),
+            schedule,
+            ...(schedule.interval === "custom" ? {
+                readOnlyReason: ( localize(4836, "This automation uses a schedule that cannot be edited in VS Code."))
+            } : {}),
             target,
             sessionTemplate: projectAutomationSessionTemplate(state.definition, modelId),
             enabled: state.definition.enabled,
@@ -659,23 +374,22 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         const lifecycle = run.lifecycle;
         const primarySession = run.primarySession ? this._projectSessionResource(run.primarySession) : undefined;
         return {
-            id: automationRunId(run.resource),
-            automationId: automationId(run.automation),
+            id: this._resourceId(run.resource),
+            automationId: this._resourceId(run.automation),
             status: lifecycle.status === AutomationRunStatus.Cancelled ? "failed" : lifecycle.status,
             trigger: run.origin.kind === AutomationRunOriginKind.Manual ? "manual" : run.origin.catchUp ? "catch_up" : "schedule",
             sessionResource: primarySession,
             startedAt: lifecycle.status === AutomationRunStatus.Pending ? lifecycle.createdAt : lifecycle.startedAt ?? lifecycle.createdAt,
             completedAt: lifecycle.status === AutomationRunStatus.Completed || lifecycle.status === AutomationRunStatus.Failed || lifecycle.status === AutomationRunStatus.Cancelled ? lifecycle.completedAt : undefined,
-            errorMessage: lifecycle.status === AutomationRunStatus.Failed ? lifecycle.error.message : lifecycle.status === AutomationRunStatus.Cancelled ? ( localize(4191, "Cancelled")) : undefined,
-            leaderWindowId: 0
+            errorMessage: lifecycle.status === AutomationRunStatus.Failed ? lifecycle.error.message : lifecycle.status === AutomationRunStatus.Cancelled ? ( localize(4837, "Cancelled")) : undefined
         };
     }
     _findAutomationEntry(id) {
-        return this._findAutomationEntryByResource(automationResource(id));
-    }
-    _findAutomationEntryByResource(resource) {
         const catalog = this._catalog.value;
-        return catalog && !(catalog instanceof Error) ? catalog.entries.find(automation => automation.resource === resource) : undefined;
+        return catalog && !(catalog instanceof Error) ? catalog.entries.find(automation => this._resourceId(automation.resource) === id) : undefined;
+    }
+    _resourceId(resource) {
+        return `${encodeURIComponent(this._providerId)}:${resource}`;
     }
     _requireAutomation(id) {
         const automation = this.getAutomation(id);
@@ -685,15 +399,19 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         return automation;
     }
     _operationAvailable(id, operation) {
-        if (!this._ready.get() && this._legacySource?.getAutomation(id)) {
-            return true;
-        }
-        return this._findAutomationEntry(id)?.operations.includes(operation) === true;
+        return !this._store.isDisposed && this.catalogueState.get() === "ready" && this._findAutomationEntry(id)?.operations.includes(operation) === true;
     }
     _requireOperation(id, operation) {
-        if (!this._operationAvailable(id, operation)) {
-            throw ( new Error(`Automation operation '${operation}' is not available: ${id}`));
+        const automation = this._findAutomationEntry(id);
+        if (this._store.isDisposed || this.catalogueState.get() !== "ready" || !automation?.operations.includes(operation)) {
+            throw ( new AutomationUnavailableError(( localize(
+                4838,
+                "Automation operation '{0}' is not available for '{1}'.",
+                operation,
+                id
+            ))));
         }
+        return automation;
     }
     _requireProjectedAutomation(state) {
         const automation = this._projectAutomation(state);
@@ -704,73 +422,118 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         }
         return automation;
     }
-    async _createDescriptor(descriptor, imported = false, importPending) {
-        const resource = automationResource(descriptor.id);
-        const definition = this._definitionFromDescriptor(descriptor, undefined, imported, importPending);
-        const state = await this._dispatchAndWait({
-            type: ActionType.AutomationCreateRequested,
-            resource,
-            definition
-        }, catalog => ( catalog.entries.some(automation => automation.resource === resource)));
-        if (!state) {
-            throw ( new Error(`Automation create completed without authoritative state: ${resource}`));
+    async _createDescriptor(resource, descriptor, mutationGuard, customizationIds) {
+        const definition = this._definitionFromDescriptor(descriptor);
+        const scope = this._acquireCustomizationScope(descriptor.target, definition.session.provider);
+        try {
+            if (scope) {
+                await this._captureCustomizations(definition, scope, undefined, customizationIds);
+            }
+            const state = await this._dispatchAndWait({
+                type: ActionType.AutomationCreateRequested,
+                resource,
+                definition
+            }, catalog => ( catalog.entries.some(automation => automation.resource === resource)), mutationGuard);
+            if (!state) {
+                throw ( new Error(`Automation create completed without authoritative state: ${resource}`));
+            }
+            return state;
+        } finally {
+            scope?.dispose();
         }
-        return state;
     }
-    async _replaceDescriptor(descriptor, imported = false, importPending, resetSessionTemplate = false) {
-        const resource = automationResource(descriptor.id);
+    async _replaceDescriptor(descriptor, resetSessionTemplate = false, mutationGuard, customizationIds) {
         const current = this._findAutomationEntry(descriptor.id);
         if (!current) {
             throw ( new Error(`Automation does not exist: ${descriptor.id}`));
         }
-        const definition = this._definitionFromDescriptor(
-            descriptor,
-            current.definition,
-            imported,
-            importPending,
-            resetSessionTemplate
-        );
-        const expected = this._requireProjectedAutomation({
-            ...current,
-            definition
-        });
-        const state = await this._dispatchAndWait({
-            type: ActionType.AutomationUpdateRequested,
-            resource,
-            changes: {
-                title: definition.title,
-                message: definition.message,
-                session: definition.session,
-                enabled: definition.enabled,
-                triggers: definition.triggers,
-                _meta: definition._meta
-            }
-        }, catalog => {
-            const state = catalog.entries.find(automation => automation.resource === resource);
-            const projected = this._projectAutomation(state);
-            if (projected === undefined || serializeAutomationEditableState(projected) !== serializeAutomationEditableState(expected)) {
-                return false;
-            }
-            if (importPending === true) {
-                return isAgentHostLegacyAutomationImportPending(state.definition);
+        const resource = current.resource;
+        const definition = this._definitionFromDescriptor(descriptor, current.definition, resetSessionTemplate);
+        const scope = customizationIds !== undefined || !this._isCustomizationTargetUnchanged(descriptor.target, current.definition, definition.session.provider) ? this._acquireCustomizationScope(descriptor.target, definition.session.provider) : undefined;
+        try {
+            if (scope) {
+                await this._captureCustomizations(definition, scope, current.definition, customizationIds);
             }
-            if (importPending === false) {
-                return !isAgentHostLegacyAutomationImportPending(state.definition);
+            const expected = this._requireProjectedAutomation({
+                ...current,
+                definition
+            });
+            const state = await this._dispatchAndWait({
+                type: ActionType.AutomationUpdateRequested,
+                resource,
+                changes: {
+                    title: definition.title,
+                    message: definition.message,
+                    session: definition.session,
+                    enabled: definition.enabled,
+                    triggers: definition.triggers,
+                    _meta: definition._meta
+                }
+            }, catalog => {
+                const state = catalog.entries.find(automation => automation.resource === resource);
+                if (scope && stableStringify(state?.definition.session.customizations) !== stableStringify(definition.session.customizations)) {
+                    return false;
+                }
+                const projected = this._projectAutomation(state);
+                if (projected === undefined || serializeAutomationEditableState(projected) !== serializeAutomationEditableState(expected)) {
+                    return false;
+                }
+                return true;
+            }, mutationGuard, !!scope);
+            if (!state) {
+                throw ( new Error(`Automation update completed without authoritative state: ${resource}`));
             }
-            return true;
-        });
-        if (!state) {
-            throw ( new Error(`Automation update completed without authoritative state: ${resource}`));
+            return state;
+        } finally {
+            scope?.dispose();
         }
-        return state;
     }
-    _definitionFromDescriptor(
-        descriptor,
-        existing,
-        imported = false,
-        importPending,
-        resetSessionTemplate = false
-    ) {
+    _isCustomizationTargetUnchanged(target, existing, provider, compareIsolation = false) {
+        const previousTarget = this._projectTarget(existing);
+        return !!previousTarget && previousTarget.providerId === target.providerId && previousTarget.sessionTypeId === target.sessionTypeId && existing.session.provider === provider && previousTarget.kind === target.kind && (previousTarget.kind !== "workspace" || target.kind !== "workspace" || (isEqual(previousTarget.folderUri, target.folderUri) && (!compareIsolation || stableStringify(previousTarget.isolation) === stableStringify(target.isolation))));
+    }
+    _acquireCustomizationScope(target, provider) {
+        if (!this._connection.initializeResult.get()?.automations?.customizations || !provider) {
+            return undefined;
+        }
+        const sessionType = this._boundaryMapper?.resourceSchemeForProvider(provider) ?? provider;
+        return this._activeClientService.acquireScope(sessionType, target.kind === "workspace" ? [target.folderUri] : []);
+    }
+    async _captureCustomizations(definition, scope, previous, customizationIds) {
+        await scope.whenResolved();
+        const current = scope.customizations.get().filter(isCustomizationEnabled);
+        const currentIds = ( new Set(current.map(plugin => plugin.id)));
+        const selectedIds = customizationIds !== undefined ? ( new Set(customizationIds)) : undefined;
+        const customizations = selectedIds ? [
+            ...current,
+            ...(previous?.session.customizations ?? []).filter(plugin => !( currentIds.has(plugin.id)))
+        ].filter(plugin => ( selectedIds.has(plugin.id))) : current;
+        definition.session.customizations = customizations;
+        if (!definition.session.agent) {
+            return;
+        }
+        const agentUri = ( URI.parse(definition.session.agent.uri));
+        const findBundle = (plugins, contains) => plugins?.map(plugin => ( URI.parse(plugin.uri))).find(
+            uri => uri.scheme === SYNCED_CUSTOMIZATION_SCHEME && (!contains || isEqualOrParent(contains, uri))
+        );
+        let syncedUri = scope.getSyncedUri(agentUri);
+        const previousBundle = findBundle(previous?.session.customizations, agentUri);
+        const bundle = findBundle(customizations);
+        const relative = previousBundle && relativePath(previousBundle, agentUri);
+        if (!syncedUri && bundle && relative !== undefined) {
+            const candidate = joinPath(bundle, relative);
+            syncedUri = this._activeClientService.getOrigin(candidate) ? candidate : undefined;
+        }
+        if (syncedUri && ( customizations.some(plugin => isEqualOrParent(syncedUri, ( URI.parse(plugin.uri)))))) {
+            definition.session.agent = {
+                uri: ( syncedUri.toString())
+            };
+        }
+    }
+    _definitionFromDescriptor(descriptor, existing, resetSessionTemplate = false) {
+        if (descriptor.target.providerId !== this._providerId) {
+            throw ( new AutomationUnavailableError(( localize(4839, "The automation target must belong to this Agent Host."))));
+        }
         const sessionTemplate = descriptor.sessionTemplate;
         assertAutomationSessionTemplate(sessionTemplate);
         const modelId = sessionTemplate ? sessionTemplate.modelId : descriptor.modelId;
@@ -794,7 +557,7 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
                 descriptor.permissionLevel
             );
         }
-        const config = imported ? migrateLegacyAutomationSessionConfig(provider, projectedConfig) : projectedConfig;
+        const config = projectedConfig;
         if (descriptor.target.kind === "workspace") {
             setOptional(
                 config,
@@ -810,17 +573,7 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
             setOptional(config, SessionConfigKey.Isolation, undefined);
             setOptional(config, SessionConfigKey.Branch, undefined);
         }
-        const meta = {
-            ...existing?._meta,
-            ...((imported || isAgentHostLegacyAutomationImport(existing)) ? {
-                [AGENT_HOST_LEGACY_AUTOMATION_IMPORT_META_KEY]: true
-            } : {})
-        };
-        if (importPending === true) {
-            meta[AGENT_HOST_LEGACY_AUTOMATION_IMPORT_PENDING_META_KEY] = true;
-        } else if (importPending === false) {
-            delete meta[AGENT_HOST_LEGACY_AUTOMATION_IMPORT_PENDING_META_KEY];
-        }
+        const meta = existing?._meta ?? {};
         return {
             title: descriptor.name,
             message: {
@@ -839,7 +592,10 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
                 } : undefined,
                 agent: resetSessionTemplate ? undefined : sessionTemplate ? sessionTemplate.agent : existingSession?.agent,
                 workingDirectories: descriptor.target.kind === "workspace" ? [( (this._boundaryMapper?.toHost(descriptor.target.folderUri) ?? descriptor.target.folderUri).toString())] : undefined,
-                config: ( Object.keys(config)).length > 0 ? config : undefined
+                config: ( Object.keys(config)).length > 0 ? config : undefined,
+                ...(existingSession?.customizations !== undefined && this._connection.initializeResult.get()?.automations?.customizations ? {
+                    customizations: existingSession.customizations
+                } : {})
             },
             enabled: descriptor.enabled,
             triggers: scheduleTrigger(descriptor.schedule),
@@ -869,13 +625,6 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
         const prefix = resourceScheme ? `${resourceScheme}:` : undefined;
         return prefix && !modelId.startsWith(prefix) ? `${prefix}${modelId}` : modelId;
     }
-    _canonicalDescriptor(descriptor, state) {
-        const definition = this._definitionFromDescriptor(descriptor, state.definition);
-        return this._requireProjectedAutomation({
-            ...state,
-            definition
-        });
-    }
     _applyPatch(current, patch) {
         assertAutomationSessionTemplateAuthority(current, patch);
         const now = ( new Date());
@@ -910,9 +659,17 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
             updatedAt: now.toISOString()
         };
     }
-    async _dispatchAndWait(action, predicate) {
+    async _dispatchAndWait(action, predicate, mutationGuard, waitForCatalogChange = false) {
         await this._waitForCatalog(() => true);
-        const result = this._waitForCatalog(predicate, action);
+        if (this._store.isDisposed) {
+            throw ( new CancellationError());
+        }
+        mutationGuard?.();
+        const beforeDispatch = this._catalog.value;
+        const result = this._waitForCatalog(
+            catalog => (!waitForCatalogChange || catalog !== beforeDispatch) && predicate(catalog),
+            action
+        );
         this._connection.dispatch(AUTOMATION_CATALOG_URI, action);
         const catalog = await result;
         const state = catalog.entries.find(automation => automation.resource === action.resource);
@@ -981,190 +738,46 @@ let AgentHostAutomationStore = class AgentHostAutomationStore extends Disposable
             check();
         }));
     }
-    async _waitForMigrationCompletion() {
-        const deadline = Date.now() + MUTATION_TIMEOUT_MS;
-        let lastError;
-        while (Date.now() < deadline) {
-            if (this._store.isDisposed) {
-                throw ( new CancellationError());
-            }
-            try {
-                await this._connection.listAutomationTriggerDefinitions({
-                    channel: ROOT_STATE_URI
-                });
-                return;
-            } catch (error) {
-                if (isCancellationError(error) || this._store.isDisposed) {
-                    throw ( new CancellationError());
-                }
-                lastError = error instanceof Error ? error : ( new Error(String(error)));
-                await timeout(MIGRATION_POLL_INTERVAL_MS);
-            }
-        }
-        if (this._store.isDisposed) {
-            throw ( new CancellationError());
-        }
-        throw lastError ?? ( new Error("Timed out waiting for Agent Host Automation migration completion."));
-    }
     _loadArchivedRuns() {
         const raw = this._storageService.get(this._archiveKey, StorageScope.APPLICATION);
         if (!raw) {
-            return {
-                runs: [],
-                repairedRuns: 0
-            };
+            return [];
         }
         const parsed = parseArchivedRuns(raw);
         if (parsed.kind === "unsupported") {
             this._logService.error(
                 `[AgentHostAutomationStore] Ignoring legacy run archive with unsupported version: key=${this._archiveKey}, version=${parsed.version}.`
             );
-            return {
-                runs: [],
-                repairedRuns: 0
-            };
+            return [];
         }
         if (parsed.kind === "invalid") {
             this._logService.error(
                 `[AgentHostAutomationStore] Ignoring invalid legacy run archive: key=${this._archiveKey}, error=${parsed.error}.`
             );
-            return {
-                runs: [],
-                repairedRuns: 0
-            };
+            return [];
         }
         if (parsed.droppedRuns > 0) {
             this._logService.warn(
                 `[AgentHostAutomationStore] Dropped ${parsed.droppedRuns} malformed run(s) from legacy run archive: key=${this._archiveKey}.`
             );
         }
-        let repairedRuns = 0;
-        const runs = parsed.runs.map(run => {
-            const terminalRun = terminalizeArchivedRun(run);
-            if (terminalRun !== run) {
-                repairedRuns++;
-            }
-            return terminalRun;
-        });
-        return {
-            runs,
-            repairedRuns
-        };
-    }
-    _persistRepairedArchivedRuns(archive) {
-        if (archive.repairedRuns === 0) {
-            return;
-        }
-        this._logService.warn(
-            `[AgentHostAutomationStore] Repairing ${archive.repairedRuns} non-terminal legacy Automation run(s): key=${this._archiveKey}.`
-        );
-        void this._repairArchivedRuns().catch(error => {
-            this._logService.error(
-                `[AgentHostAutomationStore] Failed to persist repaired legacy Automation runs: key=${this._archiveKey}, error=${error instanceof Error ? error.message : String(error)}.`
-            );
-        });
-    }
-    async _repairArchivedRuns() {
-        let raw = await this._automationStorageService.read(this._archiveKey);
-        for (let attempt = 0; attempt < LEGACY_RUN_ARCHIVE_WRITE_ATTEMPTS; attempt++) {
-            if (raw === undefined) {
-                return;
-            }
-            const parsed = parseArchivedRuns(raw);
-            if (parsed.kind === "unsupported") {
-                throw ( new Error(
-                    `Cannot repair legacy Automation run archive with unsupported version: key=${this._archiveKey}, version=${parsed.version}.`
-                ));
-            }
-            if (parsed.kind === "invalid") {
-                throw ( new Error(
-                    `Cannot repair invalid legacy Automation run archive: key=${this._archiveKey}, error=${parsed.error}.`
-                ));
-            }
-            const runs = parsed.runs.map(terminalizeArchivedRun);
-            if (runs.every((run, index) => run === parsed.runs[index])) {
-                this._archivedRuns.set(runs, undefined);
-                return;
-            }
-            const archive = {
-                version: LEGACY_RUN_ARCHIVE_VERSION,
-                runs: runs.map(run => ({
-                    ...run,
-                    sessionResource: run.sessionResource?.toString()
-                }))
-            };
-            const result = await this._automationStorageService.compareAndSwap(this._archiveKey, raw, JSON.stringify(archive));
-            if (result.swapped) {
-                this._archivedRuns.set(runs, undefined);
-                return;
-            }
-            raw = result.currentValue;
-        }
-        throw ( new Error(
-            `Legacy Automation run archive kept changing while it was being repaired: ${this._archiveKey}`
-        ));
-    }
-    async _archiveRuns(runs) {
-        if (runs.length === 0) {
-            return;
-        }
-        let raw = await this._automationStorageService.read(this._archiveKey);
-        for (let attempt = 0; attempt < LEGACY_RUN_ARCHIVE_WRITE_ATTEMPTS; attempt++) {
-            let current = [];
-            if (raw !== undefined) {
-                const parsed = parseArchivedRuns(raw);
-                if (parsed.kind === "unsupported") {
-                    throw ( new Error(
-                        `Cannot update legacy Automation run archive with unsupported version: key=${this._archiveKey}, version=${parsed.version}.`
-                    ));
-                }
-                if (parsed.kind === "invalid") {
-                    this._logService.error(
-                        `[AgentHostAutomationStore] Replacing invalid legacy run archive: key=${this._archiveKey}, error=${parsed.error}.`
-                    );
-                } else {
-                    current = parsed.runs;
-                    if (parsed.droppedRuns > 0) {
-                        this._logService.warn(
-                            `[AgentHostAutomationStore] Dropping ${parsed.droppedRuns} malformed run(s) while repairing legacy run archive: key=${this._archiveKey}.`
-                        );
-                    }
-                }
-            }
-            const merged = distinctById([...runs, ...current]).map(terminalizeArchivedRun);
-            const archive = {
-                version: LEGACY_RUN_ARCHIVE_VERSION,
-                runs: merged.map(run => ({
-                    ...run,
-                    sessionResource: run.sessionResource?.toString()
-                }))
-            };
-            const next = JSON.stringify(archive);
-            const result = await this._automationStorageService.compareAndSwap(this._archiveKey, raw, next);
-            if (result.swapped) {
-                this._archivedRuns.set(merged, undefined);
-                return;
-            }
-            raw = result.currentValue;
-        }
-        throw ( new Error(
-            `Legacy Automation run archive kept changing while it was being updated: ${this._archiveKey}`
-        ));
+        return parsed.runs.map(run => ({
+            ...terminalizeArchivedRun(run),
+            id: this._resourceId(( ( URI.from({
+                scheme: "legacy-automation-run",
+                path: `/${run.id}`
+            })).toString())),
+            automationId: this._resourceId(automationResource(run.automationId))
+        }));
     }
 };
-AgentHostAutomationStore = ( __decorate([( __param(4, ILogService)), ( __param(5, IStorageService)), ( __param(6, IAutomationStorageService))], AgentHostAutomationStore));
+AgentHostAutomationStore = ( __decorate([( __param(3, ILogService)), ( __param(4, IStorageService)), ( __param(5, IAgentHostActiveClientService))], AgentHostAutomationStore));
 function automationResource(id) {
     return ( ( URI.from({
         scheme: "ahp-automation",
         path: `/${id}`
     })).toString());
 }
-function automationId(resource) {
-    return ( URI.parse(resource)).path.split("/").filter(Boolean).at(-1) ?? resource;
-}
-function automationRunId(resource) {
-    return ( URI.parse(resource)).path.split("/").filter(Boolean).at(-1) ?? resource;
-}
 function isTerminalRun(run) {
     return run.lifecycle.status === AutomationRunStatus.Completed || run.lifecycle.status === AutomationRunStatus.Failed || run.lifecycle.status === AutomationRunStatus.Cancelled;
 }
@@ -1181,7 +794,7 @@ function projectSchedule(triggers) {
     const [minuteValue, hourValue, dayOfMonth, month, dayValue, ...remaining] = trigger.schedule.expression.trim().split(/\s+/);
     if (remaining.length > 0 || dayOfMonth !== "*" || month !== "*") {
         return {
-            interval: "manual",
+            interval: "custom",
             scheduleHour: 0,
             scheduleMinute: 0,
             scheduleDay: 0
@@ -1190,7 +803,7 @@ function projectSchedule(triggers) {
     const scheduleMinute = parseCronValue(minuteValue, 0, 59);
     if (scheduleMinute === undefined) {
         return {
-            interval: "manual",
+            interval: "custom",
             scheduleHour: 0,
             scheduleMinute: 0,
             scheduleDay: 0
@@ -1207,7 +820,7 @@ function projectSchedule(triggers) {
     const scheduleHour = parseCronValue(hourValue, 0, 23);
     if (scheduleHour === undefined) {
         return {
-            interval: "manual",
+            interval: "custom",
             scheduleHour: 0,
             scheduleMinute: 0,
             scheduleDay: 0
@@ -1221,9 +834,25 @@ function projectSchedule(triggers) {
             scheduleDay: 0
         };
     }
+    if (dayValue === "1-5" || dayValue?.toUpperCase() === "MON-FRI" || dayValue === "1,2,3,4,5") {
+        if (triggers.length !== 1 || (trigger.misfirePolicy !== undefined && trigger.misfirePolicy !== AutomationMisfirePolicy.RunOnce) || trigger.schedule.timeZone !== (Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC")) {
+            return {
+                interval: "custom",
+                scheduleHour: 0,
+                scheduleMinute: 0,
+                scheduleDay: 0
+            };
+        }
+        return {
+            interval: "weekdays",
+            scheduleHour,
+            scheduleMinute,
+            scheduleDay: 0
+        };
+    }
     const scheduleDay = parseCronValue(dayValue, 0, 6);
     return scheduleDay === undefined ? {
-        interval: "manual",
+        interval: "custom",
         scheduleHour: 0,
         scheduleMinute: 0,
         scheduleDay: 0
@@ -1242,6 +871,9 @@ function parseCronValue(value, minimum, maximum) {
     return parsed >= minimum && parsed <= maximum ? parsed : undefined;
 }
 function scheduleTrigger(schedule) {
+    if (schedule.interval === "custom" || schedule.timeZone === "UTC") {
+        throw ( new Error(( localize(4840, "Choose a local-time schedule for this Agent Host automation."))));
+    }
     if (schedule.interval === "manual") {
         return [];
     }
@@ -1254,6 +886,9 @@ function scheduleTrigger(schedule) {
     case "daily":
         expression = `${schedule.scheduleMinute} ${schedule.scheduleHour} * * *`;
         break;
+    case "weekdays":
+        expression = `${schedule.scheduleMinute} ${schedule.scheduleHour} * * 1-5`;
+        break;
     case "weekly":
         expression = `${schedule.scheduleMinute} ${schedule.scheduleHour} * * ${schedule.scheduleDay}`;
         break;
@@ -1333,12 +968,6 @@ function distinctById(items) {
     }
     return result;
 }
-function assertTerminalRunHistory(runs) {
-    const activeRun = runs.find(isNonTerminalRun);
-    if (activeRun) {
-        throw ( new AutomationActiveRunError(activeRun.automationId, activeRun.id));
-    }
-}
 function isNonTerminalRun(run) {
     return run.status === "pending" || run.status === "running";
 }
@@ -1350,7 +979,7 @@ function terminalizeArchivedRun(run) {
         ...run,
         status: "failed",
         completedAt: run.completedAt ?? run.startedAt,
-        errorMessage: run.errorMessage ?? ( localize(4192, "Interrupted while migrating Automation history"))
+        errorMessage: run.errorMessage ?? ( localize(4841, "Legacy run tracking was interrupted."))
     }));
 }
 function isSerializedArchivedRun(value) {
@@ -1358,7 +987,7 @@ function isSerializedArchivedRun(value) {
         return false;
     }
     const run = value;
-    return typeof run["id"] === "string" && typeof run["automationId"] === "string" && (run["status"] === "pending" || run["status"] === "running" || run["status"] === "completed" || run["status"] === "failed") && (run["trigger"] === "schedule" || run["trigger"] === "catch_up" || run["trigger"] === "manual") && typeof run["startedAt"] === "string" && typeof run["leaderWindowId"] === "number" && (run["sessionResource"] === undefined || typeof run["sessionResource"] === "string") && (run["completedAt"] === undefined || typeof run["completedAt"] === "string") && (run["errorMessage"] === undefined || typeof run["errorMessage"] === "string");
+    return typeof run["id"] === "string" && typeof run["automationId"] === "string" && (run["status"] === "pending" || run["status"] === "running" || run["status"] === "completed" || run["status"] === "failed") && (run["trigger"] === "schedule" || run["trigger"] === "catch_up" || run["trigger"] === "manual") && typeof run["startedAt"] === "string" && (run["sessionResource"] === undefined || typeof run["sessionResource"] === "string") && (run["completedAt"] === undefined || typeof run["completedAt"] === "string") && (run["errorMessage"] === undefined || typeof run["errorMessage"] === "string");
 }
 function parseArchivedRuns(raw) {
     let value;