@codingame/monaco-vscode-api 37.2.0 → 37.3.0

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagementEditor.js

@@ -0,0 +1,4132 @@
+
+import { registerCss } from '../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
+import { $ as $$1, append, clearNode, addDisposableListener, getWindow, EventType, DisposableResizeObserver, isHTMLElement, EventHelper, addStandardDisposableListener, scheduleAtNextAnimationFrame, isAncestorOfActiveElement } from '../../../../../base/browser/dom.js';
+import { Button } from '../../../../../base/browser/ui/button/button.js';
+import { Checkbox, TriStateCheckbox } from '../../../../../base/browser/ui/toggle/toggle.js';
+import { defaultCheckboxStyles, defaultButtonStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
+import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
+import { dirname as dirname$1 } from '../../../../../base/common/path.js';
+import { status } from '../../../../../base/browser/ui/aria/aria.js';
+import { RunOnceScheduler, timeout } from '../../../../../base/common/async.js';
+import { CancellationToken } from '../../../../../base/common/cancellation.js';
+import { VSBuffer } from '../../../../../base/common/buffer.js';
+import { onUnexpectedError, getErrorMessage } from '../../../../../base/common/errors.js';
+import { DisposableStore, MutableDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { Action } from '../../../../../base/common/actions.js';
+import { Event } from '../../../../../base/common/event.js';
+import { isMarkdownString, MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { ResourceMap, ResourceSet } from '../../../../../base/common/map.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { SplitView, Sizing } from '../../../../../base/browser/ui/splitview/splitview.js';
+import { Color } from '../../../../../base/common/color.js';
+import { localize } from '../../../../../nls.js';
+import { generateUuid } from '../../../../../base/common/uuid.js';
+import { StorageScope, StorageTarget } from '../../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
+import { IFileDialogService, IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
+import { EditorPane } from '../../../../browser/parts/editor/editorPane.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { WorkbenchList } from '../../../../../platform/list/browser/listService.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { KeyCode } from '../../../../../base/common/keyCodes.js';
+import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
+import { getComparisonKey, isEqual, basename, dirname } from '../../../../../base/common/resources.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { AICustomizationManagementEditorInput } from './aiCustomizationManagementEditorInput.js';
+import { aiCustomizationManagementSectionRegistry } from './aiCustomizationManagementSectionRegistry.js';
+import { AICustomizationListWidget } from './aiCustomizationListWidget.js';
+import { ITEMS_MODEL_SECTIONS } from './aiCustomizationItemsModel.js';
+import { IAICustomizationItemsModel } from './aiCustomizationItemsModel.service.js';
+import { McpListWidget } from './mcpListWidget.js';
+import { PluginListWidget } from './pluginListWidget.js';
+import { ToolsListWidget } from './toolsListWidget.js';
+import { AGENT_HOST_COPILOT_CLI_SESSION_TYPE } from '../agentSessions/agentHost/agentHostToolSetEnablementService.js';
+import { AI_CUSTOMIZATION_MANAGEMENT_EDITOR_ID, CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_EDITOR, CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_SECTION, CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_HARNESS, AI_CUSTOMIZATION_MANAGEMENT_SELECTED_SECTION_KEY, AI_CUSTOMIZATION_MANAGEMENT_SIDEBAR_WIDTH_KEY, SIDEBAR_DEFAULT_WIDTH, SIDEBAR_MAX_WIDTH, SIDEBAR_MIN_WIDTH, CONTENT_MIN_WIDTH } from './aiCustomizationManagement.js';
+import { toolsIcon, pluginIcon, hookIcon, promptIcon, instructionsIcon, skillIcon, agentIcon } from './aiCustomizationIcons.js';
+import { ChatModelsWidget } from '../chatManagement/chatModelsWidget.js';
+import { PromptsType, Target } from '../../common/promptSyntax/promptTypes.js';
+import { CustomizationMigrationType, isMcpServerCustomizationMigrationCandidate, getCustomizationMigrationTargetType, getMcpServerCustomizationMigrationCandidateKey } from '../../common/promptSyntax/service/customizationMigrationService.js';
+import { ICustomizationMigrationService } from '../../common/promptSyntax/service/customizationMigrationService.service.js';
+import { PromptsStorage } from '../../common/promptSyntax/service/promptsService.js';
+import { IPromptsService } from '../../common/promptSyntax/service/promptsService.service.js';
+import { AGENT_MD_FILENAME } from '../../common/promptSyntax/config/promptFileLocations.js';
+import { PromptsConfig } from '../../common/promptSyntax/config/config.js';
+import { getTarget, getAttributeDefinition } from '../../common/promptSyntax/languageProviders/promptFileAttributes.js';
+import { NEW_SKILL_COMMAND_ID, NEW_AGENT_COMMAND_ID, NEW_INSTRUCTIONS_COMMAND_ID, NEW_PROMPT_COMMAND_ID } from '../promptSyntax/newPromptFileActions.js';
+import { showConfigureHooksQuickPick } from '../promptSyntax/hookActions.js';
+import { CustomizationLocationPicker, resolveWorkspaceTargetDirectory, resolveUserTargetDirectory } from './customizationCreatorService.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
+import { AICustomizationManagementSection, AICustomizationSources } from '../../common/aiCustomizationWorkspaceService.js';
+import { IAICustomizationWorkspaceService } from '../../common/aiCustomizationWorkspaceService.service.js';
+import { hasReadableCustomizationContent } from '../../../../../platform/agentHost/common/agentHostCustomizationUri.js';
+import { CodeEditorWidget } from '../../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { DomScrollableElement } from '../../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { createTextBufferFactoryFromSnapshot } from '../../../../../editor/common/model/textModel.js';
+import { IModelService } from '../../../../../editor/common/services/model.service.js';
+import { ITextModelService } from '../../../../../editor/common/services/resolverService.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { getSimpleEditorOptions } from '../../../codeEditor/browser/simpleEditorOptions.js';
+import { IWorkingCopyService } from '../../../../services/workingCopy/common/workingCopyService.service.js';
+import { IHoverService } from '../../../../../platform/hover/browser/hover.service.js';
+import { FileSystemProviderCapabilities } from '../../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../../platform/files/common/files.service.js';
+import { IMarkdownRendererService } from '../../../../../platform/markdown/browser/markdownRenderer.service.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.service.js';
+import { getDefaultHoverDelegate } from '../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { ScrollbarVisibility } from '../../../../../base/common/scrollable.js';
+import { EmbeddedMcpServerDetail } from './embeddedMcpServerDetail.js';
+import { EmbeddedAgentPluginDetail } from './embeddedAgentPluginDetail.js';
+import { layoutVirtualizedSections, getVirtualizedSectionMinimumHeight, layoutVirtualizedSectionList } from './customizationCardList.js';
+import { IMcpService, IMcpWorkbenchService } from '../../../mcp/common/mcpTypes.service.js';
+import { IAgentHostCustomizationService } from '../agentSessions/agentHost/agentHostCustomizationService.service.js';
+import { EmbeddedExtensionToolsDetail } from './embeddedExtensionToolsDetail.js';
+import { ICustomizationHarnessService } from '../../common/customizationHarnessService.service.js';
+import { ChatConfiguration } from '../../common/constants.js';
+import { AICustomizationWelcomePage } from './aiCustomizationWelcomePage.js';
+import { migrateCustomizations } from './customizationMigration.js';
+import { CustomizationMigrationCategoryId, CUSTOMIZATION_MIGRATION_CATEGORIES, getCustomizationMigrationCategory } from './customizationMigrationCategories.js';
+import { CustomizationMigrationDashboard } from './customizationMigrationDashboard.js';
+import { IViewsService } from '../../../../services/views/common/viewsService.service.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { showNoFoldersDialog } from '../promptSyntax/pickers/askForPromptSourceFolder.js';
+import { isAgentHostTarget } from '../../common/chatSessionsService.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { Orientation } from '../../../../../base/browser/ui/sash/sash.js';
+
+var AICustomizationManagementEditor_1;
+registerCss(aiCustomizationManagement, 1);
+const $ = $$1;
+const homepageMigrationCategories = [
+    CustomizationMigrationCategoryId.PromptFiles,
+    CustomizationMigrationCategoryId.UserData,
+    CustomizationMigrationCategoryId.McpServers
+];
+function isCurrentPluginContributionNavigation(
+    requestGeneration,
+    currentGeneration,
+    requestedSection,
+    selectedSection,
+    isListView
+) {
+    return requestGeneration === currentGeneration && requestedSection === selectedSection && isListView;
+}
+class SectionItemDelegate {
+    getHeight() {
+        return 26;
+    }
+    getTemplateId() {
+        return "sectionItem";
+    }
+}
+class SectionItemRenderer {
+    constructor(hoverService) {
+        this.hoverService = hoverService;
+        this.templateId = "sectionItem";
+    }
+    renderTemplate(container) {
+        container.classList.add("section-list-item");
+        const icon = append(container, $(".section-icon"));
+        const label = append(container, $(".section-label"));
+        const count = append(container, $(".section-count"));
+        const templateDisposables = ( new DisposableStore());
+        return {
+            container,
+            icon,
+            label,
+            count,
+            templateDisposables
+        };
+    }
+    renderElement(element, index, templateData) {
+        templateData.templateDisposables.clear();
+        templateData.icon.className = "section-icon";
+        templateData.icon.classList.add(...ThemeIcon.asClassNameArray(element.icon));
+        templateData.label.textContent = element.label;
+        if (element.count > 0) {
+            templateData.count.textContent = String(element.count);
+            templateData.count.style.display = "";
+        } else {
+            templateData.count.textContent = "";
+            templateData.count.style.display = "none";
+        }
+        templateData.templateDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("element"),
+            templateData.container,
+            element.description
+        ));
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+}
+const MIGRATION_ITEM_HEIGHT = 56;
+class MigrationItemDelegate {
+    getHeight() {
+        return MIGRATION_ITEM_HEIGHT;
+    }
+    getTemplateId() {
+        return "migrationItem";
+    }
+}
+class MigrationItemRenderer {
+    constructor(
+        isSelected,
+        getPresentation,
+        onSelectionChange,
+        onOpen,
+        onMore,
+        onFirstFocusable,
+        hoverService
+    ) {
+        this.isSelected = isSelected;
+        this.getPresentation = getPresentation;
+        this.onSelectionChange = onSelectionChange;
+        this.onOpen = onOpen;
+        this.onMore = onMore;
+        this.onFirstFocusable = onFirstFocusable;
+        this.hoverService = hoverService;
+        this.templateId = "migrationItem";
+        this.templates = ( new Set());
+    }
+    renderTemplate(container) {
+        container.classList.add("ai-customization-list-item", "prompt-migration-item");
+        const templateDisposables = ( new DisposableStore());
+        const elementDisposables = templateDisposables.add(( new DisposableStore()));
+        const checkboxContainer = append(container, $(".item-sync-checkbox.prompt-migration-checkbox"));
+        const checkbox = templateDisposables.add(( new Checkbox("", false, defaultCheckboxStyles)));
+        checkboxContainer.replaceChildren(checkbox.domNode);
+        const itemLeft = append(container, $("span.item-left"));
+        const openButton = templateDisposables.add(( new Button(itemLeft, {})));
+        clearNode(openButton.element);
+        openButton.element.classList.add("item-text", "prompt-migration-open-button");
+        const openNameRow = append(openButton.element, $("span.item-name-row"));
+        const openNameLabel = append(openNameRow, $("span.item-name.prompt-migration-item-name"));
+        const openPathLabel = append(
+            openButton.element,
+            $("span.item-description.is-filename.prompt-migration-item-path")
+        );
+        const staticText = append(itemLeft, $("span.item-text.prompt-migration-static-text"));
+        const staticNameRow = append(staticText, $("span.item-name-row"));
+        const staticNameLabel = append(staticNameRow, $("span.item-name.prompt-migration-item-name"));
+        const staticPathLabel = append(
+            staticText,
+            $("span.item-description.is-filename.prompt-migration-item-path")
+        );
+        const itemRight = append(container, $("span.item-right"));
+        const moreButton = append(itemRight, $("button.icon-button.prompt-migration-more-action", {
+            type: "button"
+        }));
+        moreButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.ellipsis));
+        const template = {
+            container,
+            checkbox,
+            openButton,
+            openNameLabel,
+            openPathLabel,
+            staticText,
+            staticNameLabel,
+            staticPathLabel,
+            moreButton,
+            templateDisposables,
+            elementDisposables,
+            hasFileActions: false
+        };
+        this.templates.add(template);
+        return template;
+    }
+    renderElement(customization, index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.container.removeAttribute("aria-selected");
+        templateData.currentIndex = index;
+        templateData.currentElement = customization;
+        const presentation = this.getPresentation(customization);
+        const file = presentation.file;
+        templateData.hasFileActions = file !== undefined;
+        this.updateCheckboxState(templateData, customization);
+        templateData.checkbox.domNode.setAttribute("aria-label", presentation.selectionAriaLabel);
+        templateData.openNameLabel.textContent = presentation.name;
+        templateData.openPathLabel.textContent = presentation.pathLabel;
+        templateData.staticNameLabel.textContent = presentation.name;
+        templateData.staticPathLabel.textContent = presentation.pathLabel;
+        templateData.openButton.element.style.display = file ? "" : "none";
+        templateData.staticText.style.display = file ? "none" : "";
+        templateData.moreButton.style.display = file ? "" : "none";
+        if (index === 0) {
+            this.onFirstFocusable(templateData.checkbox.domNode);
+        }
+        templateData.elementDisposables.add(templateData.checkbox.onChange(() => {
+            this.onSelectionChange(customization, templateData.checkbox.checked);
+        }));
+        if (file) {
+            templateData.openButton.element.setAttribute("aria-label", ( localize(8511, "Open {0}, {1}", presentation.name, presentation.pathLabel)));
+            templateData.moreButton.setAttribute("aria-label", ( localize(8512, "More actions for {0}", presentation.name)));
+            templateData.elementDisposables.add(templateData.openButton.onDidClick(() => this.onOpen(file)));
+            templateData.elementDisposables.add(this.hoverService.setupManagedHover(
+                getDefaultHoverDelegate("element"),
+                templateData.moreButton,
+                ( localize(8513, "More Actions"))
+            ));
+            templateData.elementDisposables.add(addDisposableListener(templateData.moreButton, "click", event => {
+                event.stopPropagation();
+                this.onMore(file, templateData.moreButton);
+            }));
+        } else {
+            templateData.openButton.element.removeAttribute("aria-label");
+            templateData.moreButton.removeAttribute("aria-label");
+        }
+    }
+    refreshSelectionState() {
+        for (const template of this.templates) {
+            if (template.currentElement) {
+                this.updateCheckboxState(template, template.currentElement);
+            }
+        }
+    }
+    updateCheckboxState(templateData, customization) {
+        const selected = this.isSelected(customization);
+        templateData.checkbox.checked = selected;
+        templateData.checkbox.domNode.setAttribute("aria-checked", String(selected));
+    }
+    getIndex(target) {
+        for (const template of this.templates) {
+            if (template.container.contains(target)) {
+                return template.currentIndex;
+            }
+        }
+        return undefined;
+    }
+    getControls(index) {
+        for (const template of this.templates) {
+            if (template.currentIndex === index) {
+                return template.hasFileActions ? [
+                    template.checkbox.domNode,
+                    template.openButton.element,
+                    template.moreButton
+                ] : [template.checkbox.domNode];
+            }
+        }
+        return [];
+    }
+    disposeElement(_customization, _index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.currentIndex = undefined;
+        templateData.currentElement = undefined;
+        templateData.hasFileActions = false;
+    }
+    disposeTemplate(templateData) {
+        this.templates.delete(templateData);
+        templateData.templateDisposables.dispose();
+    }
+}
+let AICustomizationManagementEditor = class AICustomizationManagementEditor extends EditorPane {
+    static {
+        AICustomizationManagementEditor_1 = this;
+    }
+    static {
+        this.ID = AI_CUSTOMIZATION_MANAGEMENT_EDITOR_ID;
+    }
+    constructor(
+        group,
+        telemetryService,
+        themeService,
+        storageService,
+        instantiationService,
+        contextKeyService,
+        openerService,
+        commandService,
+        workspaceService,
+        promptsService,
+        customizationMigrationService,
+        textModelService,
+        configurationService,
+        workingCopyService,
+        hoverService,
+        markdownRendererService,
+        modelService,
+        quickInputService,
+        fileService,
+        notificationService,
+        fileDialogService,
+        dialogService,
+        contextMenuService,
+        harnessService,
+        viewsService,
+        labelService,
+        itemsModel,
+        mcpService,
+        mcpWorkbenchService,
+        agentHostCustomizationService
+    ) {
+        super(
+            AICustomizationManagementEditor_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.openerService = openerService;
+        this.commandService = commandService;
+        this.workspaceService = workspaceService;
+        this.promptsService = promptsService;
+        this.customizationMigrationService = customizationMigrationService;
+        this.textModelService = textModelService;
+        this.configurationService = configurationService;
+        this.workingCopyService = workingCopyService;
+        this.hoverService = hoverService;
+        this.markdownRendererService = markdownRendererService;
+        this.modelService = modelService;
+        this.quickInputService = quickInputService;
+        this.fileService = fileService;
+        this.notificationService = notificationService;
+        this.fileDialogService = fileDialogService;
+        this.dialogService = dialogService;
+        this.contextMenuService = contextMenuService;
+        this.harnessService = harnessService;
+        this.viewsService = viewsService;
+        this.labelService = labelService;
+        this.itemsModel = itemsModel;
+        this.mcpService = mcpService;
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.agentHostCustomizationService = agentHostCustomizationService;
+        this.contributedSectionContainers = ( new Map());
+        this.contributedSectionWidgets = ( new Map());
+        this.editorActionButtonInProgress = false;
+        this.editorDisplayMode = "preview";
+        this.editorModelChangeDisposables = this._register(( new DisposableStore()));
+        this.editorPreviewDisposables = this._register(( new DisposableStore()));
+        this.editorPreviewRenderScheduler = this._register(( new RunOnceScheduler(() => {
+            if (this.viewMode === "editor" && this.editorDisplayMode === "preview") {
+                this.renderCurrentEditorPreview();
+            }
+        }, 200)));
+        this.builtinEditingSessions = ( new Map());
+        this.currentEditingReadOnly = false;
+        this.editorReturnViewMode = "list";
+        this.viewMode = "list";
+        this.migrationSectionLists = [];
+        this.migrationSectionScrollPositions = ( new Map());
+        this.migrationWorkspaceSkipped = false;
+        this.selectedCustomizationMigrationItems = ( new ResourceMap());
+        this.selectedMcpServerMigrationItems = ( new Set());
+        this.knownMcpServerMigrationItems = ( new Set());
+        this.migrationSelectionContextKey = "";
+        this.selectedCustomizationMigrationTargets = ( new Map());
+        this.explicitlySelectedCustomizationMigrationTargets = ( new Set());
+        this.migrationPageDisposables = this._register(( new DisposableStore()));
+        this.migrationBannerDisposables = this._register(( new DisposableStore()));
+        this.mcpDetailDisposables = this._register(( new DisposableStore()));
+        this.pluginDetailDisposables = this._register(( new DisposableStore()));
+        this.toolsDetailDisposables = this._register(( new DisposableStore()));
+        this.sections = [];
+        this.allSections = [];
+        this.contentNavigationGeneration = 0;
+        this.customizationsByMigrationCategory = ( new Map());
+        this.customizationMigrationTargetFoldersByType = ( new Map());
+        this.customizationMigrationRefreshSequence = 0;
+        this.customizationMigrationLoading = false;
+        this.customizationMigrationInProgress = false;
+        this.customizationMigrationWritesInProgress = false;
+        this.editorDisposables = this._register(( new DisposableStore()));
+        this.pendingMigrationLayout = this._register(( new MutableDisposable()));
+        this._editorContentChanged = false;
+        this.sidebarWidth = 0;
+        this.sidebarHeight = 0;
+        this.inEditorContextKey = CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_EDITOR.bindTo(contextKeyService);
+        this.sectionContextKey = CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_SECTION.bindTo(contextKeyService);
+        this.harnessContextKey = CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_HARNESS.bindTo(contextKeyService);
+        this.updateTargetLabelPresentation();
+        this._register(autorun(reader => {
+            this.workspaceService.activeProjectRoot.read(reader);
+            this.workspaceService.activeProjectLabel.read(reader);
+            this.updateTargetLabelPresentation();
+            if (this.viewMode === "editor") {
+                this.currentEditingProjectRoot = this.workspaceService.getActiveProjectRoot();
+            }
+        }));
+        this._register(toDisposable(() => {
+            this.currentModelRef?.dispose();
+            this.currentModelRef = undefined;
+        }));
+        this._register(toDisposable(() => this.disposeBuiltinEditingSessions()));
+        const sectionInfo = {
+            [AICustomizationManagementSection.Agents]: {
+                label: ( localize(8514, "Agents")),
+                icon: agentIcon,
+                description: ( localize(
+                    8515,
+                    "Define custom agents with specialized personas, tool access, and instructions for specific tasks."
+                ))
+            },
+            [AICustomizationManagementSection.Skills]: {
+                label: ( localize(8516, "Skills")),
+                icon: skillIcon,
+                description: ( localize(
+                    8517,
+                    "Create reusable skill files that provide domain-specific knowledge and workflows."
+                ))
+            },
+            [AICustomizationManagementSection.Instructions]: {
+                label: ( localize(8518, "Instructions")),
+                icon: instructionsIcon,
+                description: ( localize(
+                    8519,
+                    "Set always-on instructions that guide AI behavior across your workspace or user profile."
+                ))
+            },
+            [AICustomizationManagementSection.Prompts]: {
+                label: ( localize(8520, "Prompts")),
+                icon: promptIcon,
+                description: ( localize(8521, "Reusable prompt templates that can be invoked as slash commands."))
+            },
+            [AICustomizationManagementSection.Hooks]: {
+                label: ( localize(8522, "Hooks")),
+                icon: hookIcon,
+                description: ( localize(
+                    8523,
+                    "Configure automated actions triggered by events like saving files or running tasks."
+                ))
+            },
+            [AICustomizationManagementSection.McpServers]: {
+                label: ( localize(8524, "MCP Servers")),
+                icon: Codicon.server,
+                description: ( localize(
+                    8525,
+                    "Connect external tool servers that extend AI capabilities with custom tools and data sources."
+                ))
+            },
+            [AICustomizationManagementSection.Plugins]: {
+                label: ( localize(8526, "Plugins")),
+                icon: pluginIcon,
+                description: ( localize(
+                    8527,
+                    "Install and manage agent plugins that add additional tools, skills, and integrations."
+                ))
+            },
+            [AICustomizationManagementSection.Models]: {
+                label: ( localize(8528, "Models")),
+                icon: Codicon.vm,
+                description: ( localize(8529, "Configure and manage language models available for use."))
+            },
+            [AICustomizationManagementSection.Tools]: {
+                label: ( localize(8530, "Tools")),
+                icon: toolsIcon,
+                description: ( localize(
+                    8531,
+                    "Enable or disable groups of language model tools available to chat."
+                ))
+            }
+        };
+        const activeHarnessId = this.harnessService.activeHarness.get();
+        for (const id of this.workspaceService.managementSections) {
+            const contribution = aiCustomizationManagementSectionRegistry.get(id, activeHarnessId) ?? aiCustomizationManagementSectionRegistry.getDefault(id);
+            const info = contribution ?? sectionInfo[id];
+            if (info) {
+                this.allSections.push({
+                    id,
+                    label: info.label,
+                    icon: info.icon,
+                    description: info.description,
+                    count: 0
+                });
+            }
+        }
+        this.rebuildVisibleSections();
+        const savedSection = this.storageService.get(AI_CUSTOMIZATION_MANAGEMENT_SELECTED_SECTION_KEY, StorageScope.PROFILE);
+        if (savedSection && ( this.sections.some(s => s.id === savedSection))) {
+            this.selectedSection = savedSection;
+        } else {
+            this.selectedSection = undefined;
+        }
+    }
+    createEditor(parent) {
+        this.pendingMigrationLayout.clear();
+        this.editorDisposables.clear();
+        this.contributedSectionContainers.clear();
+        this.contributedSectionWidgets.clear();
+        this.container = append(parent, $(".ai-customization-management-editor"));
+        this.createSplitView();
+        this.updateStyles();
+    }
+    createSplitView() {
+        this.splitViewContainer = append(this.container, $(".management-split-view"));
+        this.sidebarContainer = $(".management-sidebar");
+        this.contentContainer = $(".management-content");
+        this.createSidebar();
+        this.createContent();
+        this.splitView = this.editorDisposables.add(( new SplitView(this.splitViewContainer, {
+            orientation: Orientation.HORIZONTAL,
+            proportionalLayout: true
+        })));
+        const savedWidth = this.storageService.getNumber(
+            AI_CUSTOMIZATION_MANAGEMENT_SIDEBAR_WIDTH_KEY,
+            StorageScope.PROFILE,
+            SIDEBAR_DEFAULT_WIDTH
+        );
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: this.sidebarContainer,
+            minimumSize: SIDEBAR_MIN_WIDTH,
+            maximumSize: SIDEBAR_MAX_WIDTH,
+            layout: (width, _, height) => {
+                this.sidebarContainer.style.width = `${width}px`;
+                if (height !== undefined) {
+                    this.layoutSidebar(width, height);
+                }
+            }
+        }, savedWidth, undefined, true);
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: this.contentContainer,
+            minimumSize: CONTENT_MIN_WIDTH,
+            maximumSize: Number.POSITIVE_INFINITY,
+            layout: (width, _, height) => {
+                this.contentContainer.style.width = `${width}px`;
+                if (height !== undefined) {
+                    if (this.promptsContentContainer?.style.display !== "none") {
+                        this.listWidget.layout(height - 16, width - 24);
+                    }
+                    if (this.mcpContentContainer?.style.display !== "none") {
+                        this.mcpListWidget?.layout(height - 16, width - 24);
+                    }
+                    if (this.pluginContentContainer?.style.display !== "none") {
+                        this.pluginListWidget?.layout(height - 16, width - 24);
+                    }
+                    if (this.toolsContentContainer?.style.display !== "none") {
+                        this.toolsListWidget?.layout(height - 16, width - 24);
+                    }
+                    const modelsFooterHeight = this.modelsFooterElement?.offsetHeight || 80;
+                    this.modelsWidget?.layout(height - 16 - modelsFooterHeight, width);
+                    if (this.viewMode === "editor" && this.embeddedEditor && this.embeddedEditorContainer) {
+                        const {
+                            clientWidth,
+                            clientHeight
+                        } = this.embeddedEditorContainer;
+                        if (clientWidth > 0 && clientHeight > 0) {
+                            this.embeddedEditor.layout({
+                                width: clientWidth,
+                                height: clientHeight
+                            });
+                        } else if (this.dimension) {
+                            getWindow(this.embeddedEditorContainer).requestAnimationFrame(() => {
+                                if (this.embeddedEditor && this.embeddedEditorContainer) {
+                                    const {
+                                        clientWidth: w,
+                                        clientHeight: h
+                                    } = this.embeddedEditorContainer;
+                                    if (w > 0 && h > 0) {
+                                        this.embeddedEditor.layout({
+                                            width: w,
+                                            height: h
+                                        });
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        }, Sizing.Distribute, undefined, true);
+        this.editorDisposables.add(this.splitView.onDidSashChange(() => {
+            const width = this.splitView.getViewSize(0);
+            this.storageService.store(
+                AI_CUSTOMIZATION_MANAGEMENT_SIDEBAR_WIDTH_KEY,
+                width,
+                StorageScope.PROFILE,
+                StorageTarget.USER
+            );
+        }));
+        this.editorDisposables.add(this.splitView.onDidSashReset(() => {
+            const totalWidth = this.splitView.getViewSize(0) + this.splitView.getViewSize(1);
+            this.splitView.resizeView(0, SIDEBAR_DEFAULT_WIDTH);
+            this.splitView.resizeView(1, totalWidth - SIDEBAR_DEFAULT_WIDTH);
+        }));
+    }
+    getActiveHarnessLabel() {
+        const label = this.harnessService.getActiveDescriptor().label;
+        return label || (this.workspaceService.isSessionsWindow ? "" : ( localize(8532, "Local")));
+    }
+    updateTargetLabelPresentation() {
+        const harnessLabel = this.getActiveHarnessLabel();
+        const workspaceLabel = this.workspaceService.activeProjectLabel.get();
+        this.welcomePage?.setHarnessLabel(harnessLabel);
+        if (this.input instanceof AICustomizationManagementEditorInput) {
+            this.input.setTargetLabels(harnessLabel, workspaceLabel);
+        }
+    }
+    rebuildVisibleSections() {
+        const activeId = this.harnessService.activeHarness.get();
+        const descriptor = this.harnessService.findHarnessById(activeId);
+        const hidden = ( new Set(descriptor?.hiddenSections ?? []));
+        this.sections.length = 0;
+        for (const s of this.allSections) {
+            const contribution = aiCustomizationManagementSectionRegistry.get(s.id, activeId);
+            const contributed = ( aiCustomizationManagementSectionRegistry.has(s.id));
+            if (!( hidden.has(s.id)) && (!contributed || !!contribution)) {
+                this.sections.push(contribution ? {
+                    ...s,
+                    label: contribution.label,
+                    icon: contribution.icon,
+                    description: contribution.description
+                } : s);
+            }
+        }
+        if (this.sectionsList) {
+            this.sectionsList.splice(0, this.sectionsList.length, this.sections);
+            this.layoutSidebar(this.sidebarWidth, this.sidebarHeight);
+        }
+        this.welcomePage?.rebuildCards(( new Set(this.sections.map(s => s.id))));
+        if (this.selectedSection !== undefined && !( this.sections.some(s => s.id === this.selectedSection)) && this.sections.length > 0) {
+            this.showWelcomePage();
+        } else {
+            this.ensureSectionsListReflectsActiveSection();
+        }
+    }
+    createSidebar() {
+        const sidebarContent = append(this.sidebarContainer, $(".sidebar-content"));
+        this.createSidebarHeader(sidebarContent);
+        const sectionsListContainer = this.sectionsListContainer = append(sidebarContent, $(".sidebar-sections-list"));
+        this.sectionsList = this.editorDisposables.add(this.instantiationService.createInstance(
+            WorkbenchList,
+            "AICustomizationManagementSections",
+            sectionsListContainer,
+            ( new SectionItemDelegate()),
+            [( new SectionItemRenderer(this.hoverService))],
+            {
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getAriaLabel: item => item.count > 0 ? ( localize(8533, "{0}, {1} items", item.label, item.count)) : item.label,
+                    getWidgetAriaLabel: () => ( localize(8534, "Agent Customization Sections"))
+                },
+                openOnSingleClick: true,
+                identityProvider: {
+                    getId: item => item.id
+                }
+            }
+        ));
+        this.sectionsList.splice(0, this.sectionsList.length, this.sections);
+        this.ensureSectionsListReflectsActiveSection();
+        this.editorDisposables.add(this.sectionsList.onDidChangeSelection(e => {
+            if (e.elements.length === 0) {
+                if (this.selectedSection !== undefined) {
+                    this.showWelcomePage();
+                }
+                return;
+            }
+            this.selectSection(e.elements[0].id);
+        }));
+        this.editorDisposables.add(autorun(reader => {
+            this.harnessService.availableHarnesses.read(reader);
+            const activeId = this.harnessService.activeHarness.read(reader);
+            this.harnessContextKey.set(activeId);
+            this.updateHomeButtonHarnessPresentation();
+            this.rebuildVisibleSections();
+            if (this._previousActiveHarnessId !== undefined && this._previousActiveHarnessId !== activeId) {
+                for (const [section, widget] of this.contributedSectionWidgets) {
+                    this.editorDisposables.delete(widget);
+                    this.contributedSectionContainers.get(section)?.replaceChildren();
+                }
+                this.contributedSectionWidgets.clear();
+                for (const section of this.sections) {
+                    this.updateSectionCount(section.id, 0);
+                }
+            }
+            this._previousActiveHarnessId = activeId;
+        }));
+        this.editorDisposables.add(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.ChatCustomizationsStructuredPreviewEnabled)) {
+                this.onStructuredPreviewSettingChanged();
+            }
+            if (( CUSTOMIZATION_MIGRATION_CATEGORIES.some(
+                category => e.affectsConfiguration(category.enablementSetting) || category.configurationSettingIds?.some(settingId => e.affectsConfiguration(settingId))
+            ))) {
+                void this.refreshCustomizationMigrationInfo();
+            }
+        }));
+        this.createSidebarMigrationShortcut(sidebarContent);
+    }
+    layoutSidebar(width, height) {
+        this.sidebarWidth = width;
+        this.sidebarHeight = height;
+        if (!this.sectionsListContainer) {
+            return;
+        }
+        const headerHeight = this.sidebarHeaderContainer?.offsetHeight ?? 0;
+        const migrationHeight = this.migrationShortcutContainer?.style.display !== "none" ? (this.migrationShortcutContainer?.offsetHeight ?? 0) : 0;
+        const availableListHeight = Math.max(0, height - 8 - headerHeight - migrationHeight);
+        const listHeight = Math.min(availableListHeight, this.sections.length * 26);
+        this.sectionsListContainer.style.height = `${listHeight}px`;
+        this.sectionsList.layout(listHeight, width);
+    }
+    createSidebarHeader(sidebarContent) {
+        const headerRow = this.sidebarHeaderContainer = append(sidebarContent, $(".sidebar-header-row"));
+        const homeButton = this.homeButton = append(headerRow, $("button.sidebar-home-button"));
+        homeButton.classList.add("sidebar-harness-home-button");
+        homeButton.setAttribute("aria-label", ( localize(8535, "Overview")));
+        this.editorDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), homeButton, ( localize(8536, "Back to overview")))
+        );
+        const homeIcon = this.homeButtonIcon = append(homeButton, $("span.sidebar-home-icon"));
+        homeIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.home));
+        homeIcon.setAttribute("aria-hidden", "true");
+        const homeLabel = this.homeButtonLabel = append(homeButton, $("span.sidebar-home-label"));
+        homeLabel.textContent = ( localize(8537, "Overview"));
+        this.editorDisposables.add(addDisposableListener(homeButton, "click", () => {
+            this.showWelcomePage();
+        }));
+        this.updateHomeButtonHarnessPresentation();
+        this.updateHomeButtonStyle();
+    }
+    updateHomeButtonStyle() {
+        if (!this.homeButtonLabel || !this.homeButton) {
+            return;
+        }
+        this.homeButtonLabel.style.display = "";
+        this.homeButton.style.flex = "1";
+    }
+    updateHomeButtonHarnessPresentation() {
+        this.updateTargetLabelPresentation();
+        if (!this.homeButton || !this.homeButtonIcon || !this.homeButtonLabel) {
+            return;
+        }
+        this.homeButtonIcon.className = "sidebar-home-icon";
+        this.homeButtonIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.home));
+        this.homeButtonLabel.textContent = ( localize(8537, "Overview"));
+        this.homeButton.setAttribute("aria-label", ( localize(8535, "Overview")));
+        this.homeButton.title = ( localize(8536, "Back to overview"));
+    }
+    createSidebarMigrationShortcut(sidebarContent) {
+        const container = this.migrationShortcutContainer = append(sidebarContent, $(".sidebar-migration-shortcut"));
+        container.style.display = "none";
+        append(container, $("div.sidebar-migration-separator"));
+        const button = this.migrationShortcutButton = append(container, $("button.sidebar-migration-button"));
+        button.type = "button";
+        button.setAttribute("aria-label", ( localize(8538, "Migrations")));
+        this.editorDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), button, ( localize(8539, "Review customizations that need migration")))
+        );
+        const icon = append(button, $("span.sidebar-migration-icon"));
+        icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.warning));
+        icon.setAttribute("aria-hidden", "true");
+        append(button, $("span.sidebar-migration-label")).textContent = ( localize(8540, "Migrations"));
+        this.migrationShortcutCount = append(button, $("span.sidebar-migration-count"));
+        this.editorDisposables.add(
+            addDisposableListener(button, "click", () => this.showCustomizationMigrationDashboard())
+        );
+    }
+    createWelcomePage(parent) {
+        this.welcomePage = this.editorDisposables.add(( new AICustomizationWelcomePage(parent, this.workspaceService.welcomePageFeatures, {
+            selectSection: section => this.selectSection(section),
+            selectSectionWithMarketplace: section => this.selectSection(section, {
+                showMarketplace: true
+            }),
+            closeEditor: () => {
+                if (this.input) {
+                    this.group.closeEditor(this.input);
+                }
+            },
+            reviewMigrations: () => {
+                this.showCustomizationMigrationDashboard();
+            },
+            prefillChat: async (query, options) => {
+                try {
+                    if (this.workspaceService.isSessionsWindow) {
+                        const sessionsViewId = "workbench.view.sessions.chat";
+                        if (options?.newChat) {
+                            await this.commandService.executeCommand("workbench.action.sessions.newChat");
+                        }
+                        const view = await this.viewsService.openView(sessionsViewId, true);
+                        const chatView = view;
+                        if (options?.isPartialQuery && chatView?.prefillInput) {
+                            chatView.prefillInput(query);
+                        } else if (chatView?.sendQuery) {
+                            chatView.sendQuery(query);
+                        }
+                    } else {
+                        if (options?.newChat) {
+                            await this.commandService.executeCommand("workbench.action.chat.newChat");
+                        }
+                        await this.commandService.executeCommand("workbench.action.chat.open", {
+                            query,
+                            isPartialQuery: options?.isPartialQuery ?? false
+                        });
+                    }
+                } catch (err) {
+                    onUnexpectedError(err);
+                }
+            }
+        }, this.commandService, this.workspaceService, this.hoverService, this.getActiveHarnessLabel())));
+        this.welcomePage.rebuildCards(( new Set(this.sections.map(s => s.id))));
+        this.welcomePage.setMigrationCategories(this.getMigrationCategorySummaries());
+    }
+    createBackArrowButton(
+        onClick,
+        ariaLabel = ( localize(8541, "Back to overview")),
+        tooltip = ( localize(8542, "Back to overview"))
+    ) {
+        const button = $("button.section-back-arrow-button");
+        button.type = "button";
+        button.setAttribute("aria-label", ariaLabel);
+        this.editorDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), button, tooltip)
+        );
+        const icon = append(button, $("span.section-back-arrow-icon"));
+        icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.arrowLeft));
+        icon.setAttribute("aria-hidden", "true");
+        this.editorDisposables.add(addDisposableListener(button, "click", () => {
+            if (onClick) {
+                onClick();
+            } else {
+                this.showWelcomePage();
+            }
+        }));
+        return button;
+    }
+    createCustomizationMigrationContent(contentInner) {
+        this.migrationContentContainer = append(
+            contentInner,
+            $(".prompt-migration-content-container.ai-customization-list-widget")
+        );
+        const header = this.migrationHeader = append(this.migrationContentContainer, $(".section-title-header"));
+        const titleRow = append(header, $(".section-title-row"));
+        this.migrationBackButton = this.createBackArrowButton(() => this.showCustomizationMigrationDashboard(), ( localize(8543, "Back to customization migrations")), ( localize(8544, "Back to customization migrations")));
+        titleRow.appendChild(this.migrationBackButton);
+        this.migrationTitleElement = append(titleRow, $("h2.section-title"));
+        this.migrationDescriptionElement = append(header, $("p.section-title-description"));
+        this.migrationDescriptionTextElement = append(this.migrationDescriptionElement, $("span.section-title-description-text"));
+        const sectionLink = this.migrationLinkElement = append(
+            this.migrationDescriptionElement,
+            $("a.section-title-link.migration-learn-more-link")
+        );
+        this.editorDisposables.add(addDisposableListener(sectionLink, "click", e => {
+            e.preventDefault();
+            this.openerService.open(( URI.parse(sectionLink.href)));
+        }));
+        this.migrationBannerContainer = append(this.migrationContentContainer, $(".customization-migration-banner"));
+        this.migrationBannerContainer.style.display = "none";
+        const migrationScrollContainer = $(".prompt-migration-scroll-container");
+        this.migrationListContainer = append(
+            migrationScrollContainer,
+            $(".prompt-migration-list.list-container.distributed-section-layout")
+        );
+        const migrationListScrollable = this.editorDisposables.add(( new DomScrollableElement(migrationScrollContainer, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
+        })));
+        this.migrationListScrollable = migrationListScrollable;
+        this.editorDisposables.add(
+            addDisposableListener(migrationScrollContainer, EventType.SCROLL, () => {
+                migrationListScrollable.setScrollPosition({
+                    scrollTop: migrationScrollContainer.scrollTop
+                });
+            })
+        );
+        const migrationListScrollableNode = migrationListScrollable.getDomNode();
+        migrationListScrollableNode.classList.add("prompt-migration-list-scrollable");
+        this.migrationContentContainer.appendChild(migrationListScrollableNode);
+        const footer = this.migrationFooter = append(this.migrationContentContainer, $(".prompt-migration-footer"));
+        this.migrationSelectedCountElement = append(footer, $("span.prompt-migration-selected-count"));
+        this.migrationSelectedCountElement.setAttribute("aria-live", "polite");
+        const clearSettingsLabel = ( localize(8545, "Clear unused location settings after migration"));
+        this.migrationClearSettingsCheckbox = this.editorDisposables.add(( new Checkbox(clearSettingsLabel, true, defaultCheckboxStyles)));
+        const actionButtonContainer = append(footer, $(".list-add-button-container"));
+        this.migrationMigrateButton = this.editorDisposables.add(( new Button(actionButtonContainer, defaultButtonStyles)));
+        this.migrationMigrateButton.element.classList.add("list-add-button", "prompt-migration-button");
+        this.editorDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("element"),
+            this.migrationMigrateButton.element,
+            () => this.getActiveMigrationCategory()?.migrateButtonTooltip ?? ( localize(8546, "Migrate all customizations"))
+        ));
+        this.editorDisposables.add(this.migrationMigrateButton.onDidClick(() => {
+            const category = this.getActiveMigrationCategory();
+            if (!category) {
+                return;
+            }
+            const selectedCustomizations = this.getMigrationCandidates(category, this.activeMigrationStorage).filter(customization => this.isCustomizationSelectedForMigration(customization));
+            void this.migrateSelectedCustomizations(category, selectedCustomizations);
+        }));
+        const targetWindow = getWindow(this.migrationContentContainer);
+        const migrationResizeObserver = this.editorDisposables.add(new DisposableResizeObserver(
+            "AICustomizationManagementEditor.promptMigrationListScrollable",
+            () => this.scheduleMigrationSectionLayout(),
+            targetWindow
+        ));
+        this.editorDisposables.add(migrationResizeObserver.observe(migrationListScrollableNode));
+        this.migrationDashboardContainer = $(".customization-migration-dashboard-container");
+        this.migrationDashboardScrollable = this.editorDisposables.add(( new DomScrollableElement(this.migrationDashboardContainer, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
+        })));
+        const dashboardScrollableNode = this.migrationDashboardScrollable.getDomNode();
+        dashboardScrollableNode.classList.add("customization-migration-dashboard-scrollable");
+        this.migrationContentContainer.appendChild(dashboardScrollableNode);
+        const migrationDashboardResizeObserver = this.editorDisposables.add(new DisposableResizeObserver(
+            "AICustomizationManagementEditor.customizationMigrationDashboard",
+            () => this.migrationDashboardScrollable?.scanDomNode(),
+            targetWindow
+        ));
+        this.editorDisposables.add(migrationDashboardResizeObserver.observe(dashboardScrollableNode));
+        this.editorDisposables.add(migrationDashboardResizeObserver.observe(this.migrationDashboardContainer));
+        this.migrationDashboard = this.editorDisposables.add(
+            this.instantiationService.createInstance(CustomizationMigrationDashboard, this.migrationDashboardContainer, {
+                onDidChangeContent: () => this.migrationDashboardScrollable?.scanDomNode(),
+                configureLocations: storage => void this.configureCustomizationMigrationLocations(storage).finally(() => this.migrationDashboard?.focusDestination(storage)),
+                dismissResult: () => {
+                    this.migrationResult = undefined;
+                    this.renderCustomizationMigrationPage();
+                },
+                reviewCategory: (id, storage) => void this.showCustomizationMigrationPage(id, storage),
+                setWorkspaceSkipped: skipped => {
+                    this.migrationWorkspaceSkipped = skipped;
+                    this.storeMigrationActivityState(PromptsStorage.local, {
+                        ...this.getMigrationActivityState(PromptsStorage.local),
+                        skipped
+                    });
+                    this.refreshCustomizationMigrationUi();
+                },
+                dismissActivity: id => {
+                    for (const storage of [PromptsStorage.user, PromptsStorage.local]) {
+                        const state = this.getMigrationActivityState(storage);
+                        this.storeMigrationActivityState(storage, {
+                            ...state,
+                            activity: state.activity.filter(entry => entry.id !== id)
+                        });
+                    }
+                    this.renderCustomizationMigrationPage();
+                }
+            })
+        );
+        this.renderCustomizationMigrationPage();
+        if (this.viewMode === "migration") {
+            this.scheduleMigrationSectionLayout();
+        }
+    }
+    createContent() {
+        const contentInner = append(this.contentContainer, $(".content-inner"));
+        this.createWelcomePage(contentInner);
+        this.editorDisposables.add(Event.any(
+            this.promptsService.onDidChangeSlashCommands,
+            this.promptsService.onDidChangeCustomAgents,
+            this.promptsService.onDidChangeInstructions,
+            this.promptsService.onDidChangeAgentInstructions
+        )(() => this.refreshCustomizationMigrationInfoFromPromptChange()));
+        this.editorDisposables.add(
+            this.agentHostCustomizationService.onDidChangeCustomizations(() => this.refreshCustomizationMigrationInfoFromMcpChange())
+        );
+        this.editorDisposables.add(
+            Event.any(this.mcpWorkbenchService.onChange, this.mcpWorkbenchService.onReset)(() => this.refreshCustomizationMigrationInfoFromMcpChange())
+        );
+        this.editorDisposables.add(autorun(reader => {
+            for (const server of this.mcpService.servers.read(reader)) {
+                server.enablement.read(reader);
+                server.readDefinitions().read(reader);
+            }
+            this.refreshCustomizationMigrationInfoFromMcpChange();
+        }));
+        this.registerCustomizationMigrationSessionRefresh();
+        this.promptsContentContainer = append(contentInner, $(".prompts-content-container"));
+        this.listWidget = this.editorDisposables.add(this.instantiationService.createInstance(AICustomizationListWidget));
+        this.promptsContentContainer.appendChild(this.listWidget.element);
+        this.createCustomizationMigrationContent(contentInner);
+        this.editorDisposables.add(this.listWidget.onDidSelectItem(item => {
+            this.telemetryService.publicLog2("chatCustomizationEditor.itemSelected", {
+                section: this.selectedSection ?? "welcome",
+                promptType: item.promptType,
+                storage: item.source ?? "external"
+            });
+            const source = item.source;
+            const isWorkspaceFile = source === AICustomizationSources.local;
+            const isReadOnly = !source || source === AICustomizationSources.extension || source === AICustomizationSources.plugin || source === AICustomizationSources.builtin;
+            this.showEmbeddedEditor(
+                item.uri,
+                item.name,
+                item.promptType,
+                source ?? AICustomizationSources.builtin,
+                isWorkspaceFile,
+                isReadOnly
+            );
+        }));
+        this.editorDisposables.add(this.listWidget.onDidRequestCreate(promptType => {
+            this.createNewItemWithAI(promptType);
+        }));
+        this.editorDisposables.add(this.listWidget.onDidRequestCreateManual((
+            {
+                type,
+                target,
+                rootFileName
+            }
+        ) => {
+            this.createNewItemManual(type, target, rootFileName);
+        }));
+        const hasSections = ( new Set(this.workspaceService.managementSections));
+        if (( hasSections.has(AICustomizationManagementSection.Models))) {
+            this.modelsContentContainer = append(contentInner, $(".models-content-container"));
+            const modelsBackBar = append(this.modelsContentContainer, $(".section-back-bar"));
+            modelsBackBar.appendChild(this.createBackArrowButton());
+            this.modelsWidget = this.editorDisposables.add(this.instantiationService.createInstance(ChatModelsWidget));
+            this.modelsContentContainer.appendChild(this.modelsWidget.element);
+            this.modelsFooterElement = append(this.modelsContentContainer, $(".section-footer"));
+            const modelsDescription = append(this.modelsFooterElement, $("p.section-footer-description"));
+            modelsDescription.textContent = ( localize(
+                8547,
+                "Browse and manage language models from different providers. Select models for use in chat, code completion, and other AI features."
+            ));
+            const modelsLink = append(this.modelsFooterElement, $("a.section-footer-link"));
+            modelsLink.textContent = ( localize(8548, "Learn more about language models"));
+            modelsLink.href = "https://code.visualstudio.com/docs/agent-customization/language-models?referrer=in-product";
+            this.editorDisposables.add(addDisposableListener(modelsLink, "click", e => {
+                e.preventDefault();
+                this.openerService.open(( URI.parse(modelsLink.href)));
+            }));
+        }
+        if (( hasSections.has(AICustomizationManagementSection.McpServers))) {
+            this.mcpContentContainer = append(contentInner, $(".mcp-content-container"));
+            this.mcpListWidget = this.editorDisposables.add(this.instantiationService.createInstance(McpListWidget));
+            this.mcpContentContainer.appendChild(this.mcpListWidget.element);
+            this.mcpDetailContainer = append(contentInner, $(".mcp-detail-container"));
+            this.editorDisposables.add(this.mcpListWidget.onDidSelectServer(server => {
+                this.showEmbeddedMcpDetail(server);
+            }));
+            this.editorDisposables.add(this.mcpListWidget.onDidRequestShowPlugin(item => {
+                this.showPluginDetail(item);
+            }));
+        }
+        if (( hasSections.has(AICustomizationManagementSection.Plugins))) {
+            this.pluginContentContainer = append(contentInner, $(".plugin-content-container"));
+            this.pluginListWidget = this.editorDisposables.add(this.instantiationService.createInstance(PluginListWidget, undefined));
+            this.pluginContentContainer.appendChild(this.pluginListWidget.element);
+            this.pluginDetailContainer = append(contentInner, $(".plugin-detail-container"));
+            this.createEmbeddedPluginDetail();
+            this.editorDisposables.add(this.pluginListWidget.onDidSelectPlugin(item => {
+                this.pluginDetailReturnSection = undefined;
+                this.showEmbeddedPluginDetail(item);
+            }));
+        }
+        if (( hasSections.has(AICustomizationManagementSection.Tools))) {
+            this.toolsContentContainer = append(contentInner, $(".tools-content-container"));
+            this.toolsListWidget = this.editorDisposables.add(
+                this.instantiationService.createInstance(ToolsListWidget, AGENT_HOST_COPILOT_CLI_SESSION_TYPE)
+            );
+            this.toolsContentContainer.appendChild(this.toolsListWidget.element);
+            this.toolsDetailContainer = append(contentInner, $(".tools-detail-container"));
+            this.createEmbeddedToolDetail();
+            this.editorDisposables.add(this.toolsListWidget.onDidSelectExtension(extension => {
+                this.showEmbeddedToolDetail(extension);
+            }));
+        }
+        for (const section of this.workspaceService.managementSections) {
+            if (!( aiCustomizationManagementSectionRegistry.has(section))) {
+                continue;
+            }
+            const container = append(contentInner, $(".contributed-section-container"));
+            this.contributedSectionContainers.set(section, container);
+        }
+        this.editorContentContainer = append(contentInner, $(".editor-content-container"));
+        this.createEmbeddedEditor();
+        this.updateContentVisibility();
+        this.editorDisposables.add(this.listWidget.onDidChangeItemCount(count => {
+            if (this.isPromptsSection(this.selectedSection)) {
+                this.updateSectionCount(this.selectedSection, count);
+            }
+        }));
+        if (this.mcpListWidget) {
+            this.editorDisposables.add(this.mcpListWidget.onDidChangeItemCount(count => {
+                this.updateSectionCount(AICustomizationManagementSection.McpServers, count);
+            }));
+            this.mcpListWidget.fireItemCount();
+        }
+        if (this.pluginListWidget) {
+            this.editorDisposables.add(this.pluginListWidget.onDidChangeItemCount(count => {
+                this.updateSectionCount(AICustomizationManagementSection.Plugins, count);
+            }));
+            this.pluginListWidget.fireItemCount();
+        }
+        if (this.modelsWidget) {
+            this.editorDisposables.add(this.modelsWidget.onDidChangeItemCount(count => {
+                this.updateSectionCount(AICustomizationManagementSection.Models, count);
+            }));
+            this.modelsWidget.fireItemCount();
+        }
+        if (this.toolsListWidget) {
+            this.editorDisposables.add(this.toolsListWidget.onDidChangeItemCount(count => {
+                this.updateSectionCount(AICustomizationManagementSection.Tools, count);
+            }));
+            this.toolsListWidget.fireItemCount();
+        }
+        for (const section of ITEMS_MODEL_SECTIONS) {
+            const observable = this.itemsModel.getCount(section);
+            this.editorDisposables.add(autorun(reader => {
+                this.updateSectionCount(section, observable.read(reader));
+            }));
+        }
+        if (this.isPromptsSection(this.selectedSection)) {
+            void this.listWidget.setSection(this.selectedSection);
+        }
+        void this.refreshCustomizationMigrationInfo();
+    }
+    registerCustomizationMigrationSessionRefresh() {
+        this.editorDisposables.add(autorun(reader => {
+            this.harnessService.activeSessionResource.read(reader);
+            this.workspaceService.activeProjectRoot.read(reader);
+            this.activeMigrationStorage = undefined;
+            this.migrationWorkspaceSkipped = this.getMigrationActivityState(PromptsStorage.local).skipped;
+            this.migrationResult = undefined;
+            void this.refreshCustomizationMigrationInfo();
+        }));
+    }
+    refreshCustomizationMigrationInfoFromPromptChange() {
+        if (!this.customizationMigrationWritesInProgress) {
+            void this.refreshCustomizationMigrationInfo();
+        }
+    }
+    refreshCustomizationMigrationInfoFromMcpChange() {
+        if (!this.customizationMigrationWritesInProgress) {
+            void this.refreshCustomizationMigrationInfo();
+        }
+    }
+    async refreshCustomizationMigrationInfo() {
+        const activeHarnessId = this.harnessService.activeHarness.get();
+        const activeSessionResource = this.harnessService.activeSessionResource.get();
+        const projectRoot = this.workspaceService.activeProjectRoot.get();
+        const selectionContextKey = `${activeHarnessId}\n${( activeSessionResource.toString())}\n${projectRoot ? getComparisonKey(projectRoot) : ""}`;
+        if (selectionContextKey !== this.migrationSelectionContextKey) {
+            this.migrationSelectionContextKey = selectionContextKey;
+            this.knownMcpServerMigrationItems.clear();
+            this.selectedMcpServerMigrationItems.clear();
+            this.selectedCustomizationMigrationTargets.clear();
+            this.explicitlySelectedCustomizationMigrationTargets.clear();
+        }
+        const refreshSequence = ++this.customizationMigrationRefreshSequence;
+        this.customizationMigrationLoading = true;
+        this.customizationMigrationLoadError = undefined;
+        this.renderCustomizationMigrationPage();
+        if (!isAgentHostTarget(activeHarnessId)) {
+            this.customizationMigrationLoading = false;
+            this.setCustomizationsToMigrate(( new Map()), ( new Map()));
+            return;
+        }
+        try {
+            const enabledCategories = this.getEnabledMigrationCategories();
+            if (enabledCategories.length === 0) {
+                this.customizationMigrationLoading = false;
+                this.setCustomizationsToMigrate(( new Map()), ( new Map()));
+                return;
+            }
+            const migrationsByCategory = await Promise.all(enabledCategories.map(async category => {
+                let migration;
+                switch (category.migrationType) {
+                case CustomizationMigrationType.McpServers:
+                    migration = await this.customizationMigrationService.computeMigration(activeSessionResource, CustomizationMigrationType.McpServers);
+                    break;
+                default:
+                    migration = await this.customizationMigrationService.computeMigration(activeSessionResource, category.migrationType);
+                    break;
+                }
+                return [category.id, migration];
+            }));
+            if (refreshSequence !== this.customizationMigrationRefreshSequence || activeHarnessId !== this.harnessService.activeHarness.get() || !isEqual(activeSessionResource, this.harnessService.activeSessionResource.get())) {
+                return;
+            }
+            const candidatesByCategory = ( new Map(
+                migrationsByCategory.map(([categoryId, migration]) => [categoryId, migration.candidates])
+            ));
+            const provider = this.harnessService.findHarnessById(activeHarnessId)?.itemProvider;
+            const targetTypes = ( new Set([...( candidatesByCategory.values())].flat().filter(candidate => !isMcpServerCustomizationMigrationCandidate(candidate)).map(getCustomizationMigrationTargetType)));
+            const targetFolderEntries = await Promise.all([...targetTypes].map(async targetType => {
+                const folders = await provider?.provideSourceFolders?.(activeSessionResource, targetType, CancellationToken.None);
+                return [targetType, folders ?? []];
+            }));
+            if (refreshSequence !== this.customizationMigrationRefreshSequence || activeHarnessId !== this.harnessService.activeHarness.get() || !isEqual(activeSessionResource, this.harnessService.activeSessionResource.get())) {
+                return;
+            }
+            const targetFoldersByType = ( new Map(targetFolderEntries));
+            this.customizationMigrationLoading = false;
+            this.setCustomizationsToMigrate(candidatesByCategory, targetFoldersByType);
+        } catch (error) {
+            if (refreshSequence === this.customizationMigrationRefreshSequence) {
+                this.customizationMigrationLoading = false;
+                this.customizationMigrationLoadError = getErrorMessage(error);
+                this.renderCustomizationMigrationPage();
+            }
+            onUnexpectedError(error);
+        }
+    }
+    setCustomizationsToMigrate(candidatesByCategory, targetFoldersByType) {
+        const previousFileItems = this.createCustomizationMigrationItemMap(
+            this.getAllMigrationCandidates().filter(candidate => !isMcpServerCustomizationMigrationCandidate(candidate))
+        );
+        const selectedItems = ( new ResourceMap());
+        for (const customization of [...( candidatesByCategory.values())].flat()) {
+            if (isMcpServerCustomizationMigrationCandidate(customization)) {
+                const key = getMcpServerCustomizationMigrationCandidateKey(customization);
+                if (!( this.knownMcpServerMigrationItems.has(key))) {
+                    this.knownMcpServerMigrationItems.add(key);
+                    this.selectedMcpServerMigrationItems.add(key);
+                }
+            } else if (!this.hasCustomizationMigrationItem(previousFileItems, customization) || this.isCustomizationSelectedForMigration(customization)) {
+                this.addCustomizationMigrationItem(selectedItems, customization);
+            }
+        }
+        this.selectedCustomizationMigrationItems = selectedItems;
+        this.customizationsByMigrationCategory = candidatesByCategory;
+        this.customizationMigrationTargetFoldersByType = targetFoldersByType;
+        this.reconcileCustomizationMigrationTargets();
+        this.refreshCustomizationMigrationUi();
+        if (this.viewMode === "migration" && this.activeMigrationCategoryId !== undefined && !( candidatesByCategory.has(this.activeMigrationCategoryId))) {
+            this.showWelcomePage();
+        }
+    }
+    reconcileCustomizationMigrationTargets() {
+        const requiredTargets = ( new Map());
+        for (const customization of this.getAllMigrationCandidates()) {
+            if (isMcpServerCustomizationMigrationCandidate(customization)) {
+                continue;
+            }
+            const type = getCustomizationMigrationTargetType(customization);
+            const key = this.getCustomizationMigrationTargetKey(type, customization.storage);
+            requiredTargets.set(key, {
+                type,
+                storage: customization.storage
+            });
+        }
+        for (const key of ( this.selectedCustomizationMigrationTargets.keys())) {
+            if (!( requiredTargets.has(key))) {
+                this.selectedCustomizationMigrationTargets.delete(key);
+                this.explicitlySelectedCustomizationMigrationTargets.delete(key);
+            }
+        }
+        for (const [key, target] of requiredTargets) {
+            if (( this.selectedCustomizationMigrationTargets.has(key)) && ( this.explicitlySelectedCustomizationMigrationTargets.has(key))) {
+                continue;
+            }
+            const folder = this.getCustomizationMigrationFolders(target.type, target.storage)[0];
+            if (folder) {
+                this.selectedCustomizationMigrationTargets.set(key, folder);
+            } else {
+                this.selectedCustomizationMigrationTargets.delete(key);
+            }
+        }
+    }
+    getCustomizationMigrationTargetKey(type, storage) {
+        return `${type}:${storage}`;
+    }
+    createCustomizationMigrationItemMap(customizations) {
+        const result = ( new ResourceMap());
+        for (const customization of customizations) {
+            this.addCustomizationMigrationItem(result, customization);
+        }
+        return result;
+    }
+    hasCustomizationMigrationItem(items, customization) {
+        return items.get(customization.uri)?.has(customization.storage) === true;
+    }
+    addCustomizationMigrationItem(items, customization) {
+        const storages = items.get(customization.uri) ?? ( new Set());
+        storages.add(customization.storage);
+        items.set(customization.uri, storages);
+    }
+    getCustomizationMigrationCandidateKey(customization) {
+        return isMcpServerCustomizationMigrationCandidate(customization) ? `mcp:${getMcpServerCustomizationMigrationCandidateKey(customization)}` : `file:${customization.storage}:${( customization.uri.toString())}`;
+    }
+    isCustomizationSelectedForMigration(customization) {
+        if (isMcpServerCustomizationMigrationCandidate(customization)) {
+            return ( this.selectedMcpServerMigrationItems.has(getMcpServerCustomizationMigrationCandidateKey(customization)));
+        }
+        return this.hasCustomizationMigrationItem(this.selectedCustomizationMigrationItems, customization);
+    }
+    setCustomizationSelectedForMigration(customization, selected) {
+        if (isMcpServerCustomizationMigrationCandidate(customization)) {
+            const key = getMcpServerCustomizationMigrationCandidateKey(customization);
+            if (selected) {
+                this.selectedMcpServerMigrationItems.add(key);
+            } else {
+                this.selectedMcpServerMigrationItems.delete(key);
+            }
+            return;
+        }
+        if (selected) {
+            this.addCustomizationMigrationItem(this.selectedCustomizationMigrationItems, customization);
+            return;
+        }
+        const storages = this.selectedCustomizationMigrationItems.get(customization.uri);
+        storages?.delete(customization.storage);
+        if (storages?.size === 0) {
+            this.selectedCustomizationMigrationItems.delete(customization.uri);
+        }
+    }
+    getMigrationCandidates(category, storage) {
+        if (!this.isMigrationCategoryEnabled(category)) {
+            return [];
+        }
+        const candidates = this.customizationsByMigrationCategory.get(category.id) ?? [];
+        return storage === undefined ? candidates : candidates.filter(candidate => this.getMigrationCandidateStorage(candidate) === storage);
+    }
+    getMigrationCandidateStorage(candidate) {
+        return isMcpServerCustomizationMigrationCandidate(candidate) ? PromptsStorage.local : candidate.storage;
+    }
+    getAllMigrationCandidates() {
+        return [...( this.customizationsByMigrationCategory.values())].flat();
+    }
+    getActiveMigrationCategory() {
+        return this.activeMigrationCategoryId ? getCustomizationMigrationCategory(this.activeMigrationCategoryId) : undefined;
+    }
+    getDashboardFileMigrationCandidates() {
+        return [
+            CustomizationMigrationCategoryId.PromptFiles,
+            CustomizationMigrationCategoryId.UserData
+        ].flatMap(id => this.getMigrationCandidates(getCustomizationMigrationCategory(id))).filter(candidate => !isMcpServerCustomizationMigrationCandidate(candidate));
+    }
+    getMigrationCategorySummaries() {
+        const harnessLabel = this.getActiveHarnessLabel();
+        const summaries = [];
+        for (const id of homepageMigrationCategories) {
+            const category = getCustomizationMigrationCategory(id);
+            const candidates = this.getMigrationCandidates(category).filter(
+                candidate => !this.migrationWorkspaceSkipped || this.getMigrationCandidateStorage(candidate) !== PromptsStorage.local
+            );
+            if (candidates.length === 0) {
+                continue;
+            }
+            summaries.push({
+                id: category.id,
+                label: category.cardLabel,
+                description: category.getCardDescription(candidates, harnessLabel),
+                actionLabel: category.cardActionLabel,
+                actionAriaLabel: category.cardActionAriaLabel,
+                count: candidates.length
+            });
+        }
+        return summaries;
+    }
+    refreshCustomizationMigrationUi() {
+        this.welcomePage?.setMigrationCategories(this.getMigrationCategorySummaries());
+        this.updateSidebarMigrationShortcut();
+        this.renderCustomizationMigrationPage();
+    }
+    updateSidebarMigrationShortcut() {
+        if (!this.migrationShortcutContainer || !this.migrationShortcutButton || !this.migrationShortcutCount) {
+            return;
+        }
+        const candidates = homepageMigrationCategories.flatMap(id => this.getMigrationCandidates(getCustomizationMigrationCategory(id)));
+        const count = candidates.filter(
+            candidate => !this.migrationWorkspaceSkipped || this.getMigrationCandidateStorage(candidate) !== PromptsStorage.local
+        ).length;
+        const enabled = isAgentHostTarget(this.harnessService.activeHarness.get()) && ( homepageMigrationCategories.some(
+            id => this.isMigrationCategoryEnabled(getCustomizationMigrationCategory(id))
+        ));
+        this.migrationShortcutContainer.style.display = enabled ? "" : "none";
+        this.migrationShortcutCount.textContent = count > 0 ? String(count) : "";
+        this.migrationShortcutButton.setAttribute("aria-label", count === 1 ? ( localize(8549, "Migrations, 1 customization needs attention")) : ( localize(8550, "Migrations, {0} customizations need attention", count)));
+        this.layoutSidebar(this.sidebarWidth, this.sidebarHeight);
+    }
+    async migrateSelectedCustomizations(category, customizations) {
+        if (this.customizationMigrationInProgress || customizations.length === 0 || !this.isMigrationCategoryEnabled(category)) {
+            return;
+        }
+        this.customizationMigrationInProgress = true;
+        this.updateCustomizationMigrationActionState();
+        try {
+            const sessionResource = this.harnessService.activeSessionResource.get();
+            const activityContexts = this.getMigrationActivityContexts();
+            if (category.migrationType === CustomizationMigrationType.McpServers) {
+                await this.migrateSelectedMcpServers(
+                    category,
+                    customizations.filter(isMcpServerCustomizationMigrationCandidate),
+                    sessionResource
+                );
+                return;
+            }
+            const files = customizations.filter(candidate => !isMcpServerCustomizationMigrationCandidate(candidate));
+            const settingsToClear = this.getConfiguredLocationSettingsToClear(category, files);
+            const targetFolders = await this.resolveCustomizationMigrationTargetFolders(files, this.customizationMigrationTargetFoldersByType, sessionResource);
+            if (!targetFolders || !this.isCustomizationMigrationSessionActive(sessionResource)) {
+                return;
+            }
+            const confirmation = category.getConfirmation(
+                files,
+                this.getActiveHarnessLabel(),
+                this.getCustomizationMigrationDestinationLabel([...( targetFolders.values())].flatMap(folders => [...( folders.values())]))
+            );
+            const confirmed = await this.dialogService.confirm({
+                type: "question",
+                message: confirmation.message,
+                detail: confirmation.detail,
+                primaryButton: confirmation.primaryButton,
+                ...(confirmation.deleteOriginalsLabel ? {
+                    checkbox: {
+                        label: confirmation.deleteOriginalsLabel,
+                        checked: true
+                    }
+                } : {})
+            });
+            if (!confirmed.confirmed || !this.isCustomizationMigrationSessionActive(sessionResource)) {
+                return;
+            }
+            const deleteOriginalFiles = confirmed.checkboxChecked !== false;
+            this.migrationResult = undefined;
+            const result = await this.runCustomizationMigration(files, targetFolders, deleteOriginalFiles);
+            for (const context of activityContexts) {
+                const items = result.migratedSources.flatMap((source, index) => {
+                    const target = result.migratedCustomizations[index];
+                    const file = files.find(file => file.storage === source.storage && isEqual(file.uri, source.uri));
+                    return source.storage === context.storage && target && file ? [{
+                        label: file.name ?? basename(source.uri),
+                        sourceLabel: this.labelService.getUriLabel(source.uri),
+                        targetLabel: this.labelService.getUriLabel(target.uri),
+                        operation: file.type === PromptsType.prompt ? "converted" : deleteOriginalFiles ? "moved" : "copied"
+                    }] : [];
+                });
+                this.recordMigrationActivity(category, context, items);
+            }
+            if (result.failedCustomizationFileNames.length > 0) {
+                const displayedFileNames = result.failedCustomizationFileNames.slice(0, 3);
+                this.notificationService.error(category.getFailedMessage(
+                    displayedFileNames,
+                    result.failedCustomizationFileNames.length - displayedFileNames.length
+                ));
+            }
+            if (result.migratedCount === 0) {
+                if (result.failedCustomizationFileNames.length === 0) {
+                    this.notificationService.warn(category.noFilesMigratedMessage);
+                }
+                return;
+            }
+            if (result.failedCustomizationFileNames.length === 0 && result.migratedCount === files.length && settingsToClear.length > 0) {
+                try {
+                    await this.clearConfiguredLocationSettings(settingsToClear);
+                } catch (error) {
+                    this.notificationService.error(( localize(
+                        8551,
+                        "Customizations were migrated, but the custom location settings could not be cleared: {0}",
+                        getErrorMessage(error)
+                    )));
+                }
+            }
+            if (deleteOriginalFiles) {
+                await this.refreshCustomizationMigrationInfo();
+            }
+            const unsupportedKeys = result.unsupportedHeaderKeys.join(", ");
+            this.notificationService.info(
+                unsupportedKeys && category.getMigratedWithReviewMessage ? category.getMigratedWithReviewMessage(result.migratedCount, unsupportedKeys) : category.getMigratedMessage(result.migratedCount)
+            );
+            this.showCustomizationMigrationDashboard();
+        } finally {
+            this.customizationMigrationInProgress = false;
+            this.updateCustomizationMigrationActionState();
+        }
+    }
+    async migrateSelectedMcpServers(category, servers, sessionResource) {
+        if (servers.length === 0) {
+            return;
+        }
+        const context = this.getMigrationActivityContext(PromptsStorage.local);
+        const confirmation = category.getConfirmation(servers, this.getActiveHarnessLabel());
+        const confirmResult = await this.dialogService.confirm({
+            type: "question",
+            message: confirmation.message,
+            detail: confirmation.detail,
+            primaryButton: confirmation.primaryButton
+        });
+        if (!confirmResult.confirmed || !this.isCustomizationMigrationSessionActive(sessionResource)) {
+            return;
+        }
+        this.customizationMigrationWritesInProgress = true;
+        this.migrationResult = undefined;
+        let result;
+        try {
+            result = await this.customizationMigrationService.migrateMcpServers(sessionResource, servers);
+        } finally {
+            await timeout(0);
+            this.customizationMigrationWritesInProgress = false;
+        }
+        const migratedServers = servers.filter(server => !( result.failures.some(
+            failure => failure.id === server.id && isEqual(failure.sourceUri, server.sourceUri)
+        )));
+        if (result.migratedCount > 0) {
+            this.recordMigrationActivity(category, context, migratedServers.map(server => ({
+                label: server.name,
+                sourceLabel: this.labelService.getUriLabel(server.sourceUri),
+                targetLabel: this.labelService.getUriLabel(server.targetUri),
+                operation: "server"
+            })));
+        }
+        await this.refreshCustomizationMigrationInfo();
+        for (const failure of result.failures) {
+            if (failure.error) {
+                onUnexpectedError(failure.error);
+            }
+        }
+        if (result.failures.length > 0) {
+            const message = category.getMcpServerFailureMessage?.(result.failures) ?? category.getFailedMessage(
+                result.failures.slice(0, 3).map(failure => failure.name),
+                Math.max(0, result.failures.length - 3)
+            );
+            this.notificationService.error(message);
+        }
+        if (result.migratedCount > 0) {
+            this.notificationService.info(category.getMigratedMessage(result.migratedCount));
+            this.showCustomizationMigrationDashboard();
+        } else if (result.failures.length === 0) {
+            this.notificationService.warn(category.noFilesMigratedMessage);
+        }
+    }
+    getConfiguredLocationSettingsToClear(category, customizations) {
+        if (category.id !== CustomizationMigrationCategoryId.ConfiguredLocations || !this.migrationClearSettingsCheckbox?.checked) {
+            return [];
+        }
+        const selectedCustomizations = this.createCustomizationMigrationItemMap(customizations);
+        const remainingCustomizations = this.getMigrationCandidates(category).filter(
+            customization => !isMcpServerCustomizationMigrationCandidate(customization)
+        ).filter(
+            customization => !this.hasCustomizationMigrationItem(selectedCustomizations, customization)
+        );
+        return this.getModifiedConfiguredLocationSettingIds(category).filter(settingId => ( customizations.some(
+            customization => this.configuredLocationSettingAppliesTo(settingId, customization)
+        )) && !( remainingCustomizations.some(
+            customization => this.configuredLocationSettingAppliesTo(settingId, customization)
+        )));
+    }
+    getModifiedConfiguredLocationSettingIds(category) {
+        return category.getModifiedSettingIds?.(this.configurationService) ?? [];
+    }
+    configuredLocationSettingAppliesTo(settingId, customization) {
+        switch (settingId) {
+        case PromptsConfig.AGENTS_LOCATION_KEY:
+        case PromptsConfig.MODE_LOCATION_KEY:
+            return customization.type === PromptsType.agent;
+        case PromptsConfig.INSTRUCTIONS_LOCATION_KEY:
+            return customization.type === PromptsType.instructions;
+        case PromptsConfig.SKILLS_LOCATION_KEY:
+            return customization.type === PromptsType.skill;
+        default:
+            return false;
+        }
+    }
+    async clearConfiguredLocationSettings(settingIds) {
+        for (const settingId of settingIds) {
+            await this.configurationService.updateValue(settingId, undefined);
+        }
+    }
+    async runCustomizationMigration(customizations, targetFolders, deleteOriginalFiles) {
+        this.customizationMigrationWritesInProgress = true;
+        try {
+            return await migrateCustomizations(customizations, targetFolders, this.fileService, onUnexpectedError, {
+                deleteOriginalFiles
+            });
+        } finally {
+            await timeout(0);
+            this.customizationMigrationWritesInProgress = false;
+        }
+    }
+    renderCustomizationMigrationPage() {
+        if (!this.migrationListContainer) {
+            return;
+        }
+        const category = this.getActiveMigrationCategory();
+        this.migrationContentContainer?.classList.toggle("showing-dashboard", !category);
+        if (this.migrationDashboardScrollable) {
+            this.migrationDashboardScrollable.getDomNode().style.display = category ? "none" : "";
+        }
+        if (this.migrationDashboardContainer) {
+            this.migrationDashboardContainer.style.display = category ? "none" : "";
+        }
+        if (this.migrationListScrollable) {
+            this.migrationListScrollable.getDomNode().style.display = category ? "" : "none";
+        }
+        if (this.migrationHeader) {
+            this.migrationHeader.style.display = category ? "" : "none";
+        }
+        if (this.migrationFooter) {
+            this.migrationFooter.style.display = category ? "" : "none";
+        }
+        if (!category) {
+            this.renderCustomizationMigrationBanner(undefined);
+            this.renderCustomizationMigrationDashboardState();
+            return;
+        }
+        const targetDocument = getWindow(this.migrationListContainer).document;
+        const activeElement = targetDocument.activeElement;
+        const capturedFocusState = this.captureCustomizationMigrationFocus();
+        if (capturedFocusState) {
+            this.migrationFocusState = capturedFocusState;
+        } else if (isHTMLElement(activeElement) && activeElement.isConnected && activeElement !== targetDocument.body) {
+            this.migrationFocusState = undefined;
+        }
+        for (const section of this.migrationSectionLists) {
+            this.migrationSectionScrollPositions?.set(section.key, section.list.scrollTop);
+        }
+        this.migrationPageDisposables.clear();
+        clearNode(this.migrationListContainer);
+        this.migrationClearSettingsContainer = undefined;
+        this.migrationFirstFocusableElement = undefined;
+        this.migrationSectionLists = [];
+        const candidates = this.getMigrationCandidates(category, this.activeMigrationStorage);
+        this.updateCustomizationMigrationPageHeader(category, candidates);
+        this.updateCustomizationMigrationActionState();
+        if (this.customizationMigrationLoading) {
+            this.renderCustomizationMigrationState(( localize(8552, "Loading customizations...")), ( localize(8553, "Checking the active harness and available destinations.")));
+            if (this.migrationMigrateButton) {
+                this.migrationMigrateButton.enabled = false;
+            }
+            this.migrationListScrollable?.scanDomNode();
+            return;
+        }
+        if (this.customizationMigrationLoadError) {
+            this.renderCustomizationMigrationState(( localize(8554, "Customizations could not be loaded")), ( localize(8555, "Check the active agent connection, then try again.")), () => void this.refreshCustomizationMigrationInfo());
+            if (this.migrationMigrateButton) {
+                this.migrationMigrateButton.enabled = false;
+            }
+            return;
+        }
+        if (candidates.length === 0) {
+            this.renderCustomizationMigrationState(
+                category.pageEmptyMessage,
+                category.getPageDescription(candidates, this.getActiveHarnessLabel())
+            );
+            return;
+        }
+        const renderGroup = (groupKey, groupLabel, customizations) => {
+            const group = append(this.migrationListContainer, $(".prompt-migration-group"));
+            const groupHeader = append(group, $(".prompt-migration-group-header"));
+            const groupHeading = append(groupHeader, $(".prompt-migration-group-heading"));
+            const label = append(groupHeading, $("h3.prompt-migration-group-title"));
+            label.textContent = groupLabel;
+            if (customizations.length === 0) {
+                const count = append(groupHeading, $("span.prompt-migration-group-count"));
+                count.textContent = "0";
+                const emptyItems = append(group, $(".prompt-migration-group-items"));
+                append(emptyItems, $(".plugin-inventory-empty.prompt-migration-group-empty")).textContent = ( localize(8556, "No customizations are available to migrate from {0}.", groupLabel));
+                return;
+            }
+            const selectedInGroup = customizations.filter(customization => this.isCustomizationSelectedForMigration(customization)).length;
+            const initialGroupState = selectedInGroup === customizations.length ? true : selectedInGroup === 0 ? false : "mixed";
+            const groupCheckboxAriaLabel = ( localize(8557, "Select all customizations in {0}", groupLabel));
+            const groupCheckbox = this.migrationPageDisposables.add(( new TriStateCheckbox(groupCheckboxAriaLabel, initialGroupState, defaultCheckboxStyles)));
+            const count = append(groupHeading, $("span.prompt-migration-group-count"));
+            count.textContent = String(customizations.length);
+            const groupControls = append(groupHeader, $(".prompt-migration-group-controls"));
+            const groupCheckboxContainer = append(groupControls, $(".item-sync-checkbox.prompt-migration-group-checkbox"));
+            groupCheckboxContainer.replaceChildren(groupCheckbox.domNode);
+            this.migrationFirstFocusableElement ??= groupCheckbox.domNode;
+            const selectAllLabel = append(groupControls, $("span.prompt-migration-select-all-label"));
+            selectAllLabel.textContent = ( localize(8558, "Select all"));
+            const setGroupCheckboxState = state => {
+                groupCheckbox.checked = state;
+                groupCheckbox.domNode.setAttribute("aria-checked", String(state));
+            };
+            setGroupCheckboxState(initialGroupState);
+            const updateGroupCheckboxState = () => {
+                const selectedCount = customizations.filter(customization => this.isCustomizationSelectedForMigration(customization)).length;
+                setGroupCheckboxState(
+                    selectedCount === customizations.length ? true : selectedCount === 0 ? false : "mixed"
+                );
+            };
+            const groupId = `prompt-migration-group-${category.id}-${groupKey}`;
+            const groupItems = append(group, $(".prompt-migration-group-items.virtualized-section-list"));
+            groupItems.id = `${groupId}-items`;
+            const sectionKey = `${category.id}:${groupKey}`;
+            const section = this.createMigrationSectionList(
+                groupItems,
+                sectionKey,
+                groupLabel,
+                customizations,
+                updateGroupCheckboxState
+            );
+            const setGroupSelection = selected => {
+                for (const customization of customizations) {
+                    this.setCustomizationSelectedForMigration(customization, selected);
+                }
+                this.updateCustomizationMigrationActionState();
+                section.renderer.refreshSelectionState();
+            };
+            this.migrationPageDisposables.add(
+                groupCheckbox.onChange(() => setGroupSelection(groupCheckbox.checked === true))
+            );
+            this.migrationPageDisposables.add(addDisposableListener(selectAllLabel, "click", e => {
+                EventHelper.stop(e, true);
+                const selected = groupCheckbox.checked !== true;
+                setGroupCheckboxState(selected);
+                setGroupSelection(selected);
+                groupCheckbox.focus();
+            }));
+        };
+        const groups = category.group(candidates).filter(
+            group => this.activeMigrationStorage === undefined || group.customizations.length > 0
+        );
+        const groupedCandidates = ( new Set());
+        for (const group of groups) {
+            for (const customization of group.customizations) {
+                groupedCandidates.add(this.getCustomizationMigrationCandidateKey(customization));
+            }
+            renderGroup(group.key, group.label, group.customizations);
+        }
+        const ungroupedCandidates = candidates.filter(candidate => !( groupedCandidates.has(this.getCustomizationMigrationCandidateKey(candidate))));
+        if (ungroupedCandidates.length > 0) {
+            const ungroupedItems = append(
+                this.migrationListContainer,
+                $(".prompt-migration-group-items.virtualized-section-list")
+            );
+            this.createMigrationSectionList(
+                ungroupedItems,
+                `${category.id}:ungrouped`,
+                category.pageTitle,
+                ungroupedCandidates
+            );
+        }
+        if (category.id === CustomizationMigrationCategoryId.ConfiguredLocations) {
+            this.renderConfiguredLocationSettingsGroup();
+        }
+        this.updateCustomizationMigrationActionState();
+        this.restoreCustomizationMigrationFocus();
+        this.scheduleMigrationSectionLayout();
+    }
+    captureCustomizationMigrationFocus() {
+        const activeElement = this.migrationListContainer ? getWindow(this.migrationListContainer).document.activeElement : undefined;
+        if (!isHTMLElement(activeElement)) {
+            return undefined;
+        }
+        for (const section of this.migrationSectionLists) {
+            const index = section.renderer.getIndex(activeElement);
+            if (index === undefined) {
+                continue;
+            }
+            const candidate = section.items[index];
+            if (candidate) {
+                const controls = section.renderer.getControls(index);
+                const controlIndex = controls.findIndex(control => control === activeElement || control.contains(activeElement));
+                return {
+                    candidateKey: this.getCustomizationMigrationCandidateKey(candidate),
+                    controlIndex: Math.max(0, controlIndex)
+                };
+            }
+        }
+        return undefined;
+    }
+    restoreCustomizationMigrationFocus() {
+        const focusState = this.migrationFocusState;
+        if (!focusState) {
+            return;
+        }
+        this.migrationFocusState = undefined;
+        for (const section of this.migrationSectionLists) {
+            const index = section.items.findIndex(
+                candidate => this.getCustomizationMigrationCandidateKey(candidate) === focusState.candidateKey
+            );
+            if (index < 0) {
+                continue;
+            }
+            section.list.setFocus([index]);
+            section.list.reveal(index);
+            section.renderer.getControls(index)[focusState.controlIndex]?.focus();
+            return;
+        }
+    }
+    renderConfiguredLocationSettingsGroup() {
+        if (!this.migrationListContainer || !this.migrationClearSettingsCheckbox) {
+            return;
+        }
+        const group = append(
+            this.migrationListContainer,
+            $(".prompt-migration-group.prompt-migration-settings-group")
+        );
+        const groupHeader = append(group, $(".prompt-migration-group-header"));
+        const groupHeading = append(groupHeader, $(".prompt-migration-group-heading"));
+        const settingsGroupLabel = ( localize(8559, "Settings"));
+        append(groupHeading, $("h3.prompt-migration-group-title")).textContent = settingsGroupLabel;
+        const groupItems = append(group, $(".prompt-migration-group-items"));
+        const item = this.migrationClearSettingsContainer = append(groupItems, $(".prompt-migration-settings-item"));
+        const checkboxContainer = append(item, $(".item-sync-checkbox.prompt-migration-checkbox"));
+        checkboxContainer.replaceChildren(this.migrationClearSettingsCheckbox.domNode);
+        const itemText = append(item, $("span.prompt-migration-settings-item-text"));
+        const label = append(itemText, $("span.prompt-migration-settings-item-label"));
+        label.textContent = ( localize(8560, "Clear unused location settings"));
+        const description = append(itemText, $("span.prompt-migration-settings-item-description"));
+        description.textContent = ( localize(
+            8561,
+            "Remove deprecated settings that are no longer needed after the selected customizations migrate successfully."
+        ));
+        this.migrationPageDisposables.add(addDisposableListener(itemText, "click", () => {
+            if (!this.migrationClearSettingsCheckbox?.enabled) {
+                return;
+            }
+            this.migrationClearSettingsCheckbox.checked = !this.migrationClearSettingsCheckbox.checked;
+            this.migrationClearSettingsCheckbox.focus();
+        }));
+    }
+    createMigrationSectionList(container, key, label, items, onSelectionChange) {
+        container.style.height = `${MIGRATION_ITEM_HEIGHT}px`;
+        const category = this.getActiveMigrationCategory() ?? CUSTOMIZATION_MIGRATION_CATEGORIES[0];
+        const renderer = ( new MigrationItemRenderer(
+            customization => this.isCustomizationSelectedForMigration(customization),
+            customization => category.getCandidatePresentation(customization, uri => this.labelService.getUriLabel(uri, {
+                relative: true
+            })),
+            (customization, selected) => {
+                this.setCustomizationSelectedForMigration(customization, selected);
+                this.updateCustomizationMigrationActionState();
+                onSelectionChange?.();
+            },
+            customization => {
+                const isWorkspaceFile = customization.storage === PromptsStorage.local;
+                void this.showEmbeddedEditor(
+                    customization.uri,
+                    customization.name ?? basename(customization.uri),
+                    customization.type,
+                    customization.storage,
+                    isWorkspaceFile
+                );
+            },
+            (customization, anchor) => this.showCustomizationMigrationItemActions(customization, anchor),
+            element => this.migrationFirstFocusableElement ??= element,
+            this.hoverService
+        ));
+        const list = this.migrationPageDisposables.add(this.instantiationService.createInstance(
+            WorkbenchList,
+            `CustomizationMigration.${label}`,
+            container,
+            ( new MigrationItemDelegate()),
+            [renderer],
+            {
+                multipleSelectionSupport: false,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getWidgetAriaLabel: () => label,
+                    getAriaLabel: customization => {
+                        const presentation = category.getCandidatePresentation(customization, uri => this.labelService.getUriLabel(uri, {
+                            relative: true
+                        }));
+                        return localize(8562, "{0}, {1}", presentation.name, presentation.pathLabel);
+                    },
+                    getSetSize: (_element, _index, listLength) => listLength,
+                    getPosInSet: (_element, index) => index + 1
+                },
+                identityProvider: {
+                    getId: customization => this.getCustomizationMigrationCandidateKey(customization)
+                }
+            }
+        ));
+        list.splice(0, 0, items);
+        list.scrollTop = this.migrationSectionScrollPositions?.get(key) ?? 0;
+        this.migrationPageDisposables.add(list.onDidChangeSelection(event => {
+            if (event.indexes.length > 0) {
+                list.setSelection([]);
+            }
+        }));
+        this.migrationPageDisposables.add(
+            addStandardDisposableListener(container, EventType.KEY_DOWN, event => {
+                if (event.keyCode !== KeyCode.Tab) {
+                    return;
+                }
+                const target = event.target;
+                if (!isHTMLElement(target)) {
+                    return;
+                }
+                const index = renderer.getIndex(target);
+                if (index === undefined) {
+                    return;
+                }
+                const controls = renderer.getControls(index);
+                const controlIndex = controls.findIndex(control => control === target || control.contains(target));
+                const targetIndex = event.shiftKey ? index - 1 : index + 1;
+                const crossesRowBoundary = event.shiftKey ? controlIndex === 0 : controlIndex === controls.length - 1;
+                if (!crossesRowBoundary || targetIndex < 0 || targetIndex >= items.length) {
+                    return;
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                list.setFocus([targetIndex]);
+                list.reveal(targetIndex);
+                const targetControls = renderer.getControls(targetIndex);
+                targetControls[event.shiftKey ? targetControls.length - 1 : 0]?.focus();
+            })
+        );
+        const section = {
+            list,
+            renderer,
+            container,
+            items,
+            key
+        };
+        this.migrationSectionLists.push(section);
+        return section;
+    }
+    showCustomizationMigrationItemActions(customization, anchor) {
+        const actions = ( new DisposableStore());
+        const deleteAction = actions.add(( new Action("customizationMigration.delete", ( localize(8563, "Delete")), ThemeIcon.asClassName(Codicon.trash), true, () => this.deleteCustomizationFile(customization))));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => [deleteAction],
+            onHide: () => actions.dispose()
+        });
+    }
+    layoutMigrationSectionLists() {
+        if (!this.migrationListContainer) {
+            return;
+        }
+        const heights = layoutVirtualizedSections(this.migrationListContainer, this.migrationSectionLists.map(section => ({
+            container: section.container,
+            contentHeight: section.items.length * MIGRATION_ITEM_HEIGHT,
+            minimumHeight: getVirtualizedSectionMinimumHeight(section.items, () => MIGRATION_ITEM_HEIGHT)
+        })));
+        for (let index = 0; index < this.migrationSectionLists.length; index++) {
+            const section = this.migrationSectionLists[index];
+            const height = heights[index];
+            layoutVirtualizedSectionList(
+                section.list,
+                section.container,
+                height,
+                section.container.clientWidth || undefined
+            );
+        }
+    }
+    scheduleMigrationSectionLayout() {
+        this.migrationDashboardScrollable?.scanDomNode();
+        if (this.migrationContentContainer?.style.display === "none") {
+            this.pendingMigrationLayout?.clear();
+            return;
+        }
+        if (!this.pendingMigrationLayout) {
+            this.layoutMigrationSectionLists();
+            this.migrationListScrollable?.scanDomNode();
+            return;
+        }
+        if (!this.migrationListContainer) {
+            this.pendingMigrationLayout.clear();
+            return;
+        }
+        this.pendingMigrationLayout.value = scheduleAtNextAnimationFrame(getWindow(this.migrationListContainer), () => {
+            this.layoutMigrationSectionLists();
+            this.migrationListScrollable?.scanDomNode();
+        });
+    }
+    renderCustomizationMigrationDashboardState() {
+        if (!this.migrationDashboard) {
+            return;
+        }
+        if (this.customizationMigrationLoading) {
+            this.migrationDashboard.showLoading(( localize(8552, "Loading customizations...")), ( localize(8553, "Checking the active harness and available destinations.")));
+            return;
+        }
+        if (this.customizationMigrationLoadError) {
+            this.migrationDashboard.showLoading(( localize(8554, "Customizations could not be loaded")), ( localize(8555, "Check the active agent connection, then try again.")), () => void this.refreshCustomizationMigrationInfo());
+            this.migrationListScrollable?.scanDomNode();
+            return;
+        }
+        this.renderCustomizationMigrationDashboard();
+    }
+    renderCustomizationMigrationDashboard() {
+        if (!this.migrationDashboard) {
+            return;
+        }
+        this.migrationDashboard.showOverview(this.getCustomizationMigrationDashboardOverview());
+        this.migrationDashboardScrollable?.scanDomNode();
+        this.migrationListScrollable?.scanDomNode();
+    }
+    getMigrationAccessibilityContent() {
+        if (this.viewMode !== "migration" || this.activeMigrationCategoryId || !this.migrationDashboard || !isAncestorOfActiveElement(this.migrationDashboard.element)) {
+            return undefined;
+        }
+        const overview = this.getCustomizationMigrationDashboardOverview();
+        return [( localize(8564, "Your migration checklist")), ...overview.scopes.map(scope => [scope.label, scope.skipped ? ( localize(8565, "Skipped")) : scope.count === 0 ? ( localize(8566, "No remaining migrations.")) : "", ...(scope.skipped ? [] : scope.categories.map(category => ( localize(
+            8567,
+            "{0}: {1}. {2}{3}",
+            category.label,
+            category.countLabel,
+            category.highRisk ? ( localize(8568, "High risk. ")) : "",
+            category.description
+        ))))].filter(Boolean).join("\n")), ...overview.activity.map(entry => [( localize(
+            8569,
+            "Migration activity: {0}, {1}",
+            entry.categoryLabel,
+            entry.scopeLabel
+        )), ...entry.items.map(item => ( localize(
+            8570,
+            "{0}: from {1} to {2}",
+            item.label,
+            item.sourceLabel,
+            item.targetLabel
+        )))].join("\n"))].join("\n\n");
+    }
+    getCustomizationMigrationDashboardOverview() {
+        const storages = [PromptsStorage.user];
+        if (this.workspaceService.activeProjectRoot.get()) {
+            storages.push(PromptsStorage.local);
+        }
+        const scopes = storages.map(storage => {
+            const categories = homepageMigrationCategories.flatMap(id => {
+                const candidates = this.getMigrationCandidates(getCustomizationMigrationCategory(id), storage);
+                return candidates.length ? [this.getHomepageMigrationCategory(id, candidates)] : [];
+            });
+            return {
+                storage,
+                label: this.getMigrationScopeLabel(storage),
+                count: categories.reduce((count, category) => count + category.count, 0),
+                skipped: storage === PromptsStorage.local && this.migrationWorkspaceSkipped,
+                started: this.getMigrationActivityState(storage).started === true,
+                hasConfigurableDestinations: ( categories.some(category => category.id !== CustomizationMigrationCategoryId.McpServers)),
+                categories
+            };
+        });
+        return {
+            scopes,
+            activity: storages.flatMap(storage => this.getMigrationActivityState(storage).activity).sort((a, b) => b.id.localeCompare(a.id)),
+            result: this.migrationResult
+        };
+    }
+    getHomepageMigrationCategory(id, candidates) {
+        const count = candidates.length;
+        switch (id) {
+        case CustomizationMigrationCategoryId.PromptFiles:
+            return {
+                id,
+                count,
+                label: ( localize(8571, "Prompts to skills")),
+                description: ( localize(
+                    8572,
+                    "Convert reusable prompt files into skills so agents can discover and run them as supported customizations."
+                )),
+                countLabel: count === 1 ? ( localize(8573, "1 prompt")) : ( localize(8574, "{0} prompts", count)),
+                highRisk: true
+            };
+        case CustomizationMigrationCategoryId.McpServers:
+            return {
+                id,
+                count,
+                label: ( localize(8575, "MCP Servers")),
+                description: ( localize(
+                    8576,
+                    "Move supported workspace servers to the root .mcp.json so agents can discover them directly."
+                )),
+                countLabel: count === 1 ? ( localize(8577, "1 server")) : ( localize(8578, "{0} servers", count))
+            };
+        case CustomizationMigrationCategoryId.UserData:
+            {
+                const agents = candidates.filter(candidate => candidate.type === PromptsType.agent).length;
+                const instructions = candidates.filter(candidate => candidate.type === PromptsType.instructions).length;
+                const counts = [];
+                if (agents) {
+                    counts.push(agents === 1 ? ( localize(8579, "1 agent")) : ( localize(8580, "{0} agents", agents)));
+                }
+                if (instructions) {
+                    counts.push(instructions === 1 ? ( localize(8581, "1 instruction")) : ( localize(8582, "{0} instructions", instructions)));
+                }
+                return {
+                    id,
+                    count,
+                    label: ( localize(8583, "User Data")),
+                    description: ( localize(
+                        8584,
+                        "Move agents and instructions to shared locations so they remain available to supported agent experiences."
+                    )),
+                    countLabel: counts.join(" · ")
+                };
+            }
+        default:
+            throw ( new Error(`Unsupported migration checklist category: ${id}`));
+        }
+    }
+    getMigrationScopeLabel(storage) {
+        return storage === PromptsStorage.user ? ( localize(8585, "Your profile")) : this.workspaceService.activeProjectLabel.get() || ( localize(8586, "Workspace"));
+    }
+    getMigrationActivityKey(storage) {
+        const project = this.workspaceService.activeProjectRoot.get();
+        return storage === PromptsStorage.user ? `chat.customizationMigration.activity.profile.${this.harnessService.activeHarness.get()}` : `chat.customizationMigration.activity.workspace.${project ? getComparisonKey(project) : ""}.${this.harnessService.activeHarness.get()}`;
+    }
+    getMigrationActivityState(storage) {
+        return this.storageService.getObject(this.getMigrationActivityKey(storage), StorageScope.PROFILE, {
+            activity: [],
+            skipped: false
+        });
+    }
+    getMigrationActivityContexts() {
+        return [PromptsStorage.user, PromptsStorage.local].map(storage => this.getMigrationActivityContext(storage));
+    }
+    getMigrationActivityContext(storage) {
+        return {
+            storage,
+            key: this.getMigrationActivityKey(storage),
+            label: this.getMigrationScopeLabel(storage)
+        };
+    }
+    recordMigrationActivity(category, context, items) {
+        if (!items.length || !( homepageMigrationCategories.some(id => id === category.id))) {
+            return;
+        }
+        const state = this.storageService.getObject(context.key, StorageScope.PROFILE, {
+            activity: [],
+            skipped: false
+        });
+        const entry = {
+            id: `${Date.now()}-${generateUuid()}`,
+            categoryLabel: this.getHomepageMigrationCategory(category.id, []).label,
+            scopeLabel: context.label,
+            storage: context.storage,
+            items
+        };
+        this.storageService.store(context.key, {
+            ...state,
+            started: true,
+            activity: [entry, ...state.activity]
+        }, StorageScope.PROFILE, StorageTarget.MACHINE);
+        if (context.key === this.getMigrationActivityKey(context.storage)) {
+            this.migrationResult = {
+                migratedCount: (this.migrationResult?.migratedCount ?? 0) + items.length
+            };
+        }
+    }
+    storeMigrationActivityState(storage, state) {
+        this.storageService.store(
+            this.getMigrationActivityKey(storage),
+            state,
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+    getCustomizationMigrationDashboardDestinations(customizations) {
+        const destinations = ( new Map());
+        for (const customization of customizations) {
+            const targetType = getCustomizationMigrationTargetType(customization);
+            const key = this.getCustomizationMigrationTargetKey(targetType, customization.storage);
+            if (( destinations.has(key))) {
+                continue;
+            }
+            const folder = this.selectedCustomizationMigrationTargets.get(key);
+            const contextLabel = this.getCustomizationMigrationDestinationContextLabel(targetType, customization.storage);
+            if (!folder) {
+                const label = ( localize(8587, "Not configured"));
+                destinations.set(key, {
+                    targetType,
+                    storage: customization.storage,
+                    contextLabel,
+                    label,
+                    ariaLabel: ( localize(8588, "Configure destination for {0}", contextLabel))
+                });
+                continue;
+            }
+            const folderLabel = this.getCustomizationMigrationFolderLabel(folder);
+            destinations.set(key, {
+                targetType,
+                storage: customization.storage,
+                contextLabel,
+                label: folderLabel,
+                ariaLabel: ( localize(
+                    8589,
+                    "Change destination for {0}, currently {1}",
+                    contextLabel,
+                    folderLabel
+                ))
+            });
+        }
+        return [...( destinations.values())];
+    }
+    async configureCustomizationMigrationLocations(storage) {
+        const sessionResource = this.harnessService.activeSessionResource.get();
+        const destinations = this.getCustomizationMigrationDashboardDestinations(
+            this.getDashboardFileMigrationCandidates().filter(candidate => candidate.storage === storage)
+        );
+        if (destinations.length === 0) {
+            this.notificationService.info(( localize(
+                8590,
+                "There are no file migration destinations to configure. MCP servers migrate to the workspace root .mcp.json."
+            )));
+            return;
+        }
+        const selected = await this.quickInputService.pick(destinations.map(destination => ({
+            label: destination.contextLabel,
+            description: destination.label,
+            destination
+        })), {
+            canPickMany: false,
+            placeHolder: ( localize(8591, "Choose a migration location to customize")),
+            matchOnDescription: true
+        });
+        if (selected && this.isCustomizationMigrationSessionActive(sessionResource)) {
+            await this.chooseCustomizationMigrationDestination(selected.destination);
+        }
+    }
+    getCustomizationMigrationDestinationContextLabel(targetType, storage) {
+        const scope = storage === PromptsStorage.local ? ( localize(8592, "Workspace")) : ( localize(8593, "User"));
+        switch (targetType) {
+        case PromptsType.skill:
+            return localize(8594, "{0} skills", scope);
+        case PromptsType.agent:
+            return localize(8595, "{0} agents", scope);
+        default:
+            return localize(8596, "{0} instructions", scope);
+        }
+    }
+    async chooseCustomizationMigrationDestination(destination) {
+        const sessionResource = this.harnessService.activeSessionResource.get();
+        const key = this.getCustomizationMigrationTargetKey(destination.targetType, destination.storage);
+        const currentFolder = this.selectedCustomizationMigrationTargets.get(key);
+        const availableFolders = this.getCustomizationMigrationFolders(destination.targetType, destination.storage);
+        const picks = availableFolders.map(folder => ({
+            label: folder.label,
+            description: this.getCustomizationMigrationFolderPickDescription(folder, this.getCustomizationMigrationFolderLabel(folder)),
+            picked: currentFolder ? isEqual(folder.uri, currentFolder.uri) : false,
+            folder
+        }));
+        picks.push({
+            label: ( localize(8597, "Choose another folder...")),
+            description: ( localize(8598, "Use a custom migration destination")),
+            chooseAnother: true
+        });
+        const selected = await this.quickInputService.pick(picks, {
+            canPickMany: false,
+            placeHolder: ( localize(8599, "Choose a destination for {0}", destination.contextLabel)),
+            matchOnDescription: true
+        });
+        if (!selected || !this.isCustomizationMigrationSessionActive(sessionResource)) {
+            return;
+        }
+        let folder = selected.folder;
+        if (selected.chooseAnother) {
+            const folders = await this.fileDialogService.showOpenDialog({
+                title: ( localize(8600, "Choose a Custom Migration Destination")),
+                openLabel: ( localize(8601, "Select Folder")),
+                canSelectFiles: false,
+                canSelectFolders: true,
+                canSelectMany: false,
+                defaultUri: currentFolder?.uri
+            });
+            const uri = folders?.[0];
+            if (!uri || !this.isCustomizationMigrationSessionActive(sessionResource)) {
+                return;
+            }
+            folder = {
+                uri,
+                label: this.labelService.getUriLabel(uri, {
+                    relative: true
+                }),
+                source: destination.storage
+            };
+        }
+        if (!folder) {
+            return;
+        }
+        this.selectedCustomizationMigrationTargets.set(key, folder);
+        this.explicitlySelectedCustomizationMigrationTargets.add(key);
+        this.renderCustomizationMigrationPage();
+    }
+    renderCustomizationMigrationState(title, description, retry) {
+        const state = append(
+            this.migrationListContainer,
+            $(".plugin-inventory-empty.prompt-migration-state")
+        );
+        append(state, $("strong.prompt-migration-state-title")).textContent = title;
+        append(state, $("span.prompt-migration-state-description")).textContent = description;
+        if (retry) {
+            const retryButton = this.migrationPageDisposables.add(( new Button(state, {
+                ...defaultButtonStyles,
+                secondary: true,
+                ariaLabel: ( localize(8602, "Retry loading customizations"))
+            })));
+            retryButton.label = ( localize(8603, "Retry"));
+            this.migrationFirstFocusableElement ??= retryButton.element;
+            this.migrationPageDisposables.add(retryButton.onDidClick(retry));
+        }
+        this.migrationListScrollable?.scanDomNode();
+    }
+    updateCustomizationMigrationPageHeader(category, candidates) {
+        if (this.migrationHeader) {
+            this.migrationHeader.style.display = "";
+        }
+        if (this.migrationBackButton) {
+            this.migrationBackButton.style.display = "";
+        }
+        if (this.migrationFooter) {
+            this.migrationFooter.style.display = "";
+        }
+        if (this.migrationTitleElement) {
+            this.migrationTitleElement.textContent = category.pageTitle;
+        }
+        const banner = candidates.length > 0 ? category.getBanner?.(
+            candidates,
+            this.getActiveHarnessLabel(),
+            this.getCustomizationMigrationDestinationLabel(candidates.filter(
+                customization => !isMcpServerCustomizationMigrationCandidate(customization)
+            ).flatMap(customization => {
+                const targetType = getCustomizationMigrationTargetType(customization);
+                return this.customizationMigrationTargetFoldersByType.get(targetType)?.filter(folder => folder.source === customization.storage) ?? [];
+            })),
+            category.getModifiedSettingIds?.(this.configurationService) ?? []
+        ) : undefined;
+        this.renderCustomizationMigrationBanner(banner);
+        if (this.migrationDescriptionElement) {
+            const description = banner ? "" : category.getPageDescription(candidates, this.getActiveHarnessLabel());
+            if (this.migrationDescriptionTextElement) {
+                this.migrationDescriptionTextElement.textContent = description;
+            } else {
+                this.migrationDescriptionElement.textContent = description;
+            }
+            this.migrationDescriptionElement.style.display = banner ? "none" : "";
+        }
+        if (this.migrationLinkElement) {
+            this.migrationLinkElement.style.display = "";
+            this.migrationLinkElement.textContent = category.pageLinkLabel;
+            this.migrationLinkElement.href = category.pageLinkUrl;
+        }
+    }
+    renderCustomizationMigrationBanner(banner) {
+        const container = this.migrationBannerContainer;
+        if (!container) {
+            return;
+        }
+        this.migrationBannerDisposables.clear();
+        clearNode(container);
+        if (!banner) {
+            if (this.migrationLinkElement && this.migrationDescriptionElement) {
+                this.migrationDescriptionElement.appendChild(this.migrationLinkElement);
+            }
+            container.style.display = "none";
+            return;
+        }
+        container.style.display = "";
+        const content = append(container, $(".customization-migration-banner-content"));
+        if (isMarkdownString(banner.message)) {
+            const renderedMessage = this.migrationBannerDisposables.add(this.markdownRendererService.render(banner.message));
+            renderedMessage.element.classList.add("customization-migration-banner-message");
+            content.appendChild(renderedMessage.element);
+        } else {
+            append(content, $("p.customization-migration-banner-message")).textContent = banner.message;
+        }
+        if (banner.consequence) {
+            append(content, $("p.customization-migration-banner-consequence")).textContent = banner.consequence;
+        }
+        if (this.migrationLinkElement) {
+            content.appendChild(this.migrationLinkElement);
+        }
+    }
+    updateCustomizationMigrationActionState() {
+        if (!this.migrationMigrateButton) {
+            return;
+        }
+        const category = this.getActiveMigrationCategory();
+        if (!category) {
+            this.migrationMigrateButton.enabled = false;
+            return;
+        }
+        const selectedCount = this.getMigrationCandidates(category, this.activeMigrationStorage).filter(customization => this.isCustomizationSelectedForMigration(customization)).length;
+        this.migrationMigrateButton.enabled = selectedCount > 0 && !this.customizationMigrationInProgress;
+        if (this.migrationClearSettingsCheckbox) {
+            const hasModifiedSettings = this.getModifiedConfiguredLocationSettingIds(category).length > 0;
+            const canClearSettings = category.id === CustomizationMigrationCategoryId.ConfiguredLocations && hasModifiedSettings && !this.customizationMigrationInProgress && !this.customizationMigrationLoading && !this.customizationMigrationLoadError;
+            this.migrationClearSettingsContainer?.classList.toggle("disabled", !canClearSettings);
+            if (canClearSettings) {
+                this.migrationClearSettingsCheckbox.enable();
+                this.migrationClearSettingsCheckbox.setTitle(( localize(8545, "Clear unused location settings after migration")));
+            } else {
+                this.migrationClearSettingsCheckbox.disable();
+                this.migrationClearSettingsCheckbox.setTitle(( localize(8604, "The custom location settings are managed and cannot be cleared")));
+            }
+        }
+        if (this.migrationSelectedCountElement) {
+            this.migrationSelectedCountElement.textContent = selectedCount === 1 ? ( localize(8605, "1 selected")) : ( localize(8606, "{0} selected", selectedCount));
+        }
+        if (category.id === CustomizationMigrationCategoryId.PromptFiles) {
+            this.migrationMigrateButton.label = selectedCount > 0 ? ( localize(8607, "Convert {0} to Skills", selectedCount)) : ( localize(8608, "Convert to Skills"));
+        } else {
+            this.migrationMigrateButton.label = selectedCount > 0 ? ( localize(8609, "Migrate {0}", selectedCount)) : ( localize(8610, "Migrate"));
+        }
+    }
+    async deleteCustomizationFile(customization) {
+        if (this.customizationMigrationInProgress) {
+            return;
+        }
+        const fileName = customization.name ?? basename(customization.uri);
+        const confirmation = await this.dialogService.confirm({
+            message: ( localize(8611, "Are you sure you want to delete '{0}'?", fileName)),
+            detail: ( localize(8612, "This action cannot be undone.")),
+            primaryButton: ( localize(8563, "Delete")),
+            type: "warning"
+        });
+        if (!confirmation.confirmed) {
+            return;
+        }
+        const useTrash = this.fileService.hasCapability(customization.uri, FileSystemProviderCapabilities.Trash);
+        await this.fileService.del(customization.uri, {
+            useTrash
+        });
+        if (customization.storage === PromptsStorage.local) {
+            const projectRoot = this.workspaceService.getActiveProjectRoot();
+            if (projectRoot) {
+                await this.workspaceService.deleteFiles(projectRoot, [customization.uri]);
+            }
+        }
+        const updatedCandidates = ( new Map());
+        for (const [categoryId, candidates] of this.customizationsByMigrationCategory) {
+            updatedCandidates.set(categoryId, candidates.filter(
+                candidate => isMcpServerCustomizationMigrationCandidate(candidate) || !isEqual(candidate.uri, customization.uri)
+            ));
+        }
+        this.setCustomizationsToMigrate(updatedCandidates, this.customizationMigrationTargetFoldersByType);
+    }
+    isMigrationCategoryEnabled(category) {
+        if (this.configurationService.getValue(category.enablementSetting) !== true) {
+            return false;
+        }
+        const modifiedSettingIds = category.getModifiedSettingIds?.(this.configurationService);
+        return modifiedSettingIds === undefined || modifiedSettingIds.length > 0;
+    }
+    getEnabledMigrationCategories() {
+        return CUSTOMIZATION_MIGRATION_CATEGORIES.filter(category => this.isMigrationCategoryEnabled(category));
+    }
+    async resolveCustomizationMigrationTargetFolders(customizations, availableSourceFolders, sessionResource) {
+        const requiredStorageByTargetType = ( new Map());
+        for (const customization of customizations) {
+            const targetType = getCustomizationMigrationTargetType(customization);
+            const storages = requiredStorageByTargetType.get(targetType) ?? ( new Set());
+            storages.add(customization.storage);
+            requiredStorageByTargetType.set(targetType, storages);
+        }
+        const targetFolders = ( new Map());
+        const selectedDestinationGroupIds = ( new Map());
+        for (const [targetType, requiredStorages] of requiredStorageByTargetType) {
+            const availableFolders = availableSourceFolders.get(targetType) ?? [];
+            if (!this.isCustomizationMigrationSessionActive(sessionResource)) {
+                return undefined;
+            }
+            const foldersByStorage = ( new Map());
+            for (const storage of requiredStorages) {
+                const matchingFolders = this.getCustomizationMigrationFolders(targetType, storage, availableFolders);
+                const selectedFolder = this.selectedCustomizationMigrationTargets.get(this.getCustomizationMigrationTargetKey(targetType, storage));
+                if (matchingFolders.length === 0 && !selectedFolder) {
+                    this.notificationService.error(this.getMissingMigrationTargetFolderMessage(targetType, storage));
+                    return undefined;
+                }
+                const selectedDestinationGroupId = selectedDestinationGroupIds.get(storage);
+                const foldersAtSelectedDestination = selectedDestinationGroupId ? matchingFolders.filter(folder => folder.destinationGroupId === selectedDestinationGroupId) : [];
+                let targetFolder = selectedFolder;
+                if (targetFolder?.destinationGroupId) {
+                    selectedDestinationGroupIds.set(storage, targetFolder.destinationGroupId);
+                } else if (foldersAtSelectedDestination.length === 1) {
+                    targetFolder = foldersAtSelectedDestination[0];
+                } else if (!targetFolder && matchingFolders.length === 1) {
+                    targetFolder = matchingFolders[0];
+                } else if (!targetFolder) {
+                    targetFolder = await this.pickCustomizationMigrationTargetFolder(matchingFolders, targetType, requiredStorageByTargetType.size > 1);
+                    if (targetFolder?.destinationGroupId) {
+                        selectedDestinationGroupIds.set(storage, targetFolder.destinationGroupId);
+                    }
+                }
+                if (!targetFolder || !this.isCustomizationMigrationSessionActive(sessionResource)) {
+                    return undefined;
+                }
+                foldersByStorage.set(storage, targetFolder);
+            }
+            targetFolders.set(targetType, foldersByStorage);
+        }
+        return targetFolders;
+    }
+    isCustomizationMigrationSessionActive(sessionResource) {
+        return isEqual(sessionResource, this.harnessService.activeSessionResource.get());
+    }
+    getMissingMigrationTargetFolderMessage(targetType, storage) {
+        if (storage === PromptsStorage.local) {
+            switch (targetType) {
+            case PromptsType.skill:
+                return localize(8613, "No workspace skills folder is configured for the active harness.");
+            case PromptsType.agent:
+                return localize(8614, "No workspace agents folder is configured for the active harness.");
+            default:
+                return localize(
+                    8615,
+                    "No workspace instructions folder is configured for the active harness."
+                );
+            }
+        }
+        switch (targetType) {
+        case PromptsType.skill:
+            return localize(8616, "No global skills folder is configured for the active harness.");
+        case PromptsType.agent:
+            return localize(8617, "No global agents folder is configured for the active harness.");
+        default:
+            return localize(
+                8618,
+                "No global instructions folder is configured for the active harness."
+            );
+        }
+    }
+    async pickCustomizationMigrationTargetFolder(sourceFolders, targetType, selectsMultipleTypes) {
+        const picks = this.sortCustomizationMigrationFolders(sourceFolders).map(folder => ({
+            label: folder.label,
+            description: this.getCustomizationMigrationFolderPickDescription(folder, this.labelService.getUriLabel(folder.uri, {
+                relative: true
+            })),
+            folder
+        }));
+        const selected = await this.quickInputService.pick(picks, {
+            canPickMany: false,
+            placeHolder: this.getMigrationTargetFolderPlaceholder(targetType, selectsMultipleTypes),
+            matchOnDescription: true
+        });
+        return selected?.folder;
+    }
+    sortCustomizationMigrationFolders(folders) {
+        return [...folders].sort(
+            (first, second) => Number(this.isRecommendedCustomizationMigrationFolder(second)) - Number(this.isRecommendedCustomizationMigrationFolder(first))
+        );
+    }
+    getCustomizationMigrationFolders(
+        type,
+        storage,
+        availableFolders = this.customizationMigrationTargetFoldersByType.get(type) ?? []
+    ) {
+        return this.sortCustomizationMigrationFolders(availableFolders.filter(
+            folder => folder.source === storage && !(type === PromptsType.skill && storage === PromptsStorage.local && basename(dirname(folder.uri)).toLowerCase() === ".claude")
+        ));
+    }
+    isRecommendedCustomizationMigrationFolder(folder) {
+        const root = basename(dirname(folder.uri)).toLowerCase();
+        return root === (folder.source === PromptsStorage.local ? ".github" : ".copilot");
+    }
+    getCustomizationMigrationFolderPickDescription(folder, description) {
+        return this.isRecommendedCustomizationMigrationFolder(folder) ? ( localize(8619, "{0} (Recommended)", description)) : description;
+    }
+    getMigrationTargetFolderPlaceholder(targetType, selectsMultipleTypes) {
+        if (selectsMultipleTypes) {
+            return localize(8620, "Select a destination for the migrated customizations");
+        }
+        switch (targetType) {
+        case PromptsType.skill:
+            return localize(8621, "Select a destination folder for migrated skills");
+        case PromptsType.agent:
+            return localize(8622, "Select a destination folder for migrated agents");
+        default:
+            return localize(8623, "Select a destination folder for migrated instructions");
+        }
+    }
+    getCustomizationMigrationFolderLabel(folder) {
+        const useSourceLabel = folder.label.startsWith("~") || (folder.source === PromptsStorage.local && folder.label.startsWith("."));
+        let label = useSourceLabel ? folder.label : this.labelService.getUriLabel(folder.uri, {
+            relative: folder.source === PromptsStorage.local
+        });
+        const folderName = basename(folder.uri);
+        const normalizedLabel = label.replaceAll("\\", "/");
+        if (useSourceLabel && normalizedLabel.split("/").at(-1) !== folderName) {
+            const separator = label.includes("\\") ? "\\" : "/";
+            label = `${label}${separator}${folderName}`;
+        }
+        return label;
+    }
+    getCustomizationMigrationDestinationLabel(folders) {
+        const seen = ( new ResourceSet());
+        const uniqueFolders = folders.filter(folder => {
+            if (( seen.has(folder.uri))) {
+                return false;
+            }
+            seen.add(folder.uri);
+            return true;
+        });
+        if (uniqueFolders.length === 0) {
+            return undefined;
+        }
+        const commonLabel = uniqueFolders[0].label;
+        if (commonLabel && uniqueFolders.every(folder => folder.label === commonLabel)) {
+            return commonLabel;
+        }
+        const labelParent = dirname$1(uniqueFolders[0].label);
+        if (labelParent !== "." && uniqueFolders.every(folder => dirname$1(folder.label) === labelParent)) {
+            return labelParent;
+        }
+        let destination = uniqueFolders[0].uri;
+        if (uniqueFolders.length > 1) {
+            const commonParent = dirname(destination);
+            if (!uniqueFolders.every(folder => isEqual(dirname(folder.uri), commonParent))) {
+                return undefined;
+            }
+            destination = commonParent;
+        }
+        return this.labelService.getUriLabel(destination);
+    }
+    isPromptsSection(section) {
+        return section === AICustomizationManagementSection.Agents || section === AICustomizationManagementSection.Skills || section === AICustomizationManagementSection.Instructions || section === AICustomizationManagementSection.Prompts || section === AICustomizationManagementSection.Hooks;
+    }
+    updateSectionCount(sectionId, count) {
+        const section = this.sections.find(s => s.id === sectionId);
+        if (!section || section.count === count) {
+            return;
+        }
+        section.count = count;
+        this.sectionsList.splice(0, this.sectionsList.length, this.sections);
+        this.ensureSectionsListReflectsActiveSection();
+    }
+    showWelcomePage() {
+        if (this.viewMode === "editor") {
+            this.goBackToList();
+        }
+        if (this.viewMode === "migration") {
+            this.viewMode = "list";
+        }
+        if (this.viewMode === "mcpDetail") {
+            this.goBackFromMcpDetail();
+        }
+        if (this.viewMode === "pluginDetail") {
+            this.goBackFromPluginDetail();
+        }
+        if (this.viewMode === "toolsDetail") {
+            this.goBackFromToolDetail();
+        }
+        this.selectedSection = undefined;
+        this.activeMigrationStorage = undefined;
+        this.sectionContextKey.set("");
+        this.storageService.remove(AI_CUSTOMIZATION_MANAGEMENT_SELECTED_SECTION_KEY, StorageScope.PROFILE);
+        this.welcomePage?.reset();
+        this.updateContentVisibility();
+        this.ensureSectionsListReflectsActiveSection(undefined);
+        this.welcomePage?.focus();
+    }
+    selectSection(section, options) {
+        if (this.selectedSection === section && !options?.showMarketplace) {
+            this.ensureSectionsListReflectsActiveSection(section);
+            return;
+        }
+        this.telemetryService.publicLog2("chatCustomizationEditor.sectionChanged", {
+            section
+        });
+        if (this.viewMode === "editor") {
+            this.goBackToList();
+        }
+        if (this.viewMode === "migration") {
+            this.viewMode = "list";
+        }
+        if (this.viewMode === "mcpDetail") {
+            this.goBackFromMcpDetail();
+        }
+        if (this.viewMode === "pluginDetail") {
+            this.goBackFromPluginDetail();
+        }
+        if (this.viewMode === "toolsDetail") {
+            this.goBackFromToolDetail();
+        }
+        this.selectedSection = section;
+        this.sectionContextKey.set(section);
+        this.storageService.store(
+            AI_CUSTOMIZATION_MANAGEMENT_SELECTED_SECTION_KEY,
+            section,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this.updateContentVisibility();
+        if (this.isPromptsSection(section)) {
+            void this.listWidget.setSection(section);
+        }
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        this.ensureSectionsListReflectsActiveSection(section);
+        if (options?.showMarketplace) {
+            if (section === AICustomizationManagementSection.McpServers) {
+                this.mcpListWidget?.showBrowseMarketplace();
+            } else if (section === AICustomizationManagementSection.Plugins) {
+                this.pluginListWidget?.showBrowseMarketplace();
+            }
+        }
+        if (section === AICustomizationManagementSection.McpServers) {
+            this.mcpListWidget?.focusSearch();
+        } else if (section === AICustomizationManagementSection.Plugins) {
+            this.pluginListWidget?.focusSearch();
+        } else if (section === AICustomizationManagementSection.Models) {
+            this.modelsWidget?.focusSearch();
+        } else if (section === AICustomizationManagementSection.Tools) {
+            this.toolsListWidget?.focusSearch();
+        } else {
+            this.listWidget?.focusSearch();
+        }
+    }
+    ensureSectionsListReflectsActiveSection(section = this.selectedSection) {
+        if (!this.sectionsList) {
+            return;
+        }
+        if (section === undefined) {
+            this.sectionsList.setSelection([]);
+            this.sectionsList.setFocus([]);
+            return;
+        }
+        const index = this.sections.findIndex(s => s.id === section);
+        if (index < 0) {
+            return;
+        }
+        const selection = this.sectionsList.getSelection();
+        if (selection.length !== 1 || selection[0] !== index) {
+            this.sectionsList.setSelection([index]);
+        }
+        const focus = this.sectionsList.getFocus();
+        if (focus.length !== 1 || focus[0] !== index) {
+            this.sectionsList.setFocus([index]);
+        }
+    }
+    updateContentVisibility() {
+        this.contentNavigationGeneration++;
+        const isEditorMode = this.viewMode === "editor";
+        const isMigrationMode = this.viewMode === "migration";
+        const isMcpDetailMode = this.viewMode === "mcpDetail";
+        const isPluginDetailMode = this.viewMode === "pluginDetail";
+        const isToolsDetailMode = this.viewMode === "toolsDetail";
+        const isDetailMode = isMcpDetailMode || isPluginDetailMode || isToolsDetailMode;
+        const isWelcome = this.selectedSection === undefined;
+        const isPromptsSection = this.selectedSection !== undefined && this.isPromptsSection(this.selectedSection);
+        const isModelsSection = this.selectedSection === AICustomizationManagementSection.Models;
+        const isMcpSection = this.selectedSection === AICustomizationManagementSection.McpServers;
+        const isPluginsSection = this.selectedSection === AICustomizationManagementSection.Plugins;
+        const isToolsSection = this.selectedSection === AICustomizationManagementSection.Tools;
+        if (this.welcomePage) {
+            this.welcomePage.container.style.display = isWelcome && !isEditorMode && !isMigrationMode && !isDetailMode ? "" : "none";
+        }
+        if (this.promptsContentContainer) {
+            this.promptsContentContainer.style.display = !isEditorMode && !isMigrationMode && !isDetailMode && isPromptsSection ? "" : "none";
+        }
+        if (this.migrationContentContainer) {
+            this.migrationContentContainer.style.display = isMigrationMode ? "" : "none";
+        }
+        if (this.migrationShortcutButton) {
+            this.migrationShortcutButton.classList.toggle("selected", isMigrationMode);
+            if (isMigrationMode) {
+                this.migrationShortcutButton.setAttribute("aria-current", "page");
+            } else {
+                this.migrationShortcutButton.removeAttribute("aria-current");
+            }
+        }
+        if (this.modelsContentContainer) {
+            this.modelsContentContainer.style.display = !isEditorMode && !isMigrationMode && !isDetailMode && isModelsSection ? "" : "none";
+        }
+        if (this.mcpContentContainer) {
+            this.mcpContentContainer.style.display = !isEditorMode && !isMigrationMode && !isDetailMode && isMcpSection ? "" : "none";
+        }
+        this.mcpListWidget?.setVisible(!isEditorMode && !isMigrationMode && !isDetailMode && isMcpSection);
+        if (this.mcpDetailContainer) {
+            this.mcpDetailContainer.style.display = isMcpDetailMode ? "" : "none";
+        }
+        if (this.pluginContentContainer) {
+            this.pluginContentContainer.style.display = !isEditorMode && !isMigrationMode && !isDetailMode && isPluginsSection ? "" : "none";
+        }
+        this.pluginListWidget?.setVisible(!isEditorMode && !isMigrationMode && !isDetailMode && isPluginsSection);
+        if (this.pluginDetailContainer) {
+            this.pluginDetailContainer.style.display = isPluginDetailMode ? "" : "none";
+        }
+        if (this.toolsContentContainer) {
+            this.toolsContentContainer.style.display = !isEditorMode && !isMigrationMode && !isDetailMode && isToolsSection ? "" : "none";
+        }
+        if (this.toolsDetailContainer) {
+            this.toolsDetailContainer.style.display = isToolsDetailMode ? "" : "none";
+        }
+        for (const [section, container] of this.contributedSectionContainers) {
+            const visible = !isEditorMode && !isMigrationMode && !isDetailMode && this.selectedSection === section;
+            container.style.display = visible ? "" : "none";
+            if (visible) {
+                this.ensureContributedSectionWidget(section);
+            }
+        }
+        if (this.editorContentContainer) {
+            this.editorContentContainer.style.display = isEditorMode ? "" : "none";
+        }
+        if (isModelsSection && this.modelsWidget) {
+            this.modelsWidget.render();
+            if (this.dimension) {
+                this.layout(this.dimension);
+            }
+        }
+    }
+    ensureContributedSectionWidget(section) {
+        const existing = this.contributedSectionWidgets.get(section);
+        if (existing) {
+            return existing;
+        }
+        const contribution = aiCustomizationManagementSectionRegistry.get(section, this.harnessService.activeHarness.get());
+        const container = this.contributedSectionContainers.get(section);
+        if (!contribution || !container) {
+            return undefined;
+        }
+        const widget = contribution.create(this.instantiationService, container);
+        this.contributedSectionWidgets.set(section, widget);
+        this.editorDisposables.add(widget);
+        if (this.dimension) {
+            widget.layout?.(this.dimension);
+        }
+        return widget;
+    }
+    async createNewItemWithAI(type) {
+        this.telemetryService.publicLog2("chatCustomizationEditor.createItem", {
+            section: this.selectedSection ?? "welcome",
+            promptType: type,
+            creationMode: "ai",
+            target: "workspace"
+        });
+        if (this.input) {
+            this.group.closeEditor(this.input);
+        }
+        await this.workspaceService.generateCustomization(type);
+    }
+    async createNewItemManual(type, target, rootFileName) {
+        this.telemetryService.publicLog2("chatCustomizationEditor.createItem", {
+            section: this.selectedSection ?? "welcome",
+            promptType: type,
+            creationMode: "manual",
+            target: target === "workspace-root" ? "workspace" : target
+        });
+        if (target === "workspace-root") {
+            const projectRoot = this.workspaceService.getActiveProjectRoot();
+            if (!projectRoot) {
+                return;
+            }
+            const override = this.selectedSection ? this.harnessService.getActiveDescriptor().sectionOverrides?.get(this.selectedSection) : undefined;
+            const fileName = rootFileName ?? override?.rootFile ?? AGENT_MD_FILENAME;
+            const fileUri = URI.joinPath(projectRoot, fileName);
+            if (await this.fileService.exists(fileUri)) {
+                await this.showEmbeddedEditor(fileUri, fileName, PromptsType.instructions, PromptsStorage.local, true);
+            } else {
+                await this.fileService.createFile(fileUri);
+                await this.showEmbeddedEditor(fileUri, fileName, PromptsType.instructions, PromptsStorage.local, true);
+            }
+            this.listWidget.refresh();
+            return;
+        }
+        if (type === PromptsType.hook) {
+            const preferredStorage = target === "user" ? PromptsStorage.user : PromptsStorage.local;
+            if (this.workspaceService.isSessionsWindow) {
+                await this.instantiationService.invokeFunction(showConfigureHooksQuickPick, {
+                    openEditor: async resource => {
+                        await this.showEmbeddedEditor(
+                            resource,
+                            basename(resource),
+                            PromptsType.hook,
+                            preferredStorage,
+                            preferredStorage === PromptsStorage.local
+                        );
+                        return;
+                    },
+                    target: Target.GitHubCopilot,
+                    preferredStorage
+                });
+            } else {
+                await this.instantiationService.invokeFunction(showConfigureHooksQuickPick, {
+                    openEditor: async resource => {
+                        await this.showEmbeddedEditor(
+                            resource,
+                            basename(resource),
+                            PromptsType.hook,
+                            preferredStorage,
+                            preferredStorage === PromptsStorage.local
+                        );
+                        return;
+                    },
+                    preferredStorage
+                });
+            }
+            return;
+        }
+        const sessionResource = this.harnessService.activeSessionResource.get();
+        const picker = this.instantiationService.createInstance(CustomizationLocationPicker);
+        const targetDir = await picker.resolveTargetDirectoryWithPicker(sessionResource, type, target);
+        if (targetDir === null) {
+            return;
+        }
+        if (targetDir === undefined) {
+            await this.instantiationService.invokeFunction(showNoFoldersDialog, type);
+            return;
+        }
+        const override = this.selectedSection ? this.harnessService.getActiveDescriptor().sectionOverrides?.get(this.selectedSection) : undefined;
+        const options = {
+            targetFolder: targetDir,
+            targetStorage: target === AICustomizationSources.user ? PromptsStorage.user : PromptsStorage.local,
+            fileExtension: override?.fileExtension,
+            openFile: async uri => {
+                const isWorkspace = target === AICustomizationSources.local;
+                await this.showEmbeddedEditor(uri, basename(uri), type, target, isWorkspace);
+                return this.embeddedEditor;
+            }
+        };
+        let commandId;
+        switch (type) {
+        case PromptsType.prompt:
+            commandId = NEW_PROMPT_COMMAND_ID;
+            break;
+        case PromptsType.instructions:
+            commandId = NEW_INSTRUCTIONS_COMMAND_ID;
+            break;
+        case PromptsType.agent:
+            commandId = NEW_AGENT_COMMAND_ID;
+            break;
+        case PromptsType.skill:
+            commandId = NEW_SKILL_COMMAND_ID;
+            break;
+        default:
+            return;
+        }
+        await this.commandService.executeCommand(commandId, options);
+        this.listWidget.refresh();
+    }
+    updateStyles() {
+        this.splitView?.style({
+            separatorBorder: Color.transparent
+        });
+    }
+    async setInput(input, options, context, token) {
+        this.workspaceService.clearOverrideProjectRoot();
+        this.inEditorContextKey.set(true);
+        this.sectionContextKey.set(this.selectedSection ?? "");
+        input.setSaveHandler(() => this.handleBuiltinSave());
+        this.telemetryService.publicLog2("chatCustomizationEditor.opened", {
+            section: this.selectedSection ?? "welcome"
+        });
+        await super.setInput(input, options, context, token);
+        input.setTargetLabels(
+            this.getActiveHarnessLabel(),
+            this.workspaceService.activeProjectLabel.get()
+        );
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    clearInput() {
+        const input = this.input;
+        if (input instanceof AICustomizationManagementEditorInput) {
+            input.setSaveHandler(undefined);
+            input.setDirty(false);
+        }
+        this.inEditorContextKey.set(false);
+        if (this.viewMode === "editor") {
+            this.goBackToList();
+        }
+        if (this.viewMode === "migration") {
+            this.viewMode = "list";
+        }
+        if (this.viewMode === "mcpDetail") {
+            this.goBackFromMcpDetail();
+        }
+        if (this.viewMode === "pluginDetail") {
+            this.goBackFromPluginDetail();
+        }
+        if (this.viewMode === "toolsDetail") {
+            this.goBackFromToolDetail();
+        }
+        this.workspaceService.clearOverrideProjectRoot();
+        this.disposeBuiltinEditingSessions();
+        super.clearInput();
+    }
+    setEditorVisible(visible) {
+        super.setEditorVisible(visible);
+        if (visible && this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        if (this.container && this.splitView) {
+            this.splitViewContainer.style.height = `${dimension.height}px`;
+            this.splitView.layout(dimension.width, dimension.height);
+        }
+        for (const widget of ( this.contributedSectionWidgets.values())) {
+            widget.layout?.(dimension);
+        }
+        if (this.viewMode === "migration") {
+            this.scheduleMigrationSectionLayout();
+        }
+        if (this.migrationContentContainer) {
+            const migrationWidth = this.migrationContentContainer.offsetWidth || dimension.width;
+            this.migrationContentContainer.classList.toggle("narrow-layout", migrationWidth < 500);
+        }
+        this.migrationListScrollable?.scanDomNode();
+        this.migrationDashboardScrollable?.scanDomNode();
+    }
+    focus() {
+        super.focus();
+        if (this.viewMode === "editor") {
+            if (this.editorDisplayMode === "raw") {
+                this.embeddedEditor?.focus();
+            } else {
+                this.editorModeButton?.focus();
+            }
+            return;
+        }
+        if (this.viewMode === "migration") {
+            this.focusCustomizationMigrationPage();
+            return;
+        }
+        if (this.selectedSection === undefined) {
+            this.welcomePage?.focus();
+            return;
+        }
+        if (this.selectedSection === AICustomizationManagementSection.McpServers) {
+            this.mcpListWidget?.focusSearch();
+        } else if (this.selectedSection === AICustomizationManagementSection.Plugins) {
+            this.pluginListWidget?.focusSearch();
+        } else if (this.selectedSection === AICustomizationManagementSection.Models) {
+            this.modelsWidget?.focusSearch();
+        } else if (this.selectedSection === AICustomizationManagementSection.Tools) {
+            this.toolsListWidget?.focusSearch();
+        } else if (this.selectedSection && ( this.contributedSectionContainers.has(this.selectedSection))) {
+            this.ensureContributedSectionWidget(this.selectedSection)?.focus?.();
+        } else {
+            this.listWidget?.focusSearch();
+        }
+    }
+    selectSectionById(sectionId, options) {
+        const index = this.sections.findIndex(s => s.id === sectionId);
+        if (index >= 0) {
+            if (this.viewMode === "editor") {
+                this.goBackToList();
+            }
+            if (this.viewMode === "migration") {
+                this.viewMode = "list";
+            }
+            if (this.viewMode === "mcpDetail") {
+                this.goBackFromMcpDetail();
+            }
+            if (this.viewMode === "pluginDetail") {
+                this.goBackFromPluginDetail();
+            }
+            if (this.viewMode === "toolsDetail") {
+                this.goBackFromToolDetail();
+            }
+            this.selectedSection = sectionId;
+            this.sectionContextKey.set(sectionId);
+            this.storageService.store(
+                AI_CUSTOMIZATION_MANAGEMENT_SELECTED_SECTION_KEY,
+                sectionId,
+                StorageScope.PROFILE,
+                StorageTarget.USER
+            );
+            this.updateContentVisibility();
+            if (this.isPromptsSection(sectionId)) {
+                void this.listWidget.setSection(sectionId);
+            }
+            if (this.dimension) {
+                this.layout(this.dimension);
+            }
+            this.ensureSectionsListReflectsActiveSection(sectionId);
+            if (options?.showMarketplace) {
+                if (sectionId === AICustomizationManagementSection.McpServers) {
+                    this.mcpListWidget?.showBrowseMarketplace();
+                } else if (sectionId === AICustomizationManagementSection.Plugins) {
+                    this.pluginListWidget?.showBrowseMarketplace();
+                }
+            }
+        }
+    }
+    prepareCustomizationMigrationView() {
+        if (this.viewMode === "editor") {
+            this.goBackToList();
+        }
+        if (this.viewMode === "mcpDetail") {
+            this.goBackFromMcpDetail();
+        }
+        if (this.viewMode === "pluginDetail") {
+            this.goBackFromPluginDetail();
+        }
+        if (this.viewMode === "toolsDetail") {
+            this.goBackFromToolDetail();
+        }
+        this.selectedSection = undefined;
+        this.sectionContextKey.set("");
+        this.viewMode = "migration";
+        this.ensureSectionsListReflectsActiveSection(undefined);
+    }
+    showCustomizationMigrationDashboard() {
+        this.prepareCustomizationMigrationView();
+        this.activeMigrationCategoryId = undefined;
+        this.activeMigrationStorage = undefined;
+        this.renderCustomizationMigrationPage();
+        this.updateContentVisibility();
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        if (this.migrationContentContainer) {
+            getWindow(this.migrationContentContainer).requestAnimationFrame(() => this.focusCustomizationMigrationPage());
+        }
+    }
+    async showCustomizationMigrationPage(categoryId, storage) {
+        if (!categoryId) {
+            await this.refreshCustomizationMigrationInfo();
+            this.showCustomizationMigrationDashboard();
+            return;
+        }
+        if (!this.isMigrationCategoryEnabled(getCustomizationMigrationCategory(categoryId))) {
+            return;
+        }
+        this.prepareCustomizationMigrationView();
+        this.activeMigrationCategoryId = categoryId;
+        this.activeMigrationStorage = storage;
+        if (this.migrationClearSettingsCheckbox) {
+            this.migrationClearSettingsCheckbox.checked = true;
+        }
+        this.renderCustomizationMigrationPage();
+        this.updateContentVisibility();
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        if (this.migrationContentContainer) {
+            getWindow(this.migrationContentContainer).requestAnimationFrame(() => this.focusCustomizationMigrationPage());
+        }
+    }
+    refreshList() {
+        this.listWidget.refresh();
+    }
+    async revealCustomizationByUri(uri) {
+        if (!this.isPromptsSection(this.selectedSection)) {
+            return;
+        }
+        for (let attempt = 0; attempt < 10; attempt++) {
+            if (this.listWidget.revealAndSelectFirstItemByUri([uri])) {
+                return;
+            }
+            if (attempt === 0) {
+                this.listWidget.clearSearch();
+            }
+            await timeout(100);
+        }
+    }
+    revealLastItem() {
+        if (this.selectedSection === AICustomizationManagementSection.McpServers) {
+            this.mcpListWidget?.revealLastItem();
+        } else if (this.selectedSection === AICustomizationManagementSection.Plugins) {
+            this.pluginListWidget?.revealLastItem();
+        } else {
+            this.listWidget.revealLastItem();
+        }
+    }
+    async generateDebugReport() {
+        return this.listWidget.generateDebugReport();
+    }
+    createEmbeddedEditor() {
+        if (!this.editorContentContainer) {
+            return;
+        }
+        const editorHeader = append(this.editorContentContainer, $(".editor-header"));
+        this.editorActionButton = append(editorHeader, $("button.editor-back-button"));
+        this.editorActionButton.setAttribute("aria-label", ( localize(8624, "Back to list")));
+        this.editorDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("element"),
+            this.editorActionButton,
+            ( localize(8625, "Back to list"))
+        ));
+        this.editorActionButtonIcon = append(
+            this.editorActionButton,
+            $(`.codicon.codicon-${Codicon.arrowLeft.id}.editor-action-button-icon`)
+        );
+        this.editorActionButtonIcon.setAttribute("aria-hidden", "true");
+        this.editorDisposables.add(addDisposableListener(this.editorActionButton, "click", () => {
+            void this.handleEditorActionButton().catch(error => {
+                console.error("Failed to handle editor back action:", error);
+                this.notificationService.error(( localize(8626, "Failed to finish the prompt action.")));
+            });
+        }));
+        const itemInfo = append(editorHeader, $(".editor-item-info"));
+        this.editorItemNameElement = append(itemInfo, $(".editor-item-name"));
+        this.editorItemPathElement = append(itemInfo, $(".editor-item-path"));
+        this.editorModeButton = append(editorHeader, $("button.editor-mode-button"));
+        this.editorModeButton.type = "button";
+        this.editorModeButton.setAttribute("aria-pressed", "false");
+        this.editorDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("element"),
+            this.editorModeButton,
+            () => this.getEditorModeButtonTooltip()
+        ));
+        this.editorDisposables.add(addDisposableListener(this.editorModeButton, "click", () => {
+            this.toggleEditorDisplayMode();
+        }));
+        this.editorSaveIndicator = append(editorHeader, $(".editor-save-indicator"));
+        this.editorPreviewContainer = append(this.editorContentContainer, $(".editor-preview-container"));
+        this.editorPreviewScrollContainer = append(this.editorPreviewContainer, $(".editor-preview-scroll-container"));
+        this.editorPreviewScrollContainer.setAttribute("role", "region");
+        this.editorPreviewScrollContainer.setAttribute("aria-label", ( localize(8627, "Customization preview")));
+        this.editorPreviewIssuesContainer = append(this.editorPreviewScrollContainer, $(".editor-preview-issues"));
+        const frontMatterSection = append(
+            this.editorPreviewScrollContainer,
+            $(".editor-preview-section.editor-preview-frontmatter-section")
+        );
+        this.editorPreviewFrontMatterContainer = append(frontMatterSection, $(".editor-preview-frontmatter-list"));
+        const bodySection = append(
+            this.editorPreviewScrollContainer,
+            $(".editor-preview-section.editor-preview-body-section")
+        );
+        this.editorPreviewBodyContainer = append(bodySection, $(".editor-preview-body-content"));
+        this.embeddedEditorContainer = append(this.editorContentContainer, $(".embedded-editor-container"));
+        const overflowWidgetsDomNode = append(
+            this.editorContentContainer,
+            $(".embedded-editor-overflow-widgets.monaco-editor")
+        );
+        this.editorDisposables.add(toDisposable(() => overflowWidgetsDomNode.remove()));
+        this.embeddedEditor = this.editorDisposables.add(
+            this.instantiationService.createInstance(CodeEditorWidget, this.embeddedEditorContainer, {
+                ...getSimpleEditorOptions(this.configurationService),
+                readOnly: false,
+                minimap: {
+                    enabled: false
+                },
+                lineNumbers: "on",
+                wordWrap: "on",
+                scrollBeyondLastLine: false,
+                automaticLayout: false,
+                folding: true,
+                renderLineHighlight: "all",
+                scrollbar: {
+                    vertical: "auto",
+                    horizontal: "auto"
+                },
+                overflowWidgetsDomNode
+            }, {
+                isSimpleWidget: false
+            })
+        );
+        this.updateEditorDisplayMode();
+    }
+    async showEmbeddedEditor(
+        uri,
+        displayName,
+        promptType,
+        source,
+        isWorkspaceFile = false,
+        isReadOnly = false
+    ) {
+        if (!hasReadableCustomizationContent(uri)) {
+            return;
+        }
+        this.editorReturnViewMode = this.viewMode === "migration" ? "migration" : "list";
+        this.currentModelRef?.dispose();
+        this.currentModelRef = undefined;
+        this.editorModelChangeDisposables.clear();
+        this.editorPreviewDisposables.clear();
+        this.editorPreviewRenderScheduler.cancel();
+        this.currentEditingUri = uri;
+        this.currentEditingProjectRoot = isWorkspaceFile ? this.workspaceService.getActiveProjectRoot() : undefined;
+        this.currentEditingSource = source;
+        this.currentEditingPromptType = promptType;
+        this.currentEditingReadOnly = isReadOnly;
+        this.editorDisplayMode = this.isStructuredPreviewSupported(promptType) ? "preview" : "raw";
+        this.viewMode = "editor";
+        this.editorItemNameElement.textContent = displayName;
+        this.editorItemPathElement.textContent = basename(uri);
+        this._editorContentChanged = false;
+        this.resetEditorSaveIndicator();
+        this.updateEditorActionButton();
+        this.updateEditorDisplayMode();
+        this.updateContentVisibility();
+        try {
+            if (source === AICustomizationSources.builtin && (promptType === PromptsType.prompt || promptType === PromptsType.skill)) {
+                const session = await this.getOrCreateBuiltinEditingSession(uri);
+                if (!isEqual(this.currentEditingUri, uri)) {
+                    return;
+                }
+                this.embeddedEditor.setModel(session.model);
+                this.embeddedEditor.updateOptions({
+                    readOnly: false
+                });
+                this._editorContentChanged = session.model.getValue() !== session.originalContent;
+                this.renderCurrentEditorPreview();
+                this.updateEditorActionButton();
+                if (this.dimension) {
+                    this.layout(this.dimension);
+                }
+                if (this.editorDisplayMode === "raw") {
+                    this.embeddedEditor.focus();
+                } else {
+                    this.editorModeButton?.focus();
+                }
+                this.editorModelChangeDisposables.add(session.model.onDidChangeContent(() => {
+                    this._editorContentChanged = session.model.getValue() !== session.originalContent;
+                    this.scheduleCurrentEditorPreviewRender();
+                    this.updateEditorActionButton();
+                }));
+                return;
+            }
+            const ref = await this.textModelService.createModelReference(uri);
+            if (!isEqual(this.currentEditingUri, uri)) {
+                ref.dispose();
+                return;
+            }
+            this.currentModelRef = ref;
+            this.embeddedEditor.setModel(ref.object.textEditorModel);
+            this.embeddedEditor.updateOptions({
+                readOnly: isReadOnly
+            });
+            this.renderCurrentEditorPreview();
+            if (this.dimension) {
+                this.layout(this.dimension);
+            }
+            if (this.editorDisplayMode === "raw") {
+                this.embeddedEditor.focus();
+            } else {
+                this.editorModeButton?.focus();
+            }
+            this._editorContentChanged = this.workingCopyService.isDirty(uri);
+            this.editorModelChangeDisposables.add(ref.object.textEditorModel.onDidChangeContent(() => {
+                this._editorContentChanged = true;
+                this.scheduleCurrentEditorPreviewRender();
+                this.resetEditorSaveIndicator();
+            }));
+            this.editorModelChangeDisposables.add(this.workingCopyService.onDidSave(e => {
+                if (isEqual(e.workingCopy.resource, uri)) {
+                    this._editorContentChanged = this.workingCopyService.isDirty(uri);
+                    this.editorSaveIndicator.className = "editor-save-indicator visible saved";
+                    this.editorSaveIndicator.classList.add(...ThemeIcon.asClassNameArray(Codicon.check));
+                    this.editorSaveIndicator.title = ( localize(8628, "Saved"));
+                    this.editorSaveIndicator.setAttribute("aria-label", ( localize(8628, "Saved")));
+                    status(( localize(8628, "Saved")));
+                }
+            }));
+        } catch (error) {
+            console.error("Failed to load model for embedded editor:", error);
+            if (isEqual(this.currentEditingUri, uri)) {
+                this.goBackToList();
+            }
+        }
+    }
+    goBackToList() {
+        const returnViewMode = this.editorReturnViewMode;
+        this.editorReturnViewMode = "list";
+        const fileUri = this.currentEditingUri;
+        const backgroundSaveRequest = this.createExistingCustomizationSaveRequest();
+        if (backgroundSaveRequest) {
+            this.telemetryService.publicLog2("chatCustomizationEditor.saveItem", {
+                promptType: this.currentEditingPromptType ?? "",
+                storage: String(this.currentEditingSource ?? ""),
+                saveTarget: "existing"
+            });
+        }
+        if (fileUri && this.currentEditingSource === AICustomizationSources.builtin) {
+            this.disposeBuiltinEditingSession(fileUri);
+        }
+        this.currentModelRef?.dispose();
+        this.currentModelRef = undefined;
+        this.currentEditingUri = undefined;
+        this.currentEditingProjectRoot = undefined;
+        this.currentEditingSource = undefined;
+        this.currentEditingPromptType = undefined;
+        this.currentEditingReadOnly = false;
+        this.editorDisplayMode = "preview";
+        this._editorContentChanged = false;
+        this.editorModelChangeDisposables.clear();
+        this.editorPreviewRenderScheduler.cancel();
+        this.clearEditorPreview();
+        this.resetEditorSaveIndicator();
+        this.updateEditorActionButton();
+        this.updateEditorDisplayMode();
+        this.embeddedEditor?.setModel(null);
+        this.viewMode = returnViewMode;
+        this.updateContentVisibility();
+        if (returnViewMode === "migration") {
+            this.renderCustomizationMigrationPage();
+            void this.refreshCustomizationMigrationInfo();
+        } else {
+            void this.listWidget?.refresh();
+        }
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        if (returnViewMode === "migration") {
+            this.focusCustomizationMigrationPage();
+        } else {
+            this.listWidget?.focusSearch();
+        }
+        if (backgroundSaveRequest) {
+            const saveRequest = backgroundSaveRequest;
+            void this.saveExistingCustomization(saveRequest).catch(error => {
+                console.error("Failed to save customization changes on exit:", error);
+                this.notificationService.warn(( localize(8629, "Could not save changes to {0}.", basename(saveRequest.fileUri))));
+            });
+        }
+    }
+    focusCustomizationMigrationPage() {
+        if (this.activeMigrationCategoryId !== undefined) {
+            (this.migrationFirstFocusableElement ?? this.migrationLinkElement ?? this.migrationMigrateButton?.element)?.focus();
+        } else {
+            this.migrationDashboard?.focus();
+        }
+    }
+    async getOrCreateBuiltinEditingSession(uri) {
+        const key = ( uri.toString());
+        const existing = this.builtinEditingSessions.get(key);
+        if (existing && !existing.model.isDisposed()) {
+            return existing;
+        }
+        const ref = await this.textModelService.createModelReference(uri);
+        try {
+            const session = {
+                model: this.modelService.createModel(
+                    createTextBufferFactoryFromSnapshot(ref.object.textEditorModel.createSnapshot()),
+                    {
+                        languageId: ref.object.textEditorModel.getLanguageId(),
+                        onDidChange: Event.None
+                    },
+                    ( URI.from({
+                        scheme: "ai-customization-builtin",
+                        path: uri.path,
+                        query: generateUuid()
+                    })),
+                    false
+                ),
+                originalContent: ref.object.textEditorModel.getValue()
+            };
+            this.builtinEditingSessions.set(key, session);
+            return session;
+        } finally {
+            ref.dispose();
+        }
+    }
+    createBuiltinPromptSaveRequest(target) {
+        const sourceUri = this.currentEditingUri;
+        const promptType = this.currentEditingPromptType;
+        if (!sourceUri || this.currentEditingSource !== AICustomizationSources.builtin || (promptType !== PromptsType.prompt && promptType !== PromptsType.skill) || !target.folder || target.target === "cancel") {
+            return;
+        }
+        const session = this.builtinEditingSessions.get(( sourceUri.toString()));
+        if (!session || !this._editorContentChanged) {
+            return;
+        }
+        return {
+            target: target.target,
+            folder: target.folder,
+            sourceUri,
+            content: session.model.getValue(),
+            promptType,
+            projectRoot: target.target === "workspace" ? this.workspaceService.getActiveProjectRoot() : undefined
+        };
+    }
+    createExistingCustomizationSaveRequest() {
+        if (!this._editorContentChanged || this.currentEditingSource === AICustomizationSources.builtin || !this.currentEditingUri) {
+            return undefined;
+        }
+        const model = this.currentModelRef?.object.textEditorModel;
+        if (!model) {
+            return undefined;
+        }
+        return {
+            fileUri: this.currentEditingUri,
+            content: model.getValue(),
+            projectRoot: this.currentEditingProjectRoot
+        };
+    }
+    async saveBuiltinPromptCopy(request) {
+        let targetUri;
+        if (request.promptType === PromptsType.skill) {
+            const skillFolderName = basename(dirname(request.sourceUri));
+            targetUri = URI.joinPath(request.folder, skillFolderName, basename(request.sourceUri));
+        } else {
+            targetUri = URI.joinPath(request.folder, basename(request.sourceUri));
+        }
+        await this.fileService.createFolder(dirname(targetUri));
+        await this.fileService.writeFile(targetUri, VSBuffer.fromString(request.content));
+        if (request.target === "workspace" && request.projectRoot) {
+            await this.workspaceService.commitFiles(request.projectRoot, [targetUri]);
+        }
+    }
+    async saveExistingCustomization(request) {
+        await this.fileService.writeFile(request.fileUri, VSBuffer.fromString(request.content));
+        if (request.projectRoot) {
+            await this.workspaceService.commitFiles(request.projectRoot, [request.fileUri]);
+        }
+    }
+    async pickBuiltinPromptSaveTarget() {
+        const items = [];
+        const promptType = this.currentEditingPromptType ?? PromptsType.prompt;
+        const workspaceFolder = resolveWorkspaceTargetDirectory(this.workspaceService, promptType);
+        if (workspaceFolder) {
+            items.push({
+                label: ( localize(8630, "Workspace")),
+                description: this.labelService.getUriLabel(workspaceFolder, {
+                    relative: true
+                }),
+                target: "workspace",
+                folder: workspaceFolder
+            });
+        }
+        const userFolder = await resolveUserTargetDirectory(this.promptsService, promptType);
+        if (userFolder) {
+            items.push({
+                label: ( localize(8631, "User")),
+                description: this.labelService.getUriLabel(userFolder, {
+                    relative: true
+                }),
+                target: "user",
+                folder: userFolder
+            });
+        }
+        items.push({
+            label: ( localize(8632, "Cancel")),
+            target: "cancel"
+        });
+        return this.quickInputService.pick(items, {
+            canPickMany: false,
+            placeHolder: ( localize(8633, "Select Workspace, User, or Cancel")),
+            matchOnDescription: true
+        });
+    }
+    async handleEditorActionButton() {
+        if (this.editorActionButtonInProgress) {
+            return;
+        }
+        this.editorActionButtonInProgress = true;
+        this.updateEditorActionButton();
+        let backgroundSaveRequest;
+        try {
+            if (this.shouldShowBuiltinSaveAction()) {
+                const selection = await this.pickBuiltinPromptSaveTarget();
+                if (!selection || selection.target === "cancel") {
+                    return;
+                }
+                backgroundSaveRequest = this.createBuiltinPromptSaveRequest(selection);
+                if (backgroundSaveRequest) {
+                    this.telemetryService.publicLog2("chatCustomizationEditor.saveItem", {
+                        promptType: this.currentEditingPromptType ?? "",
+                        storage: String(this.currentEditingSource ?? ""),
+                        saveTarget: selection.target
+                    });
+                }
+            }
+            this.goBackToList();
+            if (backgroundSaveRequest) {
+                const saveRequest = backgroundSaveRequest;
+                void this.saveBuiltinPromptCopy(saveRequest).then(() => {
+                    void this.listWidget?.refresh();
+                }, error => {
+                    console.error("Failed to save built-in override:", error);
+                    this.notificationService.warn(saveRequest.target === "workspace" ? ( localize(8634, "Could not save the override to the workspace.")) : ( localize(8635, "Could not save the override to your user folder.")));
+                });
+            }
+        } finally {
+            this.editorActionButtonInProgress = false;
+            this.updateEditorActionButton();
+        }
+    }
+    updateEditorActionButton() {
+        this.updateInputDirtyState();
+        if (!this.editorActionButton || !this.editorActionButtonIcon) {
+            return;
+        }
+        const shouldShowBuiltinSaveAction = this.shouldShowBuiltinSaveAction();
+        this.editorActionButtonIcon.className = `codicon codicon-${shouldShowBuiltinSaveAction ? Codicon.save.id : Codicon.arrowLeft.id} editor-action-button-icon`;
+        this.editorActionButton.disabled = this.editorActionButtonInProgress;
+        this.editorActionButton.setAttribute("aria-label", shouldShowBuiltinSaveAction ? ( localize(8636, "Save override")) : this.editorReturnViewMode === "migration" ? (this.getActiveMigrationCategory()?.backLabel ?? ( localize(8637, "Back to migration"))) : ( localize(8624, "Back to list")));
+        this.editorActionButton.title = shouldShowBuiltinSaveAction ? ( localize(8638, "Save override (choose Workspace, User, or Cancel)")) : this.editorReturnViewMode === "migration" ? (this.getActiveMigrationCategory()?.backLabel ?? ( localize(8637, "Back to migration"))) : ( localize(8624, "Back to list"));
+    }
+    shouldShowBuiltinSaveAction() {
+        return this._editorContentChanged && this.currentEditingSource === AICustomizationSources.builtin && (this.currentEditingPromptType === PromptsType.prompt || this.currentEditingPromptType === PromptsType.skill);
+    }
+    updateInputDirtyState() {
+        const input = this.input;
+        if (input instanceof AICustomizationManagementEditorInput) {
+            input.setDirty(this.shouldShowBuiltinSaveAction());
+        }
+    }
+    async handleBuiltinSave() {
+        if (!this.shouldShowBuiltinSaveAction()) {
+            return false;
+        }
+        const target = await this.pickBuiltinPromptSaveTarget();
+        if (!target || target.target === "cancel") {
+            return false;
+        }
+        const saveRequest = this.createBuiltinPromptSaveRequest(target);
+        if (!saveRequest) {
+            return false;
+        }
+        try {
+            await this.saveBuiltinPromptCopy(saveRequest);
+            this.telemetryService.publicLog2("chatCustomizationEditor.saveItem", {
+                promptType: this.currentEditingPromptType ?? "",
+                storage: String(this.currentEditingSource ?? ""),
+                saveTarget: target.target
+            });
+            this._editorContentChanged = false;
+            this.updateEditorActionButton();
+            return true;
+        } catch (error) {
+            console.error("Failed to save built-in override:", error);
+            this.notificationService.warn(target.target === "workspace" ? ( localize(8634, "Could not save the override to the workspace.")) : ( localize(8635, "Could not save the override to your user folder.")));
+            return false;
+        }
+    }
+    resetEditorSaveIndicator() {
+        this.editorSaveIndicator.className = "editor-save-indicator";
+        this.editorSaveIndicator.title = "";
+        this.editorSaveIndicator.removeAttribute("aria-label");
+    }
+    isStructuredPreviewSupported(promptType) {
+        if (this.configurationService.getValue(ChatConfiguration.ChatCustomizationsStructuredPreviewEnabled) !== true) {
+            return false;
+        }
+        return promptType === PromptsType.agent || promptType === PromptsType.skill || promptType === PromptsType.instructions || promptType === PromptsType.prompt;
+    }
+    onStructuredPreviewSettingChanged() {
+        if (this.viewMode !== "editor") {
+            return;
+        }
+        const supportsStructuredPreview = this.isStructuredPreviewSupported(this.currentEditingPromptType);
+        if (!supportsStructuredPreview) {
+            this.editorDisplayMode = "raw";
+            this.editorPreviewRenderScheduler.cancel();
+            this.clearEditorPreview();
+        } else if (this.editorDisplayMode === "preview") {
+            this.editorPreviewRenderScheduler.schedule();
+        }
+        this.updateEditorDisplayMode();
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    getCurrentEditingModel() {
+        if (!this.currentEditingUri) {
+            return undefined;
+        }
+        if (this.currentEditingSource === AICustomizationSources.builtin) {
+            return this.builtinEditingSessions.get(( this.currentEditingUri.toString()))?.model;
+        }
+        return this.currentModelRef?.object.textEditorModel;
+    }
+    toggleEditorDisplayMode() {
+        if (!this.isStructuredPreviewSupported(this.currentEditingPromptType)) {
+            return;
+        }
+        this.editorDisplayMode = this.editorDisplayMode === "preview" ? "raw" : "preview";
+        if (this.editorDisplayMode === "preview") {
+            this.editorPreviewRenderScheduler.cancel();
+            this.renderCurrentEditorPreview();
+        }
+        this.updateEditorDisplayMode();
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        if (this.editorDisplayMode === "raw") {
+            this.embeddedEditor?.focus();
+        } else {
+            this.editorModeButton?.focus();
+        }
+    }
+    updateEditorDisplayMode() {
+        const supportsStructuredPreview = this.isStructuredPreviewSupported(this.currentEditingPromptType);
+        const showPreview = supportsStructuredPreview && this.editorDisplayMode === "preview";
+        if (this.editorModeButton) {
+            this.editorModeButton.style.display = supportsStructuredPreview ? "" : "none";
+            this.editorModeButton.textContent = this.getEditorModeButtonLabel();
+            this.editorModeButton.setAttribute("aria-label", this.getEditorModeButtonTooltip());
+            this.editorModeButton.setAttribute("aria-pressed", String(this.editorDisplayMode === "raw"));
+            this.editorModeButton.title = this.getEditorModeButtonTooltip();
+        }
+        if (this.editorPreviewContainer) {
+            this.editorPreviewContainer.style.display = showPreview ? "" : "none";
+        }
+        if (this.embeddedEditorContainer) {
+            this.embeddedEditorContainer.style.display = showPreview ? "none" : "";
+        }
+    }
+    getEditorModeButtonLabel() {
+        if (!this.isStructuredPreviewSupported(this.currentEditingPromptType)) {
+            return "";
+        }
+        if (this.editorDisplayMode === "raw") {
+            return localize(8639, "Preview");
+        }
+        return this.canEditCurrentRaw() ? ( localize(8640, "Edit")) : ( localize(8641, "View Raw"));
+    }
+    getEditorModeButtonTooltip() {
+        if (!this.isStructuredPreviewSupported(this.currentEditingPromptType)) {
+            return "";
+        }
+        if (this.editorDisplayMode === "raw") {
+            return localize(8642, "Show structured preview");
+        }
+        return this.canEditCurrentRaw() ? ( localize(8643, "Edit the raw markdown file")) : ( localize(8644, "Show the raw markdown file"));
+    }
+    canEditCurrentRaw() {
+        const promptType = this.currentEditingPromptType;
+        if (!promptType) {
+            return false;
+        }
+        return (this.currentEditingSource === AICustomizationSources.builtin && (promptType === PromptsType.prompt || promptType === PromptsType.skill)) || !this.currentEditingReadOnly;
+    }
+    scheduleCurrentEditorPreviewRender() {
+        if (this.editorDisplayMode !== "preview") {
+            return;
+        }
+        this.editorPreviewRenderScheduler.schedule();
+    }
+    renderCurrentEditorPreview() {
+        const model = this.getCurrentEditingModel();
+        const promptType = this.currentEditingPromptType;
+        if (!model || !promptType || this.editorDisplayMode !== "preview" || !this.isStructuredPreviewSupported(promptType)) {
+            this.clearEditorPreview();
+            return;
+        }
+        const parsedPromptFile = this.promptsService.getParsedPromptFile(model);
+        this.renderEditorPreview(parsedPromptFile, promptType);
+    }
+    renderEditorPreview(parsedPromptFile, promptType) {
+        if (!this.editorPreviewIssuesContainer || !this.editorPreviewFrontMatterContainer || !this.editorPreviewBodyContainer) {
+            return;
+        }
+        this.editorPreviewDisposables.clear();
+        clearNode(this.editorPreviewIssuesContainer);
+        clearNode(this.editorPreviewFrontMatterContainer);
+        clearNode(this.editorPreviewBodyContainer);
+        const target = getTarget(promptType, parsedPromptFile.header ?? parsedPromptFile.uri);
+        this.renderPreviewIssues(parsedPromptFile);
+        this.renderPreviewFrontMatter(parsedPromptFile, promptType, target);
+        this.renderPreviewBody(parsedPromptFile);
+    }
+    renderPreviewIssues(parsedPromptFile) {
+        if (!this.editorPreviewIssuesContainer || !parsedPromptFile.header?.errors.length) {
+            return;
+        }
+        const issuesContainer = append(this.editorPreviewIssuesContainer, $(".editor-preview-issues-box"));
+        append(issuesContainer, $("div.editor-preview-issues-title")).textContent = ( localize(8645, "Header issues detected"));
+        append(issuesContainer, $("div.editor-preview-issues-description")).textContent = ( localize(8646, "Switch to raw view to fix invalid or unsupported metadata entries."));
+        const list = append(issuesContainer, $("ul.editor-preview-issues-list"));
+        for (const error of parsedPromptFile.header.errors) {
+            append(list, $("li.editor-preview-issues-item")).textContent = error.message;
+        }
+    }
+    renderPreviewFrontMatter(parsedPromptFile, promptType, target) {
+        if (!this.editorPreviewFrontMatterContainer) {
+            return;
+        }
+        const attributes = parsedPromptFile.header?.attributes ?? [];
+        if (!attributes.length) {
+            append(
+                this.editorPreviewFrontMatterContainer,
+                $("div.editor-preview-empty-state")
+            ).textContent = ( localize(8647, "No metadata found in this file."));
+            return;
+        }
+        for (const attribute of attributes) {
+            this.renderPreviewAttribute(attribute, promptType, target);
+        }
+    }
+    renderPreviewAttribute(attribute, promptType, target) {
+        if (!this.editorPreviewFrontMatterContainer) {
+            return;
+        }
+        const row = append(this.editorPreviewFrontMatterContainer, $(".editor-preview-row"));
+        const header = append(row, $(".editor-preview-row-header"));
+        append(header, $("div.editor-preview-row-key")).textContent = attribute.key;
+        const helpButton = append(header, $("button.editor-preview-row-help"));
+        helpButton.type = "button";
+        helpButton.setAttribute("aria-label", ( localize(8648, "Show help for '{0}'", attribute.key)));
+        const helpIcon = append(helpButton, $("span.editor-preview-row-help-icon"));
+        helpIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.info));
+        helpIcon.setAttribute("aria-hidden", "true");
+        const description = getAttributeDefinition(attribute.key, promptType, target)?.description ?? ( localize(8649, "Custom metadata field `{0}`.", attribute.key));
+        const helpHover = this.editorPreviewDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), helpButton, {
+                markdown: ( new MarkdownString(description)),
+                markdownNotSupportedFallback: description
+            })
+        );
+        this.editorPreviewDisposables.add(addDisposableListener(helpButton, "click", e => {
+            e.preventDefault();
+            e.stopPropagation();
+            helpHover.show(true);
+        }));
+        const valueElement = append(row, $("div.editor-preview-row-value"));
+        const valueText = this.stringifyPreviewValue(attribute.value);
+        valueElement.textContent = valueText;
+        valueElement.classList.toggle("multiline", valueText.includes("\n"));
+    }
+    renderPreviewBody(parsedPromptFile) {
+        if (!this.editorPreviewBodyContainer) {
+            return;
+        }
+        const bodyContent = parsedPromptFile.body?.getContent() ?? "";
+        if (!bodyContent.trim()) {
+            append(this.editorPreviewBodyContainer, $("div.editor-preview-empty-state")).textContent = ( localize(8650, "No markdown body found in this file."));
+            return;
+        }
+        const markdown = ( new MarkdownString(bodyContent, {
+            supportThemeIcons: true
+        }));
+        markdown.baseUri = parsedPromptFile.uri;
+        const renderedMarkdown = this.editorPreviewDisposables.add(this.markdownRendererService.render(markdown));
+        this.editorPreviewBodyContainer.appendChild(renderedMarkdown.element);
+    }
+    stringifyPreviewValue(value) {
+        switch (value.type) {
+        case "scalar":
+            return value.value;
+        case "sequence":
+            if (value.items.every(item => item.type === "scalar")) {
+                return value.items.map(item => item.value).join("\n");
+            }
+            return JSON.stringify(this.toPreviewObject(value), null, 2);
+        case "map":
+            return JSON.stringify(this.toPreviewObject(value), null, 2);
+        }
+    }
+    toPreviewObject(value) {
+        switch (value.type) {
+        case "scalar":
+            return value.value;
+        case "sequence":
+            return value.items.map(item => this.toPreviewObject(item));
+        case "map":
+            {
+                const entries = {};
+                for (const property of value.properties) {
+                    entries[property.key.value] = this.toPreviewObject(property.value);
+                }
+                return entries;
+            }
+        }
+    }
+    clearEditorPreview() {
+        this.editorPreviewRenderScheduler.cancel();
+        this.editorPreviewDisposables.clear();
+        if (this.editorPreviewIssuesContainer) {
+            clearNode(this.editorPreviewIssuesContainer);
+        }
+        if (this.editorPreviewFrontMatterContainer) {
+            clearNode(this.editorPreviewFrontMatterContainer);
+        }
+        if (this.editorPreviewBodyContainer) {
+            clearNode(this.editorPreviewBodyContainer);
+        }
+    }
+    disposeBuiltinEditingSessions() {
+        for (const session of ( this.builtinEditingSessions.values())) {
+            session.model.dispose();
+        }
+        this.builtinEditingSessions.clear();
+    }
+    disposeBuiltinEditingSession(uri) {
+        const key = ( uri.toString());
+        const session = this.builtinEditingSessions.get(key);
+        if (!session) {
+            return;
+        }
+        session.model.dispose();
+        this.builtinEditingSessions.delete(key);
+    }
+    createEmbeddedMcpDetail() {
+        if (!this.mcpDetailContainer) {
+            return;
+        }
+        const detailBody = append(this.mcpDetailContainer, $(".mcp-detail-editor-container"));
+        this.embeddedMcpDetail = this.editorDisposables.add(
+            this.instantiationService.createInstance(EmbeddedMcpServerDetail, detailBody)
+        );
+        const backButton = append(this.embeddedMcpDetail.leadingSlot, $("button.editor-back-button"));
+        this.mcpDetailBackButton = backButton;
+        backButton.setAttribute("type", "button");
+        backButton.setAttribute("aria-label", ( localize(8651, "Back to MCP servers")));
+        this.editorDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), backButton, ( localize(8652, "Back to MCP servers")))
+        );
+        const backIconEl = append(
+            backButton,
+            $(`.codicon.codicon-${Codicon.arrowLeft.id}.editor-action-button-icon`)
+        );
+        backIconEl.setAttribute("aria-hidden", "true");
+        this.editorDisposables.add(addDisposableListener(backButton, "click", () => {
+            this.goBackFromMcpDetail();
+        }));
+    }
+    async showEmbeddedMcpDetail(server) {
+        if (!this.embeddedMcpDetail) {
+            this.createEmbeddedMcpDetail();
+        }
+        if (!this.embeddedMcpDetail) {
+            return;
+        }
+        this.viewMode = "mcpDetail";
+        this.updateContentVisibility();
+        this.mcpDetailDisposables.clear();
+        this.embeddedMcpDetail.setInput(server);
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        this.mcpDetailBackButton?.focus();
+    }
+    goBackFromMcpDetail() {
+        this.mcpDetailDisposables.clear();
+        this.embeddedMcpDetail?.clearInput();
+        this.viewMode = "list";
+        this.updateContentVisibility();
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        this.mcpListWidget?.focusSearch();
+    }
+    createEmbeddedPluginDetail() {
+        if (!this.pluginDetailContainer) {
+            return;
+        }
+        const detailBody = append(this.pluginDetailContainer, $(".plugin-detail-editor-container"));
+        this.embeddedPluginDetail = this.editorDisposables.add(
+            this.instantiationService.createInstance(EmbeddedAgentPluginDetail, detailBody)
+        );
+        this.editorDisposables.add(this.embeddedPluginDetail.onDidRequestOpenSkill(uri => {
+            this.openSkillFromPluginDetail(uri);
+        }));
+        this.editorDisposables.add(this.embeddedPluginDetail.onDidRequestOpenAgent(uri => {
+            this.openPromptsItemFromPluginDetail(AICustomizationManagementSection.Agents, uri);
+        }));
+        this.editorDisposables.add(this.embeddedPluginDetail.onDidRequestOpenSection(section => {
+            this.openSectionFromPluginDetail(section);
+        }));
+        this.editorDisposables.add(this.embeddedPluginDetail.onDidUninstall(() => {
+            this.goBackFromPluginDetail();
+        }));
+        const backButton = append(this.embeddedPluginDetail.leadingSlot, $("button.editor-back-button"));
+        backButton.setAttribute("type", "button");
+        backButton.setAttribute("aria-label", ( localize(8653, "Back to plugins")));
+        this.editorDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), backButton, ( localize(8654, "Back to plugins")))
+        );
+        const backIconEl = append(backButton, $(`.codicon.codicon-${Codicon.arrowLeft.id}`));
+        backIconEl.setAttribute("aria-hidden", "true");
+        this.editorDisposables.add(addDisposableListener(backButton, "click", () => {
+            this.goBackFromPluginDetail();
+        }));
+    }
+    async showEmbeddedPluginDetail(item) {
+        if (!this.embeddedPluginDetail) {
+            return;
+        }
+        this.viewMode = "pluginDetail";
+        this.updateContentVisibility();
+        this.pluginDetailDisposables.clear();
+        this.embeddedPluginDetail.setInput(item);
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    async openSkillFromPluginDetail(uri) {
+        await this.openPromptsItemFromPluginDetail(AICustomizationManagementSection.Skills, uri);
+    }
+    async openPromptsItemFromPluginDetail(section, uri) {
+        this.pluginDetailDisposables.clear();
+        this.embeddedPluginDetail?.clearInput();
+        this.pluginDetailReturnSection = undefined;
+        this.viewMode = "list";
+        this.selectedSection = section;
+        this.sectionContextKey.set(section);
+        this.storageService.store(
+            AI_CUSTOMIZATION_MANAGEMENT_SELECTED_SECTION_KEY,
+            section,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this.updateContentVisibility();
+        const navigationGeneration = this.contentNavigationGeneration;
+        await this.listWidget.setSection(section);
+        const modelSection = ITEMS_MODEL_SECTIONS.find(s => s === section);
+        if (modelSection) {
+            await this.itemsModel.whenSectionLoaded(modelSection);
+            if (!isCurrentPluginContributionNavigation(
+                navigationGeneration,
+                this.contentNavigationGeneration,
+                section,
+                this.selectedSection,
+                this.viewMode === "list"
+            )) {
+                return;
+            }
+            const item = this.itemsModel.getItems(modelSection).get().find(item => isEqual(item.uri, uri));
+            if (item) {
+                const source = item.source;
+                const isWorkspaceFile = source === AICustomizationSources.local;
+                const isReadOnly = !source || source === AICustomizationSources.extension || source === AICustomizationSources.plugin || source === AICustomizationSources.builtin;
+                this.showEmbeddedEditor(
+                    item.uri,
+                    item.name,
+                    item.promptType,
+                    source ?? AICustomizationSources.builtin,
+                    isWorkspaceFile,
+                    isReadOnly
+                );
+            }
+        }
+        this.ensureSectionsListReflectsActiveSection(section);
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    openSectionFromPluginDetail(section) {
+        this.pluginDetailDisposables.clear();
+        this.embeddedPluginDetail?.clearInput();
+        this.pluginDetailReturnSection = undefined;
+        this.viewMode = "list";
+        this.updateContentVisibility();
+        this.selectSectionById(section);
+    }
+    async showPluginDetail(item) {
+        if (this.selectedSection !== AICustomizationManagementSection.Plugins) {
+            this.pluginDetailReturnSection = this.selectedSection ?? AICustomizationManagementSection.Agents;
+        }
+        await this.showEmbeddedPluginDetail(item);
+    }
+    goBackFromPluginDetail() {
+        this.pluginDetailDisposables.clear();
+        this.embeddedPluginDetail?.clearInput();
+        const returnSection = this.pluginDetailReturnSection;
+        this.pluginDetailReturnSection = undefined;
+        if (returnSection) {
+            this.viewMode = "list";
+            this.updateContentVisibility();
+            this.selectSection(returnSection);
+        } else {
+            this.viewMode = "list";
+            this.updateContentVisibility();
+            this.pluginListWidget?.focusSearch();
+        }
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    createEmbeddedToolDetail() {
+        if (!this.toolsDetailContainer) {
+            return;
+        }
+        const detailBody = append(this.toolsDetailContainer, $(".tools-detail-editor-container"));
+        this.embeddedToolDetail = this.editorDisposables.add(
+            this.instantiationService.createInstance(EmbeddedExtensionToolsDetail, detailBody)
+        );
+        const backButton = append(this.embeddedToolDetail.leadingSlot, $("button.editor-back-button"));
+        backButton.setAttribute("type", "button");
+        backButton.setAttribute("aria-label", ( localize(8655, "Back to tools")));
+        this.editorDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), backButton, ( localize(8656, "Back to tools")))
+        );
+        const backIconEl = append(backButton, $(`.codicon.codicon-${Codicon.arrowLeft.id}`));
+        backIconEl.setAttribute("aria-hidden", "true");
+        this.editorDisposables.add(addDisposableListener(backButton, "click", () => {
+            this.goBackFromToolDetail();
+        }));
+    }
+    async showEmbeddedToolDetail(extension) {
+        if (!this.embeddedToolDetail) {
+            return;
+        }
+        this.viewMode = "toolsDetail";
+        this.updateContentVisibility();
+        this.toolsDetailDisposables.clear();
+        this.embeddedToolDetail.setInput(extension);
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    goBackFromToolDetail() {
+        this.toolsDetailDisposables.clear();
+        this.embeddedToolDetail?.clearInput();
+        this.viewMode = "list";
+        this.updateContentVisibility();
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+        this.toolsListWidget?.focusSearch();
+    }
+};
+AICustomizationManagementEditor = AICustomizationManagementEditor_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IThemeService)), ( __param(3, IStorageService)), ( __param(4, IInstantiationService)), ( __param(5, IContextKeyService)), ( __param(6, IOpenerService)), ( __param(7, ICommandService)), ( __param(8, IAICustomizationWorkspaceService)), ( __param(9, IPromptsService)), ( __param(10, ICustomizationMigrationService)), ( __param(11, ITextModelService)), ( __param(12, IConfigurationService)), ( __param(13, IWorkingCopyService)), ( __param(14, IHoverService)), ( __param(15, IMarkdownRendererService)), ( __param(16, IModelService)), ( __param(17, IQuickInputService)), ( __param(18, IFileService)), ( __param(19, INotificationService)), ( __param(20, IFileDialogService)), ( __param(21, IDialogService)), ( __param(22, IContextMenuService)), ( __param(23, ICustomizationHarnessService)), ( __param(24, IViewsService)), ( __param(25, ILabelService)), ( __param(26, IAICustomizationItemsModel)), ( __param(27, IMcpService)), ( __param(28, IMcpWorkbenchService)), ( __param(29, IAgentHostCustomizationService))], AICustomizationManagementEditor));
+
+export { AICustomizationManagementEditor, isCurrentPluginContributionNavigation };