@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/browser/actions/developerActions.js

@@ -6,14 +6,18 @@ import { IKeybindingService } from '../../../platform/keybinding/common/keybindi
 import { DomEmitter } from '../../../base/browser/event.js';
 import { Color } from '../../../base/common/color.js';
 import { Event, Emitter } from '../../../base/common/event.js';
+import { getErrorMessage } from '../../../base/common/errors.js';
 import { DisposableStore, toDisposable, dispose, DisposableTracker, setDisposableTracker } from '../../../base/common/lifecycle.js';
+import { Schemas } from '../../../base/common/network.js';
+import { URI } from '../../../base/common/uri.js';
+import { generateUuid } from '../../../base/common/uuid.js';
 import { createElement, getActiveDocument, getDomNodePagePosition, append, $, getWindows, onDidRegisterWindow } from '../../../base/browser/dom.js';
 import { createStyleSheet, createCSSRule } from '../../../base/browser/domStylesheets.js';
 import { IConfigurationService } from '../../../platform/configuration/common/configuration.service.js';
 import { RawContextKey, ContextKeyExpr } from '../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.service.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
-import { RunOnceScheduler } from '../../../base/common/async.js';
+import { RunOnceScheduler, raceTimeout } from '../../../base/common/async.js';
 import { ILayoutService } from '../../../platform/layout/browser/layoutService.service.js';
 import { Registry } from '../../../platform/registry/common/platform.js';
 import { Action2, MenuRegistry, registerAction2 } from '../../../platform/actions/common/actions.js';
@@ -36,27 +40,38 @@ import { IUserDataProfileService } from '../../services/userDataProfile/common/u
 import { IEditorService } from '../../services/editor/common/editorService.service.js';
 import product from '../../../platform/product/common/product.js';
 import { CommandsRegistry } from '../../../platform/commands/common/commands.js';
+import { ICommandService } from '../../../platform/commands/common/commands.service.js';
 import { IEnvironmentService } from '../../../platform/environment/common/environment.service.js';
 import { IProductService } from '../../../platform/product/common/productService.service.js';
 import { IDefaultAccountService } from '../../../platform/defaultAccount/common/defaultAccount.service.js';
+import { isManagedSettingsFreshnessBlocking } from '../../../platform/policy/common/managedSettingsFreshness.js';
 import { IAuthenticationService } from '../../services/authentication/common/authentication.service.js';
 import { IAuthenticationAccessService } from '../../services/authentication/browser/authenticationAccessService.service.js';
+import { PolicyValueSource } from '../../../platform/policy/common/policy.js';
 import { IPolicyService } from '../../../platform/policy/common/policy.service.js';
-import { pickManagedSettings, projectManagedSettings, COPILOT_ENABLED_PLUGINS_KEY, COPILOT_STRICT_MARKETPLACES_KEY, COPILOT_EXTRA_MARKETPLACES_KEY, MANAGED_SETTINGS_CHANNELS } from '../../../platform/policy/common/copilotManagedSettings.js';
+import { IWorkspaceContextService } from '../../../platform/workspace/common/workspace.service.js';
+import { isVirtualWorkspace } from '../../../platform/workspace/common/virtualWorkspace.js';
+import { pickManagedSettings, projectManagedSettings, normalizeManagedSettings, COPILOT_ENABLED_PLUGINS_KEY, COPILOT_STRICT_MARKETPLACES_KEY, COPILOT_EXTRA_MARKETPLACES_KEY } from '../../../platform/policy/common/copilotManagedSettings.js';
 import { INativeManagedSettingsService, IFileManagedSettingsService } from '../../../platform/policy/common/copilotManagedSettings.service.js';
-import { APPROVED_ACCOUNT_ORGANIZATIONS_POLICY_NAME, AccountPolicyGateState, AccountPolicyGateUnsatisfiedReason } from '../../services/policies/common/accountPolicyService.js';
+import { APPROVED_ACCOUNT_ORGANIZATIONS_POLICY_NAME } from '../../services/policies/common/accountPolicyService.js';
 import { IAccountPolicyGateService } from '../../services/policies/common/accountPolicyService.service.js';
-import { adaptManagedSettings } from '../../services/accounts/browser/managedSettings.js';
+import { adaptManagedSettings, appendManagedSettingsClientIdentity } from '../../services/accounts/browser/managedSettings.js';
 import { isObject } from '../../../base/common/types.js';
 import { parse } from '../../../base/common/json.js';
 import { getParseErrorMessage } from '../../../base/common/jsonErrorMessages.js';
+import { IAgentHostService } from '../../../platform/agentHost/common/agentService.service.js';
+import { IAgentHostEnablementService } from '../../../platform/agentHost/common/agentHostEnablementService.service.js';
+import { ProgressLocation } from '../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../platform/progress/common/progress.service.js';
+import { INotificationService } from '../../../platform/notification/common/notification.service.js';
+import { markdownText, markdownJsonBlock, markdownDetails, markdownTable } from './policyDiagnosticsMarkdown.js';
 
 registerCss(actions);
 class InspectContextKeysAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.inspectContextKeys",
-            title: ( localize2(2970, "Inspect Context Keys")),
+            title: ( localize2(3220, "Inspect Context Keys")),
             category: Categories.Developer,
             f1: true
         });
@@ -102,7 +117,7 @@ class ToggleScreencastModeAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.toggleScreencastMode",
-            title: ( localize2(2971, "Toggle Screencast Mode")),
+            title: ( localize2(3221, "Toggle Screencast Mode")),
             category: Categories.Developer,
             f1: true
         });
@@ -347,7 +362,7 @@ class LogStorageAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.logStorage",
-            title: ( localize2(2972, "Log Storage Database Contents")),
+            title: ( localize2(3222, "Log Storage Database Contents")),
             category: Categories.Developer,
             f1: true
         });
@@ -357,16 +372,16 @@ class LogStorageAction extends Action2 {
         const dialogService = accessor.get(IDialogService);
         storageService.log();
         dialogService.info(( localize(
-            2973,
+            3223,
             "The storage database contents have been logged to the developer tools."
-        )), ( localize(2974, "Open developer tools from the menu and select the Console tab.")));
+        )), ( localize(3224, "Open developer tools from the menu and select the Console tab.")));
     }
 }
 class LogWorkingCopiesAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.logWorkingCopies",
-            title: ( localize2(2975, "Log Working Copies")),
+            title: ( localize2(3225, "Log Working Copies")),
             category: Categories.Developer,
             f1: true
         });
@@ -396,7 +411,7 @@ class RemoveLargeStorageEntriesAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.removeLargeStorageDatabaseEntries",
-            title: ( localize2(2976, "Remove Large Storage Database Entries...")),
+            title: ( localize2(3226, "Remove Large Storage Database Entries...")),
             category: Categories.Developer,
             f1: true
         });
@@ -424,10 +439,10 @@ class RemoveLargeStorageEntriesAction extends Action2 {
                             label: key,
                             description: ByteSize.formatSize(value.length),
                             detail: ( localize(
-                                2977,
+                                3227,
                                 "Scope: {0}, Target: {1}",
-                                scope === StorageScope.APPLICATION ? ( localize(2978, "Global")) : scope === StorageScope.PROFILE ? ( localize(2979, "Profile")) : ( localize(2980, "Workspace")),
-                                target === StorageTarget.MACHINE ? ( localize(2981, "Machine")) : ( localize(2982, "User"))
+                                scope === StorageScope.APPLICATION ? ( localize(3228, "Global")) : scope === StorageScope.PROFILE ? ( localize(3229, "Profile")) : ( localize(3230, "Workspace")),
+                                target === StorageTarget.MACHINE ? ( localize(3231, "Machine")) : ( localize(3232, "User"))
                             ))
                         });
                     }
@@ -443,10 +458,10 @@ class RemoveLargeStorageEntriesAction extends Action2 {
             picker.ok = false;
             picker.customButton = true;
             picker.hideCheckAll = true;
-            picker.customLabel = ( localize(2983, "Remove"));
-            picker.placeholder = ( localize(2984, "Select large entries to remove from storage"));
+            picker.customLabel = ( localize(3233, "Remove"));
+            picker.placeholder = ( localize(3234, "Select large entries to remove from storage"));
             if (items.length === 0) {
-                picker.description = ( localize(2985, "There are no large storage entries to remove."));
+                picker.description = ( localize(3235, "There are no large storage entries to remove."));
             }
             picker.show();
             disposables.add(picker.onDidCustom(() => {
@@ -463,15 +478,15 @@ class RemoveLargeStorageEntriesAction extends Action2 {
         } = await dialogService.confirm({
             type: "warning",
             message: ( localize(
-                2986,
+                3236,
                 "Do you want to remove the selected storage entries from the database?"
             )),
             detail: ( localize(
-                2987,
+                3237,
                 "{0}\n\nThis action is irreversible and may result in data loss!",
                 ( selectedItems.map(item => item.label)).join("\n")
             )),
-            primaryButton: ( localize(2988, "&&Remove"))
+            primaryButton: ( localize(3238, "&&Remove"))
         });
         if (!confirmed) {
             return;
@@ -493,7 +508,7 @@ class StartTrackDisposables extends Action2 {
     constructor() {
         super({
             id: "workbench.action.startTrackDisposables",
-            title: ( localize2(2989, "Start Tracking Disposables")),
+            title: ( localize2(3239, "Start Tracking Disposables")),
             category: Categories.Developer,
             f1: true,
             precondition: ( ContextKeyExpr.and(( ( DisposablesSnapshotStateContext.isEqualTo("pending")).negate()), ( ( DisposablesSnapshotStateContext.isEqualTo("started")).negate())))
@@ -511,7 +526,7 @@ class SnapshotTrackedDisposables extends Action2 {
     constructor() {
         super({
             id: "workbench.action.snapshotTrackedDisposables",
-            title: ( localize2(2990, "Snapshot Tracked Disposables")),
+            title: ( localize2(3240, "Snapshot Tracked Disposables")),
             category: Categories.Developer,
             f1: true,
             precondition: ( DisposablesSnapshotStateContext.isEqualTo("started"))
@@ -529,7 +544,7 @@ class StopTrackDisposables extends Action2 {
     constructor() {
         super({
             id: "workbench.action.stopTrackDisposables",
-            title: ( localize2(2991, "Stop Tracking Disposables")),
+            title: ( localize2(3241, "Stop Tracking Disposables")),
             category: Categories.Developer,
             f1: true,
             precondition: ( DisposablesSnapshotStateContext.isEqualTo("pending"))
@@ -583,27 +598,52 @@ function managedSettingsSourceShortLabel(source) {
         return "None";
     }
 }
-function jsonBlock(value) {
-    return "```json\n" + JSON.stringify(value ?? {}, null, 2) + "\n```\n\n";
-}
-function managedValueCell(value) {
-    if (value === undefined) {
-        return "—";
+function policyValueSourceLabel(source) {
+    switch (source) {
+    case PolicyValueSource.Device:
+        return "Device";
+    case PolicyValueSource.NativeMdm:
+        return "Managed Settings: Native MDM";
+    case PolicyValueSource.ServerManagedSettings:
+        return "Managed Settings: Server";
+    case PolicyValueSource.FileManagedSettings:
+        return "Managed Settings: File";
+    case PolicyValueSource.MixedManagedSettings:
+        return "Managed Settings: Mixed";
+    case PolicyValueSource.Account:
+        return "Account";
+    case PolicyValueSource.AccountGate:
+        return "Account Policy Gate";
+    case undefined:
+        return "Unknown";
     }
-    return `\`${JSON.stringify(value).replace(/\|/g, "\\|")}\``;
 }
-const PROPERTY_VALUE_TABLE_HEADER = "| Property | Value |\n|----------|-------|\n";
+function managedSettingsPipeline(rawLabel, raw, normalized, projected, rawUnavailableMessage) {
+    let content = `**${markdownText(rawLabel)}**\n\n`;
+    content += raw === undefined ? `*${markdownText(rawUnavailableMessage ?? "Unavailable")}*\n\n` : markdownJsonBlock(raw);
+    content += "**Normalized bag**\n\n";
+    content += markdownJsonBlock(normalized);
+    content += "**VS Code policy projection**\n\n";
+    content += markdownJsonBlock(projected);
+    return markdownDetails("Source, normalized, and VS Code projection", content);
+}
+function formatDiagnosticValue(value) {
+    return JSON.stringify(value) ?? String(value);
+}
+const AGENT_RUNTIME_DIAGNOSTICS_TIMEOUT = 6000;
 class PolicyDiagnosticsAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.showPolicyDiagnostics",
-            title: ( localize2(2992, "Policy Diagnostics")),
+            title: ( localize2(3242, "Policy Diagnostics")),
             category: Categories.Developer,
             f1: true
         });
     }
     async run(accessor) {
         const editorService = accessor.get(IEditorService);
+        const commandService = accessor.get(ICommandService);
+        const notificationService = accessor.get(INotificationService);
         const configurationService = accessor.get(IConfigurationService);
         const productService = accessor.get(IProductService);
         const defaultAccountService = accessor.get(IDefaultAccountService);
@@ -611,6 +651,10 @@ class PolicyDiagnosticsAction extends Action2 {
         const authenticationAccessService = accessor.get(IAuthenticationAccessService);
         const policyService = accessor.get(IPolicyService);
         const accountPolicyGateService = accessor.get(IAccountPolicyGateService);
+        const agentHostService = accessor.get(IAgentHostService);
+        const agentHostEnablementService = accessor.get(IAgentHostEnablementService);
+        const workspaceContextService = accessor.get(IWorkspaceContextService);
+        const progressService = accessor.get(IProgressService);
         let nativeManagedSettingsService;
         try {
             nativeManagedSettingsService = accessor.get(INativeManagedSettingsService);
@@ -619,14 +663,59 @@ class PolicyDiagnosticsAction extends Action2 {
         try {
             fileManagedSettingsService = accessor.get(IFileManagedSettingsService);
         } catch {}
+        return progressService.withProgress({
+            location: ProgressLocation.Notification,
+            title: ( localize(3243, "Generating policy diagnostics...")),
+            type: "loading"
+        }, () => this.openPolicyDiagnostics({
+            editorService,
+            commandService,
+            notificationService,
+            configurationService,
+            productService,
+            defaultAccountService,
+            authenticationService,
+            authenticationAccessService,
+            policyService,
+            accountPolicyGateService,
+            agentHostService,
+            agentHostEnablementService,
+            workspaceContextService,
+            nativeManagedSettingsService,
+            fileManagedSettingsService
+        }));
+    }
+    async openPolicyDiagnostics(services) {
+        const {
+            editorService,
+            commandService,
+            notificationService,
+            configurationService,
+            productService,
+            defaultAccountService,
+            authenticationService,
+            authenticationAccessService,
+            policyService,
+            accountPolicyGateService,
+            agentHostService,
+            agentHostEnablementService,
+            workspaceContextService,
+            nativeManagedSettingsService,
+            fileManagedSettingsService
+        } = services;
         const configurationRegistry = ( Registry.as(Extensions.Configuration));
-        let content = "# VS Code Policy Diagnostics\n\n";
-        content += "*WARNING: This file may contain sensitive information.*\n\n";
+        const summary = {
+            accountPolicyGate: "Unavailable",
+            managedSettingsSources: "Unavailable",
+            effectiveManagedSettings: "Unavailable",
+            managedSettingsIssues: "Unavailable",
+            agentRuntime: "Unavailable",
+            chatHarnessEnforcement: "Unavailable",
+            policyControlledSettings: "Unavailable"
+        };
+        let content = "";
         content += "## System Information\n\n";
-        content += PROPERTY_VALUE_TABLE_HEADER;
-        content += `| Generated | ${( new Date()).toISOString()} |\n`;
-        content += `| Product | ${productService.nameLong} ${productService.version} |\n`;
-        content += `| Commit | ${productService.commit || "n/a"} |\n\n`;
+        content += markdownTable(["Property", "Value"], [["Generated", ( new Date()).toISOString()], ["Product", `${productService.nameLong} ${productService.version}`], ["Commit", productService.commit || "n/a"]]);
         content += "## Account Information\n\n";
         try {
             const account = await defaultAccountService.getDefaultAccount();
@@ -647,41 +736,44 @@ class PolicyDiagnosticsAction extends Action2 {
                     }
                 } catch (error) {}
                 content += "### Default Account Summary\n\n";
-                content += `**Account ID/Username**: ${username}\n\n`;
-                content += `**Account Label**: ${accountLabel}\n\n`;
-                content += "### Detailed Account Properties\n\n";
-                content += PROPERTY_VALUE_TABLE_HEADER;
+                content += markdownTable(
+                    ["Property", "Value"],
+                    [["Account ID/Username", username], ["Account Label", accountLabel]]
+                );
+                const accountPropertyRows = [];
                 for (const [key, value] of Object.entries(account)) {
                     if (value !== undefined && value !== null) {
-                        let displayValue;
-                        if (sensitiveKeys.includes(key)) {
-                            displayValue = "***";
-                        } else if (typeof value === "object") {
-                            displayValue = JSON.stringify(value);
-                        } else {
-                            displayValue = String(value);
-                        }
-                        content += `| ${key} | ${displayValue} |\n`;
+                        const displayValue = sensitiveKeys.includes(key) ? "***" : typeof value === "object" ? formatDiagnosticValue(value) : String(value);
+                        accountPropertyRows.push([key, displayValue]);
                     }
                 }
                 const policyData = defaultAccountService.policyData;
-                content += `| policyData | ${policyData ? JSON.stringify(policyData) : "No Policy Data"} |\n`;
-                content += "\n";
+                accountPropertyRows.push([
+                    "policyData",
+                    policyData ? formatDiagnosticValue(policyData) : "No Policy Data"
+                ]);
+                content += markdownDetails(
+                    "Detailed account properties",
+                    markdownTable(["Property", "Value"], accountPropertyRows)
+                );
             } else {
                 content += "*No default account configured*\n\n";
             }
         } catch (error) {
-            content += `*Error retrieving account information: ${error}*\n\n`;
+            content += `*Error retrieving account information: ${markdownText(getErrorMessage(error))}*\n\n`;
         }
         content += "## Account Policy Gate\n\n";
         try {
             const gateInfo = accountPolicyGateService.gateInfo;
             const approvedOrgsRaw = policyService.getPolicyValue(APPROVED_ACCOUNT_ORGANIZATIONS_POLICY_NAME);
-            content += PROPERTY_VALUE_TABLE_HEADER;
-            content += `| State | \`${gateInfo.state}\` |\n`;
-            content += `| Reason | ${gateInfo.reason ? `\`${gateInfo.reason}\`` : "*n/a*"} |\n`;
-            content += `| ${APPROVED_ACCOUNT_ORGANIZATIONS_POLICY_NAME} | ${approvedOrgsRaw !== undefined ? `\`${String(approvedOrgsRaw)}\`` : "*not set*"} |\n`;
-            content += "\n";
+            summary.accountPolicyGate = gateInfo.reason ? `${gateInfo.state} (${gateInfo.reason})` : gateInfo.state;
+            content += markdownTable(
+                ["Property", "Value"],
+                [["State", gateInfo.state], ["Reason", gateInfo.reason ?? "n/a"], [
+                    APPROVED_ACCOUNT_ORGANIZATIONS_POLICY_NAME,
+                    approvedOrgsRaw !== undefined ? String(approvedOrgsRaw) : "not set"
+                ]]
+            );
             content += "**Legend**\n\n";
             content += "- `inactive`: gate disabled (no approved orgs configured) — policies behave as account data dictates.\n";
             content += "- `satisfied`: gate active and approved — account policy values flow normally.\n";
@@ -691,74 +783,15 @@ class PolicyDiagnosticsAction extends Action2 {
             content += "  - `orgNotApproved`: signed in but account is not a member of any approved organization.\n";
             content += "  - `policyNotResolved`: signed in to an approved org but account-side policy data has not yet been fetched.\n\n";
         } catch (error) {
-            content += `*Error retrieving account policy gate info: ${error}*\n\n`;
+            content += `*Error retrieving account policy gate info: ${markdownText(getErrorMessage(error))}*\n\n`;
         }
         content += "## Managed Settings\n\n";
-        const activeManagedSettingSources = ( new Map());
         try {
             const policyData = defaultAccountService.policyData;
-            const serverManagedSettings = policyData?.managedSettings;
-            const nativeManagedSettings = nativeManagedSettingsService?.managedSettings;
-            const fileManagedSettings = fileManagedSettingsService?.managedSettings;
-            const pick = pickManagedSettings(nativeManagedSettings, serverManagedSettings, fileManagedSettings);
-            content += `**Active sources** (in precedence order): ${pick.activeSources.length > 0 ? ( pick.activeSources.map(managedSettingsSourceLabel)).join(", ") : managedSettingsSourceLabel("none")}\n\n`;
-            content += "*Precedence is resolved per key: native MDM wins over the server endpoint, which wins over the file on disk. A key left unset by a higher channel is still filled in by a lower one.*\n\n";
-            const parseErrors = [];
-            const channelContributes = channel => pick.activeSources.includes(channel);
-            content += "### Native MDM\n\n";
-            content += PROPERTY_VALUE_TABLE_HEADER;
-            content += `| Available | ${nativeManagedSettingsService ? "yes" : "no"} |\n`;
-            content += `| Contributes winning keys | ${channelContributes("nativeMdm") ? "yes" : "no"} |\n\n`;
-            if (nativeManagedSettingsService) {
-                content += jsonBlock(nativeManagedSettings);
-            }
-            content += "### GitHub Server API\n\n";
-            content += PROPERTY_VALUE_TABLE_HEADER;
-            content += "| Endpoint | `/copilot_internal/managed_settings` |\n";
-            const fetchStatus = defaultAccountService.managedSettingsFetchStatus;
-            content += `| Last fetch | ${fetchStatus === null ? "*never*" : `\`${fetchStatus}\``} |\n`;
-            const fetchedAt = defaultAccountService.managedSettingsFetchedAt;
-            content += `| Last successful fetch | ${fetchedAt ? ( new Date(fetchedAt)).toLocaleString() : "*n/a*"} |\n`;
-            content += `| Contributes winning keys | ${channelContributes("server") ? "yes" : "no"} |\n\n`;
-            const rawResponse = defaultAccountService.managedSettingsRawResponse;
-            if (isObject(rawResponse)) {
-                adaptManagedSettings(rawResponse, message => parseErrors.push({
-                    stage: "adapt",
-                    message
-                }));
-                content += "**Raw response** (last successful fetch)\n\n";
-                content += jsonBlock(rawResponse);
-            }
-            content += "**Normalized bag**\n\n";
-            content += jsonBlock(serverManagedSettings);
-            content += "### File (managed-settings.json)\n\n";
-            content += PROPERTY_VALUE_TABLE_HEADER;
-            content += `| Available | ${fileManagedSettingsService ? "yes" : "no"} |\n`;
-            content += `| Contributes winning keys | ${channelContributes("file") ? "yes" : "no"} |\n\n`;
-            if (fileManagedSettingsService) {
-                content += jsonBlock(fileManagedSettings);
-            }
-            content += "### Resolution (per key)\n\n";
-            if (pick.resolutions.size > 0) {
-                content += "| Key | Effective | Winning Source | Native MDM | Server | File |\n";
-                content += "|-----|-----------|----------------|------------|--------|------|\n";
-                const channelValue = (resolution, channel) => {
-                    const contribution = resolution.contributions.find(c => c.channel === channel);
-                    if (!contribution) {
-                        return "—";
-                    }
-                    const cell = managedValueCell(contribution.value);
-                    return channel === resolution.source ? cell : `~~${cell}~~`;
-                };
-                for (const key of [...( pick.resolutions.keys())].sort()) {
-                    const resolution = pick.resolutions.get(key);
-                    content += `| ${key} | ${managedValueCell(resolution.value)} | ${managedSettingsSourceShortLabel(resolution.source)} | ${channelValue(resolution, "nativeMdm")} | ${channelValue(resolution, "server")} | ${channelValue(resolution, "file")} |\n`;
-                }
-                content += "\n";
-                content += "*Struck-through values were supplied by a channel but overridden by a higher-precedence channel for that key.*\n\n";
-            } else {
-                content += "*No managed-settings keys are supplied by any channel.*\n\n";
-            }
+            const serverManagedSettings = policyData?.managedSettings ?? {};
+            const nativeManagedSettings = nativeManagedSettingsService?.managedSettings ?? {};
+            const fileManagedSettings = fileManagedSettingsService?.managedSettings ?? {};
+            const fileRawManagedSettings = fileManagedSettingsService?.rawManagedSettings;
             const declaredDefinitions = {};
             for (const property of [...( Object.values(configurationRegistry.getConfigurationProperties())), ...( Object.values(configurationRegistry.getExcludedConfigurationProperties()))]) {
                 const declared = property.policy?.managedSettings;
@@ -766,15 +799,32 @@ class PolicyDiagnosticsAction extends Action2 {
                     Object.assign(declaredDefinitions, declared);
                 }
             }
+            const pick = pickManagedSettings(nativeManagedSettings, serverManagedSettings, fileManagedSettings);
+            const parseErrors = [];
+            const projectChannel = (channel, values) => projectManagedSettings(values, declaredDefinitions, message => parseErrors.push({
+                stage: `${channel}: project`,
+                message
+            }));
+            const channelContributes = channel => pick.activeSources.includes(channel);
+            const nativeProjected = projectChannel("nativeMdm", nativeManagedSettings);
+            const serverProjected = projectChannel("server", serverManagedSettings);
+            const fileProjected = projectChannel("file", fileManagedSettings);
             const effective = projectManagedSettings(pick.values, declaredDefinitions, message => parseErrors.push({
-                stage: "project",
+                stage: "effective: project",
                 message
             }));
-            for (const key of ( Object.keys(effective))) {
-                const resolution = pick.resolutions.get(key);
-                if (resolution) {
-                    activeManagedSettingSources.set(key, resolution.source);
-                }
+            const rawResponse = defaultAccountService.managedSettingsRawResponse;
+            if (isObject(rawResponse)) {
+                adaptManagedSettings(rawResponse, message => parseErrors.push({
+                    stage: "adapt",
+                    message
+                }));
+            }
+            if (fileRawManagedSettings) {
+                normalizeManagedSettings(fileRawManagedSettings, message => parseErrors.push({
+                    stage: "file: normalize",
+                    message
+                }));
             }
             for (const key of [
                 COPILOT_ENABLED_PLUGINS_KEY,
@@ -787,29 +837,161 @@ class PolicyDiagnosticsAction extends Action2 {
                 }
                 const jsonErrors = [];
                 parse(value, jsonErrors);
-                for (const e of jsonErrors) {
+                for (const error of jsonErrors) {
                     parseErrors.push({
                         stage: "parse",
-                        message: `${key} @ offset ${e.offset}: ${getParseErrorMessage(e.error)}`
+                        message: `${key} @ offset ${error.offset}: ${getParseErrorMessage(error.error)}`
                     });
                 }
             }
-            content += "### Effective\n\n";
-            content += jsonBlock(effective);
-            content += `### Parse Errors (${parseErrors.length})\n\n`;
+            const activeSources = pick.activeSources.length > 0 ? ( pick.activeSources.map(managedSettingsSourceLabel)).join(", ") : managedSettingsSourceLabel("none");
+            const effectiveKeyCount = ( Object.keys(effective)).length;
+            summary.managedSettingsSources = activeSources;
+            summary.effectiveManagedSettings = `${effectiveKeyCount} ${effectiveKeyCount === 1 ? "key" : "keys"}`;
+            summary.managedSettingsIssues = `${parseErrors.length} ${parseErrors.length === 1 ? "issue" : "issues"}`;
+            content += markdownTable(["Property", "Value"], [
+                ["Active sources (precedence order)", activeSources],
+                ["Supplied keys", String(pick.resolutions.size)],
+                ["Effective VS Code policy keys", String(effectiveKeyCount)]
+            ]);
+            content += "*Precedence is resolved per key: native MDM wins over the server endpoint, which wins over the file on disk. A key left unset by a higher channel is still filled in by a lower one. For sandbox.enabled, any managed true wins regardless of channel precedence, matching the runtime sandbox floor.*\n\n";
+            content += "### Effective Resolution\n\n";
+            if (pick.resolutions.size > 0) {
+                const resolutions = [...pick.resolutions.entries()].sort(([first], [second]) => first.localeCompare(second));
+                content += markdownTable(["Key", "Effective Value", "Winning Source"], ( resolutions.map(([key, resolution]) => [
+                    key,
+                    formatDiagnosticValue(resolution.value),
+                    managedSettingsSourceShortLabel(resolution.source)
+                ])));
+                const contributionRows = resolutions.flatMap(([key, resolution]) => ( resolution.contributions.map(contribution => [
+                    key,
+                    managedSettingsSourceShortLabel(contribution.channel),
+                    formatDiagnosticValue(contribution.value),
+                    contribution.channel === resolution.source ? "Effective" : "Overridden"
+                ])));
+                content += markdownDetails(
+                    "Per-channel contributions",
+                    markdownTable(["Key", "Source", "Value", "Status"], contributionRows)
+                );
+            } else {
+                content += "*No managed-settings keys are supplied by any channel.*\n\n";
+            }
+            content += markdownDetails("Merged normalized bag", markdownJsonBlock(pick.values));
+            content += markdownDetails("Effective VS Code policy bag", markdownJsonBlock(effective));
+            content += `### Normalization and Parse Issues (${parseErrors.length})\n\n`;
             if (parseErrors.length > 0) {
-                content += "| Stage | Message |\n";
-                content += "|-------|---------|\n";
-                for (const {
-                    stage,
-                    message
-                } of parseErrors) {
-                    content += `| ${stage} | ${message.replace(/\|/g, "\\|")} |\n`;
+                content += markdownTable(["Stage", "Message"], ( parseErrors.map((
+                    {
+                        stage,
+                        message
+                    }
+                ) => [stage, message])));
+            } else {
+                content += "*None.*\n\n";
+            }
+            content += "### Delivery Channel Details\n\n";
+            content += "#### Native MDM\n\n";
+            content += markdownTable(["Property", "Value"], [
+                ["Available", nativeManagedSettingsService ? "yes" : "no"],
+                ["Contributes winning keys", channelContributes("nativeMdm") ? "yes" : "no"]
+            ]);
+            if (nativeManagedSettingsService) {
+                content += "*The native policy watcher exposes only declared scalar keys, so its source values are already definition-scoped and canonical.*\n\n";
+                content += managedSettingsPipeline(
+                    "Source values (definition-scoped)",
+                    nativeManagedSettings,
+                    nativeManagedSettings,
+                    nativeProjected
+                );
+            }
+            const fetchStatus = defaultAccountService.managedSettingsFetchStatus;
+            const fetchedAt = defaultAccountService.managedSettingsFetchedAt;
+            const clientIdentity = appendManagedSettingsClientIdentity("https://api.github.com/copilot_internal/managed_settings", productService);
+            const compatibilityError = defaultAccountService.managedSettingsCompatibilityError;
+            const freshness = defaultAccountService.managedSettingsFreshness;
+            const freshnessScope = freshness.state === "notRequired" ? undefined : freshness.scope;
+            const freshnessFailure = freshness.state === "blocked" ? freshness.failure === "httpError" ? `${freshness.failure} (${freshness.httpStatus})` : freshness.failure : "none";
+            content += "#### GitHub Server API\n\n";
+            content += markdownTable(
+                ["Property", "Value"],
+                [["Endpoint", "/copilot_internal/managed_settings"], [
+                    "Last fetch",
+                    fetchStatus === null ? "never" : `${fetchStatus}${fetchedAt ? ` at ${( new Date(fetchedAt)).toLocaleString()}` : ""}`
+                ], ["Freshness", freshness.state], [
+                    "Freshness source",
+                    freshness.state === "notRequired" ? "none" : freshness.source
+                ], [
+                    "Last freshness attempt",
+                    freshness.state !== "notRequired" && freshness.lastAttemptAt ? ( new Date(freshness.lastAttemptAt)).toLocaleString() : "never"
+                ], ["Freshness failure", freshnessFailure], [
+                    "Freshness scope",
+                    freshnessScope ? `${freshnessScope.authenticationProviderId} at ${freshnessScope.endpointOrigin}` : "none"
+                ], ["Client identity", ( new URL(clientIdentity)).search.replace(/^\?/, "")], [
+                    "Compatibility",
+                    compatibilityError ? `update required (${compatibilityError.clientVersion ?? "?"} → ${compatibilityError.minimumClientVersion ?? "?"})` : "compatible or not evaluated"
+                ], ["Contributes winning keys", channelContributes("server") ? "yes" : "no"]]
+            );
+            content += managedSettingsPipeline(
+                "Raw response (last successful fetch)",
+                isObject(rawResponse) ? rawResponse : undefined,
+                serverManagedSettings,
+                serverProjected,
+                "No successful managed-settings response has been captured."
+            );
+            content += "#### File (managed-settings.json)\n\n";
+            content += markdownTable(["Property", "Value"], [
+                ["Available", fileManagedSettingsService ? "yes" : "no"],
+                ["Contributes winning keys", channelContributes("file") ? "yes" : "no"]
+            ]);
+            if (fileManagedSettingsService) {
+                content += managedSettingsPipeline(
+                    "Raw parsed file",
+                    fileRawManagedSettings,
+                    fileManagedSettings,
+                    fileProjected
+                );
+            }
+            content += markdownDetails(
+                "VS Code managed-settings schema",
+                "*Only keys declared here can reach VS Code policy callbacks. Runtime-owned keys may still be enforced by the Copilot runtime even when absent from the projections above.*\n\n" + markdownJsonBlock(declaredDefinitions)
+            );
+            content += "### Agent Runtime Resolution\n\n";
+            content += "*Resolved independently by each provider through its own SDK/runtime. This may include runtime-owned keys that VS Code does not declare as configuration policies.*\n\n";
+            if (!agentHostEnablementService.enabled.get()) {
+                summary.agentRuntime = "Agent Host disabled";
+                content += "*Agent Host is disabled; runtime managed-settings diagnostics were not queried.*\n\n";
+            } else {
+                try {
+                    const runtimeDiagnostics = await raceTimeout(
+                        agentHostService.getManagedSettingsDiagnostics(),
+                        AGENT_RUNTIME_DIAGNOSTICS_TIMEOUT
+                    );
+                    if (!runtimeDiagnostics) {
+                        summary.agentRuntime = "Timed out";
+                        content += "*The Agent Host did not return provider diagnostics within 6 seconds. The report continued without a runtime snapshot; check the Agent Host log for a stalled provider.*\n\n";
+                    } else if (runtimeDiagnostics.length === 0) {
+                        summary.agentRuntime = "No provider diagnostics";
+                        content += "*No agent provider exposes managed-settings diagnostics.*\n\n";
+                    } else {
+                        const failedProviderCount = runtimeDiagnostics.filter(diagnostic => diagnostic.error).length;
+                        summary.agentRuntime = `${runtimeDiagnostics.length} ${runtimeDiagnostics.length === 1 ? "provider" : "providers"}, ${failedProviderCount} failed`;
+                        for (const diagnostic of runtimeDiagnostics) {
+                            content += `#### ${markdownText(diagnostic.provider)}\n\n`;
+                            if (diagnostic.error) {
+                                content += `*Probe failed: ${markdownText(diagnostic.error)}*\n\n`;
+                            } else {
+                                content += markdownDetails("Resolved settings snapshot", markdownJsonBlock(diagnostic.snapshot));
+                            }
+                        }
+                    }
+                } catch (error) {
+                    const message = getErrorMessage(error);
+                    summary.agentRuntime = `Unavailable (${message})`;
+                    content += `*Agent runtime diagnostics unavailable: ${markdownText(message)}*\n\n`;
                 }
-                content += "\n";
             }
         } catch (error) {
-            content += `*Error rendering managed settings diagnostics: ${error}*\n\n`;
+            content += `*Error rendering managed settings diagnostics: ${markdownText(getErrorMessage(error))}*\n\n`;
         }
         content += "## Policy-Controlled Settings\n\n";
         const policyConfigurations = configurationRegistry.getPolicyConfigurations();
@@ -844,146 +1026,152 @@ class PolicyDiagnosticsAction extends Action2 {
                     collectPolicySetting(policyName, settingKey);
                 }
             }
-            const policySourceMemo = ( new Map());
-            const getPolicySource = policyName => {
-                if (( policySourceMemo.has(policyName))) {
-                    return policySourceMemo.get(policyName);
-                }
-                try {
-                    const policyServiceConstructorName = policyService.constructor.name;
-                    if (policyServiceConstructorName === "MultiplexPolicyService") {
-                        const multiplexService = policyService;
-                        if (multiplexService.policyServices) {
-                            const componentServices = multiplexService.policyServices;
-                            for (const service of componentServices) {
-                                if (service.getPolicyValue && service.getPolicyValue(policyName) !== undefined) {
-                                    policySourceMemo.set(policyName, service.constructor.name);
-                                    return service.constructor.name;
-                                }
-                            }
-                        }
-                    }
-                    return "";
-                } catch {
-                    return "Unknown";
-                }
-            };
-            const gateInfo = accountPolicyGateService.gateInfo;
-            const gateRestricted = gateInfo.state === AccountPolicyGateState.Restricted && gateInfo.reason !== AccountPolicyGateUnsatisfiedReason.PolicyNotResolved;
-            const getRefinedPolicySource = item => {
-                const declaredKeys = item.property.policy?.managedSettings ? ( Object.keys(item.property.policy.managedSettings)) : [];
-                if (!gateRestricted) {
-                    const winningSources = ( new Set());
-                    for (const key of declaredKeys) {
-                        const source = activeManagedSettingSources.get(key);
-                        if (source) {
-                            winningSources.add(source);
-                        }
-                    }
-                    if (winningSources.size > 0) {
-                        const ordered = MANAGED_SETTINGS_CHANNELS.filter(channel => ( winningSources.has(channel)));
-                        return `Managed Settings: ${( ordered.map(managedSettingsSourceShortLabel)).join(", ")}`;
-                    }
-                }
-                return getPolicySource(item.name);
-            };
+            const getPolicySource = policyName => policyValueSourceLabel(policyService.getPolicyValueSource(policyName));
             content += "### Applied Policy\n\n";
             appliedPolicy.sort(
-                (a, b) => getRefinedPolicySource(a).localeCompare(getRefinedPolicySource(b)) || a.name.localeCompare(b.name)
+                (a, b) => getPolicySource(a.name).localeCompare(getPolicySource(b.name)) || a.name.localeCompare(b.name)
             );
+            notAppliedPolicy.sort((a, b) => a.name.localeCompare(b.name) || a.key.localeCompare(b.key));
+            summary.policyControlledSettings = `${appliedPolicy.length} applied, ${notAppliedPolicy.length} not applied`;
             if (appliedPolicy.length > 0) {
-                content += "| Setting Key | Policy Name | Policy Source | Managed Settings | Default Value | Current Value | Policy Value |\n";
-                content += "|-------------|-------------|---------------|------------------|---------------|---------------|-------------|\n";
+                content += markdownTable(["Setting Key", "Policy Name", "Policy Source"], ( appliedPolicy.map(setting => [setting.key, setting.name, getPolicySource(setting.name)])));
+                let policyDetails = "";
                 for (const setting of appliedPolicy) {
-                    const defaultValue = JSON.stringify(setting.property.default);
-                    const currentValue = JSON.stringify(setting.inspection.value);
-                    const policyValue = JSON.stringify(setting.inspection.policyValue);
-                    const policySource = getRefinedPolicySource(setting);
                     const managedSettingsKeys = setting.property.policy?.managedSettings ? ( Object.keys(setting.property.policy.managedSettings)).join(", ") : "";
-                    content += `| ${setting.key} | ${setting.name} | ${policySource} | ${managedSettingsKeys || "*n/a*"} | \`${defaultValue}\` | \`${currentValue}\` | \`${policyValue}\` |\n`;
+                    policyDetails += `**${markdownText(setting.key)}**\n\n`;
+                    policyDetails += markdownTable(["Property", "Value"], [
+                        ["Policy name", setting.name],
+                        ["Policy source", getPolicySource(setting.name)],
+                        ["Managed settings", managedSettingsKeys || "n/a"],
+                        ["Default value", formatDiagnosticValue(setting.property.default)],
+                        ["Current value", formatDiagnosticValue(setting.inspection.value)],
+                        ["Policy value", formatDiagnosticValue(setting.inspection.policyValue)]
+                    ]);
                 }
-                content += "\n";
+                content += markdownDetails("Applied policy values and configuration details", policyDetails);
             } else {
                 content += "*No settings are currently controlled by policies*\n\n";
             }
-            content += "###  Non-applied Policy\n\n";
+            content += "### Non-applied Policy\n\n";
             if (notAppliedPolicy.length > 0) {
-                content += "| Setting Key | Policy Name  \n";
-                content += "|-------------|-------------|\n";
-                for (const setting of notAppliedPolicy) {
-                    content += `| ${setting.key} | ${setting.name}|\n`;
-                }
-                content += "\n";
+                content += markdownTable(["Setting Key", "Policy Name"], ( notAppliedPolicy.map(setting => [setting.key, setting.name])));
             } else {
                 content += "*All policy-controllable settings are currently being enforced*\n\n";
             }
         } else {
+            summary.policyControlledSettings = "No policy-controlled settings found";
             content += "*No policy-controlled settings found*\n\n";
         }
+        content += "## Chat Harness Enforcement\n\n";
+        try {
+            const sandboxEnforced = agentHostEnablementService.managedSandboxEnforced.get();
+            const virtualWorkspace = isVirtualWorkspace(workspaceContextService.getWorkspace());
+            const agentHostEnabled = agentHostEnablementService.enabled.get();
+            if (!sandboxEnforced) {
+                summary.chatHarnessEnforcement = "Not enforced";
+            } else if (virtualWorkspace) {
+                summary.chatHarnessEnforcement = "Mandated, not applied (virtual workspace)";
+            } else if (!agentHostEnabled) {
+                summary.chatHarnessEnforcement = "Mandated, not applied (Agent Host disabled)";
+            } else {
+                summary.chatHarnessEnforcement = "Local harness hidden, new chats use the Agent Host Copilot SDK";
+            }
+            content += `**Effective decision:** ${summary.chatHarnessEnforcement}.\n\n`;
+        } catch (error) {
+            const message = getErrorMessage(error);
+            summary.chatHarnessEnforcement = `Unavailable (${message})`;
+            content += `*Error resolving chat harness enforcement: ${markdownText(message)}*\n\n`;
+        }
         content += "## Authentication Information\n\n";
         try {
             const providerIds = authenticationService.getProviderIds();
             if (providerIds.length > 0) {
                 content += "### Authentication Providers\n\n";
-                content += "| Provider ID | Sessions | Accounts |\n";
-                content += "|-------------|----------|----------|\n";
+                const providerRows = [];
+                let sessionDetails = "";
                 for (const providerId of providerIds) {
                     try {
                         const sessions = await authenticationService.getSessions(providerId);
                         const accounts = ( sessions.map(session => session.account));
                         const uniqueAccounts = Array.from(( new Set(( accounts.map(account => account.label)))));
-                        content += `| ${providerId} | ${sessions.length} | ${uniqueAccounts.join(", ") || "None"} |\n`;
-                    } catch (error) {
-                        content += `| ${providerId} | Error | ${error} |\n`;
-                    }
-                }
-                content += "\n";
-                content += "### Detailed Session Information\n\n";
-                for (const providerId of providerIds) {
-                    try {
-                        const sessions = await authenticationService.getSessions(providerId);
+                        providerRows.push([providerId, String(sessions.length), uniqueAccounts.join(", ") || "None"]);
                         if (sessions.length > 0) {
-                            content += `#### ${providerId}\n\n`;
-                            content += "| Account | Scopes | Extensions with Access |\n";
-                            content += "|---------|--------|------------------------|\n";
+                            sessionDetails += `**${markdownText(providerId)}**\n\n`;
+                            const sessionRows = [];
                             for (const session of sessions) {
                                 const accountName = session.account.label;
                                 const scopes = session.scopes.join(", ") || "Default";
                                 try {
                                     const allowedExtensions = authenticationAccessService.readAllowedExtensions(providerId, accountName);
                                     const extensionNames = ( allowedExtensions.filter(ext => ext.allowed !== false).map(ext => `${ext.name}${ext.trusted ? " (trusted)" : ""}`)).join(", ") || "None";
-                                    content += `| ${accountName} | ${scopes} | ${extensionNames} |\n`;
+                                    sessionRows.push([accountName, scopes, extensionNames]);
                                 } catch (error) {
-                                    content += `| ${accountName} | ${scopes} | Error: ${error} |\n`;
+                                    sessionRows.push([accountName, scopes, `Error: ${getErrorMessage(error)}`]);
                                 }
                             }
-                            content += "\n";
+                            sessionDetails += markdownTable(["Account", "Scopes", "Extensions with Access"], sessionRows);
                         }
                     } catch (error) {
-                        content += `#### ${providerId}\n*Error retrieving sessions: ${error}*\n\n`;
+                        const message = getErrorMessage(error);
+                        providerRows.push([providerId, "Error", message]);
+                        sessionDetails += `**${markdownText(providerId)}**\n\n*Error retrieving sessions: ${markdownText(message)}*\n\n`;
                     }
                 }
+                content += markdownTable(["Provider ID", "Sessions", "Accounts"], providerRows);
+                if (sessionDetails) {
+                    content += markdownDetails("Detailed session information", sessionDetails);
+                }
             } else {
                 content += "*No authentication providers found*\n\n";
             }
         } catch (error) {
-            content += `*Error retrieving authentication information: ${error}*\n\n`;
+            content += `*Error retrieving authentication information: ${markdownText(getErrorMessage(error))}*\n\n`;
         }
-        await editorService.openEditor({
-            resource: undefined,
-            contents: content,
+        const report = "# VS Code Policy Diagnostics\n\n" + "*WARNING: This file may contain sensitive information.*\n\n" + "## Summary\n\n" + markdownTable(["Diagnostic", "Result"], [
+            ["Account policy gate", summary.accountPolicyGate],
+            ["Managed-settings sources", summary.managedSettingsSources],
+            ["Effective managed settings", summary.effectiveManagedSettings],
+            ["Managed-settings issues", summary.managedSettingsIssues],
+            ["Agent Runtime", summary.agentRuntime],
+            ["Chat harness enforcement", summary.chatHarnessEnforcement],
+            ["Policy-controlled settings", summary.policyControlledSettings]
+        ]) + content;
+        const resource = ( URI.from({
+            scheme: Schemas.untitled,
+            path: ( localize(3244, "Policy Diagnostics")),
+            query: generateUuid()
+        }));
+        const editorPane = await editorService.openEditor({
+            resource,
+            contents: report,
             languageId: "markdown",
             options: {
                 pinned: true
             }
         });
+        if (!editorPane) {
+            notificationService.warn(( localize(
+                3245,
+                "Policy diagnostics opened as Markdown source because the rendered preview could not be initialized."
+            )));
+            return;
+        }
+        try {
+            await commandService.executeCommand("markdown.reopenAsPreview");
+        } catch (error) {
+            notificationService.warn(( localize(
+                3246,
+                "Policy diagnostics opened as Markdown source because the rendered preview could not be opened: {0}",
+                getErrorMessage(error)
+            )));
+        }
     }
 }
 class SyncAccountPolicyAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.syncAccountPolicy",
-            title: ( localize2(2993, "Sync Account Policy")),
+            title: ( localize2(3247, "Sync Account Policy")),
             category: Categories.Developer,
             f1: true
         });
@@ -995,12 +1183,20 @@ class SyncAccountPolicyAction extends Action2 {
         try {
             logService.info("[DefaultAccount] Manually syncing account policy");
             await defaultAccountService.refresh({
-                forceRefresh: true
+                forceRefresh: true,
+                retryManagedSettings: true
             });
-            await dialogService.info(( localize(2994, "Account policy has been synced.")));
+            if (isManagedSettingsFreshnessBlocking(defaultAccountService.managedSettingsFreshness)) {
+                logService.warn(
+                    "[DefaultAccount] Account policy sync completed without satisfying managed settings freshness"
+                );
+                await dialogService.error(( localize(3248, "Failed to sync account policy.")), ( localize(3249, "The required managed settings could not be refreshed.")));
+                return;
+            }
+            await dialogService.info(( localize(3250, "Account policy has been synced.")));
         } catch (error) {
             logService.error("[DefaultAccount] Failed to sync account policy", error);
-            await dialogService.error(( localize(2995, "Failed to sync account policy.")), error instanceof Error ? error.message : String(error));
+            await dialogService.error(( localize(3251, "Failed to sync account policy.")), error instanceof Error ? error.message : String(error));
         }
     }
 }
@@ -1020,7 +1216,7 @@ const configurationRegistry = ( Registry.as(Extensions.Configuration));
 configurationRegistry.registerConfiguration({
     id: "screencastMode",
     order: 9,
-    title: ( localize(2996, "Screencast Mode")),
+    title: ( localize(3252, "Screencast Mode")),
     type: "object",
     properties: {
         "screencastMode.verticalOffset": {
@@ -1029,7 +1225,7 @@ configurationRegistry.registerConfiguration({
             minimum: 0,
             maximum: 90,
             description: ( localize(
-                2997,
+                3253,
                 "Controls the vertical offset of the screencast mode overlay from the bottom as a percentage of the workbench height."
             ))
         },
@@ -1039,38 +1235,38 @@ configurationRegistry.registerConfiguration({
             minimum: 20,
             maximum: 100,
             description: ( localize(
-                2998,
+                3254,
                 "Controls the font size (in pixels) of the screencast mode keyboard."
             ))
         },
         "screencastMode.keyboardOptions": {
             type: "object",
-            description: ( localize(2999, "Options for customizing the keyboard overlay in screencast mode.")),
+            description: ( localize(3255, "Options for customizing the keyboard overlay in screencast mode.")),
             properties: {
                 "showKeys": {
                     type: "boolean",
                     default: true,
-                    description: ( localize(3000, "Show raw keys."))
+                    description: ( localize(3256, "Show raw keys."))
                 },
                 "showKeybindings": {
                     type: "boolean",
                     default: true,
-                    description: ( localize(3001, "Show keyboard shortcuts."))
+                    description: ( localize(3257, "Show keyboard shortcuts."))
                 },
                 "showCommands": {
                     type: "boolean",
                     default: true,
-                    description: ( localize(3002, "Show command names."))
+                    description: ( localize(3258, "Show command names."))
                 },
                 "showCommandGroups": {
                     type: "boolean",
                     default: false,
-                    description: ( localize(3003, "Show command group names, when commands are also shown."))
+                    description: ( localize(3259, "Show command group names, when commands are also shown."))
                 },
                 "showSingleEditorCursorMoves": {
                     type: "boolean",
                     default: true,
-                    description: ( localize(3004, "Show single editor cursor move commands."))
+                    description: ( localize(3260, "Show single editor cursor move commands."))
                 }
             },
             default: {
@@ -1088,7 +1284,7 @@ configurationRegistry.registerConfiguration({
             minimum: 500,
             maximum: 5000,
             description: ( localize(
-                3005,
+                3261,
                 "Controls how long (in milliseconds) the keyboard overlay is shown in screencast mode."
             ))
         },
@@ -1097,7 +1293,7 @@ configurationRegistry.registerConfiguration({
             format: "color-hex",
             default: "#FF0000",
             description: ( localize(
-                3006,
+                3262,
                 "Controls the color in hex (#RGB, #RGBA, #RRGGBB or #RRGGBBAA) of the mouse indicator in screencast mode."
             ))
         },
@@ -1107,7 +1303,7 @@ configurationRegistry.registerConfiguration({
             minimum: 20,
             maximum: 100,
             description: ( localize(
-                3007,
+                3263,
                 "Controls the size (in pixels) of the mouse indicator in screencast mode."
             ))
         }