@codingame/monaco-vscode-api 28.4.1 → 29.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionsService.service.d.ts

@@ -1,12 +1,10 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
-import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IChatService } from "./chatService/chatService.service.js";
-import { IChatSessionsExtensionPoint, IChatSessionItemController, IChatSessionItem, IChatSessionContentProvider, IChatSession, IChatSessionProviderOptionItem, IChatSessionProviderOptionGroup, IChatSessionOptionsWillNotifyExtensionEvent } from "./chatSessionsService.js";
+import { IChatSessionItemsDelta, ResolvedChatSessionsExtensionPoint, IChatSessionsExtensionPoint, IChatSessionItemController, IChatSessionItem, IChatSessionContentProvider, IChatSession, ReadonlyChatSessionOptionsMap, IChatSessionProviderOptionItem, IChatSessionOptionsChangeEvent, IChatSessionRequestHistoryItem, IChatSessionProviderOptionGroup, IChatNewSessionRequest } from "./chatSessionsService.js";
 import { IChatModel } from "./model/chatModel.js";
-import { IChatAgentAttachmentCapabilities, IChatAgentRequest } from "./participants/chatAgents.js";
+import { IChatAgentAttachmentCapabilities } from "./participants/chatAgents.js";
 import { Target } from "./promptSyntax/promptTypes.js";
 export declare const IChatSessionsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSessionsService>;
 export interface IChatSessionsService {
@@ -14,34 +12,37 @@ export interface IChatSessionsService {
     readonly onDidChangeItemsProviders: Event<{
         readonly chatSessionType: string;
     }>;
-    readonly onDidChangeSessionItems: Event<{
-        readonly chatSessionType: string;
-    }>;
+    readonly onDidChangeSessionItems: Event<IChatSessionItemsDelta>;
     readonly onDidChangeAvailability: Event<void>;
     readonly onDidChangeInProgress: Event<void>;
-    getChatSessionContribution(chatSessionType: string): IChatSessionsExtensionPoint | undefined;
+    getChatSessionContribution(chatSessionType: string): ResolvedChatSessionsExtensionPoint | undefined;
+    getAllChatSessionContributions(): ResolvedChatSessionsExtensionPoint[];
+    /**
+    * Programmatically register a chat session contribution (for internal session types
+    * that don't go through the extension point).
+    */
+    registerChatSessionContribution(contribution: IChatSessionsExtensionPoint): IDisposable;
     registerChatSessionItemController(chatSessionType: string, controller: IChatSessionItemController): IDisposable;
+    getRegisteredChatSessionItemProviders(): readonly string[];
     activateChatSessionItemProvider(chatSessionType: string): Promise<void>;
-    getAllChatSessionContributions(): IChatSessionsExtensionPoint[];
-    getIconForSessionType(chatSessionType: string): ThemeIcon | URI | undefined;
-    getWelcomeTitleForSessionType(chatSessionType: string): string | undefined;
-    getWelcomeMessageForSessionType(chatSessionType: string): string | undefined;
-    getInputPlaceholderForSessionType(chatSessionType: string): string | undefined;
     /**
     * Get the list of current chat session items grouped by session type.
+    *
     * @param providerTypeFilter If specified, only returns items from the given providers. If undefined, returns items from all providers.
+    *
+    * @returns An async iterable that produces the list of session items for each provider. The order is not guaranteed. Some provider may take a long time to resolve.
     */
-    getChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): Promise<Array<{
+    getChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): AsyncIterable<{
         readonly chatSessionType: string;
         readonly items: readonly IChatSessionItem[];
-    }>>;
+    }>;
     /**
     * Forces the controllers to refresh their session items, optionally filtered by provider type.
     */
     refreshChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): Promise<void>;
-    reportInProgress(chatSessionType: string, count: number): void;
+    /** @deprecated Use `getChatSessionItems` */
     getInProgress(): {
-        displayName: string;
+        chatSessionType: string;
         count: number;
     }[];
     readonly onDidChangeContentProviderSchemes: Event<{
@@ -53,12 +54,14 @@ export interface IChatSessionsService {
     canResolveChatSession(sessionType: string): Promise<boolean>;
     getOrCreateChatSession(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
     hasAnySessionOptions(sessionResource: URI): boolean;
+    getSessionOptions(sessionResource: URI): ReadonlyChatSessionOptionsMap | undefined;
     getSessionOption(sessionResource: URI, optionId: string): string | IChatSessionProviderOptionItem | undefined;
     setSessionOption(sessionResource: URI, optionId: string, value: string | IChatSessionProviderOptionItem): boolean;
+    updateSessionOptions(sessionResource: URI, updates: ReadonlyChatSessionOptionsMap): boolean;
     /**
     * Fired when options for a chat session change.
     */
-    readonly onDidChangeSessionOptions: Event<URI>;
+    readonly onDidChangeSessionOptions: Event<IChatSessionOptionsChangeEvent>;
     /**
     * Get the capabilities for a specific session type
     */
@@ -72,28 +75,34 @@ export interface IChatSessionsService {
     * Returns whether the session type requires custom models. When true, the model picker should show filtered custom models.
     */
     requiresCustomModelsForSessionType(chatSessionType: string): boolean;
+    /**
+    * Returns whether the session type supports delegation.
+    * Defaults to true when not explicitly set.
+    */
+    supportsDelegationForSessionType(chatSessionType: string): boolean;
+    /**
+    * Returns whether the loaded session supports forking conversations.
+    */
+    sessionSupportsFork(sessionResource: URI): boolean;
+    /**
+    * Forks a contributed chat session from the given request point.
+    * @param sessionResource The session resource to fork.
+    * @param request The request history item to fork from, or undefined to fork from the end.
+    * @param token Cancellation token.
+    * @returns The forked session item, or undefined if forking failed.
+    */
+    forkChatSession(sessionResource: URI, request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken): Promise<IChatSessionItem>;
     readonly onDidChangeOptionGroups: Event<string>;
     getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;
     setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: IChatSessionProviderOptionGroup[]): void;
-    getNewSessionOptionsForSessionType(chatSessionType: string): Record<string, string | IChatSessionProviderOptionItem> | undefined;
-    setNewSessionOptionsForSessionType(chatSessionType: string, options: Record<string, string | IChatSessionProviderOptionItem>): void;
-    /**
-    * Event fired when session options change and need to be sent to the extension.
-    * MainThreadChatSessions subscribes to this to forward changes to the extension host.
-    * Uses IWaitUntil pattern to allow listeners to register async work.
-    */
-    readonly onRequestNotifyExtension: Event<IChatSessionOptionsWillNotifyExtensionEvent>;
-    notifySessionOptionsChange(sessionResource: URI, updates: ReadonlyArray<{
-        optionId: string;
-        value: string | IChatSessionProviderOptionItem;
-    }>): Promise<void>;
-    registerChatModelChangeListeners(chatService: IChatService, chatSessionType: string, onChange: () => void): IDisposable;
+    getNewSessionOptionsForSessionType(chatSessionType: string): ReadonlyChatSessionOptionsMap | undefined;
+    setNewSessionOptionsForSessionType(chatSessionType: string, options: ReadonlyChatSessionOptionsMap): void;
     getInProgressSessionDescription(chatModel: IChatModel): string | undefined;
     /**
     * Creates a new chat session item using the controller's newChatSessionItemHandler.
     * Returns undefined if the controller doesn't have a handler or if no controller is registered.
     */
-    createNewChatSessionItem(chatSessionType: string, request: IChatAgentRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    createNewChatSessionItem(chatSessionType: string, request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     /**
     * Registers an alias so that session-option lookups by the real resource
     * are redirected to the canonical (untitled) resource in the internal session map.

package/vscode/src/vs/workbench/contrib/chat/common/constants.d.ts

@@ -40,13 +40,18 @@ export declare enum ChatConfiguration {
     ChatViewProgressBadgeEnabled = "chat.viewProgressBadge.enabled",
     ChatContextUsageEnabled = "chat.contextUsage.enabled",
     SubagentToolCustomAgents = "chat.customAgentInSubagent.enabled",
+    SubagentsAllowInvocationsFromSubagents = "chat.subagents.allowInvocationsFromSubagents",
     ShowCodeBlockProgressAnimation = "chat.agent.codeBlockProgress",
     RestoreLastPanelSession = "chat.restoreLastPanelSession",
     ExitAfterDelegation = "chat.exitAfterDelegation",
     ExplainChangesEnabled = "chat.editing.explainChanges.enabled",
+    RevealNextChangeOnResolve = "chat.editing.revealNextChangeOnResolve",
     GrowthNotificationEnabled = "chat.growthNotification.enabled",
     ChatCustomizationMenuEnabled = "chat.customizationsMenu.enabled",
-    AutopilotEnabled = "chat.autopilot.enabled"
+    ChatCustomizationHarnessSelectorEnabled = "chat.customizations.harnessSelector.enabled",
+    AutopilotEnabled = "chat.autopilot.enabled",
+    ImageCarouselEnabled = "imageCarousel.chat.enabled",
+    ArtifactsEnabled = "chat.artifacts.enabled"
 }
 /**
  * The "kind" of agents for custom agents.

package/vscode/src/vs/workbench/contrib/chat/common/constants.js

@@ -44,13 +44,18 @@ var ChatConfiguration;
     ChatConfiguration["ChatViewProgressBadgeEnabled"] = "chat.viewProgressBadge.enabled";
     ChatConfiguration["ChatContextUsageEnabled"] = "chat.contextUsage.enabled";
     ChatConfiguration["SubagentToolCustomAgents"] = "chat.customAgentInSubagent.enabled";
+    ChatConfiguration["SubagentsAllowInvocationsFromSubagents"] = "chat.subagents.allowInvocationsFromSubagents";
     ChatConfiguration["ShowCodeBlockProgressAnimation"] = "chat.agent.codeBlockProgress";
     ChatConfiguration["RestoreLastPanelSession"] = "chat.restoreLastPanelSession";
     ChatConfiguration["ExitAfterDelegation"] = "chat.exitAfterDelegation";
     ChatConfiguration["ExplainChangesEnabled"] = "chat.editing.explainChanges.enabled";
+    ChatConfiguration["RevealNextChangeOnResolve"] = "chat.editing.revealNextChangeOnResolve";
     ChatConfiguration["GrowthNotificationEnabled"] = "chat.growthNotification.enabled";
     ChatConfiguration["ChatCustomizationMenuEnabled"] = "chat.customizationsMenu.enabled";
+    ChatConfiguration["ChatCustomizationHarnessSelectorEnabled"] = "chat.customizations.harnessSelector.enabled";
     ChatConfiguration["AutopilotEnabled"] = "chat.autopilot.enabled";
+    ChatConfiguration["ImageCarouselEnabled"] = "imageCarousel.chat.enabled";
+    ChatConfiguration["ArtifactsEnabled"] = "chat.artifacts.enabled";
 })(ChatConfiguration || (ChatConfiguration = {}));
 var ChatModeKind;
 (function(ChatModeKind) {

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.d.ts

@@ -0,0 +1,159 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { ThemeIcon } from "../../../../base/common/themables.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IStorageSourceFilter } from "./aiCustomizationWorkspaceService.js";
+import { PromptsType } from "./promptSyntax/promptTypes.js";
+import { ICustomizationHarnessService } from "./customizationHarnessService.service.js";
+/**
+ * Override for a management section's create-button behavior.
+ */
+export interface ISectionOverride {
+    /**
+     * Label for the primary button. Required when `commandId` or `rootFile`
+     * is set. Ignored otherwise (the widget uses its default label).
+     */
+    readonly label?: string;
+    /** When set, the primary button invokes this command (e.g. hooks quick pick). */
+    readonly commandId?: string;
+    /** When set, the primary button creates this file at the workspace root. */
+    readonly rootFile?: string;
+    /**
+     * Custom type label for the dropdown workspace/user create actions
+     * (e.g. "Rule" instead of "Instruction"). When undefined, the
+     * section's default type label is used.
+     */
+    readonly typeLabel?: string;
+    /**
+     * Root-level file shortcuts added to the dropdown (e.g. `['AGENTS.md']`).
+     * Each entry creates a "New {filename}" action that creates the file at
+     * the workspace root. Harnesses that don't support a file simply omit it.
+     */
+    readonly rootFileShortcuts?: readonly string[];
+    /**
+     * File extension override for new files created under this section.
+     * When set, files are created with this extension (e.g. `.md` for
+     * Claude rules) instead of the default for the prompt type
+     * (e.g. `.instructions.md`).
+     */
+    readonly fileExtension?: string;
+}
+/**
+ * Identifies the AI harness (execution environment) that customizations
+ * are filtered for. Storage answers "where did this come from?"; harness
+ * answers "who consumes it?".
+ */
+export declare enum CustomizationHarness {
+    VSCode = "vscode",
+    CLI = "cli",
+    Claude = "claude"
+}
+/**
+ * Describes a single harness option for the UI toggle.
+ */
+export interface IHarnessDescriptor {
+    readonly id: CustomizationHarness;
+    readonly label: string;
+    readonly icon: ThemeIcon;
+    /**
+     * Management sections that should be hidden when this harness is active.
+     * For example, Claude does not support prompt files so the Prompts
+     * section is hidden.
+     */
+    readonly hiddenSections?: readonly string[];
+    /**
+     * Workspace sub-paths that this harness recognizes for file creation.
+     * When set, the directory picker for new customization files only offers
+     * workspace directories under these sub-paths (e.g. `.claude` for Claude).
+     * When `undefined`, all workspace directories are shown (Local harness).
+     */
+    readonly workspaceSubpaths?: readonly string[];
+    /**
+     * When `true`, the "Generate with AI" sparkle button is hidden and replaced
+     * with a plain "New X" manual-creation button (like sessions).
+     */
+    readonly hideGenerateButton?: boolean;
+    /**
+     * Per-section overrides for the create button behavior.
+     *
+     * A `commandId` entry replaces the button entirely with a command
+     * invocation (e.g. Claude hooks → `copilot.claude.hooks`).
+     *
+     * A `rootFile` entry makes the primary button create a specific file
+     * at the workspace root (e.g. Claude instructions → `CLAUDE.md`).
+     * When combined with `typeLabel`, the dropdown create actions use
+     * that label instead of the section's default (e.g. "Rule" instead
+     * of "Instruction").
+     */
+    readonly sectionOverrides?: ReadonlyMap<string, ISectionOverride>;
+    /**
+     * The chat agent ID that must be registered for this harness to appear.
+     * When `undefined`, the harness is always available (e.g. Local).
+     */
+    readonly requiredAgentId?: string;
+    /**
+     * Instruction file patterns that this harness recognizes.
+     * Each entry is either an exact filename (e.g. `'CLAUDE.md'`) or a
+     * path prefix ending with `/` (e.g. `'.claude/rules/'`).
+     * When set, instruction items that don't match any pattern are filtered out.
+     * When `undefined`, all instruction files are shown.
+     */
+    readonly instructionFileFilter?: readonly string[];
+    /**
+     * Returns the storage source filter that should be applied to customization
+     * items of the given type when this harness is active.
+     */
+    getStorageSourceFilter(type: PromptsType): IStorageSourceFilter;
+}
+/**
+ * Returns the user-home directories accessible to the Copilot CLI harness.
+ */
+export declare function getCliUserRoots(userHome: URI): readonly URI[];
+/**
+ * Returns the user-home directories accessible to the Claude harness.
+ */
+export declare function getClaudeUserRoots(userHome: URI): readonly URI[];
+/**
+ * Creates a "VS Code" harness descriptor that shows all storage sources
+ * with no user-root restrictions.
+ */
+export declare function createVSCodeHarnessDescriptor(extras: readonly string[]): IHarnessDescriptor;
+/**
+ * Creates a "Copilot CLI" harness descriptor.
+ */
+export declare function createCliHarnessDescriptor(cliUserRoots: readonly URI[], extras: readonly string[]): IHarnessDescriptor;
+/**
+ * Creates a "Claude" harness descriptor.
+ * Claude does not support prompt files (.prompt.md), AGENTS.md, or extension-contributed plugins.
+ * It supports agents (.claude/agents/), instructions (CLAUDE.md, .claude/rules/),
+ * skills (.claude/skills/), and hooks (.claude/settings.json).
+ */
+export declare function createClaudeHarnessDescriptor(claudeRoots: readonly URI[], extras: readonly string[]): IHarnessDescriptor;
+/**
+ * Tests whether a file path belongs to one of the given workspace sub-paths.
+ * Matches on path segment boundaries to avoid false positives
+ * (e.g. `.claude` must appear as `/.claude/` in the path, not as part of
+ * a longer segment like `not.claude`).
+ */
+export declare function matchesWorkspaceSubpath(filePath: string, subpaths: readonly string[]): boolean;
+/**
+ * Tests whether an instruction file matches one of the harness's recognized
+ * instruction file patterns. Patterns can be exact filenames (e.g. `CLAUDE.md`)
+ * or path prefixes ending with `/` (e.g. `.claude/rules/`).
+ */
+export declare function matchesInstructionFileFilter(filePath: string, filters: readonly string[]): boolean;
+/**
+ * Reusable base implementation of {@link ICustomizationHarnessService}.
+ * Concrete registrations only need to supply the list of harness
+ * descriptors and a default harness id.
+ */
+export declare class CustomizationHarnessServiceBase implements ICustomizationHarnessService {
+    readonly _serviceBrand: undefined;
+    private readonly _activeHarness;
+    readonly activeHarness: IObservable<CustomizationHarness>;
+    readonly availableHarnesses: IObservable<readonly IHarnessDescriptor[]>;
+    private readonly _allHarnesses;
+    constructor(harnesses: readonly IHarnessDescriptor[], defaultHarness: CustomizationHarness, availableHarnesses?: IObservable<readonly IHarnessDescriptor[]>);
+    setActiveHarness(id: CustomizationHarness): void;
+    getStorageSourceFilter(type: PromptsType): IStorageSourceFilter;
+    getActiveDescriptor(): IHarnessDescriptor;
+}

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.js

@@ -0,0 +1,157 @@
+
+import { Codicon } from '../../../../base/common/codicons.js';
+import '../../../../base/common/observableInternal/index.js';
+import { joinPath } from '../../../../base/common/resources.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { localize } from '../../../../nls.js';
+import { AICustomizationManagementSection } from './aiCustomizationWorkspaceService.js';
+import { PromptsType } from './promptSyntax/promptTypes.js';
+import { PromptsStorage } from './promptSyntax/service/promptsService.js';
+import { AGENT_MD_FILENAME } from './promptSyntax/config/promptFileLocations.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
+
+var CustomizationHarness;
+(function(CustomizationHarness) {
+    CustomizationHarness["VSCode"] = "vscode";
+    CustomizationHarness["CLI"] = "cli";
+    CustomizationHarness["Claude"] = "claude";
+})(CustomizationHarness || (CustomizationHarness = {}));
+const HOOKS_FILTER = {
+    sources: [PromptsStorage.local, PromptsStorage.plugin]
+};
+function getCliUserRoots(userHome) {
+    return [
+        joinPath(userHome, ".copilot"),
+        joinPath(userHome, ".claude"),
+        joinPath(userHome, ".agents")
+    ];
+}
+function getClaudeUserRoots(userHome) {
+    return [joinPath(userHome, ".claude")];
+}
+function buildAllSources(extras) {
+    return [
+        PromptsStorage.local,
+        PromptsStorage.user,
+        PromptsStorage.plugin,
+        ...extras
+    ];
+}
+function createVSCodeHarnessDescriptor(extras) {
+    const filter = {
+        sources: buildAllSources(extras)
+    };
+    return {
+        id: CustomizationHarness.VSCode,
+        label: ( localize(7203, "Local")),
+        icon: ThemeIcon.fromId(Codicon.vm.id),
+        sectionOverrides: ( new Map([[AICustomizationManagementSection.Instructions, {
+            rootFileShortcuts: [AGENT_MD_FILENAME]
+        }]])),
+        getStorageSourceFilter: () => filter
+    };
+}
+function createRestrictedHarnessDescriptor(id, label, icon, restrictedUserRoots, extras, options) {
+    const allSources = buildAllSources(extras);
+    const allRootsFilter = {
+        sources: allSources
+    };
+    const restrictedFilter = {
+        sources: allSources,
+        includedUserFileRoots: restrictedUserRoots
+    };
+    return {
+        id,
+        label,
+        icon,
+        hiddenSections: options?.hiddenSections,
+        workspaceSubpaths: options?.workspaceSubpaths,
+        hideGenerateButton: options?.hideGenerateButton,
+        sectionOverrides: options?.sectionOverrides,
+        requiredAgentId: options?.requiredAgentId,
+        instructionFileFilter: options?.instructionFileFilter,
+        getStorageSourceFilter(type) {
+            if (type === PromptsType.hook) {
+                return HOOKS_FILTER;
+            }
+            if (type === PromptsType.prompt) {
+                return allRootsFilter;
+            }
+            return restrictedFilter;
+        }
+    };
+}
+function createCliHarnessDescriptor(cliUserRoots, extras) {
+    return createRestrictedHarnessDescriptor(CustomizationHarness.CLI, ( localize(7204, "Copilot CLI")), ThemeIcon.fromId(Codicon.worktree.id), cliUserRoots, extras, {
+        hideGenerateButton: true,
+        requiredAgentId: "copilotcli",
+        workspaceSubpaths: [".github", ".copilot", ".agents", ".claude"],
+        sectionOverrides: ( new Map([[AICustomizationManagementSection.Instructions, {
+            rootFileShortcuts: [AGENT_MD_FILENAME]
+        }]]))
+    });
+}
+function createClaudeHarnessDescriptor(claudeRoots, extras) {
+    return createRestrictedHarnessDescriptor(CustomizationHarness.Claude, ( localize(7205, "Claude")), ThemeIcon.fromId(Codicon.claude.id), claudeRoots, extras, {
+        hiddenSections: [
+            AICustomizationManagementSection.Prompts,
+            AICustomizationManagementSection.Plugins
+        ],
+        workspaceSubpaths: [".claude"],
+        hideGenerateButton: true,
+        requiredAgentId: "claude-code",
+        sectionOverrides: ( new Map([[AICustomizationManagementSection.Hooks, {
+            label: ( localize(7206, "Configure Claude Hooks")),
+            commandId: "copilot.claude.hooks"
+        }], [AICustomizationManagementSection.Instructions, {
+            label: ( localize(7207, "Add CLAUDE.md")),
+            rootFile: "CLAUDE.md",
+            typeLabel: ( localize(7208, "Rule")),
+            fileExtension: ".md"
+        }]])),
+        instructionFileFilter: [
+            "CLAUDE.md",
+            "CLAUDE.local.md",
+            ".claude/rules/",
+            "copilot-instructions.md"
+        ]
+    });
+}
+function matchesWorkspaceSubpath(filePath, subpaths) {
+    return ( subpaths.some(sp => filePath.includes(`/${sp}/`) || filePath.endsWith(`/${sp}`)));
+}
+function matchesInstructionFileFilter(filePath, filters) {
+    const name = filePath.substring(filePath.lastIndexOf("/") + 1);
+    return ( filters.some(f => {
+        if (f.endsWith("/")) {
+            return filePath.includes(`/${f}`) || filePath.startsWith(f);
+        }
+        return name === f;
+    }));
+}
+class CustomizationHarnessServiceBase {
+    constructor(harnesses, defaultHarness, availableHarnesses) {
+        this._allHarnesses = harnesses;
+        this._activeHarness = observableValue(this, defaultHarness);
+        this.activeHarness = this._activeHarness;
+        this.availableHarnesses = availableHarnesses ?? constObservable(harnesses);
+    }
+    setActiveHarness(id) {
+        const available = this.availableHarnesses.get();
+        if (( available.some(h => h.id === id))) {
+            this._activeHarness.set(id, undefined);
+        }
+    }
+    getStorageSourceFilter(type) {
+        const descriptor = this.getActiveDescriptor();
+        return descriptor.getStorageSourceFilter(type);
+    }
+    getActiveDescriptor() {
+        const activeId = this._activeHarness.get();
+        const available = this.availableHarnesses.get();
+        return available.find(h => h.id === activeId) ?? available[0] ?? this._allHarnesses[0];
+    }
+}
+
+export { CustomizationHarness, CustomizationHarnessServiceBase, createClaudeHarnessDescriptor, createCliHarnessDescriptor, createVSCodeHarnessDescriptor, getClaudeUserRoots, getCliUserRoots, matchesInstructionFileFilter, matchesWorkspaceSubpath };

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.service.d.ts

@@ -0,0 +1,39 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { IStorageSourceFilter } from "./aiCustomizationWorkspaceService.js";
+import { CustomizationHarness, IHarnessDescriptor } from "./customizationHarnessService.js";
+import { PromptsType } from "./promptSyntax/promptTypes.js";
+export declare const ICustomizationHarnessService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ICustomizationHarnessService>;
+/**
+* Service that manages the active customization harness and provides
+* per-type storage source filters based on the selected harness.
+*
+* The default (core) registration exposes a single "VS Code" harness
+* that shows all storage sources. The sessions window overrides this
+* to provide CLI-scoped harnesses.
+*/
+export interface ICustomizationHarnessService {
+    readonly _serviceBrand: undefined;
+    /**
+    * The currently active harness.
+    */
+    readonly activeHarness: IObservable<CustomizationHarness>;
+    /**
+    * All harnesses available in this window.
+    * When only one harness is available the UI should hide the toggle.
+    */
+    readonly availableHarnesses: IObservable<readonly IHarnessDescriptor[]>;
+    /**
+    * Changes the active harness. The new id must be present in
+    * `availableHarnesses`.
+    */
+    setActiveHarness(id: CustomizationHarness): void;
+    /**
+    * Convenience: returns the storage source filter for the active harness
+    * and the given customization type.
+    */
+    getStorageSourceFilter(type: PromptsType): IStorageSourceFilter;
+    /**
+    * Returns the descriptor of the currently active harness.
+    */
+    getActiveDescriptor(): IHarnessDescriptor;
+}

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ICustomizationHarnessService = ( createDecorator("customizationHarnessService"));
+
+export { ICustomizationHarnessService };

package/vscode/src/vs/workbench/contrib/chat/common/editing/chatEditingService.js

@@ -45,9 +45,9 @@ var ChatEditingSessionState;
     ChatEditingSessionState[ChatEditingSessionState["Disposed"] = 3] = "Disposed";
 })(ChatEditingSessionState || (ChatEditingSessionState = {}));
 const CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME = "chat-editing-multi-diff-source";
-const chatEditingWidgetFileStateContextKey = ( new RawContextKey("chatEditingWidgetFileState", undefined, ( localize(6986, "The current state of the file in the chat editing widget"))));
+const chatEditingWidgetFileStateContextKey = ( new RawContextKey("chatEditingWidgetFileState", undefined, ( localize(7209, "The current state of the file in the chat editing widget"))));
 const chatEditingAgentSupportsReadonlyReferencesContextKey = ( new RawContextKey("chatEditingAgentSupportsReadonlyReferences", undefined, ( localize(
-    6987,
+    7210,
     "Whether the chat editing agent supports readonly references (temporary)"
 ))));
 const decidedChatEditingResourceContextKey = ( new RawContextKey("decidedChatEditingResource", []));

package/vscode/src/vs/workbench/contrib/chat/common/enablement.d.ts

@@ -0,0 +1,35 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IReader } from "../../../../base/common/observable.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+export declare enum ContributionEnablementState {
+    DisabledProfile = 0,
+    DisabledWorkspace = 1,
+    EnabledProfile = 2,
+    EnabledWorkspace = 3
+}
+export declare function isContributionEnabled(state: ContributionEnablementState): boolean;
+export declare function isContributionDisabled(state: ContributionEnablementState): boolean;
+export interface IEnablementModel {
+    readEnabled(key: string, reader?: IReader): ContributionEnablementState;
+    setEnabled(key: string, state: ContributionEnablementState): void;
+    remove(key: string): void;
+}
+/**
+ * A reusable enablement model for string-keyed contributions. Uses
+ * `observableMemento` to persist enable/disable state in both profile-scoped
+ * and workspace-scoped storage.
+ *
+ * Resolution order: if a workspace-scoped entry exists for a key, it wins.
+ * Otherwise, the profile-scoped entry is used. The default (absence of any
+ * entry) is {@link ContributionEnablementState.EnabledProfile}.
+ */
+export declare class EnablementModel extends Disposable implements IEnablementModel {
+    private readonly _profileState;
+    private readonly _workspaceState;
+    constructor(storageKey: string, storageService: IStorageService);
+    readEnabled(key: string, reader?: IReader): ContributionEnablementState;
+    setEnabled(key: string, state: ContributionEnablementState): void;
+    remove(key: string): void;
+    private _setInMap;
+    private _deleteFromMap;
+}