@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

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

@@ -10,16 +10,19 @@ import { ConfirmationOptionKind } from '@codingame/monaco-vscode-api/vscode/vs/p
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 import { isAutomationModelConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation';
 import { IAutomationRunner } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner.service';
-import { ConfigureAutomationToolReferenceName, serializeAutomationEditableState, AutomationSessionTemplateAuthorityError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
+import { AutomationUnavailableError, ConfigureAutomationToolReferenceName, serializeAutomationEditableState, assertAutomationTargetAuthority, AutomationSessionTemplateAuthorityError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
 import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service';
 import { ChatAutomationsEnabledContext, CHAT_AUTOMATIONS_ENABLED_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
 import { ChatPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
 import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { logAutomationConfigureOutcome } from './automationTelemetry.js';
 
 const ListAutomationsToolId = "vscode_listAutomations";
 const ConfigureAutomationToolId = "vscode_configureAutomation";
@@ -27,8 +30,7 @@ const RunAutomationToolId = "vscode_runAutomation";
 const DeleteAutomationToolId = "vscode_deleteAutomation";
 const automationToolWhen = ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatAutomationsEnabledContext));
 const deleteAutomationConfirmationId = "delete";
-const manualRunLeaderWindowId = 0;
-const automationIntervals = ["manual", "hourly", "daily", "weekly"];
+const automationIntervals = ["manual", "hourly", "daily", "weekdays", "weekly"];
 const automationIsolationKinds = ["default", "folder", "worktree"];
 const chatPermissionLevels = [
     ChatPermissionLevel.Default,
@@ -47,9 +49,10 @@ class AutomationToolMutationBlockedError extends Error {
     }
 }
 let ListAutomationsTool = class ListAutomationsTool {
-    constructor(automationService, configurationService) {
+    constructor(automationService, configurationService, sessionsProvidersService) {
         this.automationService = automationService;
         this.configurationService = configurationService;
+        this.sessionsProvidersService = sessionsProvidersService;
     }
     getToolData() {
         return {
@@ -57,9 +60,9 @@ let ListAutomationsTool = class ListAutomationsTool {
             toolReferenceName: "listAutomations",
             canBeReferencedInPrompt: false,
             icon: Codicon.calendar,
-            displayName: ( localize(3366, "List Automations")),
-            userDescription: ( localize(3367, "List scheduled agent automations")),
-            modelDescription: "List all currently available scheduled automations and their stable IDs, editable fields, targets, and timing metadata. The result includes catalogueState; only \"ready\" means the list is complete, so never interpret an empty non-ready result as no configured automations. Use this before configureAutomation, runAutomation, or deleteAutomation when acting on an existing automation. This tool never changes automation state.",
+            displayName: ( localize(3776, "List Automations")),
+            userDescription: ( localize(3777, "List scheduled agent automations")),
+            modelDescription: "List Automation providers and their currently visible scheduled automations. The result is an array with one entry per provider. A provider's state applies only to that provider and never makes automations from another provider unavailable. When a provider is \"ready\", its automations array is complete; otherwise it may be incomplete, including when empty. Use canCreateAutomation and each automation's availableOperations before calling configureAutomation, runAutomation, or deleteAutomation. This tool never changes automation state.",
             source: ToolDataSource.Internal,
             when: automationToolWhen,
             runsInWorkspace: false,
@@ -72,29 +75,48 @@ let ListAutomationsTool = class ListAutomationsTool {
     }
     async prepareToolInvocation(_context, _token) {
         return {
-            invocationMessage: ( localize(3368, "Reading automations")),
-            pastTenseMessage: ( localize(3369, "Read automations"))
+            invocationMessage: ( localize(3778, "Reading automations")),
+            pastTenseMessage: ( localize(3779, "Read automations"))
         };
     }
     async invoke(_invocation, _countTokens, _progress, _token) {
         if (!isAutomationsEnabled(this.configurationService)) {
             return automationToolError("Automations are disabled.");
         }
-        const catalogueState = this.automationService.catalogueState.get();
-        const automations = this.automationService.automations.get().map(toAutomationToolOutput);
-        const result = automationToolResult(JSON.stringify({
-            catalogueState,
-            automations
-        }, undefined, 2));
-        result.toolResultMessage = catalogueState !== "ready" ? ( localize(
-            3370,
-            "Listed {0} available automations; catalogue is incomplete",
-            automations.length
-        )) : automations.length === 1 ? ( localize(3371, "Listed 1 automation")) : ( localize(3372, "Listed {0} automations", automations.length));
+        const providers = this.sessionsProvidersService.getProviders().flatMap(provider => {
+            const store = provider.automations;
+            if (!store || store.enabled?.get() === false) {
+                return [];
+            }
+            const state = store.catalogueState.get();
+            const unavailableReason = store.unavailableReason?.get();
+            return [{
+                providerId: provider.id,
+                providerLabel: provider.label,
+                state,
+                canCreateAutomation: store.canCreateAutomation.get(),
+                ...(unavailableReason !== undefined ? {
+                    unavailableReason
+                } : {}),
+                automations: store.automations.get().map(
+                    automation => toAutomationListToolOutput(automation, this.automationService)
+                )
+            }];
+        });
+        const automationCount = providers.reduce((count, provider) => count + provider.automations.length, 0);
+        const incompleteProviderCount = providers.filter(provider => provider.state !== "ready").length;
+        const result = automationToolResult(JSON.stringify(providers, undefined, 2));
+        result.toolResultMessage = incompleteProviderCount > 0 ? ( localize(
+            3780,
+            "Visible automations: {0}; incomplete providers: {1} of {2}",
+            automationCount,
+            incompleteProviderCount,
+            providers.length
+        )) : automationCount === 1 ? ( localize(3781, "Listed 1 automation")) : ( localize(3782, "Listed {0} automations", automationCount));
         return result;
     }
 };
-ListAutomationsTool = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IConfigurationService))], ListAutomationsTool));
+ListAutomationsTool = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IConfigurationService)), ( __param(2, ISessionsProvidersService))], ListAutomationsTool));
 let RunAutomationTool = class RunAutomationTool {
     constructor(automationService, automationRunner, configurationService) {
         this.automationService = automationService;
@@ -107,8 +129,8 @@ let RunAutomationTool = class RunAutomationTool {
             toolReferenceName: "runAutomation",
             canBeReferencedInPrompt: false,
             icon: Codicon.play,
-            displayName: ( localize(3373, "Run Automation")),
-            userDescription: ( localize(3374, "Run a configured agent automation now")),
+            displayName: ( localize(3783, "Run Automation")),
+            userDescription: ( localize(3784, "Run a configured agent automation now")),
             modelDescription: "Run a configured automation immediately by stable ID. Call listAutomations first to obtain the current ID. This starts a fresh agent session in the background using the saved prompt, target, and provider session configuration, even when scheduled runs are disabled. The tool returns after session dispatch commits; do not run it again unless the user asks.",
             source: ToolDataSource.Internal,
             when: automationToolWhen,
@@ -134,17 +156,17 @@ let RunAutomationTool = class RunAutomationTool {
         const activeRun = this.automationService.getActiveRunFor(automation.id);
         if (activeRun) {
             return {
-                invocationMessage: ( localize(3375, "Automation {0} is already running", automation.name)),
-                pastTenseMessage: ( localize(3376, "Automation {0} was already running", automation.name))
+                invocationMessage: ( localize(3785, "Automation {0} is already running", automation.name)),
+                pastTenseMessage: ( localize(3786, "Automation {0} was already running", automation.name))
             };
         }
         return {
-            invocationMessage: ( localize(3377, "Running automation {0}", automation.name)),
-            pastTenseMessage: ( localize(3378, "Started automation {0}", automation.name)),
+            invocationMessage: ( localize(3787, "Running automation {0}", automation.name)),
+            pastTenseMessage: ( localize(3788, "Started automation {0}", automation.name)),
             confirmationMessages: {
-                title: ( localize(3379, "Run Automation?")),
+                title: ( localize(3789, "Run Automation?")),
                 message: ( new MarkdownString(( localize(
-                    3380,
+                    3790,
                     "Run **{0}** (`{1}`) now? This starts a new agent session using the automation's configured prompt and permissions.",
                     automation.name,
                     automation.id
@@ -169,7 +191,7 @@ let RunAutomationTool = class RunAutomationTool {
             throw error;
         }
         const dispatchCancellation = ( new CancellationTokenSource(token));
-        const operation = this.automationRunner.runOnce(automation, "manual", manualRunLeaderWindowId, dispatchCancellation.token);
+        const operation = this.automationRunner.runOnce(automation, dispatchCancellation.token);
         let dispatch;
         try {
             dispatch = await operation.whenDispatched;
@@ -182,6 +204,21 @@ let RunAutomationTool = class RunAutomationTool {
         if (dispatch.kind === "notStarted") {
             return automationNotStarted(automation, dispatch);
         }
+        if (dispatch.kind === "accepted") {
+            const result = automationToolResult(JSON.stringify({
+                status: "accepted",
+                automation: {
+                    id: automation.id,
+                    name: automation.name
+                }
+            }));
+            result.toolResultMessage = ( localize(
+                3791,
+                "Requested automation {0}; the provider has not returned a run.",
+                automation.name
+            ));
+            return result;
+        }
         const result = automationToolResult(JSON.stringify({
             status: "started",
             automation: {
@@ -194,7 +231,7 @@ let RunAutomationTool = class RunAutomationTool {
                 sessionResource: ( dispatch.sessionResource.toString())
             }
         }, undefined, 2));
-        result.toolResultMessage = ( localize(3381, "Started automation {0}", automation.name));
+        result.toolResultMessage = ( localize(3792, "Started automation {0}", automation.name));
         return result;
     }
 };
@@ -210,8 +247,8 @@ let DeleteAutomationTool = class DeleteAutomationTool {
             toolReferenceName: "deleteAutomation",
             canBeReferencedInPrompt: false,
             icon: Codicon.trash,
-            displayName: ( localize(3382, "Delete Automation")),
-            userDescription: ( localize(3383, "Delete a scheduled agent automation")),
+            displayName: ( localize(3793, "Delete Automation")),
+            userDescription: ( localize(3794, "Delete a scheduled agent automation")),
             modelDescription: "Delete an automation by stable ID. Call listAutomations first to obtain the current ID. The current approval policy may approve the action automatically; otherwise the user is shown a Delete/Cancel confirmation.",
             source: ToolDataSource.Internal,
             when: automationToolWhen,
@@ -235,23 +272,23 @@ let DeleteAutomationTool = class DeleteAutomationTool {
         }
         const automation = resolveAutomationInput(this.automationService, context.parameters, "deleteAutomation");
         return {
-            invocationMessage: ( localize(3384, "Deleting automation {0}", automation.name)),
-            pastTenseMessage: ( localize(3385, "Deleted automation {0}", automation.name)),
+            invocationMessage: ( localize(3795, "Deleting automation {0}", automation.name)),
+            pastTenseMessage: ( localize(3796, "Deleted automation {0}", automation.name)),
             confirmationMessages: {
-                title: ( localize(3386, "Delete Automation?")),
+                title: ( localize(3797, "Delete Automation?")),
                 message: ( new MarkdownString(( localize(
-                    3387,
+                    3798,
                     "Delete **{0}** (`{1}`)? Its saved configuration and run history will be permanently removed. Runs already in flight will continue.",
                     automation.name,
                     automation.id
                 )))),
                 customOptions: [{
                     id: deleteAutomationConfirmationId,
-                    label: ( localize(3388, "Delete")),
+                    label: ( localize(3799, "Delete")),
                     kind: ConfirmationOptionKind.Approve
                 }, {
                     id: "cancel",
-                    label: ( localize(3389, "Cancel")),
+                    label: ( localize(3800, "Cancel")),
                     kind: ConfirmationOptionKind.Deny
                 }]
             }
@@ -282,6 +319,9 @@ let DeleteAutomationTool = class DeleteAutomationTool {
             if (error instanceof AutomationToolMutationBlockedError) {
                 return error.result;
             }
+            if (error instanceof AutomationUnavailableError) {
+                return automationToolError(error.message);
+            }
             throw error;
         }
         const result = automationToolResult(JSON.stringify({
@@ -291,7 +331,7 @@ let DeleteAutomationTool = class DeleteAutomationTool {
                 name: automation.name
             }
         }));
-        result.toolResultMessage = ( localize(3390, "Deleted automation {0}", automation.name));
+        result.toolResultMessage = ( localize(3801, "Deleted automation {0}", automation.name));
         return result;
     }
     createMutationGuard(token) {
@@ -307,10 +347,16 @@ let DeleteAutomationTool = class DeleteAutomationTool {
 };
 DeleteAutomationTool = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IConfigurationService))], DeleteAutomationTool));
 let ConfigureAutomationTool = class ConfigureAutomationTool {
-    constructor(automationService, sessionsManagementService, configurationService) {
+    constructor(
+        automationService,
+        sessionsManagementService,
+        configurationService,
+        telemetryService
+    ) {
         this.automationService = automationService;
         this.sessionsManagementService = sessionsManagementService;
         this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
     }
     getToolData() {
         return {
@@ -318,13 +364,13 @@ let ConfigureAutomationTool = class ConfigureAutomationTool {
             toolReferenceName: ConfigureAutomationToolReferenceName,
             canBeReferencedInPrompt: false,
             icon: Codicon.calendar,
-            displayName: ( localize(3391, "Configure Automation")),
-            userDescription: ( localize(3392, "Create or update an automation")),
+            displayName: ( localize(3802, "Configure Automation")),
+            userDescription: ( localize(3803, "Create or update an automation")),
             modelDescription: `Create or update a persistent scheduled automation.
 
 Create a new automation only when the user explicitly asks for an automation, or for a prompt to run on a recurring schedule. Do not infer that intent from requests merely to monitor, watch, follow, or keep something (such as a pull request) green.
 
-Omit "automationId" to create an automation; "name", "prompt", and "schedule.interval" are then required. If "target" is omitted, the automation targets the current Agents window session. Include "automationId" to update an existing automation, and only provide fields that should change. Call listAutomations first to obtain the stable ID and current values.
+Omit "automationId" to create an automation; "name", "prompt", and "schedule.interval" are then required. If "target" is omitted, the automation targets the current Agents window session. The target must be a connected Agent Host that supports automations; there is no local execution fallback. Include "automationId" to update an existing automation, and only provide fields that should change. Call listAutomations first to obtain the stable ID and current values. An existing automation cannot move between hosts; create a separate definition on the new host and explicitly disable the original if it should stop scheduling.
 
 Use "sessionTemplate" for provider-owned Model, Agent, Mode, Approvals, and other configuration returned by listAutomations. Omit it on unrelated partial updates, or set it to null to reset provider configuration. Do not combine it with the legacy "modelId", "mode", or "permissionLevel" aliases.
 
@@ -356,19 +402,19 @@ The change uses the current tool-approval policy. When approval is required, the
                             interval: {
                                 type: "string",
                                 enum: [...automationIntervals],
-                                description: "manual, hourly, daily, or weekly."
+                                description: "manual, hourly, daily, weekdays, or weekly. Weekdays runs Monday-Friday at the same local time on an Agent Host; it is not supported by Cloud."
                             },
                             scheduleHour: {
                                 type: "integer",
                                 minimum: 0,
                                 maximum: 23,
-                                description: "Local hour, used for daily and weekly schedules."
+                                description: "Local hour, used for daily, weekdays, and weekly schedules."
                             },
                             scheduleMinute: {
                                 type: "integer",
                                 minimum: 0,
                                 maximum: 59,
-                                description: "Local minute, used for daily and weekly schedules."
+                                description: "Local minute, used for daily, weekdays, and weekly schedules."
                             },
                             scheduleDay: {
                                 type: "integer",
@@ -467,21 +513,32 @@ The change uses the current tool-approval policy. When approval is required, the
     }
     async prepareToolInvocation(context, _token) {
         if (!isAutomationsEnabled(this.configurationService)) {
+            logAutomationConfigureOutcome(this.telemetryService, "unknown", "blocked");
             throw ( new AutomationToolInputError("Automations are disabled."));
         }
-        const proposal = this.parseProposal(context.parameters, context.chatSessionResource);
-        const isUpdate = proposal.kind === "update";
+        let proposal;
+        try {
+            proposal = this.parseProposal(context.parameters, context.chatSessionResource);
+        } catch (error) {
+            logAutomationConfigureOutcome(
+                this.telemetryService,
+                "unknown",
+                error instanceof AutomationToolInputError ? "blocked" : "failed"
+            );
+            throw error;
+        }
+        const existing = proposal.kind === "update" ? proposal.existing : undefined;
         return {
-            invocationMessage: isUpdate ? ( localize(3393, "Configuring automation")) : ( localize(3394, "Configuring a new automation")),
-            pastTenseMessage: isUpdate ? ( localize(3395, "Configured automation")) : ( localize(3396, "Configured a new automation")),
+            invocationMessage: existing ? ( localize(3804, "Configuring automation")) : ( localize(3805, "Configuring a new automation")),
+            pastTenseMessage: existing ? ( localize(3806, "Configured automation")) : ( localize(3807, "Configured a new automation")),
             confirmationMessages: {
-                title: isUpdate ? ( localize(3397, "Update Automation?")) : ( localize(3398, "Create Automation?")),
-                message: isUpdate ? ( new MarkdownString(( localize(
-                    3399,
+                title: existing ? ( localize(3808, "Update Automation?")) : ( localize(3809, "Create Automation?")),
+                message: existing ? ( new MarkdownString(( localize(
+                    3810,
                     "Apply the proposed changes to **{0}** (`{1}`)?",
-                    proposal.existing.name,
-                    proposal.existing.id
-                )))) : ( new MarkdownString(( localize(3400, "Create the automation **{0}**?", proposal.initialValues.name))))
+                    existing.name,
+                    existing.id
+                )))) : ( new MarkdownString(( localize(3811, "Create the automation **{0}**?", proposal.initialValues.name))))
             },
             toolSpecificData: proposal.kind === "update" ? {
                 kind: "automationConfiguration",
@@ -492,65 +549,83 @@ The change uses the current tool-approval policy. When approval is required, the
     }
     async invoke(invocation, _countTokens, _progress, token) {
         if (!isAutomationsEnabled(this.configurationService)) {
-            return automationToolError("Automations are disabled.");
+            return this.completeOperation("unknown", automationToolError("Automations are disabled."));
         }
         if (token.isCancellationRequested) {
-            return automationToolCancelled();
+            return this.completeOperation("unknown", automationToolCancelled());
         }
         let proposal;
         try {
             proposal = this.parseProposal(invocation.parameters, invocation.context?.sessionResource);
         } catch (error) {
             if (error instanceof AutomationToolInputError) {
-                return automationToolError(error.message);
+                return this.completeOperation("unknown", automationToolError(error.message));
             }
+            logAutomationConfigureOutcome(this.telemetryService, "unknown", "failed");
             throw error;
         }
         try {
             if (proposal.kind === "create") {
                 const target = proposal.validateTargetAvailability ? this.resolveAvailableTarget(proposal.initialValues.target) : proposal.initialValues.target;
-                return await this.applyCreate({
+                return this.completeOperation("create", await this.applyCreate({
                     ...proposal.initialValues,
                     target
-                }, token);
+                }, token));
             }
-            const target = proposal.initialValues.target ? proposal.validateTargetAvailability ? this.resolveAvailableTarget(proposal.initialValues.target) : proposal.initialValues.target : undefined;
-            const patch = target ? {
-                ...proposal.initialValues,
-                target
-            } : proposal.initialValues;
             const prepared = invocation.toolSpecificData?.kind === "automationConfiguration" ? invocation.toolSpecificData : undefined;
             if (prepared && (prepared.expectedAutomationId !== proposal.existing.id || prepared.expectedEditableState !== serializeAutomationEditableState(proposal.existing))) {
-                return automationToolError(
+                return this.completeOperation("update", automationToolError(
                     `Automation "${proposal.existing.id}" changed before the update was applied. Call listAutomations to refresh it before proposing new changes. No changes were made.`
-                );
+                ));
             }
-            return await this.applyUpdate(proposal.existing, patch, token);
+            const proposedTarget = proposal.initialValues.target;
+            const ownedTarget = proposedTarget?.kind === "workspace" && proposedTarget.providerId === undefined ? {
+                ...proposedTarget,
+                providerId: proposal.existing.target.providerId
+            } : proposedTarget;
+            assertAutomationTargetAuthority(proposal.existing, ownedTarget);
+            const target = ownedTarget !== undefined && proposal.validateTargetAvailability ? this.resolveAvailableTarget(ownedTarget, proposal.existing) : ownedTarget;
+            const patch = target ? {
+                ...proposal.initialValues,
+                target
+            } : proposal.initialValues;
+            return this.completeOperation("update", await this.applyUpdate(proposal.existing, patch, token));
         } catch (error) {
             if (error instanceof AutomationToolMutationBlockedError) {
-                return error.result;
+                return this.completeOperation(proposal.kind, error.result);
             }
-            if (error instanceof AutomationToolInputError) {
-                return automationToolError(error.message);
+            if (error instanceof AutomationToolInputError || error instanceof AutomationUnavailableError) {
+                return this.completeOperation(proposal.kind, automationToolError(error.message));
             }
             if (error instanceof AutomationSessionTemplateAuthorityError) {
-                return automationToolError(error.message);
+                return this.completeOperation(proposal.kind, automationToolError(error.message));
             }
+            logAutomationConfigureOutcome(this.telemetryService, proposal.kind, "failed");
             throw error;
         }
     }
+    completeOperation(operation, result) {
+        const configured = result.toolSpecificData?.kind === "automationConfigured" ? result.toolSpecificData.operation : undefined;
+        logAutomationConfigureOutcome(this.telemetryService, operation, configured ?? "blocked");
+        return result;
+    }
     async applyCreate(options, token) {
         const blocked = this.getMutationBlockedResult(token);
         if (blocked) {
             return blocked;
         }
+        if (!this.automationService.canCreateAutomation(options.target.providerId)) {
+            return automationToolError(
+                "The selected provider is unavailable or does not support automations. Connect to an Agent Host that supports automations."
+            );
+        }
         const created = await this.automationService.createAutomation(options, this.createMutationGuard(token));
         const result = automationToolResult(JSON.stringify({
             status: "created",
             automation: toAutomationToolOutput(created)
         }, undefined, 2));
         result.toolSpecificData = toAutomationConfiguredData(created, "created");
-        result.toolResultMessage = ( localize(3401, "Created automation {0}", created.name));
+        result.toolResultMessage = ( localize(3812, "Created automation {0}", created.name));
         return result;
     }
     async applyUpdate(existing, patch, token) {
@@ -575,7 +650,7 @@ The change uses the current tool-approval policy. When approval is required, the
             automation: toAutomationToolOutput(updated)
         }, undefined, 2));
         result.toolSpecificData = toAutomationConfiguredData(updated, "updated");
-        result.toolResultMessage = ( localize(3402, "Updated automation {0}", updated.name));
+        result.toolResultMessage = ( localize(3813, "Updated automation {0}", updated.name));
         return result;
     }
     createMutationGuard(token) {
@@ -595,9 +670,12 @@ The change uses the current tool-approval policy. When approval is required, the
         }
         return undefined;
     }
-    resolveAvailableTarget(target) {
+    resolveAvailableTarget(target, existing) {
         const candidates = target.kind === "quickChat" ? this.sessionsManagementService.getQuickChatSessionTypes() : this.sessionsManagementService.getSessionTypesForFolder(target.folderUri);
-        const candidate = findSessionType(candidates, target.providerId, target.sessionTypeId);
+        const eligible = candidates.filter(
+            candidate => existing === undefined ? this.automationService.canCreateAutomation(candidate.providerId) : candidate.providerId === existing.target.providerId && this.automationService.canUpdateAutomation(existing.id)
+        );
+        const candidate = findSessionType(eligible, target.providerId, target.sessionTypeId);
         if (!candidate) {
             throw ( new AutomationToolInputError(
                 target.kind === "quickChat" ? `The quick-chat target "${target.providerId}/${target.sessionTypeId}" is not available.` : "The proposed workspace target is not available for the selected provider and session type."
@@ -749,7 +827,7 @@ The change uses the current tool-approval policy. When approval is required, the
         return session ? automationTargetFromSession(session) : undefined;
     }
 };
-ConfigureAutomationTool = ( __decorate([( __param(0, IAutomationService)), ( __param(1, ISessionsManagementService)), ( __param(2, IConfigurationService))], ConfigureAutomationTool));
+ConfigureAutomationTool = ( __decorate([( __param(0, IAutomationService)), ( __param(1, ISessionsManagementService)), ( __param(2, IConfigurationService)), ( __param(3, ITelemetryService))], ConfigureAutomationTool));
 let AutomationToolsContribution = class AutomationToolsContribution extends Disposable {
     static {
         this.ID = "sessions.contrib.automationTools";
@@ -1053,6 +1131,16 @@ function toAutomationToolOutput(automation) {
         nextRunAt: automation.nextRunAt ?? null
     };
 }
+function toAutomationListToolOutput(automation, automationService) {
+    return {
+        ...toAutomationToolOutput(automation),
+        availableOperations: [
+            ...(automationService.canRunAutomation(automation.id) ? ["run"] : []),
+            ...(automationService.canUpdateAutomation(automation.id) ? ["update"] : []),
+            ...(automationService.canDeleteAutomation(automation.id) ? ["delete"] : [])
+        ]
+    };
+}
 function toAutomationConfiguredData(automation, operation) {
     return {
         kind: "automationConfigured",
@@ -1076,7 +1164,7 @@ function automationToolError(message) {
             value: message
         }],
         toolResultError: message,
-        toolResultMessage: ( localize(3403, "Automation request failed"))
+        toolResultMessage: ( localize(3814, "Automation request failed"))
     };
 }
 function automationToolCancelled() {
@@ -1084,7 +1172,7 @@ function automationToolCancelled() {
         status: "cancelled",
         message: "The automation change was cancelled. No changes were made."
     }));
-    result.toolResultMessage = ( localize(3404, "Automation change cancelled"));
+    result.toolResultMessage = ( localize(3815, "Automation change cancelled"));
     return result;
 }
 function automationDeleteCancelled() {
@@ -1092,7 +1180,7 @@ function automationDeleteCancelled() {
         status: "cancelled",
         message: "The automation was not deleted."
     }));
-    result.toolResultMessage = ( localize(3405, "Automation deletion cancelled"));
+    result.toolResultMessage = ( localize(3816, "Automation deletion cancelled"));
     return result;
 }
 function automationRunCancelled() {
@@ -1100,7 +1188,7 @@ function automationRunCancelled() {
         status: "cancelled",
         message: "The automation was not started."
     }));
-    result.toolResultMessage = ( localize(3406, "Automation run cancelled"));
+    result.toolResultMessage = ( localize(3817, "Automation run cancelled"));
     return result;
 }
 function automationAlreadyRunning(automation, run) {
@@ -1116,7 +1204,7 @@ function automationAlreadyRunning(automation, run) {
             sessionResource: run.sessionResource?.toString() ?? null
         }
     }, undefined, 2));
-    result.toolResultMessage = ( localize(3407, "Automation {0} is already running", automation.name));
+    result.toolResultMessage = ( localize(3818, "Automation {0} is already running", automation.name));
     return result;
 }
 function automationNotStarted(automation, dispatch) {

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

@@ -11,18 +11,15 @@ import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/com
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 import { Extensions, registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING, DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES, CHAT_AUTOMATIONS_ENABLED_SETTING, ChatAutomationsEnabledContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
+import { CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING, DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES, CHAT_AUTOMATIONS_ENABLED_SETTING, CHAT_CLOUD_AUTOMATIONS_ENABLED_SETTING, ChatAutomationsEnabledContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
 import './automationDialogService.js';
 import './automationRunner.js';
-import { AutomationScheduler } from './automationScheduler.js';
 import './providerAutomationService.js';
-import './automationStorageService.js';
 import { AutomationToolsContribution } from './automationTools.js';
-import { AGENT_HOST_AUTOMATION_RUN_TIMEOUT_MINUTES_CONFIG_KEY, AGENT_HOST_AUTOMATIONS_ENABLED_CONFIG_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/automationMigration';
+import { AGENT_HOST_AUTOMATION_RUN_TIMEOUT_MINUTES_CONFIG_KEY, AGENT_HOST_AUTOMATIONS_ENABLED_CONFIG_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/automationConfig';
 import { observableFromPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
 
 observableFromPromise(( Registry.as(Extensions.Workbench)).whenRestored.then(() => true)).map(result => result.value === true);
-registerWorkbenchContribution2(AutomationScheduler.ID, AutomationScheduler, WorkbenchPhase.Eventually);
 registerWorkbenchContribution2(
     AutomationToolsContribution.ID,
     AutomationToolsContribution,
@@ -31,13 +28,26 @@ registerWorkbenchContribution2(
 ( Registry.as(Extensions$1.Configuration)).registerConfiguration({
     id: "chat",
     properties: {
+        [CHAT_CLOUD_AUTOMATIONS_ENABLED_SETTING]: {
+            type: "boolean",
+            default: false,
+            scope: ConfigurationScope.MACHINE,
+            tags: ["experimental", "advanced"],
+            description: ( localize(
+                3819,
+                "Enables managing user-owned cloud automations in known private GitHub repositories. Disabling this setting does not stop schedules already running on GitHub."
+            )),
+            experiment: {
+                mode: "auto"
+            }
+        },
         [CHAT_AUTOMATIONS_ENABLED_SETTING]: {
             type: "boolean",
             default: true,
             scope: ConfigurationScope.MACHINE,
             tags: ["experimental", "advanced"],
             description: ( localize(
-                3408,
+                3820,
                 "Enables the Automations feature: scheduling agent sessions to run on a cadence. When disabled, the Automations entry in the Customizations sidebar, the Automations section in the Customizations editor, and the Automation option in the new-session composer are hidden, and scheduled automations are not dispatched."
             )),
             experiment: {
@@ -54,7 +64,7 @@ registerWorkbenchContribution2(
             scope: ConfigurationScope.MACHINE,
             tags: ["experimental", "advanced"],
             description: ( localize(
-                3409,
+                3821,
                 "Maximum number of minutes an automation run is allowed to take before it is ended. Prevents a single hung run from permanently blocking subsequent runs."
             )),
             included: product.quality !== "stable",