@codingame/monaco-vscode-api 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.d.ts

@@ -5,12 +5,19 @@ import { ConfirmResult } from "../../../../../../platform/dialogs/common/dialogs
 import { IDialogService } from "../../../../../../platform/dialogs/common/dialogs.service.js";
 import { IConfigurationService } from "../../../../../../platform/configuration/common/configuration.service.js";
 import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { ILogService } from "../../../../../../platform/log/common/log.service.js";
+import { ITelemetryService } from "../../../../../../platform/telemetry/common/telemetry.service.js";
+import { IProgressService } from "../../../../../../platform/progress/common/progress.service.js";
+import { IStorageService } from "../../../../../../platform/storage/common/storage.service.js";
+import { IWorkspaceContextService } from "../../../../../../platform/workspace/common/workspace.service.js";
+import { IAgentHostEnablementService } from "../../../../../../platform/agentHost/common/agentHostEnablementService.service.js";
 import { EditorInputCapabilities, IEditorIdentifier, IEditorSerializer, IUntypedEditorInput, Verbosity } from "../../../../../common/editor.js";
 import { EditorInput, IEditorCloseHandler } from "../../../../../common/editor/editorInput.js";
 import { IChatService } from "../../../common/chatService/chatService.service.js";
 import { IChatSessionsService } from "../../../common/chatSessionsService.service.js";
 import { IChatEditingSession } from "../../../common/editing/chatEditingService.js";
 import { IChatModel } from "../../../common/model/chatModel.js";
+import { IAgentHostConnectionsService } from "../../../../../../platform/agentHost/common/agentHostConnectionsService.service.js";
 import { IClearEditingSessionConfirmationOptions } from "../../actions/chatActions.js";
 import type { IChatEditorOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditor";
 export declare class ChatEditorInput extends EditorInput implements IEditorCloseHandler {
@@ -21,6 +28,13 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     private readonly configurationService;
     private readonly chatSessionsService;
     private readonly instantiationService;
+    private readonly storageService;
+    private readonly logService;
+    private readonly workspaceContextService;
+    private readonly agentHostEnablementService;
+    private readonly agentHostConnectionsService;
+    private readonly telemetryService;
+    private readonly progressService;
     static readonly TypeID: string;
     static readonly EditorID: string;
     private _sessionResource;
@@ -36,7 +50,7 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     private readonly _modelChangeListener;
     private get model();
     static getNewEditorUri(): URI;
-    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, configurationService: IConfigurationService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService);
+    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, configurationService: IConfigurationService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService, storageService: IStorageService, logService: ILogService, workspaceContextService: IWorkspaceContextService, agentHostEnablementService: IAgentHostEnablementService, agentHostConnectionsService: IAgentHostConnectionsService, telemetryService: ITelemetryService, progressService: IProgressService);
     closeHandler: this;
     showConfirm(): boolean;
     transferOutEditingSession(): IChatEditingSession | undefined;
@@ -44,6 +58,12 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     get editorId(): string | undefined;
     get capabilities(): EditorInputCapabilities;
     copy(): EditorInput;
+    /**
+     * A split or duplicate opens a new, empty chat of the same session type as the
+     * source, falling back to a generic editor URI when that type is unknown or
+     * cannot start a new session.
+     */
+    private getNewResourceForCopy;
     matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
     get typeId(): string;
     getName(): string;

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.js

@@ -14,18 +14,28 @@ import { ConfirmResult } from '../../../../../../platform/dialogs/common/dialogs
 import { IDialogService } from '../../../../../../platform/dialogs/common/dialogs.service.js';
 import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../../../platform/log/common/log.service.js';
+import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.service.js';
+import { ProgressLocation } from '../../../../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../../../../platform/progress/common/progress.service.js';
+import { IStorageService } from '../../../../../../platform/storage/common/storage.service.js';
 import { registerIcon } from '../../../../../../platform/theme/common/iconRegistry.js';
+import { IWorkspaceContextService } from '../../../../../../platform/workspace/common/workspace.service.js';
+import { IAgentHostEnablementService } from '../../../../../../platform/agentHost/common/agentHostEnablementService.service.js';
 import { EditorInputCapabilities, Verbosity } from '../../../../../common/editor.js';
 import { EditorInput } from '../../../../../common/editor/editorInput.js';
 import { IChatService } from '../../../common/chatService/chatService.service.js';
-import { localChatSessionType } from '../../../common/chatSessionsService.js';
+import { localChatSessionType, isAgentHostTarget } from '../../../common/chatSessionsService.js';
 import { IChatSessionsService } from '../../../common/chatSessionsService.service.js';
-import { ChatEditorTitleMaxLength, ChatAgentLocation, getDefaultNewChatSessionResource, getDefaultNewChatSessionType } from '../../../common/constants.js';
+import { isNewChatSessionTypeUsable, ChatEditorTitleMaxLength, ChatAgentLocation, getLocalFallbackSessionTypeSelectionReason, getDefaultNewChatSessionTypeAndReasonFromServices, getDefaultNewChatSessionType } from '../../../common/constants.js';
 import { ModifiedFileEntryState } from '../../../common/editing/chatEditingService.js';
-import { LocalChatSessionUri, getChatSessionType } from '../../../common/model/chatUri.js';
+import { LocalChatSessionUri, getChatSessionType, getNewChatSessionResource, isUntitledChatSession } from '../../../common/model/chatUri.js';
+import { IAgentHostConnectionsService } from '../../../../../../platform/agentHost/common/agentHostConnectionsService.service.js';
+import { adoptLegacyCopilotCliResource, LEGACY_MIGRATION_RESTORE_TIMEOUT_MS } from '../../agentSessions/agentHost/agentHostLegacyMigration.js';
+import { migratedCopilotCliResource } from '../../copilotCliEventsUri.js';
 
 var ChatEditorInput_1;
-const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(8386, "Icon of the chat editor label.")));
+const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(10063, "Icon of the chat editor label.")));
 let ChatEditorInput = class ChatEditorInput extends EditorInput {
     static {
         ChatEditorInput_1 = this;
@@ -52,7 +62,14 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         dialogService,
         configurationService,
         chatSessionsService,
-        instantiationService
+        instantiationService,
+        storageService,
+        logService,
+        workspaceContextService,
+        agentHostEnablementService,
+        agentHostConnectionsService,
+        telemetryService,
+        progressService
     ) {
         super();
         this.resource = resource;
@@ -62,6 +79,13 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         this.configurationService = configurationService;
         this.chatSessionsService = chatSessionsService;
         this.instantiationService = instantiationService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.workspaceContextService = workspaceContextService;
+        this.agentHostEnablementService = agentHostEnablementService;
+        this.agentHostConnectionsService = agentHostConnectionsService;
+        this.telemetryService = telemetryService;
+        this.progressService = progressService;
         this.didTransferOutEditingSession = false;
         this.modelRef = this._register(( new MutableDisposable()));
         this._modelChangeListener = this._register(( new MutableDisposable()));
@@ -92,8 +116,8 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (!this.model?.editingSession || this.didTransferOutEditingSession || this.getSessionType() !== localChatSessionType) {
             return ConfirmResult.SAVE;
         }
-        const titleOverride = ( localize(8387, "Close Chat Editor"));
-        const messageOverride = ( localize(8388, "Closing the chat editor will end your current edit session."));
+        const titleOverride = ( localize(10064, "Close Chat Editor"));
+        const messageOverride = ( localize(10065, "Closing the chat editor will end your current edit session."));
         const result = await showClearEditingSessionConfirmation(this.model, this.dialogService, {
             titleOverride,
             messageOverride
@@ -107,7 +131,22 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         return super.capabilities | EditorInputCapabilities.ForceReveal | EditorInputCapabilities.CanDropIntoEditor;
     }
     copy() {
-        return this.instantiationService.createInstance(ChatEditorInput_1, ChatEditorInput_1.getNewEditorUri(), {});
+        return this.instantiationService.createInstance(ChatEditorInput_1, this.getNewResourceForCopy(), {
+            sessionTypeSelectionReason: "currentSession"
+        });
+    }
+    getNewResourceForCopy() {
+        const sourceType = this._sessionResource ? getChatSessionType(this._sessionResource) : undefined;
+        if (sourceType !== undefined && (sourceType === localChatSessionType || isAgentHostTarget(sourceType)) && isNewChatSessionTypeUsable(
+            sourceType,
+            this.configurationService,
+            this.chatSessionsService,
+            this.workspaceContextService.getWorkspace(),
+            this.agentHostEnablementService.enabled.get()
+        )) {
+            return getNewChatSessionResource(sourceType);
+        }
+        return ChatEditorInput_1.getNewEditorUri();
     }
     matches(otherInput) {
         if (!(otherInput instanceof ChatEditorInput_1)) {
@@ -135,7 +174,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (this.options.title?.preferred) {
             return this.options.title.preferred;
         }
-        return this.options.title?.fallback ?? ( localize(8389, "Chat"));
+        return this.options.title?.fallback ?? ( localize(10066, "Chat"));
     }
     getTitle(verbosity) {
         const name = this.getName();
@@ -179,51 +218,133 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         const chatSessionType = searchParams.get("chatSessionType");
         const inputType = chatSessionType ?? this.resource.authority;
         if (this._sessionResource) {
-            this.modelRef.value = await this.chatService.acquireOrLoadSession(
-                this._sessionResource,
-                ChatAgentLocation.Chat,
-                CancellationToken.None,
-                "ChatEditorInput#resolve"
-            );
+            if (migratedCopilotCliResource(this._sessionResource)) {
+                const migrated = await this.progressService.withProgress({
+                    location: ProgressLocation.Window,
+                    title: ( localize(10067, "Opening chat…"))
+                }, () => adoptLegacyCopilotCliResource(
+                    this.agentHostConnectionsService.ambientConnection,
+                    this._sessionResource,
+                    this.logService,
+                    this.configurationService,
+                    this.telemetryService,
+                    "restore",
+                    LEGACY_MIGRATION_RESTORE_TIMEOUT_MS
+                ));
+                if (migrated) {
+                    this._sessionResource = migrated;
+                }
+            }
+            try {
+                this.modelRef.value = await this.chatService.acquireOrLoadSession(
+                    this._sessionResource,
+                    ChatAgentLocation.Chat,
+                    CancellationToken.None,
+                    "ChatEditorInput#resolve",
+                    this.options.sessionTypeSelectionReason
+                );
+            } catch (error) {
+                this.logService.warn(`[ChatEditorInput] Failed to acquire session ${( this._sessionResource.toString())}`, error);
+            }
+            if (!this.model && isUntitledChatSession(this._sessionResource) && getChatSessionType(this._sessionResource) !== localChatSessionType) {
+                this.logService.warn(
+                    `[ChatEditorInput] Falling back to a local chat session because ${( this._sessionResource.toString())} could not be acquired`
+                );
+                this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
+                    canUseTools: !inputType,
+                    debugOwner: "ChatEditorInput#resolveUntitledFallback",
+                    sessionTypeSelectionReason: getLocalFallbackSessionTypeSelectionReason(getChatSessionType(this._sessionResource), false)
+                });
+            }
             if (this.shouldReplaceEmptyLocalSession(this._sessionResource)) {
-                const defaultResource = getDefaultNewChatSessionResource(this.configurationService, this.chatSessionsService);
+                const defaultTypeAndReason = getDefaultNewChatSessionTypeAndReasonFromServices(
+                    this.configurationService,
+                    this.chatSessionsService,
+                    this.storageService,
+                    this.workspaceContextService.getWorkspace(),
+                    this.agentHostEnablementService.enabled.get(),
+                    undefined,
+                    this.agentHostEnablementService.managedSandboxEnforced.get()
+                );
+                const defaultResource = getNewChatSessionResource(defaultTypeAndReason.sessionType);
                 if (getChatSessionType(defaultResource) !== localChatSessionType) {
-                    this._sessionResource = defaultResource;
-                    this.modelRef.value = await this.chatService.acquireOrLoadSession(
-                        defaultResource,
-                        ChatAgentLocation.Chat,
-                        CancellationToken.None,
-                        "ChatEditorInput#resolveDefaultSession"
-                    );
+                    let modelRef;
+                    try {
+                        modelRef = await this.chatService.acquireOrLoadSession(
+                            defaultResource,
+                            ChatAgentLocation.Chat,
+                            CancellationToken.None,
+                            "ChatEditorInput#resolveDefaultSession",
+                            defaultTypeAndReason.selectionReason
+                        );
+                    } catch (error) {
+                        this.logService.warn(`[ChatEditorInput] Failed to acquire default session ${( defaultResource.toString())}`, error);
+                    }
+                    if (modelRef) {
+                        this._sessionResource = defaultResource;
+                        this.modelRef.value = modelRef;
+                    } else {
+                        this.logService.warn(
+                            `[ChatEditorInput] Keeping local chat session because default session ${( defaultResource.toString())} could not be acquired`
+                        );
+                    }
                 }
             }
             if (!this.model && LocalChatSessionUri.parseLocalSessionId(this._sessionResource)) {
                 this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
                     canUseTools: true,
-                    debugOwner: "ChatEditorInput#resolveNewLocalSession"
+                    debugOwner: "ChatEditorInput#resolveNewLocalSession",
+                    sessionTypeSelectionReason: this.options.sessionTypeSelectionReason
                 });
             }
         } else if (!this.options.target) {
             if (this.options.explicitSessionType === localChatSessionType) {
                 this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
                     canUseTools: !inputType,
-                    debugOwner: "ChatEditorInput#resolveExplicitLocal"
+                    debugOwner: "ChatEditorInput#resolveExplicitLocal",
+                    sessionTypeSelectionReason: this.options.sessionTypeSelectionReason ?? "explicitOverride"
                 });
             } else {
-                const defaultResource = getDefaultNewChatSessionResource(this.configurationService, this.chatSessionsService);
+                const defaultTypeAndReason = getDefaultNewChatSessionTypeAndReasonFromServices(
+                    this.configurationService,
+                    this.chatSessionsService,
+                    this.storageService,
+                    this.workspaceContextService.getWorkspace(),
+                    this.agentHostEnablementService.enabled.get(),
+                    undefined,
+                    this.agentHostEnablementService.managedSandboxEnforced.get()
+                );
+                const defaultResource = getNewChatSessionResource(defaultTypeAndReason.sessionType);
                 if (getChatSessionType(defaultResource) === localChatSessionType) {
                     this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
                         canUseTools: !inputType,
-                        debugOwner: "ChatEditorInput#resolveUntitled"
+                        debugOwner: "ChatEditorInput#resolveUntitled",
+                        sessionTypeSelectionReason: defaultTypeAndReason.selectionReason
                     });
                 } else {
-                    this._sessionResource = defaultResource;
-                    this.modelRef.value = await this.chatService.acquireOrLoadSession(
-                        defaultResource,
-                        ChatAgentLocation.Chat,
-                        CancellationToken.None,
-                        "ChatEditorInput#resolveDefaultUntitled"
-                    );
+                    try {
+                        this.modelRef.value = await this.chatService.acquireOrLoadSession(
+                            defaultResource,
+                            ChatAgentLocation.Chat,
+                            CancellationToken.None,
+                            "ChatEditorInput#resolveDefaultUntitled",
+                            defaultTypeAndReason.selectionReason
+                        );
+                    } catch (error) {
+                        this.logService.warn(`[ChatEditorInput] Failed to acquire default session ${( defaultResource.toString())}`, error);
+                    }
+                    if (this.model) {
+                        this._sessionResource = defaultResource;
+                    } else {
+                        this.logService.warn(
+                            `[ChatEditorInput] Falling back to a local chat session because ${( defaultResource.toString())} could not be acquired`
+                        );
+                        this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
+                            canUseTools: !inputType,
+                            debugOwner: "ChatEditorInput#resolveUntitledFallback",
+                            sessionTypeSelectionReason: getLocalFallbackSessionTypeSelectionReason(getChatSessionType(defaultResource), false)
+                        });
+                    }
                 }
             }
         } else if (this.options.target.data) {
@@ -242,7 +363,15 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         return this._register(( new ChatEditorModel(this.model)));
     }
     shouldReplaceEmptyLocalSession(sessionResource) {
-        return LocalChatSessionUri.isLocalSession(sessionResource) && this.options.explicitSessionType !== localChatSessionType && !!this.model && !this.model.hasRequests && getDefaultNewChatSessionType(this.configurationService, this.chatSessionsService) !== localChatSessionType;
+        return LocalChatSessionUri.isLocalSession(sessionResource) && this.options.explicitSessionType !== localChatSessionType && !!this.model && !this.model.hasRequests && getDefaultNewChatSessionType(
+            this.configurationService,
+            this.chatSessionsService,
+            this.storageService,
+            this.workspaceContextService.getWorkspace(),
+            this.agentHostEnablementService.enabled.get(),
+            undefined,
+            this.agentHostEnablementService.managedSandboxEnforced.get()
+        ) !== localChatSessionType;
     }
     updateModel(model) {
         this._sessionResource = model.sessionResource;
@@ -270,7 +399,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         return false;
     }
 };
-ChatEditorInput = ChatEditorInput_1 = ( __decorate([( __param(2, IChatService)), ( __param(3, IDialogService)), ( __param(4, IConfigurationService)), ( __param(5, IChatSessionsService)), ( __param(6, IInstantiationService))], ChatEditorInput));
+ChatEditorInput = ChatEditorInput_1 = ( __decorate([( __param(2, IChatService)), ( __param(3, IDialogService)), ( __param(4, IConfigurationService)), ( __param(5, IChatSessionsService)), ( __param(6, IInstantiationService)), ( __param(7, IStorageService)), ( __param(8, ILogService)), ( __param(9, IWorkspaceContextService)), ( __param(10, IAgentHostEnablementService)), ( __param(11, IAgentHostConnectionsService)), ( __param(12, ITelemetryService)), ( __param(13, IProgressService))], ChatEditorInput));
 class ChatEditorModel extends Disposable {
     constructor(model) {
         super();
@@ -324,7 +453,10 @@ class ChatEditorInputSerializer {
             return undefined;
         }
         const obj = {
-            options: input.options,
+            options: {
+                ...input.options,
+                sessionTypeSelectionReason: undefined
+            },
             sessionResource: input.sessionResource,
             resource: input.resource
         };
@@ -352,25 +484,25 @@ async function showClearEditingSessionConfirmation(model, dialogService, options
     if (!undecidedEdits) {
         return true;
     }
-    const defaultPhrase = ( localize(8390, "Starting a new chat will end your current edit session."));
-    const defaultTitle = ( localize(8391, "Start new chat?"));
+    const defaultPhrase = ( localize(10068, "Starting a new chat will end your current edit session."));
+    const defaultTitle = ( localize(10069, "Start new chat?"));
     const phrase = options?.messageOverride ?? defaultPhrase;
     const title = options?.titleOverride ?? defaultTitle;
     const {
         result
     } = await dialogService.prompt({
         title,
-        message: phrase + " " + ( localize(8392, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
+        message: phrase + " " + ( localize(10070, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
         type: "info",
         cancelButton: true,
         buttons: [{
-            label: ( localize(8393, "Keep & Continue")),
+            label: ( localize(10071, "Keep & Continue")),
             run: async () => {
                 await model.editingSession.accept();
                 return true;
             }
         }, {
-            label: ( localize(8394, "Undo & Continue")),
+            label: ( localize(10072, "Undo & Continue")),
             run: async () => {
                 await model.editingSession.reject();
                 return true;

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

@@ -7,6 +7,8 @@ export declare namespace ChatContextKeys {
     const responseSupportsIssueReporting: RawContextKey<boolean>;
     const responseIsFiltered: RawContextKey<boolean>;
     const responseHasError: RawContextKey<boolean>;
+    const responseHasFeedbackSurvey: RawContextKey<boolean>;
+    const responseFeedbackSurveyOpen: RawContextKey<boolean>;
     const requestInProgress: RawContextKey<boolean>;
     const hasActiveRequest: RawContextKey<boolean>;
     const currentlyEditing: RawContextKey<boolean>;
@@ -32,14 +34,23 @@ export declare namespace ChatContextKeys {
     const inChatQuestionCarousel: RawContextKey<boolean>;
     const chatQuestionCarouselHasTerminal: RawContextKey<boolean>;
     const inChatEditor: RawContextKey<boolean>;
+    const findSupported: RawContextKey<boolean>;
+    const findWidgetVisible: RawContextKey<boolean>;
+    const findInputFocused: RawContextKey<boolean>;
+    const findWidgetFocused: RawContextKey<boolean>;
     const inChatTodoList: RawContextKey<boolean>;
     const inChatTip: RawContextKey<boolean>;
+    const inChatComposer: RawContextKey<boolean>;
     const multipleChatTips: RawContextKey<boolean>;
     const inChatTerminalToolOutput: RawContextKey<boolean>;
     const chatModeKind: RawContextKey<ChatModeKind>;
     const chatPermissionLevel: RawContextKey<ChatPermissionLevel>;
     const chatModeName: RawContextKey<string>;
     const chatModelId: RawContextKey<string>;
+    const speechToTextRecording: RawContextKey<boolean>;
+    const speechToTextConfigured: RawContextKey<boolean>;
+    const speechToTextPreparing: RawContextKey<boolean>;
+    const speechToTextUsesMai: RawContextKey<boolean>;
     const supported: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     const enabled: RawContextKey<boolean>;
     const accountPolicyGateActive: RawContextKey<boolean>;
@@ -62,6 +73,10 @@ export declare namespace ChatContextKeys {
      * Widget-scoped: logical Agent Host provider ID for this chat widget, e.g. `copilotcli`, `claude`, or `codex`.
      */
     const chatAgentHostProviderId: RawContextKey<string>;
+    /** Widget-scoped: whether the locked Agent Host provider pins an immutable primary working directory. */
+    const chatAgentHostHasImmutablePrimaryWorkingDirectory: RawContextKey<boolean>;
+    /** Widget-scoped: whether the multi-root Folder picker should be shown for this session. Defaults to hidden; the harness decision reveals it, so the chip never flashes visible-then-hidden. */
+    const chatAgentHostFolderPickerVisible: RawContextKey<boolean>;
     /**
      * True when the chat session has a customAgentTarget defined in its contribution,
      * which means the mode picker should be shown with filtered custom agents.
@@ -148,9 +163,15 @@ export declare namespace ChatContextKeys {
     const agentSessionsViewerPosition: RawContextKey<number>;
     const agentSessionsViewerVisible: RawContextKey<boolean>;
     const agentSessionType: RawContextKey<string>;
+    /**
+     * Whether the agent session item has an associated pull request. Tri-state, so gate with
+     * `chatSessionPullRequest != 'none'` to keep contributions visible when the state is unknown.
+     */
+    const agentSessionPullRequest: RawContextKey<string>;
     const chatSessionSupportsDelegation: RawContextKey<boolean>;
     const hasPendingDelegationTarget: RawContextKey<boolean>;
     const chatSessionSupportsFork: RawContextKey<boolean>;
+    const chatSessionSupportsRename: RawContextKey<boolean>;
     const agentSessionSection: RawContextKey<string>;
     const isArchivedAgentSession: RawContextKey<boolean>;
     const isPinnedAgentSession: RawContextKey<boolean>;