@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.2.0

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

@@ -0,0 +1,253 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+export declare const CHAT_DEBUG_HAS_ACTIVE_SESSION: RawContextKey<boolean>;
+export declare const CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST: RawContextKey<boolean>;
+/**
+ * The severity level of a chat debug log event.
+ */
+export declare enum ChatDebugLogLevel {
+    Trace = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+/**
+ * The result of a hook execution.
+ */
+export declare enum ChatDebugHookResult {
+    /** The hook executed successfully (exit code 0). */
+    Success = 0,
+    /** The hook returned a blocking error (exit code 2). */
+    Error = 1,
+    /** The hook returned a non-blocking warning (other non-zero exit codes). */
+    NonBlockingError = 2
+}
+/**
+ * Common properties shared by all chat debug event types.
+ */
+export interface IChatDebugEventCommon {
+    readonly id?: string;
+    readonly sessionResource: URI;
+    readonly created: Date;
+    readonly parentEventId?: string;
+}
+/**
+ * A tool call event in the chat debug log.
+ */
+export interface IChatDebugToolCallEvent extends IChatDebugEventCommon {
+    readonly kind: "toolCall";
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly input?: string;
+    readonly output?: string;
+    readonly result?: "success" | "error";
+    readonly durationInMillis?: number;
+}
+/**
+ * A model turn event representing an LLM request/response.
+ */
+export interface IChatDebugModelTurnEvent extends IChatDebugEventCommon {
+    readonly kind: "modelTurn";
+    readonly model?: string;
+    readonly requestName?: string;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cachedTokens?: number;
+    readonly totalTokens?: number;
+    readonly copilotUsageNanoAiu?: number;
+    readonly durationInMillis?: number;
+}
+/**
+ * A generic log event for unstructured or miscellaneous messages.
+ */
+export interface IChatDebugGenericEvent extends IChatDebugEventCommon {
+    readonly kind: "generic";
+    readonly name: string;
+    readonly details?: string;
+    readonly level: ChatDebugLogLevel;
+    readonly category?: string;
+}
+/**
+ * A subagent invocation event, representing a spawned sub-agent within a session.
+ */
+export interface IChatDebugSubagentInvocationEvent extends IChatDebugEventCommon {
+    readonly kind: "subagentInvocation";
+    readonly agentName: string;
+    readonly description?: string;
+    readonly status?: "running" | "completed" | "failed";
+    readonly durationInMillis?: number;
+    readonly toolCallCount?: number;
+    readonly modelTurnCount?: number;
+}
+/**
+ * A named section within a user message or agent response.
+ */
+export interface IChatDebugMessageSection {
+    readonly name: string;
+    readonly content: string;
+}
+/**
+ * A user message event, representing the full prompt sent by the user.
+ */
+export interface IChatDebugUserMessageEvent extends IChatDebugEventCommon {
+    readonly kind: "userMessage";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * An agent response event, representing the agent's response.
+ */
+export interface IChatDebugAgentResponseEvent extends IChatDebugEventCommon {
+    readonly kind: "agentResponse";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * Union of all internal chat debug event types.
+ */
+export type IChatDebugEvent = IChatDebugToolCallEvent | IChatDebugModelTurnEvent | IChatDebugGenericEvent | IChatDebugSubagentInvocationEvent | IChatDebugUserMessageEvent | IChatDebugAgentResponseEvent;
+/**
+ * Plain text content for a resolved debug event.
+ */
+export interface IChatDebugEventTextContent {
+    readonly kind: "text";
+    readonly value: string;
+}
+/**
+ * The status of a file in a file list content.
+ */
+export type ChatDebugFileStatus = "loaded" | "skipped";
+/**
+ * A single file entry in a file list content.
+ */
+export interface IChatDebugFileEntry {
+    readonly uri: URI;
+    readonly name?: string;
+    readonly status: ChatDebugFileStatus;
+    readonly storage?: string;
+    readonly extensionId?: string;
+    readonly skipReason?: string;
+    readonly errorMessage?: string;
+    readonly duplicateOf?: URI;
+}
+/**
+ * A source folder entry in a file list content.
+ */
+export interface IChatDebugSourceFolderEntry {
+    readonly uri: URI;
+    readonly storage: string;
+}
+/**
+ * Structured file list content for a resolved debug event.
+ * Contains resolved files and skipped/failed paths for rich rendering.
+ */
+export interface IChatDebugEventFileListContent {
+    readonly kind: "fileList";
+    readonly discoveryType: string;
+    readonly durationInMillis: number;
+    readonly files: readonly IChatDebugFileEntry[];
+    readonly sourceFolders?: readonly IChatDebugSourceFolderEntry[];
+}
+/**
+ * Structured message content for a resolved debug event,
+ * containing collapsible sections.
+ */
+export interface IChatDebugEventMessageContent {
+    readonly kind: "message";
+    readonly type: "user" | "agent";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * Structured tool call content for a resolved debug event.
+ * Contains the tool name, status, arguments, and output for rich rendering.
+ */
+export interface IChatDebugEventToolCallContent {
+    readonly kind: "toolCall";
+    readonly toolName: string;
+    readonly result?: "success" | "error";
+    readonly durationInMillis?: number;
+    readonly input?: string;
+    readonly output?: string;
+}
+/**
+ * Structured model turn content for a resolved debug event.
+ * Contains request metadata, token usage, and timing for rich rendering.
+ */
+export interface IChatDebugEventModelTurnContent {
+    readonly kind: "modelTurn";
+    readonly requestName: string;
+    readonly model?: string;
+    readonly status?: string;
+    readonly durationInMillis?: number;
+    readonly timeToFirstTokenInMillis?: number;
+    readonly requestId?: string;
+    readonly maxInputTokens?: number;
+    readonly maxOutputTokens?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cachedTokens?: number;
+    readonly totalTokens?: number;
+    readonly requestOptions?: string;
+    readonly errorMessage?: string;
+    readonly sections?: readonly IChatDebugMessageSection[];
+}
+/**
+ * Structured hook execution content for a resolved debug event.
+ * Contains the hook type, command, input, output, and result for rich rendering.
+ */
+export interface IChatDebugEventHookContent {
+    readonly kind: "hook";
+    readonly hookType: string;
+    readonly command?: string;
+    readonly result?: ChatDebugHookResult;
+    readonly durationInMillis?: number;
+    readonly input?: string;
+    readonly output?: string;
+    readonly exitCode?: number;
+    readonly errorMessage?: string;
+}
+/**
+ * A single entry in the customization resolution log.
+ */
+export interface IChatDebugCustomizationLogEntry {
+    readonly category: "applying" | "skipped" | "referenced" | "skill" | "custom-agent" | "hook";
+    readonly name: string;
+    readonly uri?: URI;
+    readonly reason?: string;
+}
+/**
+ * Structured customization summary content for a resolved debug event.
+ * Contains per-file resolution logs showing how applyTo patterns, agent
+ * instructions, and referenced files were resolved by the instructions
+ * context computer.
+ */
+export interface IChatDebugEventCustomizationSummaryContent {
+    readonly kind: "customizationSummary";
+    /** Per-file resolution detail entries. */
+    readonly resolutionLogs: readonly IChatDebugCustomizationLogEntry[];
+    /** Total wall-clock time of the collect() call in milliseconds. */
+    readonly durationInMillis: number;
+    /** Counts by type for the summary header. */
+    readonly counts: {
+        readonly instructions: number;
+        readonly skills: number;
+        readonly agents: number;
+        readonly hooks: number;
+        readonly skipped: number;
+    };
+}
+/**
+ * Union of all resolved event content types.
+ */
+export type IChatDebugResolvedEventContent = IChatDebugEventTextContent | IChatDebugEventFileListContent | IChatDebugEventMessageContent | IChatDebugEventToolCallContent | IChatDebugEventModelTurnContent | IChatDebugEventHookContent | IChatDebugEventCustomizationSummaryContent;
+/**
+ * Provider interface for debug events.
+ */
+export interface IChatDebugLogProvider {
+    provideChatDebugLog(sessionResource: URI, token: CancellationToken): Promise<IChatDebugEvent[] | undefined>;
+    resolveChatDebugLogEvent?(eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContent | undefined>;
+    provideChatDebugLogExport?(sessionResource: URI, token: CancellationToken): Promise<Uint8Array | undefined>;
+    resolveChatDebugLogImport?(data: Uint8Array, token: CancellationToken): Promise<URI | undefined>;
+}

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

@@ -0,0 +1,20 @@
+
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+const CHAT_DEBUG_HAS_ACTIVE_SESSION = ( new RawContextKey("chatDebug.hasActiveSession", false));
+const CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST = ( new RawContextKey("chatDebug.activeSessionIsAgentHost", false));
+var ChatDebugLogLevel;
+(function(ChatDebugLogLevel) {
+    ChatDebugLogLevel[ChatDebugLogLevel["Trace"] = 0] = "Trace";
+    ChatDebugLogLevel[ChatDebugLogLevel["Info"] = 1] = "Info";
+    ChatDebugLogLevel[ChatDebugLogLevel["Warning"] = 2] = "Warning";
+    ChatDebugLogLevel[ChatDebugLogLevel["Error"] = 3] = "Error";
+})(ChatDebugLogLevel || (ChatDebugLogLevel = {}));
+var ChatDebugHookResult;
+(function(ChatDebugHookResult) {
+    ChatDebugHookResult[ChatDebugHookResult["Success"] = 0] = "Success";
+    ChatDebugHookResult[ChatDebugHookResult["Error"] = 1] = "Error";
+    ChatDebugHookResult[ChatDebugHookResult["NonBlockingError"] = 2] = "NonBlockingError";
+})(ChatDebugHookResult || (ChatDebugHookResult = {}));
+
+export { CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST, CHAT_DEBUG_HAS_ACTIVE_SESSION, ChatDebugHookResult, ChatDebugLogLevel };

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

@@ -2,7 +2,7 @@ import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ChatDebugLogLevel, IChatDebugEvent, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService";
+import { ChatDebugLogLevel, IChatDebugEvent, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "./chatDebugService.js";
 import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";

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

@@ -7,7 +7,7 @@ import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { extUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { CHAT_DEBUG_HAS_ACTIVE_SESSION, CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST, ChatDebugLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
+import { CHAT_DEBUG_HAS_ACTIVE_SESSION, CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST, ChatDebugLogLevel } from './chatDebugService.js';
 import { isAgentHostTarget, localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceImpl.js

@@ -40,7 +40,7 @@ import { chatEditingSessionIsReady } from '@codingame/monaco-vscode-api/vscode/v
 import { logChangesToStateModel, normalizeSerializableChatData, ChatModel, getRestoredChatRequestSource, ChatRequestModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { ChatModelStore } from '../model/chatModelStore.js';
 import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, getPromptText, chatSubcommandLeader, chatAgentLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
-import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
+import { ChatRequestParser } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
 import { ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatMcpServersStarting, ChatStopCancellationNoopEventName, ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ChatServiceTelemetry, ChatRequestTelemetry } from './chatServiceTelemetry.js';
 import { isAgentHostTarget, localChatSessionType, isTerminalCommandPrompt } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
@@ -60,7 +60,7 @@ import { ChatSessionOperationLog } from '../model/chatSessionOperationLog.js';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
 import { AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING, TROUBLESHOOT_COMMAND_NAME, COPILOT_SKILL_URI_SCHEME, TROUBLESHOOT_SKILL_PATH } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { mergeHooks } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
-import { ComputeAutomaticInstructions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/computeAutomaticInstructions';
+import { ComputeAutomaticInstructions } from '../promptSyntax/computeAutomaticInstructions.js';
 import { CustomizationMigrationHintTarget } from '../promptSyntax/service/customizationMigrationService.js';
 import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
@@ -1383,7 +1383,7 @@ let ChatService = class ChatService extends Disposable {
                         model.acceptResponseProgress(request, {
                             kind: "markdownContent",
                             content: ( new MarkdownString(( localize(
-                                10242,
+                                10435,
                                 "The `{0}` skill requires `{1}` to be enabled. After enabling, reload the window to apply. [Enable in Settings](command:workbench.action.openSettings?{2})",
                                 TROUBLESHOOT_COMMAND_NAME,
                                 AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING,
@@ -1667,18 +1667,18 @@ let ChatService = class ChatService extends Disposable {
                         }] : undefined;
                         const reviewLink = createMarkdownCommandLink({
                             id: AICustomizationManagementCommands.OpenEditor,
-                            text: ( localize(10243, "Review customizations")),
-                            tooltip: ( localize(10244, "Open Chat Customizations")),
+                            text: ( localize(10436, "Review customizations")),
+                            tooltip: ( localize(10437, "Open Chat Customizations")),
                             arguments: reviewArguments
                         });
                         const dismissLink = createMarkdownCommandLink({
                             id: AICustomizationManagementCommands.DismissMigrationHint,
-                            text: ( localize(10245, "Hide for this workspace")),
-                            tooltip: ( localize(10246, "Stop Showing Migration Hints for This Harness"))
+                            text: ( localize(10438, "Hide for this workspace")),
+                            tooltip: ( localize(10439, "Stop Showing Migration Hints for This Harness"))
                         });
                         progressCallback([{
                             kind: "systemNotification",
-                            content: ( new MarkdownString(( localize(10247, "*{0} {1} | {2}*", hint.message, reviewLink, dismissLink)), {
+                            content: ( new MarkdownString(( localize(10440, "*{0} {1} | {2}*", hint.message, reviewLink, dismissLink)), {
                                 isTrusted: {
                                     enabledCommands: [
                                         AICustomizationManagementCommands.OpenEditor,
@@ -1773,7 +1773,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         rawResult = {
                             errorDetails: {
-                                message: ( localize(10248, "Provider returned null response"))
+                                message: ( localize(10441, "Provider returned null response"))
                             }
                         };
                     }
@@ -2368,7 +2368,7 @@ let ChatService = class ChatService extends Disposable {
 };
 ChatService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, ITelemetryService)), ( __param(3, IExtensionService)), ( __param(4, IInstantiationService)), ( __param(5, IWorkspaceContextService)), ( __param(6, IChatSlashCommandService)), ( __param(7, IChatAgentService)), ( __param(8, IConfigurationService)), ( __param(9, IChatTransferService)), ( __param(10, IChatSessionsService)), ( __param(11, IMcpService)), ( __param(12, IPromptsService)), ( __param(13, IChatEntitlementService)), ( __param(14, ILanguageModelsService)), ( __param(15, IChatDebugService))], ChatService));
 async function chatModelToChatDetail(model) {
-    const title = model.title || ( localize(10249, "New Chat"));
+    const title = model.title || ( localize(10442, "New Chat"));
     return {
         sessionResource: model.sessionResource,
         title,

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

@@ -0,0 +1,300 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { AICustomizationSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { IChatPromptSlashCommand, ICustomAgent, IResolvedChatPromptSlashCommand } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { type CustomizationDisabledReason } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement";
+import { ICustomizationHarnessService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service";
+/**
+ * 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;
+}
+export interface ICustomizationItemAction {
+    readonly id: string;
+    readonly label: string;
+    readonly tooltip?: string;
+    readonly icon?: ThemeIcon;
+    readonly enabled?: boolean;
+    run(): void | Promise<void>;
+}
+/**
+ * Describes a single harness option for the UI toggle.
+ */
+export interface IHarnessDescriptor {
+    /**
+     * The harness/session-type identifier.
+     */
+    readonly id: string;
+    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[];
+    /**
+     * 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.
+     *
+     * 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;
+    /**
+     * When set, this harness is backed by an extension-contributed provider
+     * that can supply customization items directly (bypassing promptsService
+     * discovery and filtering).
+     */
+    readonly itemProvider?: ICustomizationItemProvider;
+    /**
+     * When `true`, the "Troubleshoot" action is available in item context
+     * menus. This opens chat with the `/troubleshoot` command pre-filled
+     * for the selected customization.
+     */
+    readonly supportsTroubleshoot?: boolean;
+    /**
+     * When set, this harness uses an opt-out sync model where all eligible
+     * local customizations are synced by default. The UI shows disable
+     * affordances when this harness is active.
+     */
+    readonly syncProvider?: ICustomizationSyncProvider;
+    /**
+     * Optional plugin-management actions shown in the Plugins section add menu.
+     * Harnesses can use these to add environment-specific commands alongside
+     * the default install-from-source action (for example, configuring plugins on
+     * a remote agent host). The create action remains a separate toolbar button.
+     */
+    readonly pluginActions?: readonly ICustomizationItemAction[];
+    /**
+     * Local MCP collection identifiers that do not apply to this harness.
+     * Host-published MCP servers remain visible even when their local counterpart
+     * belongs to a hidden collection.
+     */
+    readonly hiddenMcpServerCollectionIds?: readonly string[];
+}
+/**
+ * Represents a customization item provided by any source.
+ */
+export interface ICustomizationItem {
+    /** Optional stable identity used by list widgets when URI alone is not unique. */
+    readonly itemKey?: string;
+    readonly uri: URI;
+    readonly type: string;
+    readonly name: string;
+    readonly description?: string;
+    /** Customization source (local, user, extension, plugin, builtin). Set by providers that know the source. */
+    readonly source: AICustomizationSource;
+    /** The extension identifier that contributed this customization, if any. */
+    readonly extensionId: string | undefined;
+    /** The URI of the plugin that contributed this customization, if any. */
+    readonly pluginUri: URI | undefined;
+    /** Human-readable name of the plugin that contributed this customization, if any. */
+    readonly pluginLabel?: string;
+    /** Server-reported loading status for this customization. */
+    readonly status?: "loading" | "loaded" | "degraded" | "error";
+    /** Human-readable status detail (e.g. error message or warning). */
+    readonly statusMessage?: string;
+    /** Whether this customization is currently enabled. */
+    readonly enabled?: boolean;
+    /** Host-published reason for a disabled customization. */
+    readonly disabledReason?: CustomizationDisabledReason;
+    /** When set, items with the same groupKey are displayed under a shared collapsible header. */
+    readonly groupKey?: string;
+    /** When set, shows a small inline badge next to the item name (e.g. an applyTo glob pattern). */
+    readonly badge?: string;
+    /** Tooltip shown when hovering the badge. */
+    readonly badgeTooltip?: string;
+    /**
+     * Whether this customization item can be invoked by the user.
+     * Relevant for prompt / skill and custom agents
+     */
+    readonly userInvocable?: boolean;
+    /** Optional inline/context-menu actions specific to this item. */
+    readonly actions?: readonly ICustomizationItemAction[];
+}
+export interface ICustomizationAgentRef {
+    readonly id: string;
+    readonly uri: URI;
+    /** Agent name (from frontmatter `name`, or file-derived) */
+    readonly name: string;
+    /** Optional short description for UI preview (from frontmatter `description`) */
+    readonly description?: string;
+}
+export declare function isPluginCustomizationItem(item: {
+    readonly type: string;
+}): boolean;
+export declare function getCustomizationDisabledLabel(reason: CustomizationDisabledReason | undefined): string;
+/**
+ * Provider interface for extension-contributed harnesses that supply
+ * customization items directly from their SDK.
+ */
+export interface ICustomizationItemProvider {
+    /**
+     * Event that fires when the provider's customizations change.
+     */
+    readonly onDidChange: Event<void>;
+    /**
+     * Provide the customization items this harness supports.
+     *
+     * @param sessionResource URI of the chat session whose
+     *   customizations should be included. Providers that surface
+     *   session-scoped state (e.g. an agent host) should read from
+     *   this session.
+     */
+    provideChatSessionCustomizations(sessionResource: URI, token: CancellationToken): Promise<ICustomizationItem[] | undefined>;
+    /**
+     * Provide the custom agents this harness supports.
+     *
+     * @param sessionResource URI of the chat session whose
+     *   customizations should be included. Providers that surface
+     *   session-scoped state (e.g. an agent host) should read from
+     *   this session.
+     */
+    provideCustomAgents?(sessionResource: URI, token: CancellationToken): Promise<readonly ICustomAgent[]>;
+    /**
+     * Provide the directories where new customization files of the given
+     * type can be created for this session. The result includes both
+     * workspace-scoped and user-scoped folders; the caller is responsible
+     * for partitioning them by storage target.
+     *
+     * @param sessionResource URI of the chat session whose
+     *   creation locations should be returned.
+     */
+    provideSourceFolders?(sessionResource: URI, type: PromptsType, token: CancellationToken): Promise<readonly ICustomizationSourceFolder[] | undefined>;
+}
+/**
+ * A directory where new customization files of a given type can be created.
+ */
+export interface ICustomizationSourceFolder {
+    readonly uri: URI;
+    /** Display label for the picker when multiple folders are offered. */
+    readonly label: string;
+    /** Customization source for this folder (typically 'local' or 'user' for writable creation locations). */
+    readonly source: AICustomizationSource;
+    /** Opaque provider-defined identity shared by folders that belong to the same destination. */
+    readonly destinationGroupId?: string;
+}
+/**
+ * Provider interface for harnesses that use an opt-out sync model.
+ *
+ * Every eligible local customization is synced by default; the user
+ * can disable individual items. The persisted set captures only the
+ * user's opt-outs.
+ */
+export interface ICustomizationSyncProvider {
+    readonly onDidChange: Event<void>;
+    isDisabled(uri: URI): boolean;
+    setDisabled(uri: URI, disabled: boolean): void;
+}
+/**
+ * Minimal slash-command metadata resolved from the active harness.
+ */
+export interface ICustomizationSlashCommand {
+    readonly uri: URI;
+    readonly type: PromptsType.prompt | PromptsType.skill;
+    readonly name: string;
+    readonly description?: string;
+    readonly userInvocable: boolean;
+    readonly sessionTypes?: readonly string[];
+}
+/**
+ * Builds the full source list from the base set (local, user, plugin)
+ * plus any additional sources specific to the window type.
+ *
+ * Core passes `[PromptsStorage.extension]`; sessions passes its
+ * BUILTIN_STORAGE constant.
+ */
+/**
+ * Creates a "VS Code" harness descriptor that shows all storage sources
+ * with no user-root restrictions.
+ */
+export declare function createVSCodeHarnessDescriptor(): IHarnessDescriptor;
+/**
+ * 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 {
+    private readonly promptsService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeSlashCommands;
+    readonly onDidChangeSlashCommands: Event<{
+        readonly sessionType: string;
+    }>;
+    private readonly _onDidChangeCustomAgents;
+    readonly onDidChangeCustomAgents: Event<{
+        readonly sessionType: string;
+    }>;
+    private readonly _providerListeners;
+    private _isDisposed;
+    private readonly _activeSessionResource;
+    readonly activeSessionResource: IObservable<URI>;
+    private readonly _activeHarness;
+    readonly activeHarness: IObservable<string>;
+    private readonly _staticHarnesses;
+    private readonly _externalHarnesses;
+    private readonly _availableHarnesses;
+    readonly availableHarnesses: IObservable<readonly IHarnessDescriptor[]>;
+    constructor(staticHarnesses: readonly IHarnessDescriptor[], defaultHarness: string, promptsService: IPromptsService);
+    private _getAllHarnesses;
+    private _refreshAvailableHarnesses;
+    private _rebindProviderListeners;
+    dispose(): void;
+    registerExternalHarness(descriptor: IHarnessDescriptor): IDisposable;
+    findHarnessById(id: string): IHarnessDescriptor | undefined;
+    setActiveSession(sessionResource: URI): void;
+    getActiveDescriptor(): IHarnessDescriptor;
+    getSlashCommands(sessionResource: URI, token: CancellationToken): Promise<readonly IChatPromptSlashCommand[]>;
+    getCustomAgents(sessionResource: URI, token: CancellationToken): Promise<readonly ICustomAgent[]>;
+    resolvePromptSlashCommand(name: string, sessionResource: URI, token: CancellationToken): Promise<IResolvedChatPromptSlashCommand | undefined>;
+    getSessionResourceForHarness(sessionType: string): URI;
+}