automations: fix: backport catalogue readiness for badge

The badge cherry-pick calls catalogueState, but release/1.137 does not yet contain the catalogue API from #334836. Backport the required contract, aggregate readiness, legacy readability, and Agent Host lifecycle support without importing the templates UI. Include focused catalogue and migration regression coverage.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 7e75f732-f18f-42a7-b1e2-a034c03596eb

Author: ulugbekna

src/vs/sessions/contrib/automations/browser/automationService.ts

@@ -22,6 +22,7 @@ import {
 	isAutomationModelConfiguration,
 } from '../../../../workbench/contrib/chat/common/automations/automation.js';
 import {
+	AutomationCatalogueState,
 	type AutomationMutationGuard,
 	assertAutomationSessionTemplateAuthority,
 	IAutomationRunClaim,
@@ -122,14 +123,15 @@ export class AutomationStore extends Disposable implements IAutomationStore {
 
 	private readonly _automations: ISettableObservable<readonly IAutomationDescriptor[]>;
 	private readonly _runs: ISettableObservable<readonly IAutomationRun[]>;
+	private readonly _catalogueState: ISettableObservable<AutomationCatalogueState>;
 	private _now: () => Date;
 	private readonly _runsForCache = new Map<string, IObservable<readonly IAutomationRun[]>>();
 
 	private _lastSeenRevision = 0;
-	private _canCompleteMigration = true;
 
 	readonly automations: IObservable<readonly IAutomationDescriptor[]>;
 	readonly runs: IObservable<readonly IAutomationRun[]>;
+	readonly catalogueState: IObservable<AutomationCatalogueState>;
 
 	constructor(
 		private readonly storageKey: string,
@@ -144,14 +146,15 @@ export class AutomationStore extends Disposable implements IAutomationStore {
 
 		const result = this.readLedger(this.storageService.get(this.storageKey, StorageScope.APPLICATION));
 		const initial = result.kind === 'unsupportedSchema' ? EMPTY_LEDGER : result.ledger;
-		this._canCompleteMigration = result.kind === 'ledger';
 		if (result.kind !== 'unsupportedSchema') {
 			this._lastSeenRevision = result.revision;
 		}
 		this._automations = observableValue<readonly IAutomationDescriptor[]>(this, initial.automations);
 		this._runs = observableValue<readonly IAutomationRun[]>(this, initial.runs);
+		this._catalogueState = observableValue(this, result.kind === 'ledger' ? 'ready' : 'error');
 		this.automations = this._automations;
 		this.runs = this._runs;
+		this.catalogueState = this._catalogueState;
 
 		this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, this.storageKey, this._store)(() => {
 			this.refreshFromStorage();
@@ -168,7 +171,7 @@ export class AutomationStore extends Disposable implements IAutomationStore {
 	}
 
 	canCompleteMigration(): boolean {
-		return this._canCompleteMigration;
+		return this._catalogueState.get() === 'ready';
 	}
 
 	runsFor(automationId: string): IObservable<readonly IAutomationRun[]> {
@@ -475,9 +478,11 @@ export class AutomationStore extends Disposable implements IAutomationStore {
 		while (true) {
 			const readResult = this.readLedger(raw);
 			if (readResult.kind === 'unsupportedSchema') {
+				this._catalogueState.set('error', undefined);
 				throw new Error('Cannot modify automations: storage was written by a newer version');
 			}
 			if (readResult.kind === 'invalid') {
+				this._catalogueState.set('error', undefined);
 				throw new Error('Cannot modify automations: persisted storage contains data this version cannot safely interpret');
 			}
 
@@ -512,30 +517,33 @@ export class AutomationStore extends Disposable implements IAutomationStore {
 		}
 	}
 
-	private acceptLedger(ledger: ILedger, revision: number): void {
+	private acceptLedger(ledger: ILedger, revision: number, catalogueState: AutomationCatalogueState = 'ready'): void {
 		if (revision < this._lastSeenRevision) {
+			if (catalogueState === 'error') {
+				this._catalogueState.set(catalogueState, undefined);
+			}
 			return;
 		}
-		this.setLedger(ledger, revision);
+		this.setLedger(ledger, revision, catalogueState);
 	}
 
-	private setLedger(ledger: ILedger, revision: number): void {
+	private setLedger(ledger: ILedger, revision: number, catalogueState: AutomationCatalogueState = 'ready'): void {
 		this._lastSeenRevision = revision;
 		transaction(tx => {
 			this._automations.set(ledger.automations, tx);
 			this._runs.set(ledger.runs, tx);
+			this._catalogueState.set(catalogueState, tx);
 		});
 	}
 
 	private refreshFromStorage(): void {
 		const result = this.readLedger(this.storageService.get(this.storageKey, StorageScope.APPLICATION));
 		if (result.kind === 'unsupportedSchema') {
-			this._canCompleteMigration = false;
+			this._catalogueState.set('error', undefined);
 			return;
 		}
 
-		this._canCompleteMigration = result.kind === 'ledger';
-		this.acceptLedger(result.ledger, result.revision);
+		this.acceptLedger(result.ledger, result.revision, result.kind === 'ledger' ? 'ready' : 'error');
 	}
 
 	private readLedger(raw: string | undefined): ReadLedgerResult {

src/vs/sessions/contrib/automations/browser/automations.contribution.ts

@@ -4,14 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable } from '../../../../base/common/lifecycle.js';
+import { observableFromPromise } from '../../../../base/common/observable.js';
 import { localize } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { ConfigurationScope, Extensions as ConfigurationExtensions, IConfigurationRegistry } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
 import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
 import product from '../../../../platform/product/common/product.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
-import { IWorkbenchContribution, registerWorkbenchContribution2, WorkbenchPhase } from '../../../../workbench/common/contributions.js';
+import { Extensions as WorkbenchExtensions, IWorkbenchContribution, IWorkbenchContributionsRegistry, registerWorkbenchContribution2, WorkbenchPhase } from '../../../../workbench/common/contributions.js';
 import { IAutomationDialogService } from '../../../../workbench/contrib/chat/common/automations/automationDialogService.js';
 import { IAutomationRunner } from '../../../../workbench/contrib/chat/common/automations/automationRunner.js';
 import { IAutomationService } from '../../../../workbench/contrib/chat/common/automations/automationService.js';
@@ -25,8 +27,12 @@ import { AutomationToolsContribution } from './automationTools.js';
 import { IAutomationStorageService } from '../common/automationStorageService.js';
 import { AGENT_HOST_AUTOMATIONS_ENABLED_CONFIG_KEY, AGENT_HOST_AUTOMATION_RUN_TIMEOUT_MINUTES_CONFIG_KEY } from '../../../../platform/agentHost/common/automationMigration.js';
 
+const initialProvidersSettled = observableFromPromise(
+	Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).whenRestored.then(() => true)
+).map(result => result.value === true);
+
 registerSingleton(IAutomationStorageService, BrowserAutomationStorageService, InstantiationType.Delayed);
-registerSingleton(IAutomationService, ProviderAutomationService, InstantiationType.Delayed);
+registerSingleton(IAutomationService, new SyncDescriptor(ProviderAutomationService, [initialProvidersSettled], true));
 registerSingleton(IAutomationRunner, AutomationRunner, InstantiationType.Delayed);
 registerSingleton(IAutomationDialogService, AutomationDialogService, InstantiationType.Delayed);
 

src/vs/sessions/contrib/automations/browser/providerAutomationService.ts

@@ -11,7 +11,7 @@ import { localize } from '../../../../nls.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { IAutomationDescriptor, IAutomationRun, AutomationRunTrigger } from '../../../../workbench/contrib/chat/common/automations/automation.js';
-import { AutomationMutationGuard, IAutomationRunClaim, IAutomationService, ICreateAutomationOptions, IGuardedAutomationUpdateResult, isAutomationActiveRunError, serializeAutomationEditableState, IUpdateAutomationOptions, IUpdateAutomationRunOptions } from '../../../../workbench/contrib/chat/common/automations/automationService.js';
+import { AutomationCatalogueState, AutomationMutationGuard, combineAutomationCatalogueStates, IAutomationRunClaim, IAutomationService, ICreateAutomationOptions, IGuardedAutomationUpdateResult, isAutomationActiveRunError, serializeAutomationEditableState, IUpdateAutomationOptions, IUpdateAutomationRunOptions } from '../../../../workbench/contrib/chat/common/automations/automationService.js';
 import { ISessionsProvidersService } from '../../../services/sessions/browser/sessionsProvidersService.js';
 import { IAutomation, ISessionsProviderAutomations } from '../../../services/sessions/common/sessionsProvider.js';
 import { AutomationService } from './automationService.js';
@@ -40,15 +40,25 @@ export class ProviderAutomationService extends Disposable implements IAutomation
 
 	readonly automations: IObservable<readonly IAutomationDescriptor[]>;
 	readonly runs: IObservable<readonly IAutomationRun[]>;
+	readonly catalogueState: IObservable<AutomationCatalogueState>;
 
 	constructor(
+		initialProvidersSettled: IObservable<boolean>,
 		@ISessionsProvidersService private readonly sessionsProvidersService: ISessionsProvidersService,
 		@IInstantiationService instantiationService: IInstantiationService,
 		@ILogService private readonly logService: ILogService,
 	) {
 		super();
 		this.legacyStore = this._register(instantiationService.createInstance(AutomationService));
 		this.providersChanged = observableSignalFromEvent(this, sessionsProvidersService.onDidChangeProviders);
+		this.catalogueState = derived(this, reader => {
+			this.providersChanged.read(reader);
+			const states = this.getStores().map(entry => entry.store.catalogueState.read(reader));
+			if (!initialProvidersSettled.read(reader)) {
+				states.push('loading');
+			}
+			return combineAutomationCatalogueStates(states);
+		});
 		this.automations = derived(this, reader => {
 			this.providersChanged.read(reader);
 			return distinctById(

src/vs/sessions/contrib/automations/test/browser/automationService.test.ts

@@ -5,14 +5,15 @@
 
 import assert from 'assert';
 import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { autorun } from '../../../../../base/common/observable.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
 import { NullLogService } from '../../../../../platform/log/common/log.js';
 import { InMemoryStorageService, StorageScope, StorageTarget } from '../../../../../platform/storage/common/storage.js';
 import { NullTelemetryService } from '../../../../../platform/telemetry/common/telemetryUtils.js';
 import { AutomationService, AutomationStore } from '../../browser/automationService.js';
 import { AutomationRunTrigger, AutomationTarget, AutomationWorkspaceIsolation, IAutomationRun, IAutomationSchedule } from '../../../../../workbench/contrib/chat/common/automations/automation.js';
-import { AutomationActiveRunError, isAutomationActiveRunError } from '../../../../../workbench/contrib/chat/common/automations/automationService.js';
+import { AutomationActiveRunError, type AutomationCatalogueState, isAutomationActiveRunError } from '../../../../../workbench/contrib/chat/common/automations/automationService.js';
 import { createAutomationService, TestAutomationStorageService } from './automationTestUtils.js';
 
 const FOLDER = URI.parse('file:///workspace');
@@ -78,8 +79,15 @@ suite('AutomationService', () => {
 
 	test('starts with an empty ledger when nothing is persisted', () => {
 		const { service } = createService();
-		assert.deepStrictEqual(service.automations.get(), []);
-		assert.deepStrictEqual(service.runs.get(), []);
+		assert.deepStrictEqual({
+			automations: service.automations.get(),
+			runs: service.runs.get(),
+			catalogueState: service.catalogueState.get(),
+		}, {
+			automations: [],
+			runs: [],
+			catalogueState: 'ready',
+		});
 	});
 
 	test('provider stores isolate ledgers by storage key', async () => {
@@ -811,6 +819,7 @@ suite('AutomationService', () => {
 		// but the service is now in read-only mode.
 		assert.deepStrictEqual(service.automations.get(), []);
 		assert.deepStrictEqual(service.runs.get(), []);
+		assert.strictEqual(service.catalogueState.get(), 'error');
 
 		// A subsequent mutation must be rejected (read-only mode) and must not
 		// destroy the on-disk newer ledger.
@@ -836,7 +845,68 @@ suite('AutomationService', () => {
 
 		// The onDidChangeValue refresh must NOT clear our observables to
 		// empty. We keep displaying what we last knew about.
-		assert.strictEqual(service.automations.get().length, 1);
+		assert.deepStrictEqual({
+			automationCount: service.automations.get().length,
+			catalogueState: service.catalogueState.get(),
+		}, {
+			automationCount: 1,
+			catalogueState: 'error',
+		});
+	});
+
+	test('refreshFromStorage reports malformed storage after a newer valid revision', async () => {
+		const storage = teardown.add(new InMemoryStorageService());
+		const service = teardown.add(createAutomationService(storage, new NullLogService(), NullTelemetryService));
+		await service.createAutomation({ name: 'Local', prompt: 'p', schedule: dailySchedule(), target: workspaceTarget() });
+		const emissions: Array<{ automationCount: number; catalogueState: AutomationCatalogueState }> = [];
+		teardown.add(autorun(reader => emissions.push({
+			automationCount: service.automations.read(reader).length,
+			catalogueState: service.catalogueState.read(reader),
+		})));
+
+		storage.store('chat.automations.ledger', '{', StorageScope.APPLICATION, StorageTarget.MACHINE);
+
+		assert.deepStrictEqual({
+			automationCount: service.automations.get().length,
+			catalogueState: service.catalogueState.get(),
+			emissions,
+		}, {
+			automationCount: 1,
+			catalogueState: 'error',
+			emissions: [
+				{ automationCount: 1, catalogueState: 'ready' },
+				{ automationCount: 1, catalogueState: 'error' },
+			],
+		});
+	});
+
+	test('publishes catalogue contents and readability atomically on refresh and recovery', async () => {
+		const { service, storage } = createService();
+		const initialLedger = JSON.stringify({
+			schemaVersion: 4, revision: 5,
+			automations: [serializeLedgerAutomation('saved', 'Saved')],
+			runs: [],
+		});
+		storage.store('chat.automations.ledger', initialLedger, StorageScope.APPLICATION, StorageTarget.MACHINE);
+		const emissions: Array<{ ids: string[]; catalogueState: AutomationCatalogueState; readable: boolean }> = [];
+		teardown.add(autorun(reader => emissions.push({
+			ids: service.automations.read(reader).map(automation => automation.id),
+			catalogueState: service.catalogueState.read(reader),
+			readable: service.canCompleteMigration(),
+		})));
+
+		storage.store('chat.automations.ledger', JSON.stringify({
+			schemaVersion: 4, revision: 6, automations: [], runs: null,
+		}), StorageScope.APPLICATION, StorageTarget.MACHINE);
+		storage.store('chat.automations.ledger', initialLedger, StorageScope.APPLICATION, StorageTarget.MACHINE);
+		await service.updateAutomation('saved', { name: 'Recovered' });
+
+		assert.deepStrictEqual(emissions, [
+			{ ids: ['saved'], catalogueState: 'ready', readable: true },
+			{ ids: [], catalogueState: 'error', readable: false },
+			{ ids: ['saved'], catalogueState: 'ready', readable: true },
+			{ ids: ['saved'], catalogueState: 'ready', readable: true },
+		]);
 	});
 
 	test('persist bumps the revision counter on every write', async () => {