@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { DeferredPromise, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
 import { ErrorNoTelemetry, BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
@@ -14,7 +14,6 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { OffsetRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -47,15 +46,16 @@ import { ChatSessionStore } from '../model/chatSessionStore.js';
 import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service';
 import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatTransferService.service';
 import { LocalChatSessionUri, getChatSessionType, chatSessionResourceToId, isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
-import { IChatRequestVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { IChatRequestVariableEntry, ChatRequestVariableSet, isPromptTextVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 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_ENABLED_SETTING, 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 { 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 { 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';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
@@ -196,7 +196,6 @@ let ChatService = class ChatService extends Disposable {
             this.trace("constructor", `Transferred session ${transferredData}`);
             this._transferredSessionResource = transferredData;
         }
-        this.reviveSessionsWithEdits();
         this._register(storageService.onWillSaveState(() => this.saveState()));
         this.chatModels = derived(this, reader => [...( this._sessionModels.observable.read(reader).values())]);
         this.requestInProgressObs = derived(reader => {
@@ -319,26 +318,6 @@ let ChatService = class ChatService extends Disposable {
             return {};
         }
     }
-    async reviveSessionsWithEdits() {
-        const idx = await this._chatSessionStore.getIndex();
-        await Promise.all(( ( Object.values(idx)).map(async session => {
-            if (!session.hasPendingEdits) {
-                return;
-            }
-            let sessionResource;
-            if (session.sessionId.includes(":")) {
-                try {
-                    sessionResource = ( URI.parse(session.sessionId, true));
-                } catch {}
-            }
-            sessionResource ??= LocalChatSessionUri.forSession(session.sessionId);
-            const sessionRef = await this.acquireOrLoadSession(sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
-            if (sessionRef?.object.editingSession) {
-                await chatEditingSessionIsReady(sessionRef.object.editingSession);
-                sessionRef.dispose();
-            }
-        })));
-    }
     async getLocalSessionHistory() {
         const liveSessionItems = await this.getLiveSessionItems();
         const historySessionItems = await this.getHistorySessionItems();
@@ -392,7 +371,7 @@ let ChatService = class ChatService extends Disposable {
             sessionResource,
             canUseTools: options?.canUseTools ?? true,
             disableBackgroundKeepAlive: options?.disableBackgroundKeepAlive
-        });
+        }, options?.debugOwner ?? "ChatService#startNewLocalSession");
     }
     _startSession(props) {
         const {
@@ -442,12 +421,15 @@ let ChatService = class ChatService extends Disposable {
     getSession(sessionResource) {
         return this._sessionModels.get(sessionResource);
     }
-    acquireExistingSession(sessionResource) {
-        return this._sessionModels.acquireExisting(sessionResource);
+    acquireExistingSession(sessionResource, debugOwner) {
+        return this._sessionModels.acquireExisting(sessionResource, debugOwner ?? "ChatService#acquireExistingSession");
     }
-    async acquireOrRestoreLocalSession(sessionResource) {
+    getChatModelReferenceDebugInfo() {
+        return this._sessionModels.getReferenceDebugSnapshot();
+    }
+    async acquireOrRestoreLocalSession(sessionResource, debugOwner) {
         this.trace("acquireOrRestoreSession", `${sessionResource}`);
-        const existingRef = this.acquireExistingSession(sessionResource);
+        const existingRef = this.acquireExistingSession(sessionResource, debugOwner);
         if (existingRef) {
             return existingRef;
         }
@@ -469,7 +451,7 @@ let ChatService = class ChatService extends Disposable {
             location: sessionData.value.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
             canUseTools: true
-        });
+        }, debugOwner ?? "ChatService#acquireOrRestoreLocalSession");
         return sessionRef;
     }
     getSessionTitle(sessionResource) {
@@ -479,7 +461,7 @@ let ChatService = class ChatService extends Disposable {
         }
         return this._sessionModels.get(sessionResource)?.title ?? this._chatSessionStore.getMetadataForSessionSync(sessionResource)?.title;
     }
-    loadSessionFromData(data) {
+    loadSessionFromData(data, debugOwner) {
         const sessionId = data.sessionId ?? generateUuid();
         const sessionResource = LocalChatSessionUri.forSession(sessionId);
         return this._sessionModels.acquireOrCreate({
@@ -490,18 +472,18 @@ let ChatService = class ChatService extends Disposable {
             location: data.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
             canUseTools: true
-        });
+        }, debugOwner ?? "ChatService#loadSessionFromData");
     }
-    async acquireOrLoadSession(sessionResource, location, token) {
+    async acquireOrLoadSession(sessionResource, location, token, debugOwner) {
         if (sessionResource.scheme === Schemas.vscodeLocalChatSession) {
-            return this.acquireOrRestoreLocalSession(sessionResource);
+            return this.acquireOrRestoreLocalSession(sessionResource, debugOwner);
         } else {
-            return this.loadRemoteSession(sessionResource, location, token);
+            return this.loadRemoteSession(sessionResource, location, token, debugOwner);
         }
     }
-    async loadRemoteSession(sessionResource, location, token) {
+    async loadRemoteSession(sessionResource, location, token, debugOwner) {
         {
-            const existingRef = this.acquireExistingSession(sessionResource);
+            const existingRef = this.acquireExistingSession(sessionResource, debugOwner);
             if (existingRef) {
                 return existingRef;
             }
@@ -511,14 +493,13 @@ let ChatService = class ChatService extends Disposable {
         }
         const providedSession = await this.chatSessionService.getOrCreateChatSession(sessionResource, token);
         {
-            const existingRef = this.acquireExistingSession(sessionResource);
+            const existingRef = this.acquireExistingSession(sessionResource, debugOwner);
             if (existingRef) {
                 providedSession.dispose();
                 return existingRef;
             }
         }
         const chatSessionType = getChatSessionType(sessionResource);
-        const contribution = this.chatSessionService.getChatSessionContribution(chatSessionType);
         const modelId = findLast(
             providedSession.history.filter(m => m.type === "request"),
             req => req.modelId
@@ -529,7 +510,7 @@ let ChatService = class ChatService extends Disposable {
         )?.modeInstructions?.uri;
         const storedPermissionLevel = this._chatSessionStore.getMetadataForSessionSync(sessionResource)?.permissionLevel;
         let initialData = undefined;
-        if ((modelId || agentUri) && contribution?.useRequestToPopulateBuiltInPickers) {
+        if ((modelId || agentUri)) {
             const mode = agentUri ? {
                 kind: ChatModeKind.Agent,
                 id: ( agentUri.toString())
@@ -552,7 +533,6 @@ let ChatService = class ChatService extends Disposable {
                     responderUsername: "",
                     sessionId: "",
                     version: 3,
-                    hasPendingEdits: undefined,
                     inputState: {
                         attachments: [],
                         contrib: {},
@@ -574,15 +554,12 @@ let ChatService = class ChatService extends Disposable {
             canUseTools: false,
             transferEditingSession: providedSession.transferredState?.editingSession,
             inputState: providedSession.transferredState?.inputState
-        });
+        }, debugOwner ?? "ChatService#loadRemoteSession");
         if (storedPermissionLevel && !initialData) {
             modelRef.object.inputModel.setState({
                 permissionLevel: storedPermissionLevel
             });
         }
-        modelRef.object.setContributedChatSession({
-            chatSessionResource: sessionResource
-        });
         if (providedSession.title) {
             modelRef.object.setCustomTitle(providedSession.title);
         }
@@ -634,9 +611,6 @@ let ChatService = class ChatService extends Disposable {
                 }
             }
         }
-        if (providedSession.isCompleteObs?.get()) {
-            lastRequest?.response?.complete();
-        }
         const hasProgressStreaming = providedSession.progressObs && providedSession.interruptActiveResponseCallback;
         if (hasProgressStreaming) {
             let lastProgressLength = 0;
@@ -645,39 +619,28 @@ let ChatService = class ChatService extends Disposable {
                 return token.onCancellationRequested(() => {
                     providedSession.interruptActiveResponseCallback?.().then(userConfirmedInterruption => {
                         if (!userConfirmedInterruption) {
-                            const newCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined, undefined, undefined);
-                            this._pendingRequests.set(model.sessionResource, newCancellationRequest);
-                            this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
-                                action: "add",
-                                source: "remoteSession",
-                                chatSessionId: chatSessionResourceToId(model.sessionResource)
-                            });
-                            cancellationListener.value = createCancellationListener(newCancellationRequest.cancellationTokenSource.token);
+                            trackNewCancellableRequest();
                         }
                     });
                 });
             };
-            const ensureCancellationTracking = () => {
-                if (!( this._pendingRequests.has(model.sessionResource))) {
-                    const cts = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined, undefined, undefined);
-                    this._pendingRequests.set(model.sessionResource, cts);
-                    this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
-                        action: "add",
-                        source: "remoteSession",
-                        chatSessionId: chatSessionResourceToId(model.sessionResource)
-                    });
-                    cancellationListener.value = createCancellationListener(cts.cancellationTokenSource.token);
-                }
-            };
-            if (lastRequest) {
-                const initialCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined, undefined, undefined);
-                this._pendingRequests.set(model.sessionResource, initialCancellationRequest);
+            const trackNewCancellableRequest = () => {
+                const cancellableRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined, undefined, undefined);
+                this._pendingRequests.set(model.sessionResource, cancellableRequest);
                 this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
                     action: "add",
                     source: "remoteSession",
                     chatSessionId: chatSessionResourceToId(model.sessionResource)
                 });
-                cancellationListener.value = createCancellationListener(initialCancellationRequest.cancellationTokenSource.token);
+                cancellationListener.value = createCancellationListener(cancellableRequest.cancellationTokenSource.token);
+            };
+            const ensureCancellationTracking = () => {
+                if (!( this._pendingRequests.has(model.sessionResource))) {
+                    trackNewCancellableRequest();
+                }
+            };
+            if (lastRequest && !providedSession.isCompleteObs?.get()) {
+                trackNewCancellableRequest();
             }
             if (providedSession.onDidStartServerRequest) {
                 disposables.add(providedSession.onDidStartServerRequest((
@@ -717,11 +680,15 @@ let ChatService = class ChatService extends Disposable {
                     lastProgressLength = progressArray.length;
                 }
                 if (isComplete && lastRequest) {
-                    lastRequest.response?.complete();
+                    this._pendingRequests.deleteAndDispose(model.sessionResource);
                     cancellationListener.clear();
+                    lastRequest.response?.complete();
                 }
             }));
         } else {
+            if (providedSession.isCompleteObs?.get()) {
+                lastRequest?.response?.complete();
+            }
             this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
                 action: "notCancelable",
                 source: "remoteSession",
@@ -734,16 +701,6 @@ let ChatService = class ChatService extends Disposable {
         }
         return modelRef;
     }
-    getChatSessionFromInternalUri(sessionResource) {
-        const model = this._sessionModels.get(sessionResource);
-        if (!model) {
-            return;
-        }
-        const {
-            contributedChatSession
-        } = model;
-        return contributedChatSession;
-    }
     async resendRequest(request, options) {
         const model = this._sessionModels.get(request.session.sessionResource);
         if (!model && model !== request.session) {
@@ -792,7 +749,10 @@ let ChatService = class ChatService extends Disposable {
             locationData: options.locationData,
             attachedContext: options.attachedContext,
             modelId: options.userSelectedModelId,
-            userSelectedTools: options.userSelectedTools?.get()
+            userSelectedTools: options.userSelectedTools?.get(),
+            isSystemInitiated: options.isSystemInitiated,
+            systemInitiatedLabel: options.systemInitiatedLabel,
+            terminalExecutionId: options.terminalExecutionId
         }));
         const deferred = ( new DeferredPromise());
         this._queuedRequestDeferreds.set(requestModel.id, deferred);
@@ -822,86 +782,89 @@ let ChatService = class ChatService extends Disposable {
         if (!model) {
             throw ( new Error(`Unknown session: ${sessionResource}`));
         }
+        let tempRef;
         let newSessionResource;
-        if (!model.hasRequests && isUntitledChatSession(sessionResource) && getChatSessionType(sessionResource) !== localChatSessionType) {
-            const parsedRequest = this.parseChatRequest(
-                sessionResource,
-                request,
-                options?.location ?? model.initialLocation,
-                options
-            );
-            const commandPart = parsedRequest.parts.find(r => r instanceof ChatRequestSlashCommandPart);
-            const requestText = getPromptText(parsedRequest).message;
-            const initialSessionOptions = this.chatSessionService.getSessionOptions(sessionResource);
-            const newItem = await this.chatSessionService.createNewChatSessionItem(getChatSessionType(sessionResource), {
-                prompt: requestText,
-                command: commandPart?.text,
-                initialSessionOptions
-            }, CancellationToken.None);
-            if (newItem) {
-                model = (await this.loadRemoteSession(newItem.resource, model.initialLocation, CancellationToken.None))?.object;
-                if (!model) {
-                    throw ( new Error(`Failed to load session for resource: ${newItem.resource}`));
+        try {
+            if (!model.hasRequests && isUntitledChatSession(sessionResource) && getChatSessionType(sessionResource) !== localChatSessionType) {
+                const parsedRequest = this.parseChatRequest(
+                    sessionResource,
+                    request,
+                    options?.location ?? model.initialLocation,
+                    options
+                );
+                const commandPart = parsedRequest.parts.find(r => r instanceof ChatRequestSlashCommandPart);
+                const requestText = getPromptText(parsedRequest).message;
+                const initialSessionOptions = this.chatSessionService.getSessionOptions(sessionResource);
+                const newItem = await this.chatSessionService.createNewChatSessionItem(getChatSessionType(sessionResource), {
+                    prompt: requestText,
+                    command: commandPart?.text,
+                    initialSessionOptions
+                }, CancellationToken.None);
+                if (newItem) {
+                    this.chatSessionService.registerSessionResourceAlias(sessionResource, newItem.resource);
+                    tempRef = await this.loadRemoteSession(newItem.resource, model.initialLocation, CancellationToken.None);
+                    model = tempRef?.object;
+                    if (!model) {
+                        throw ( new Error(`Failed to load session for resource: ${newItem.resource}`));
+                    }
+                    if (initialSessionOptions) {
+                        this.chatSessionService.updateSessionOptions(model.sessionResource, initialSessionOptions);
+                    }
+                    sessionResource = newItem.resource;
+                    newSessionResource = newItem.resource;
                 }
-                this.chatSessionService.registerSessionResourceAlias(sessionResource, newItem.resource);
-                model.setContributedChatSession({
-                    chatSessionResource: newItem.resource,
-                    initialSessionOptions: initialSessionOptions
-                });
-                sessionResource = newItem.resource;
-                newSessionResource = newItem.resource;
             }
-        }
-        const hasPendingRequest = ( this._pendingRequests.has(sessionResource));
-        if (options?.queue) {
-            const queued = this.queuePendingRequest(model, sessionResource, request, options);
-            if (!options.pauseQueue) {
-                this.processPendingRequests(sessionResource);
-            }
-            return queued;
-        } else if (hasPendingRequest) {
-            this.trace("sendRequest", `Session ${sessionResource} already has a pending request`);
-            return {
-                kind: "rejected",
-                reason: "Request already in progress"
-            };
-        }
-        const requests = model.getRequests();
-        for (let i = requests.length - 1; i >= 0; i -= 1) {
-            const request = requests[i];
-            if (request.shouldBeRemovedOnSend) {
-                if (request.shouldBeRemovedOnSend.afterUndoStop) {
-                    request.response?.finalizeUndoState();
-                } else {
-                    await this.removeRequest(sessionResource, request.id);
+            const hasPendingRequest = ( this._pendingRequests.has(sessionResource));
+            if (options?.queue) {
+                const queued = this.queuePendingRequest(model, sessionResource, request, options);
+                if (!options.pauseQueue) {
+                    this.processPendingRequests(sessionResource);
                 }
+                return queued;
+            } else if (hasPendingRequest) {
+                this.trace("sendRequest", `Session ${sessionResource} already has a pending request`);
+                return {
+                    kind: "rejected",
+                    reason: "Request already in progress"
+                };
             }
-        }
-        const location = options?.location ?? model.initialLocation;
-        const attempt = options?.attempt ?? 0;
-        const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
-        const parsedRequest = this.parseChatRequest(sessionResource, request, location, options);
-        const silentAgent = options?.agentIdSilent ? this.chatAgentService.getAgent(options.agentIdSilent) : undefined;
-        const agent = silentAgent ?? parsedRequest.parts.find(r => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
-        const agentSlashCommandPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentSubcommandPart);
-        return {
-            kind: "sent",
-            newSessionResource,
-            data: {
-                ...this._sendRequestAsync(
-                    model,
-                    sessionResource,
-                    parsedRequest,
-                    attempt,
-                    !options?.noCommandDetection,
-                    silentAgent ?? defaultAgent,
-                    location,
-                    options
-                ),
-                agent,
-                slashCommand: agentSlashCommandPart?.command
+            const requests = model.getRequests();
+            for (let i = requests.length - 1; i >= 0; i -= 1) {
+                const request = requests[i];
+                if (request.shouldBeRemovedOnSend) {
+                    if (request.shouldBeRemovedOnSend.afterUndoStop) {
+                        request.response?.finalizeUndoState();
+                    } else {
+                        await this.removeRequest(sessionResource, request.id);
+                    }
+                }
             }
-        };
+            const location = options?.location ?? model.initialLocation;
+            const attempt = options?.attempt ?? 0;
+            const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
+            const parsedRequest = this.parseChatRequest(sessionResource, request, location, options);
+            const silentAgent = options?.agentIdSilent ? this.chatAgentService.getAgent(options.agentIdSilent) : undefined;
+            const agent = silentAgent ?? parsedRequest.parts.find(r => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
+            const agentSlashCommandPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentSubcommandPart);
+            return {
+                kind: "sent",
+                newSessionResource,
+                data: {
+                    ...this._sendRequestAsync(
+                        model,
+                        sessionResource,
+                        parsedRequest,
+                        attempt,
+                        !options?.noCommandDetection,
+                        silentAgent ?? defaultAgent,
+                        location,
+                        options
+                    ),
+                    agent,
+                    slashCommand: agentSlashCommandPart?.command
+                }
+            };
+        } finally {}
     }
     parseChatRequest(sessionResource, request, location, options) {
         let parserContext = options?.parserContext;
@@ -1004,9 +967,8 @@ let ChatService = class ChatService extends Disposable {
             let detectedAgent;
             let detectedCommand;
             {
-                const debugLogEnabled = this.configurationService.getValue(AGENT_DEBUG_LOG_ENABLED_SETTING);
                 const fileLoggingEnabled = this.configurationService.getValue(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING);
-                if (!debugLogEnabled || !fileLoggingEnabled) {
+                if (!fileLoggingEnabled) {
                     const isTroubleshootCommand = agentSlashCommandPart?.command.name === TROUBLESHOOT_COMMAND_NAME;
                     const hasTroubleshootSkill = options?.attachedContext?.some(v => {
                         const uri = IChatRequestVariableEntry.toUri(v);
@@ -1017,22 +979,14 @@ let ChatService = class ChatService extends Disposable {
                             variables: []
                         }, attempt, options?.modeInfo);
                         completeResponseCreated();
-                        const missingSettings = [];
-                        if (!debugLogEnabled) {
-                            missingSettings.push("`" + AGENT_DEBUG_LOG_ENABLED_SETTING + "`");
-                        }
-                        if (!fileLoggingEnabled) {
-                            missingSettings.push("`" + AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING + "`");
-                        }
-                        const settingsQuery = !debugLogEnabled && !fileLoggingEnabled ? AGENT_DEBUG_LOG_ENABLED_SETTING : !debugLogEnabled ? "@id:" + AGENT_DEBUG_LOG_ENABLED_SETTING : "@id:" + AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING;
-                        const settingsArg = encodeURIComponent(JSON.stringify(settingsQuery));
+                        const settingsArg = encodeURIComponent(JSON.stringify(AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING));
                         model.acceptResponseProgress(request, {
                             kind: "markdownContent",
                             content: ( new MarkdownString(( localize(
-                                7257,
-                                "The `{0}` skill requires the following settings to be enabled: {1}. After enabling, reload the window to apply. [Enable in Settings](command:workbench.action.openSettings?{2})",
+                                7379,
+                                "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,
-                                missingSettings.join(", "),
+                                AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING,
                                 settingsArg
                             )), {
                                 isTrusted: {
@@ -1042,33 +996,65 @@ let ChatService = class ChatService extends Disposable {
                         });
                         model.setResponse(request, {});
                         request.response?.complete();
+                        store.dispose();
                         return;
                     }
                 }
             }
-            let collectedHooks;
-            let hasDisabledClaudeHooks = false;
-            try {
-                const hooksInfo = await this.promptsService.getHooks(token, model.sessionResource);
-                if (hooksInfo) {
-                    collectedHooks = hooksInfo.hooks;
-                    hasDisabledClaudeHooks = hooksInfo.hasDisabledClaudeHooks;
-                }
-            } catch (error) {
-                this.logService.warn("[ChatService] Failed to collect hooks:", error);
-            }
-            const agentName = options?.modeInfo?.modeInstructions?.name;
-            if (agentName) {
+            const collectHooks = async () => {
+                let collectedHooks;
+                let hasDisabledClaudeHooks = false;
                 try {
-                    const agents = await this.promptsService.getCustomAgents(token, model.sessionResource);
-                    const customAgent = agents.find(a => a.name === agentName);
-                    if (customAgent?.hooks) {
-                        collectedHooks = mergeHooks(collectedHooks, customAgent.hooks);
+                    const hooksInfo = await this.promptsService.getHooks(token);
+                    if (hooksInfo) {
+                        collectedHooks = hooksInfo.hooks;
+                        hasDisabledClaudeHooks = hooksInfo.hasDisabledClaudeHooks;
                     }
                 } catch (error) {
-                    this.logService.warn("[ChatService] Failed to collect agent hooks:", error);
+                    this.logService.warn("[ChatService] Failed to collect hooks:", error);
                 }
-            }
+                const agentName = options?.modeInfo?.modeInstructions?.name;
+                if (agentName) {
+                    try {
+                        const agents = await this.promptsService.getCustomAgents(token);
+                        const customAgent = agents.find(a => a.name === agentName);
+                        if (customAgent?.hooks) {
+                            collectedHooks = mergeHooks(collectedHooks, customAgent.hooks);
+                        }
+                    } catch (error) {
+                        this.logService.warn("[ChatService] Failed to collect agent hooks:", error);
+                    }
+                }
+                return {
+                    hooks: collectedHooks,
+                    hasDisabledClaudeHooks
+                };
+            };
+            const collectInstructions = async () => {
+                const ctx = options?.instructionContext;
+                if (!ctx) {
+                    return [];
+                }
+                markChat(sessionResource, ChatPerfMark.WillCollectInstructions);
+                try {
+                    const variableSet = ( new ChatRequestVariableSet(options?.attachedContext));
+                    const computer = this.instantiationService.createInstance(
+                        ComputeAutomaticInstructions,
+                        ctx.modeKind,
+                        ctx.enabledTools,
+                        ctx.enabledSubAgents,
+                        getChatSessionType(sessionResource)
+                    );
+                    await computer.collect(variableSet, token);
+                    const originalIds = ( new Set(( (options?.attachedContext ?? []).map(v => v.id))));
+                    return variableSet.asArray().filter(v => !( originalIds.has(v.id)));
+                } catch (err) {
+                    this.logService.error("[ChatService] Failed to collect instructions:", err);
+                    return [];
+                } finally {
+                    markChat(sessionResource, ChatPerfMark.DidCollectInstructions);
+                }
+            };
             const stopWatch = ( new StopWatch(false));
             store.add(token.onCancellationRequested(() => {
                 this.trace(
@@ -1092,46 +1078,57 @@ let ChatService = class ChatService extends Disposable {
                 let rawResult;
                 let agentOrCommandFollowups = undefined;
                 if (agentPart || (defaultAgent && !commandPart)) {
-                    const prepareChatAgentRequest = (agent, command, enableCommandDetection, chatRequest, isParticipantDetected) => {
-                        const initVariableData = {
-                            variables: []
+                    const initialAgent = agentPart?.agent ?? defaultAgent;
+                    const initialCommand = agentSlashCommandPart?.command;
+                    const initVariableData = {
+                        variables: []
+                    };
+                    request = model.addRequest(
+                        parsedRequest,
+                        initVariableData,
+                        attempt,
+                        options?.modeInfo,
+                        initialAgent,
+                        initialCommand,
+                        options?.confirmation,
+                        options?.locationData,
+                        options?.attachedContext,
+                        undefined,
+                        options?.userSelectedModelId,
+                        options?.userSelectedTools?.get(),
+                        undefined,
+                        options?.isSystemInitiated,
+                        options?.systemInitiatedLabel,
+                        options?.terminalExecutionId
+                    );
+                    const thisRequest = request;
+                    completeResponseCreated();
+                    const [hooksResult, instructionEntries] = await Promise.all([collectHooks(), collectInstructions()]);
+                    const collectedHooks = hooksResult.hooks;
+                    const hasDisabledClaudeHooks = hooksResult.hasDisabledClaudeHooks;
+                    const allContext = this.prepareContext(request.attachedContext);
+                    if (instructionEntries.length > 0) {
+                        allContext.push(...instructionEntries);
+                    }
+                    const storedVariables = allContext.filter(v => !(isPromptTextVariableEntry(v) && v.automaticallyAdded));
+                    model.updateRequest(request, {
+                        variables: storedVariables
+                    });
+                    let variableData = {
+                        variables: allContext
+                    };
+                    if (options?.resolvedVariables?.length) {
+                        variableData = {
+                            variables: [...variableData.variables, ...options.resolvedVariables]
                         };
-                        request = chatRequest ?? model.addRequest(
-                            parsedRequest,
-                            initVariableData,
-                            attempt,
-                            options?.modeInfo,
-                            agent,
-                            command,
-                            options?.confirmation,
-                            options?.locationData,
-                            options?.attachedContext,
-                            undefined,
-                            options?.userSelectedModelId,
-                            options?.userSelectedTools?.get()
-                        );
-                        let variableData;
-                        let message;
-                        if (chatRequest) {
-                            variableData = chatRequest.variableData;
-                            message = getPromptText(request.message).message;
-                        } else {
-                            variableData = {
-                                variables: this.prepareContext(request.attachedContext)
-                            };
-                            model.updateRequest(request, variableData);
-                            if (options?.resolvedVariables?.length) {
-                                variableData = {
-                                    variables: [...variableData.variables, ...options.resolvedVariables]
-                                };
-                            }
-                            const promptTextResult = getPromptText(request.message);
-                            variableData = updateRanges(variableData, promptTextResult.diff);
-                            message = promptTextResult.message;
-                        }
+                    }
+                    const promptTextResult = getPromptText(request.message);
+                    variableData = updateRanges(variableData, promptTextResult.diff);
+                    const message = promptTextResult.message;
+                    const buildAgentRequest = (agent, command, enableCommandDetection, isParticipantDetected) => {
                         const agentRequest = {
                             sessionResource: model.sessionResource,
-                            requestId: request.id,
+                            requestId: thisRequest.id,
                             agentId: agent.id,
                             message,
                             command: command?.name,
@@ -1140,17 +1137,19 @@ let ChatService = class ChatService extends Disposable {
                             isParticipantDetected,
                             attempt,
                             location,
-                            locationData: request.locationData,
+                            locationData: thisRequest.locationData,
                             acceptedConfirmationData: options?.acceptedConfirmationData,
                             rejectedConfirmationData: options?.rejectedConfirmationData,
+                            agentHostSessionConfig: options?.agentHostSessionConfig,
                             userSelectedModelId: options?.userSelectedModelId,
                             modelConfiguration: options?.userSelectedModelId ? this.languageModelsService.getModelConfiguration(options.userSelectedModelId) : undefined,
                             userSelectedTools: options?.userSelectedTools?.get(),
                             modeInstructions: options?.modeInfo?.modeInstructions,
                             permissionLevel: options?.modeInfo?.permissionLevel,
-                            editedFileEvents: request.editedFileEvents,
+                            editedFileEvents: thisRequest.editedFileEvents,
                             hooks: collectedHooks,
-                            hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr.length > 0))
+                            hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr.length > 0)),
+                            isSystemInitiated: options?.isSystemInitiated
                         };
                         let isInitialTools = true;
                         store.add(autorun(reader => {
@@ -1168,7 +1167,7 @@ let ChatService = class ChatService extends Disposable {
                     };
                     if (this.configurationService.getValue("chat.detectParticipant.enabled") !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && !agentSlashCommandPart && enableCommandDetection && (location !== ChatAgentLocation.EditorInline || !this.configurationService.getValue(InlineChatConfigKeys.EnableV2)) && options?.modeInfo?.kind !== ChatModeKind.Agent && options?.modeInfo?.kind !== ChatModeKind.Edit && !options?.agentIdSilent) {
                         const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, location, defaultAgent.id);
-                        const chatAgentRequest = prepareChatAgentRequest(defaultAgent, undefined, enableCommandDetection, undefined, false);
+                        const chatAgentRequest = buildAgentRequest(defaultAgent, undefined, enableCommandDetection, false);
                         const result = await this.chatAgentService.detectAgentOrCommand(chatAgentRequest, defaultAgentHistory, {
                             location
                         }, token);
@@ -1182,13 +1181,7 @@ let ChatService = class ChatService extends Disposable {
                     const command = detectedCommand ?? agentSlashCommandPart?.command;
                     await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
                     const history = this.getHistoryEntriesFromModel(requests, location, agent.id);
-                    const requestProps = prepareChatAgentRequest(
-                        agent,
-                        command,
-                        enableCommandDetection,
-                        request,
-                        !!detectedAgent
-                    );
+                    const requestProps = buildAgentRequest(agent, command, enableCommandDetection, !!detectedAgent);
                     this.generateInitialChatTitleIfNeeded(model, requestProps, defaultAgent, token);
                     const pendingRequest = this._pendingRequests.get(sessionResource);
                     if (pendingRequest) {
@@ -1208,7 +1201,6 @@ let ChatService = class ChatService extends Disposable {
                             });
                         }
                     }
-                    completeResponseCreated();
                     const disabledClaudeHooksDismissedKey = "chat.disabledClaudeHooks.notification";
                     if (hasDisabledClaudeHooks && !this.storageService.getBoolean(disabledClaudeHooksDismissedKey, StorageScope.WORKSPACE)) {
                         this.storageService.store(
@@ -1289,7 +1281,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         rawResult = {
                             errorDetails: {
-                                message: ( localize(7258, "Provider returned null response"))
+                                message: ( localize(7380, "Provider returned null response"))
                             }
                         };
                     }
@@ -1314,8 +1306,9 @@ let ChatService = class ChatService extends Disposable {
                     shouldProcessPending = !rawResult.errorDetails && !token.isCancellationRequested;
                     request.response?.complete();
                     if (agentOrCommandFollowups) {
+                        const completedRequest = request;
                         agentOrCommandFollowups.then(followups => {
-                            model.setFollowups(request, followups);
+                            model.setFollowups(completedRequest, followups);
                             const commandForTelemetry = agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command;
                             this._chatServiceTelemetry.retrievedFollowups(agentPart?.agent.id ?? "", commandForTelemetry, followups?.length ?? 0);
                         });
@@ -1414,8 +1407,17 @@ let ChatService = class ChatService extends Disposable {
             }
         }
         const firstRequest = allRequests[0];
+        const terminalIds = ( new Set(( allRequests.map(req => req.sendOptions.terminalExecutionId)).filter(id => !!id)));
+        if (terminalIds.size > 1) {
+            this.info(
+                "processNextPendingRequest",
+                `Dropping terminalExecutionId: ${terminalIds.size} conflicting terminal IDs (${[...terminalIds].join(", ")})`
+            );
+        }
+        const mergedTerminalExecutionId = terminalIds.size === 1 ? [...terminalIds][0] : undefined;
         const sendOptions = {
             ...firstRequest.sendOptions,
+            terminalExecutionId: mergedTerminalExecutionId,
             attachedContext: allRequests.flatMap(req => req.request.variableData.variables.slice())
         };
         const location = sendOptions.location ?? sendOptions.locationData?.type ?? model.initialLocation;
@@ -1622,23 +1624,25 @@ let ChatService = class ChatService extends Disposable {
         this.trace("cancelCurrentRequestForSession", `session: ${sessionResource}`);
         const pendingRequest = this._pendingRequests.get(sessionResource);
         if (!pendingRequest) {
-            const model = this._sessionModels.get(sessionResource);
-            const requestInProgress = model?.requestInProgress.get();
-            const pendingRequestsCount = model?.getPendingRequests().length ?? 0;
-            const lastRequest = model?.lastRequest;
-            this.telemetryService.publicLog2(ChatStopCancellationNoopEventName, {
-                source: source ?? "chatService",
-                reason: "noPendingRequest",
-                requestInProgress: requestInProgress === undefined ? "unknown" : requestInProgress ? "true" : "false",
-                pendingRequests: pendingRequestsCount,
-                sessionScheme: sessionResource.scheme,
-                lastRequestId: lastRequest?.id,
-                chatSessionId: chatSessionResourceToId(sessionResource)
-            });
-            this.info(
-                "cancelCurrentRequestForSession",
-                `No pending request was found for session ${sessionResource}. requestInProgress=${requestInProgress ?? "unknown"}, pendingRequests=${pendingRequestsCount}`
-            );
+            if (source !== "archive") {
+                const model = this._sessionModels.get(sessionResource);
+                const requestInProgress = model?.requestInProgress.get();
+                const pendingRequestsCount = model?.getPendingRequests().length ?? 0;
+                const lastRequest = model?.lastRequest;
+                this.telemetryService.publicLog2(ChatStopCancellationNoopEventName, {
+                    source: source ?? "chatService",
+                    reason: "noPendingRequest",
+                    requestInProgress: requestInProgress === undefined ? "unknown" : requestInProgress ? "true" : "false",
+                    pendingRequests: pendingRequestsCount,
+                    sessionScheme: sessionResource.scheme,
+                    lastRequestId: lastRequest?.id,
+                    chatSessionId: chatSessionResourceToId(sessionResource)
+                });
+                this.info(
+                    "cancelCurrentRequestForSession",
+                    `No pending request was found for session ${sessionResource}. requestInProgress=${requestInProgress ?? "unknown"}, pendingRequests=${pendingRequestsCount}`
+                );
+            }
             return;
         }
         const responseCompletePromise = pendingRequest.responseCompletePromise;
@@ -1761,7 +1765,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(7259, "New Chat"));
+    const title = model.title || ( localize(7381, "New Chat"));
     return {
         sessionResource: model.sessionResource,
         title,