@codingame/monaco-vscode-api 30.0.1 → 31.0.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/computeAutomaticInstructions.js

@@ -4,10 +4,9 @@ import { splitGlobAware, match } from '../../../../../base/common/glob.js';
 import { ResourceMap, ResourceSet } from '../../../../../base/common/map.js';
 import { Schemas } from '../../../../../base/common/network.js';
 import { OperatingSystem } from '../../../../../base/common/platform.js';
-import { dirname, basename } from '../../../../../base/common/resources.js';
+import { basename, dirname } from '../../../../../base/common/resources.js';
 import { localize } from '../../../../../nls.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
-import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
 import { IFileService } from '../../../../../platform/files/common/files.service.js';
 import { ILabelService } from '../../../../../platform/label/common/label.service.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
@@ -19,37 +18,25 @@ import { VSCodeToolReference } from '../tools/languageModelToolsService.js';
 import { ILanguageModelToolsService } from '../tools/languageModelToolsService.service.js';
 import { PromptsConfig } from './config/config.js';
 import { isInClaudeRulesFolder, isInClaudeAgentsFolder, isPromptOrInstructionsFile } from './config/promptFileLocations.js';
-import { AgentFileType } from './service/promptsService.js';
+import { newInstructionsCollectionEvent, newInstructionsCollectionDebugInfo, matchesSessionType, AgentInstructionFileType } from './service/promptsService.js';
 import { IPromptsService } from './service/promptsService.service.js';
-import { AGENT_DEBUG_LOG_ENABLED_SETTING, AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING, TROUBLESHOOT_SKILL_PATH } from './promptTypes.js';
+import { AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING, TROUBLESHOOT_SKILL_PATH } from './promptTypes.js';
 import { OffsetRange } from '../../../../../editor/common/core/ranges/offsetRange.js';
-import { ChatModeKind, ChatConfiguration } from '../constants.js';
+import { ChatModeKind, ChatConfiguration, GeneralPurposeAgentName } from '../constants.js';
 import { hash } from '../../../../../base/common/hash.js';
 import { IAgentPluginService } from '../plugins/agentPluginService.service.js';
 
-function newInstructionsCollectionEvent() {
-    return {
-        applyingInstructionsCount: 0,
-        referencedInstructionsCount: 0,
-        agentInstructionsCount: 0,
-        listedInstructionsCount: 0,
-        totalInstructionsCount: 0,
-        claudeRulesCount: 0,
-        claudeMdCount: 0,
-        claudeAgentsCount: 0
-    };
-}
+let lastInstructionsCollectionResult;
 let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
     constructor(
         _modeKind,
         _enabledTools,
         _enabledSubagents,
-        _sessionResource,
+        _currentSessionType,
         _promptsService,
         _logService,
         _labelService,
         _configurationService,
-        _contextKeyService,
         _workspaceService,
         _fileService,
         _remoteAgentService,
@@ -60,12 +47,11 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
         this._modeKind = _modeKind;
         this._enabledTools = _enabledTools;
         this._enabledSubagents = _enabledSubagents;
-        this._sessionResource = _sessionResource;
+        this._currentSessionType = _currentSessionType;
         this._promptsService = _promptsService;
         this._logService = _logService;
         this._labelService = _labelService;
         this._configurationService = _configurationService;
-        this._contextKeyService = _contextKeyService;
         this._workspaceService = _workspaceService;
         this._fileService = _fileService;
         this._remoteAgentService = _remoteAgentService;
@@ -91,21 +77,28 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
         }
     }
     async collect(variables, token) {
-        const instructionFiles = await this._promptsService.getInstructionFiles(token, this._sessionResource);
+        const startTime = performance.now();
+        const instructionFiles = await this._promptsService.getInstructionFiles(token);
         this._logService.trace(
             `[InstructionsContextComputer] ${instructionFiles.length} instruction files available.`
         );
         const telemetryEvent = newInstructionsCollectionEvent();
+        const debugInfo = newInstructionsCollectionDebugInfo();
         const context = this._getContext(variables);
-        await this.addApplyingInstructions(instructionFiles, context, variables, telemetryEvent, token);
-        await this._addReferencedInstructions(variables, telemetryEvent, token);
-        await this._addAgentInstructions(variables, telemetryEvent, token);
-        const customizationsIndexVariable = await this._getCustomizationsIndex(instructionFiles, variables, telemetryEvent, token);
+        await this.addApplyingInstructions(instructionFiles, context, variables, telemetryEvent, debugInfo, token);
+        await this._addReferencedInstructions(variables, telemetryEvent, debugInfo, token);
+        await this._addAgentInstructions(variables, telemetryEvent, debugInfo, token);
+        const customizationsIndexVariable = await this._getCustomizationsIndex(instructionFiles, variables, telemetryEvent, debugInfo, token);
         if (customizationsIndexVariable) {
             variables.add(customizationsIndexVariable);
             telemetryEvent.listedInstructionsCount++;
         }
+        debugInfo.durationInMillis = performance.now() - startTime;
         this.sendTelemetry(telemetryEvent);
+        lastInstructionsCollectionResult = {
+            telemetryEvent,
+            debugInfo
+        };
     }
     sendTelemetry(telemetryEvent) {
         telemetryEvent.totalInstructionsCount = telemetryEvent.agentInstructionsCount + telemetryEvent.referencedInstructionsCount + telemetryEvent.applyingInstructionsCount + telemetryEvent.listedInstructionsCount;
@@ -136,7 +129,7 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
             this._logService.error("[InstructionsContextComputer] Failed to log skill telemetry", err);
         }
     }
-    async addApplyingInstructions(instructionFiles, context, variables, telemetryEvent, token) {
+    async addApplyingInstructions(instructionFiles, context, variables, telemetryEvent, debugInfo, token) {
         const includeApplyingInstructions = this._configurationService.getValue(PromptsConfig.INCLUDE_APPLYING_INSTRUCTIONS);
         if (!includeApplyingInstructions && this._modeKind !== ChatModeKind.Edit) {
             this._logService.trace(
@@ -144,26 +137,39 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
             );
             return;
         }
-        for (const {
-            uri
-        } of instructionFiles) {
-            const parsedFile = await this._parseInstructionsFile(uri, token);
-            if (!parsedFile) {
-                this._logService.trace(`[InstructionsContextComputer] Unable to read: ${uri}`);
+        const currentSessionType = this._currentSessionType;
+        for (const instructionFile of instructionFiles) {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const {
+                uri,
+                pattern
+            } = instructionFile;
+            if (!matchesSessionType(instructionFile.sessionTypes, currentSessionType)) {
                 continue;
             }
-            const applyTo = parsedFile.header?.applyTo;
-            const paths = parsedFile.header?.paths;
-            const isClaudeRules = isInClaudeRulesFolder(uri);
-            const pattern = isClaudeRules ? (paths?.join(", ") ?? "**") : applyTo;
             if (!pattern) {
-                this._logService.trace(`[InstructionsContextComputer] No 'applyTo' found: ${uri}`);
+                this._logService.trace(`[InstructionsContextComputer] No pattern (applyTo / paths) found: ${uri}`);
+                debugInfo.debugDetails.push({
+                    category: "skipped",
+                    name: ( basename(uri).toString()),
+                    uri,
+                    reason: ( localize(7453, "no applyTo pattern"))
+                });
                 continue;
             }
+            const isClaudeRules = isInClaudeRulesFolder(uri);
             if (( context.instructions.has(uri))) {
                 this._logService.trace(
                     `[InstructionsContextComputer] Skipping already processed instruction file: ${uri}`
                 );
+                debugInfo.debugDetails.push({
+                    category: "skipped",
+                    name: ( basename(uri).toString()),
+                    uri,
+                    reason: ( localize(7454, "already processed"))
+                });
                 continue;
             }
             const match = this._matches(context.files, pattern);
@@ -171,9 +177,9 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                 this._logService.trace(
                     `[InstructionsContextComputer] Match for ${uri} with ${match.pattern}${match.file ? ` for file ${match.file}` : ""}`
                 );
-                const reason = !match.file ? ( localize(7334, "Automatically attached as pattern is **")) : ( localize(
-                    7335,
-                    "Automatically attached as pattern {0} matches {1}",
+                const reason = !match.file ? ( localize(7455, "automatically attached as pattern is **")) : ( localize(
+                    7456,
+                    "automatically attached as pattern {0} matches {1}",
                     pattern,
                     this._labelService.getUriLabel(match.file, {
                         relative: true
@@ -183,11 +189,23 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                     toPromptFileVariableEntry(uri, PromptFileVariableKind.Instruction, reason, true)
                 );
                 telemetryEvent.applyingInstructionsCount++;
+                debugInfo.debugDetails.push({
+                    category: "applying",
+                    name: ( basename(uri).toString()),
+                    uri,
+                    reason
+                });
                 if (isClaudeRules) {
                     telemetryEvent.claudeRulesCount++;
                 }
             } else {
                 this._logService.trace(`[InstructionsContextComputer] No match for ${uri} with ${pattern}`);
+                debugInfo.debugDetails.push({
+                    category: "skipped",
+                    name: ( basename(uri).toString()),
+                    uri,
+                    reason: ( localize(7457, "applyTo '{0}' did not match any attached files", pattern))
+                });
             }
         }
     }
@@ -209,7 +227,7 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
             instructions
         };
     }
-    async _addAgentInstructions(variables, telemetryEvent, token) {
+    async _addAgentInstructions(variables, telemetryEvent, debugInfo, token) {
         const logger = {
             logInfo: message => this._logService.trace(`[InstructionsContextComputer] ${message}`)
         };
@@ -222,17 +240,23 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
         } of allCandidates) {
             const varEntry = toPromptFileVariableEntry(uri, PromptFileVariableKind.Instruction, undefined, true);
             entries.add(varEntry);
-            if (type === AgentFileType.copilotInstructionsMd) {
+            if (type === AgentInstructionFileType.copilotInstructionsMd) {
                 copilotEntries.add(varEntry);
             }
             telemetryEvent.agentInstructionsCount++;
-            if (type === AgentFileType.claudeMd) {
+            if (type === AgentInstructionFileType.claudeMd) {
                 telemetryEvent.claudeMdCount++;
             }
+            debugInfo.debugDetails.push({
+                category: "applying",
+                name: ( basename(uri).toString()),
+                uri,
+                reason: ( localize(7458, "always added"))
+            });
             logger.logInfo(`Agent instruction file added: ${( uri.toString())}`);
         }
         if (copilotEntries.length > 0) {
-            await this._addReferencedInstructions(copilotEntries, telemetryEvent, token);
+            await this._addReferencedInstructions(copilotEntries, telemetryEvent, debugInfo, token);
             for (const entry of copilotEntries.asArray()) {
                 variables.add(entry);
             }
@@ -289,9 +313,10 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
         }
         return undefined;
     }
-    async _getCustomizationsIndex(instructionFiles, _existingVariables, telemetryEvent, token) {
+    async _getCustomizationsIndex(instructionFiles, _existingVariables, telemetryEvent, debugInfo, token) {
         const readTool = this._getTool("readFile");
         const runSubagentTool = this._getTool(VSCodeToolReference.runSubagent);
+        const currentSessionType = this._currentSessionType;
         const remoteEnv = await this._remoteAgentService.getEnvironment();
         const remoteOS = remoteEnv?.os;
         const filePath = uri => getFilePath(uri, remoteOS);
@@ -314,30 +339,20 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
             );
             entries.push("Make sure to acquire the instructions before working with the codebase.");
             let hasContent = false;
-            for (const {
-                uri
-            } of instructionFiles) {
-                const parsedFile = await this._parseInstructionsFile(uri, token);
-                if (parsedFile) {
-                    entries.push("<instruction>");
-                    if (parsedFile.header) {
-                        const {
-                            description
-                        } = parsedFile.header;
-                        if (description) {
-                            entries.push(`<description>${description}</description>`);
-                        }
-                        entries.push(`<file>${filePath(uri)}</file>`);
-                        const applyToPattern = evaluateApplyToPattern(parsedFile.header, isInClaudeRulesFolder(uri));
-                        if (applyToPattern) {
-                            entries.push(`<applyTo>${applyToPattern}</applyTo>`);
-                        }
-                    } else {
-                        entries.push(`<file>${filePath(uri)}</file>`);
-                    }
-                    entries.push("</instruction>");
-                    hasContent = true;
+            for (const instruction of instructionFiles) {
+                if (!matchesSessionType(instruction.sessionTypes, currentSessionType)) {
+                    continue;
+                }
+                entries.push("<instruction>");
+                if (instruction.description) {
+                    entries.push(`<description>${instruction.description}</description>`);
+                }
+                entries.push(`<file>${filePath(instruction.uri)}</file>`);
+                if (instruction.pattern) {
+                    entries.push(`<applyTo>${instruction.pattern}</applyTo>`);
                 }
+                entries.push("</instruction>");
+                hasContent = true;
             }
             const agentsMdFiles = await agentsMdPromise;
             for (const {
@@ -346,7 +361,7 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                 const folderName = this._labelService.getUriLabel(dirname(uri), {
                     relative: true
                 });
-                const description = folderName.trim().length === 0 ? ( localize(7336, "Instructions for the workspace")) : ( localize(7337, "Instructions for folder '{0}'", folderName));
+                const description = folderName.trim().length === 0 ? ( localize(7459, "Instructions for the workspace")) : ( localize(7460, "Instructions for folder '{0}'", folderName));
                 entries.push("<instruction>");
                 entries.push(`<description>${description}</description>`);
                 entries.push(`<file>${filePath(uri)}</file>`);
@@ -358,23 +373,48 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
             } else {
                 entries.push("</instructions>", "", "");
             }
-            const agentSkills = await this._promptsService.findAgentSkills(token, this._sessionResource);
-            const isDebugLogEnabled = this._configurationService.getValue(AGENT_DEBUG_LOG_ENABLED_SETTING);
+            const agentSkills = await this._promptsService.findAgentSkills(token);
             const isFileLoggingEnabled = this._configurationService.getValue(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING);
             const modelInvocableSkills = agentSkills?.filter(skill => {
                 if (skill.disableModelInvocation) {
+                    debugInfo.debugDetails.push({
+                        category: "skipped",
+                        name: skill.name,
+                        uri: skill.uri,
+                        reason: ( localize(7461, "model invocation disabled"))
+                    });
                     return false;
                 }
-                if (skill.when && !this._contextKeyService.contextMatchesRules(skill.when)) {
+                if (!matchesSessionType(skill.sessionTypes, currentSessionType)) {
+                    debugInfo.debugDetails.push({
+                        category: "skipped",
+                        name: skill.name,
+                        uri: skill.uri,
+                        reason: ( localize(7462, "session type not matched"))
+                    });
                     return false;
                 }
-                if ((!isDebugLogEnabled || !isFileLoggingEnabled) && skill.uri.path.includes(TROUBLESHOOT_SKILL_PATH)) {
+                if (!isFileLoggingEnabled && skill.uri.path.includes(TROUBLESHOOT_SKILL_PATH)) {
+                    debugInfo.debugDetails.push({
+                        category: "skipped",
+                        name: skill.name,
+                        uri: skill.uri,
+                        reason: ( localize(7463, "debug logging disabled"))
+                    });
                     return false;
                 }
                 return true;
             });
             if (modelInvocableSkills && modelInvocableSkills.length > 0) {
                 this._logSkillLoadedTelemetry(modelInvocableSkills);
+                for (const skill of modelInvocableSkills) {
+                    debugInfo.debugDetails.push({
+                        category: "skill",
+                        name: skill.name,
+                        uri: skill.uri,
+                        reason: skill.storage
+                    });
+                }
                 const useSkillAdherencePrompt = this._configurationService.getValue(PromptsConfig.USE_SKILL_ADHERENCE_PROMPT);
                 entries.push("<skills>");
                 if (useSkillAdherencePrompt) {
@@ -431,17 +471,18 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                 entries.push("</skills>", "", "");
             }
         }
-        if (runSubagentTool && this._configurationService.getValue(ChatConfiguration.SubagentToolCustomAgents)) {
+        if (runSubagentTool) {
+            const generalPurposeAgentEnabled = !!this._configurationService.getValue(ChatConfiguration.GeneralPurposeAgentEnabled);
             const canUseAgent = (() => {
                 if (!this._enabledSubagents || this._enabledSubagents.includes("*")) {
-                    return agent => agent.visibility.agentInvocable;
+                    return agent => agent.visibility.agentInvocable && matchesSessionType(agent.sessionTypes, currentSessionType);
                 } else {
                     const subagents = this._enabledSubagents;
-                    return agent => subagents.includes(agent.name);
+                    return agent => subagents.includes(agent.name) && matchesSessionType(agent.sessionTypes, currentSessionType);
                 }
             })();
-            const agents = await this._promptsService.getCustomAgents(token, this._sessionResource);
-            if (agents.length > 0) {
+            const agents = await this._promptsService.getCustomAgents(token);
+            if (generalPurposeAgentEnabled || agents.length > 0) {
                 entries.push("<agents>");
                 entries.push("Here is a list of agents that can be used when running a subagent.");
                 entries.push(
@@ -450,6 +491,14 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                 entries.push(
                     `Use the ${runSubagentTool.variable} tool with the agent name to run the subagent.`
                 );
+                if (generalPurposeAgentEnabled) {
+                    entries.push("<agent>");
+                    entries.push(`<name>${GeneralPurposeAgentName}</name>`);
+                    entries.push(
+                        `<description>Full-capability agent for complex multi-step tasks requiring high-quality reasoning. Has access to the same tools and capabilities as the current agent and inherits the parent agent's model and system prompt. Use for tasks that don't fit a more specialized agent.</description>`
+                    );
+                    entries.push("</agent>");
+                }
                 for (const agent of agents) {
                     if (canUseAgent(agent)) {
                         entries.push("<agent>");
@@ -461,9 +510,21 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                             entries.push(`<argumentHint>${agent.argumentHint}</argumentHint>`);
                         }
                         entries.push("</agent>");
+                        debugInfo.debugDetails.push({
+                            category: "custom-agent",
+                            name: agent.name,
+                            uri: agent.uri
+                        });
                         if (isInClaudeAgentsFolder(agent.uri)) {
                             telemetryEvent.claudeAgentsCount++;
                         }
+                    } else {
+                        debugInfo.debugDetails.push({
+                            category: "skipped",
+                            name: agent.name,
+                            uri: agent.uri,
+                            reason: ( localize(7464, "not invocable by model"))
+                        });
                     }
                 }
                 entries.push("</agents>", "", "");
@@ -487,7 +548,7 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
         collectToolReference(runSubagentTool);
         return toPromptTextVariableEntry(content, true, toolReferences);
     }
-    async _addReferencedInstructions(attachedContext, telemetryEvent, token) {
+    async _addReferencedInstructions(attachedContext, telemetryEvent, debugInfo, token) {
         const includeReferencedInstructions = this._configurationService.getValue(PromptsConfig.INCLUDE_REFERENCED_INSTRUCTIONS);
         if (!includeReferencedInstructions && this._modeKind !== ChatModeKind.Edit) {
             this._logService.trace(
@@ -528,11 +589,17 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
                             if (isPromptOrInstructionsFile(uri)) {
                                 todo.push(uri);
                             }
-                            const reason = ( localize(7338, "Referenced by {0}", basename(next)));
+                            const reason = ( localize(7465, "Referenced by {0}", basename(next)));
                             attachedContext.add(
                                 toPromptFileVariableEntry(uri, PromptFileVariableKind.InstructionReference, reason, true)
                             );
                             telemetryEvent.referencedInstructionsCount++;
+                            debugInfo.debugDetails.push({
+                                category: "referenced",
+                                name: ( basename(uri).toString()),
+                                uri,
+                                reason
+                            });
                             this._logService.trace(`[InstructionsContextComputer] ${( uri.toString())} added, referenced by ${( next.toString())}`);
                         }
                     }
@@ -542,7 +609,7 @@ let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
         }
     }
 };
-ComputeAutomaticInstructions = ( __decorate([( __param(4, IPromptsService)), ( __param(5, ILogService)), ( __param(6, ILabelService)), ( __param(7, IConfigurationService)), ( __param(8, IContextKeyService)), ( __param(9, IWorkspaceContextService)), ( __param(10, IFileService)), ( __param(11, IRemoteAgentService)), ( __param(12, ITelemetryService)), ( __param(13, ILanguageModelToolsService)), ( __param(14, IAgentPluginService))], ComputeAutomaticInstructions));
+ComputeAutomaticInstructions = ( __decorate([( __param(4, IPromptsService)), ( __param(5, ILogService)), ( __param(6, ILabelService)), ( __param(7, IConfigurationService)), ( __param(8, IWorkspaceContextService)), ( __param(9, IFileService)), ( __param(10, IRemoteAgentService)), ( __param(11, ITelemetryService)), ( __param(12, ILanguageModelToolsService)), ( __param(13, IAgentPluginService))], ComputeAutomaticInstructions));
 function getFilePath(uri, remoteOS) {
     if (uri.scheme === Schemas.file || uri.scheme === Schemas.vscodeRemote) {
         const fsPath = uri.fsPath;
@@ -556,11 +623,5 @@ function getFilePath(uri, remoteOS) {
     }
     return ( uri.toString());
 }
-function evaluateApplyToPattern(header, isClaudeRules) {
-    if (isClaudeRules) {
-        return header?.paths?.join(", ") ?? "**";
-    }
-    return header?.applyTo ?? undefined;
-}
 
-export { ComputeAutomaticInstructions, evaluateApplyToPattern, getFilePath, newInstructionsCollectionEvent };
+export { ComputeAutomaticInstructions, getFilePath, lastInstructionsCollectionResult, newInstructionsCollectionDebugInfo, newInstructionsCollectionEvent };

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

@@ -1,26 +1,17 @@
 import { IJSONSchema } from "../../../../../base/common/jsonSchema.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { OperatingSystem } from "../../../../../base/common/platform.js";
+import { IParsedHookCommand } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentPlugins/common/pluginParsers";
 import { HookType } from "./hookTypes.js";
 import { Target } from "./promptTypes.js";
 import { IMapValue } from "./promptFileParser.js";
 /**
  * A single hook command configuration.
+ * Extends the platform-layer {@link IParsedHookCommand} with editor-specific
+ * metadata used for UI display and field highlighting.
  */
-export interface IHookCommand {
+export interface IHookCommand extends IParsedHookCommand {
     readonly type: "command";
-    /** Cross-platform command to execute. */
-    readonly command?: string;
-    /** Windows-specific command override. */
-    readonly windows?: string;
-    /** Linux-specific command override. */
-    readonly linux?: string;
-    /** macOS-specific command override. */
-    readonly osx?: string;
-    /** Resolved working directory URI. */
-    readonly cwd?: URI;
-    readonly env?: Record<string, string>;
-    readonly timeout?: number;
     /** Original JSON field name that provided the windows command. */
     readonly windowsSource?: "windows" | "powershell";
     /** Original JSON field name that provided the linux command. */
@@ -33,7 +24,7 @@ export interface IHookCommand {
  * This is passed to the extension host so it knows what hooks are available.
  */
 export type ChatRequestHooks = {
-    readonly [K in HookType]?: readonly IHookCommand[];
+    readonly [K in HookType]?: readonly IParsedHookCommand[];
 };
 /**
  * Merges two sets of hooks by concatenating the command arrays for each hook type.
@@ -64,11 +55,11 @@ export declare function getPlatformLabel(os: OperatingSystem): string;
  * This applies OS-specific overrides (windows, linux, osx) to get the actual command that will be executed.
  * Similar to how launch.json handles platform-specific configurations in debugAdapter.ts.
  */
-export declare function resolveEffectiveCommand(hook: IHookCommand, os: OperatingSystem): string | undefined;
+export declare function resolveEffectiveCommand(hook: IParsedHookCommand, os: OperatingSystem): string | undefined;
 /**
  * Checks if the hook is using a platform-specific command override.
  */
-export declare function isUsingPlatformOverride(hook: IHookCommand, os: OperatingSystem): boolean;
+export declare function isUsingPlatformOverride(hook: IParsedHookCommand, os: OperatingSystem): boolean;
 /**
  * Gets the source shell type for the effective command on the given platform.
  * Returns 'powershell' if the Windows command came from a powershell field,
@@ -81,13 +72,13 @@ export declare function getEffectiveCommandSource(hook: IHookCommand, os: Operat
  * Returns the actual field name from the JSON (e.g., 'bash' instead of 'osx' if bash was used).
  * This is used for editor focus to highlight the correct field.
  */
-export declare function getEffectiveCommandFieldKey(hook: IHookCommand, os: OperatingSystem): string;
+export declare function getEffectiveCommandFieldKey(hook: IHookCommand | IParsedHookCommand, os: OperatingSystem): string;
 /**
  * Formats a hook command for display.
  * Resolves OS-specific overrides to show the effective command for the given platform.
  * If using a platform-specific override, includes the platform as a prefix badge.
  */
-export declare function formatHookCommandLabel(hook: IHookCommand, os: OperatingSystem): string;
+export declare function formatHookCommandLabel(hook: IParsedHookCommand, os: OperatingSystem): string;
 /**
  * Resolves a raw hook command object to the canonical IHookCommand format.
  * Normalizes the command and resolves the cwd path relative to the workspace root.

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/hookSchema.js

@@ -25,32 +25,32 @@ function mergeHooks(base, additional) {
     return result;
 }
 const HOOK_COMMAND_FIELD_DESCRIPTIONS = {
-    type: ( localize(7339, "Must be \"command\".")),
+    type: ( localize(7466, "Must be \"command\".")),
     command: ( localize(
-        7340,
+        7467,
         "The command to execute. This is the default cross-platform command."
     )),
     windows: ( localize(
-        7341,
+        7468,
         "Windows-specific command. If specified and running on Windows, this overrides the \"command\" field."
     )),
     linux: ( localize(
-        7342,
+        7469,
         "Linux-specific command. If specified and running on Linux, this overrides the \"command\" field."
     )),
     osx: ( localize(
-        7343,
+        7470,
         "macOS-specific command. If specified and running on macOS, this overrides the \"command\" field."
     )),
-    bash: ( localize(7344, "Bash command for Linux and macOS.")),
-    powershell: ( localize(7345, "PowerShell command for Windows.")),
-    cwd: ( localize(7346, "Working directory for the script (relative to repository root).")),
+    bash: ( localize(7471, "Bash command for Linux and macOS.")),
+    powershell: ( localize(7472, "PowerShell command for Windows.")),
+    cwd: ( localize(7473, "Working directory for the script (relative to repository root).")),
     env: ( localize(
-        7347,
+        7474,
         "Additional environment variables that are merged with the existing environment."
     )),
-    timeout: ( localize(7348, "Maximum execution time in seconds (default: 30).")),
-    timeoutSec: ( localize(7349, "Maximum execution time in seconds (default: 10)."))
+    timeout: ( localize(7475, "Maximum execution time in seconds (default: 30).")),
+    timeoutSec: ( localize(7476, "Maximum execution time in seconds (default: 10)."))
 };
 const vscodeHookCommandSchema = {
     type: "object",
@@ -70,7 +70,7 @@ const vscodeHookCommandSchema = {
         required: ["powershell"]
     }],
     errorMessage: ( localize(
-        7350,
+        7477,
         "At least one of \"command\", \"windows\", \"linux\", or \"osx\" must be specified."
     )),
     properties: {
@@ -133,7 +133,7 @@ const copilotCliHookCommandSchema = {
     }, {
         required: ["powershell"]
     }],
-    errorMessage: ( localize(7351, "At least one of \"bash\" or \"powershell\" must be specified.")),
+    errorMessage: ( localize(7478, "At least one of \"bash\" or \"powershell\" must be specified.")),
     properties: {
         type: {
             type: "string",
@@ -175,7 +175,7 @@ const hookFileSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
     type: "object",
     description: ( localize(
-        7352,
+        7479,
         "GitHub Copilot hook configuration file. Hooks enable executing custom shell commands at strategic points in an agent's workflow."
     )),
     additionalProperties: true,
@@ -183,7 +183,7 @@ const hookFileSchema = {
     properties: {
         hooks: {
             type: "object",
-            description: ( localize(7353, "Hook definitions organized by type.")),
+            description: ( localize(7480, "Hook definitions organized by type.")),
             additionalProperties: true
         }
     },
@@ -199,7 +199,7 @@ const hookFileSchema = {
         properties: {
             version: {
                 type: "number",
-                description: ( localize(7354, "Hook configuration format version."))
+                description: ( localize(7481, "Hook configuration format version."))
             },
             hooks: {
                 properties: copilotCliHookProperties
@@ -214,8 +214,8 @@ const hookFileSchema = {
         }
     },
     defaultSnippets: [{
-        label: ( localize(7355, "Basic hook configuration")),
-        description: ( localize(7356, "A basic hook configuration with common hooks")),
+        label: ( localize(7482, "Basic hook configuration")),
+        description: ( localize(7483, "A basic hook configuration with common hooks")),
         body: {
             hooks: {
                 SessionStart: [{
@@ -301,12 +301,13 @@ function resolveEffectiveCommand(hook, os) {
     return hook.command;
 }
 function getEffectiveCommandFieldKey(hook, os) {
+    const h = hook;
     if (os === OperatingSystem.Windows && hook.windows) {
-        return hook.windowsSource ?? "windows";
+        return h.windowsSource ?? "windows";
     } else if (os === OperatingSystem.Macintosh && hook.osx) {
-        return hook.osxSource ?? "osx";
+        return h.osxSource ?? "osx";
     } else if (os === OperatingSystem.Linux && hook.linux) {
-        return hook.linuxSource ?? "linux";
+        return h.linuxSource ?? "linux";
     }
     return "command";
 }