@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionTools.js

@@ -0,0 +1,206 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { remoteSessionToolsWhen, parseCreateRemoteSessionOptions } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions';
+import { IRemoteSessionService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions.service';
+import { assertRemoteSessionCaller } from './remoteSessionSource.js';
+
+let ListAgentHostsTool = class ListAgentHostsTool {
+    constructor(remoteSessionsService) {
+        this.remoteSessionsService = remoteSessionsService;
+    }
+    getToolData() {
+        return {
+            id: "vscode_list_agent_hosts",
+            toolReferenceName: "list_agent_hosts",
+            displayName: ( localize(5592, "List Agent Hosts")),
+            userDescription: ( localize(5593, "List connected remote agent hosts and their resources")),
+            modelDescription: "List remote agent hosts, status, resources, load, agents/models, and workspaces to inspect capacity or get exact IDs. Only connected hosts with delegation support are usable; null support or missing resources mean unknown, not unsupported or zero. create_remote_session selects a host itself. This tool changes nothing.",
+            source: ToolDataSource.Internal,
+            icon: Codicon.remote,
+            when: remoteSessionToolsWhen,
+            runsInWorkspace: false,
+            canBeReferencedInPrompt: false,
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        };
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            invocationMessage: ( localize(5594, "Reading remote agent hosts")),
+            pastTenseMessage: ( localize(5595, "Read remote agent hosts"))
+        };
+    }
+    async invoke(_invocation, _countTokens, _progress, _token) {
+        const hosts = this.remoteSessionsService.listHosts();
+        return {
+            content: [{
+                kind: "text",
+                value: JSON.stringify({
+                    hosts
+                })
+            }],
+            toolResultMessage: ( localize(5596, "Listed {0} remote agent hosts", hosts.length))
+        };
+    }
+};
+ListAgentHostsTool = ( __decorate([( __param(0, IRemoteSessionService))], ListAgentHostsTool));
+let CreateRemoteSessionTool = class CreateRemoteSessionTool {
+    constructor(remoteSessionsService) {
+        this.remoteSessionsService = remoteSessionsService;
+    }
+    getToolData() {
+        return {
+            id: "vscode_create_remote_session",
+            toolReferenceName: "create_remote_session",
+            displayName: ( localize(5597, "Create Remote Session")),
+            userDescription: ( localize(5598, "Delegate work to a matching remote agent host")),
+            modelDescription: "Start a task on a connected remote agent host; use create_session for same-host work. Requires an Agent Host originating chat. Selects the matching host with the fewest running sessions and pending creations. Omitted workspace creates a workspace-less session; omitted model uses the target default. Workspaces must already exist and be trusted on the target; nothing is cloned, copied, or inherited from the origin. Ask for results or blockers via send_remote_message with session \"origin\"; final answers are not forwarded. Returns on prompt acceptance, not completion; replies arrive as new turns. Keep the coordinating Agents window connected. Normal approval applies. Continue independent work or end your turn; do not sleep or poll for replies. Do not retry an uncertain creation.",
+            source: ToolDataSource.Internal,
+            icon: Codicon.remote,
+            when: remoteSessionToolsWhen,
+            runsInWorkspace: false,
+            canRequestPreApproval: true,
+            canBeReferencedInPrompt: false,
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["prompt"],
+                properties: {
+                    prompt: {
+                        type: "string",
+                        minLength: 1
+                    },
+                    title: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 200
+                    },
+                    hostId: {
+                        type: "string",
+                        description: "Exact ID from list_agent_hosts; omit for automatic placement."
+                    },
+                    model: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["provider", "id"],
+                        description: "Exact provider/model pair from list_agent_hosts; no substitution.",
+                        properties: {
+                            provider: {
+                                type: "string",
+                                description: "Host-advertised agent provider."
+                            },
+                            id: {
+                                type: "string",
+                                description: "Provider-native model ID."
+                            }
+                        }
+                    },
+                    requirements: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            platform: {
+                                type: "string",
+                                enum: ["windows", "linux", "macos"],
+                                description: "Execution OS (WSL/Linux containers: linux)."
+                            },
+                            minMemoryGiB: {
+                                type: "number",
+                                exclusiveMinimum: 0,
+                                description: "Minimum capacity in GiB, not free memory."
+                            },
+                            minCpuCount: {
+                                type: "integer",
+                                minimum: 1,
+                                description: "Minimum logical CPUs."
+                            }
+                        }
+                    },
+                    workspace: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["uri"],
+                        properties: {
+                            uri: {
+                                type: "string",
+                                description: "Exact workspace URI from list_agent_hosts (pins its host), or an existing target directory's file URI. Do not guess paths."
+                            },
+                            isolation: {
+                                type: "string",
+                                enum: ["folder", "worktree"],
+                                default: "worktree",
+                                description: "worktree creates a fresh Git worktree; folder edits the directory directly."
+                            },
+                            branch: {
+                                type: "string",
+                                description: "Target-local base branch; worktree only. Omit for the target default."
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    async prepareToolInvocation(context, _token) {
+        const options = parseCreateRemoteSessionOptions(context.parameters);
+        if (!context.chatSessionResource) {
+            throw ( new Error(( localize(5599, "Remote session creation requires an originating session."))));
+        }
+        assertRemoteSessionCaller(context.chatSessionResource);
+        const message = ( new MarkdownString()).appendText(( localize(
+            5600,
+            "Start this task on {0}? The host is selected from your connected remote agent hosts using the requested resources and current workload. The new session can send messages back to this chat.",
+            options.hostId ?? ( localize(5601, "a matching remote host"))
+        )));
+        message.appendText(`\n\n${options.prompt}`);
+        message.appendText(`\n\n${options.workspace ? ( localize(
+            5602,
+            "Workspace: {0} ({1})",
+            (options.workspace.uri.toString()),
+            options.workspace.isolation
+        )) : ( localize(5603, "No workspace or files are inherited from this session."))}`);
+        if (options.model) {
+            message.appendText(`\n\n${( localize(5604, "Model: {0}/{1}", options.model.provider, options.model.id))}`);
+        }
+        if (options.workspace?.branch) {
+            message.appendText(`\n\n${( localize(5605, "Worktree base branch: {0}", options.workspace.branch))}`);
+        }
+        if (( ( Object.values(options.requirements)).some(value => value !== undefined))) {
+            message.appendText(`\n\n${( localize(5606, "Requirements: {0}", JSON.stringify(options.requirements)))}`);
+        }
+        return {
+            invocationMessage: ( localize(5607, "Creating remote session")),
+            pastTenseMessage: ( localize(5608, "Created remote session")),
+            confirmationMessages: {
+                title: ( localize(5609, "Create Remote Session?")),
+                message
+            }
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const options = parseCreateRemoteSessionOptions(invocation.parameters);
+        const source = invocation.context?.sessionResource;
+        if (!source) {
+            throw ( new Error(( localize(5599, "Remote session creation requires an originating session."))));
+        }
+        assertRemoteSessionCaller(source);
+        const created = await this.remoteSessionsService.createSession(options, source, invocation.callId, token);
+        return {
+            content: [{
+                kind: "text",
+                value: JSON.stringify(created)
+            }],
+            toolResultMessage: ( new MarkdownString()).appendLink(created.openLink, ( localize(5610, "Created remote session on {0}", created.host.label)))
+        };
+    }
+};
+CreateRemoteSessionTool = ( __decorate([( __param(0, IRemoteSessionService))], CreateRemoteSessionTool));
+
+export { CreateRemoteSessionTool, ListAgentHostsTool };

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessions.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessions.contribution.js

@@ -0,0 +1,58 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { RemoteSessionToolsEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions';
+import './remoteSessionService.js';
+import { ListAgentHostsTool, CreateRemoteSessionTool } from './remoteSessionTools.js';
+import { SendRemoteMessageTool } from './sendRemoteMessageTool.js';
+import { GetRemoteSessionTool } from './getRemoteSessionTool.js';
+import './remoteSessionChatService.js';
+
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: "chat",
+    properties: {
+        [RemoteSessionToolsEnabledSettingId]: {
+            type: "boolean",
+            default: false,
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"],
+            markdownDescription: ( localize(
+                5611,
+                "Enable built-in tools to discover remote agent hosts, create and inspect remote sessions, and send messages between sessions in the Agents window. Requires {0}. Disabling this setting does not disconnect hosts or stop sessions already running.",
+                "`#chat.remoteAgentHostsEnabled#`"
+            )),
+            experiment: {
+                mode: "auto"
+            }
+        }
+    }
+});
+let RemoteSessionToolsContribution = class RemoteSessionToolsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.remoteSessionTools";
+    }
+    constructor(instantiationService, toolsService) {
+        super();
+        const list = instantiationService.createInstance(ListAgentHostsTool);
+        const create = instantiationService.createInstance(CreateRemoteSessionTool);
+        const message = instantiationService.createInstance(SendRemoteMessageTool);
+        const inspect = instantiationService.createInstance(GetRemoteSessionTool);
+        this._register(toolsService.registerTool(list.getToolData(), list));
+        this._register(toolsService.registerTool(create.getToolData(), create));
+        this._register(toolsService.registerTool(message.getToolData(), message));
+        this._register(toolsService.registerTool(inspect.getToolData(), inspect));
+    }
+};
+RemoteSessionToolsContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageModelToolsService))], RemoteSessionToolsContribution));
+registerWorkbenchContribution2(
+    RemoteSessionToolsContribution.ID,
+    RemoteSessionToolsContribution,
+    WorkbenchPhase.Eventually
+);

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/sendRemoteMessageTool.d.ts

@@ -0,0 +1,10 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export declare class SendRemoteMessageTool implements IToolImpl {
+    private readonly router;
+    constructor(instantiationService: IInstantiationService);
+    getToolData(): IToolData;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/sendRemoteMessageTool.js

@@ -0,0 +1,90 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SendRemoteMessageToolReferenceName } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/vscode/agentRemoteSessionMeta';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { RemoteSessionMessageRouter, maxRemoteMessageLength, parseSendRemoteMessageOptions } from './remoteSessionMessageRouter.js';
+import { assertRemoteSessionCaller } from './remoteSessionSource.js';
+import { remoteSessionToolsWhen } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions';
+
+let SendRemoteMessageTool = class SendRemoteMessageTool {
+    constructor(instantiationService) {
+        this.router = instantiationService.createInstance(RemoteSessionMessageRouter);
+    }
+    getToolData() {
+        return {
+            id: "vscode_send_remote_message",
+            toolReferenceName: SendRemoteMessageToolReferenceName,
+            displayName: ( localize(5612, "Send Remote Message")),
+            userDescription: ( localize(5613, "Send a message to a session on a connected agent host")),
+            modelDescription: "Send a message to a known remote session/chat, or reply to the exact originating chat with session \"origin\". Use send_message for ordinary same-host messaging. Requires an Agent Host originating chat and a target connected to this Agents window. Starts an agent-authored turn with the target chat's existing permissions/configuration, or joins its FIFO queue. Returns delivery status, never a response. When assigning work, request a reply; final answers are not forwarded. Normal approval applies. Only claim delivery after \"sent\" or \"queued\"; report failures here. Do not retry uncertain delivery or acknowledge messages with no new task or question. Continue independent work or end your turn; do not sleep or poll for replies.",
+            source: ToolDataSource.Internal,
+            icon: Codicon.send,
+            when: remoteSessionToolsWhen,
+            runsInWorkspace: false,
+            canRequestPreApproval: true,
+            canBeReferencedInPrompt: false,
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["session", "message"],
+                properties: {
+                    session: {
+                        type: "string",
+                        minLength: 1,
+                        description: "\"origin\", or an exact host-qualified session/chat URI or openLink from the remote tools. No bare IDs."
+                    },
+                    message: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: maxRemoteMessageLength
+                    }
+                }
+            }
+        };
+    }
+    async prepareToolInvocation(context, token) {
+        const options = parseSendRemoteMessageOptions(context.parameters);
+        if (!context.chatSessionResource) {
+            throw ( new Error(( localize(5614, "Remote messaging requires an originating chat."))));
+        }
+        assertRemoteSessionCaller(context.chatSessionResource);
+        const target = await this.router.prepareTarget(context.chatSessionResource, options.session, token);
+        const message = ( new MarkdownString()).appendText(( localize(
+            5615,
+            "Send this message to {0} on {1}? It will use the target chat's existing permissions and queue behind any active or pending turns.",
+            target.chat,
+            target.host.label
+        )));
+        message.appendText(`\n\n${options.message}`);
+        return {
+            invocationMessage: ( localize(5616, "Sending a remote message")),
+            pastTenseMessage: ( localize(5617, "Processed a remote message")),
+            confirmationMessages: {
+                title: ( localize(5618, "Send Remote Message")),
+                message
+            }
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const options = parseSendRemoteMessageOptions(invocation.parameters);
+        if (!invocation.context?.sessionResource) {
+            throw ( new Error(( localize(5614, "Remote messaging requires an originating chat."))));
+        }
+        assertRemoteSessionCaller(invocation.context.sessionResource);
+        const result = await this.router.send(invocation.context.sessionResource, options, invocation.callId, token);
+        return {
+            content: [{
+                kind: "text",
+                value: JSON.stringify(result)
+            }],
+            toolResultMessage: result.status === "queued" ? ( localize(5619, "Queued a message on {0}", result.host.label)) : ( localize(5620, "Sent a message on {0}", result.host.label))
+        };
+    }
+};
+SendRemoteMessageTool = ( __decorate([( __param(0, IInstantiationService))], SendRemoteMessageTool));
+
+export { SendRemoteMessageTool };

package/vscode/src/vs/sessions/contrib/remoteSessions/common/remoteSessionInspection.d.ts

@@ -0,0 +1,38 @@
+import { ChatState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+export declare const maxRemoteSessionResponseLength: number;
+interface IRemoteSessionInspectionTarget {
+    readonly session: string;
+    readonly chat: string;
+    readonly openLink: string;
+    readonly host: {
+        readonly id: string;
+        readonly label: string;
+    };
+}
+interface IRemoteSessionTurnSnapshot {
+    readonly id: string;
+    readonly status: "running" | "completed" | "cancelled" | "failed";
+    readonly response: string;
+    readonly error: {
+        readonly type: string;
+        readonly message: string;
+        readonly resumable: boolean;
+    } | null;
+    readonly truncated: boolean;
+}
+interface IRemoteSessionSnapshot {
+    readonly status: IRemoteSessionTurnSnapshot["status"] | "idle" | "queued" | "needsInput";
+    readonly title: string;
+    readonly queuedMessages: number;
+    readonly hasSteeringMessage: boolean;
+    readonly latestTurn: IRemoteSessionTurnSnapshot | null;
+}
+export type IRemoteSessionInspectionResult = IRemoteSessionInspectionTarget & (IRemoteSessionSnapshot | {
+    readonly status: "unavailable";
+    readonly reason: string;
+});
+export declare function parseGetRemoteSessionOptions(value: unknown): {
+    readonly session: string;
+};
+export declare function remoteSessionSnapshot(chat: ChatState): IRemoteSessionSnapshot;
+export {};

package/vscode/src/vs/sessions/contrib/remoteSessions/common/remoteSessionInspection.js

@@ -0,0 +1,58 @@
+
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getErrorResponsePart } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { TurnState, ResponsePartKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+
+const maxRemoteSessionResponseLength = 16 * 1024;
+function parseGetRemoteSessionOptions(value) {
+    const input = isObject(value) ? value : undefined;
+    if (!input || typeof input.session !== "string" || !input.session.trim() || ( ( Object.keys(input)).some(key => key !== "session"))) {
+        throw ( new Error(( localize(
+            5621,
+            "Provide an exact session or chat reference returned by the remote session tools."
+        ))));
+    }
+    return {
+        session: input.session.trim()
+    };
+}
+function remoteSessionSnapshot(chat) {
+    const turn = chat.activeTurn ?? chat.turns.at(-1);
+    const completed = chat.activeTurn ? undefined : chat.turns.at(-1);
+    const turnStatus = !completed ? "running" : completed.state === TurnState.Error ? "failed" : completed.state === TurnState.Cancelled ? "cancelled" : "completed";
+    let response = "";
+    for (const part of turn?.responseParts ?? []) {
+        if (part.kind === ResponsePartKind.Markdown) {
+            response += part.content.slice(0, maxRemoteSessionResponseLength + 1 - response.length);
+            if (response.length > maxRemoteSessionResponseLength) {
+                break;
+            }
+        }
+    }
+    const errorPart = getErrorResponsePart(turn);
+    const errorMessage = errorPart?.error.message ?? "";
+    const queuedMessages = chat.queuedMessages?.length ?? 0;
+    const hasSteeringMessage = chat.steeringMessage !== undefined;
+    const status = (chat.status & SessionStatus.InputNeeded) === SessionStatus.InputNeeded ? "needsInput" : chat.activeTurn || (chat.status & SessionStatus.InProgress) !== 0 ? "running" : turnStatus === "failed" || (chat.status & SessionStatus.Error) !== 0 ? "failed" : queuedMessages || hasSteeringMessage ? "queued" : completed ? turnStatus : "idle";
+    return {
+        status,
+        title: chat.title,
+        queuedMessages,
+        hasSteeringMessage,
+        latestTurn: turn ? {
+            id: turn.id,
+            status: turnStatus,
+            response: response.slice(0, maxRemoteSessionResponseLength),
+            error: errorPart ? {
+                type: errorPart.error.errorType,
+                message: errorMessage.slice(0, maxRemoteSessionResponseLength),
+                resumable: errorPart.resumable === true
+            } : null,
+            truncated: response.length > maxRemoteSessionResponseLength || errorMessage.length > maxRemoteSessionResponseLength
+        } : null
+    };
+}
+
+export { maxRemoteSessionResponseLength, parseGetRemoteSessionOptions, remoteSessionSnapshot };

package/vscode/src/vs/sessions/contrib/search/browser/search.contribution.js

@@ -10,11 +10,10 @@ import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { KeybindingsRegistry, KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { ExplorerFolderContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { SESSIONS_FILES_VIEW_ID, ExplorerFolderContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
 import { IExplorerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/files.service';
 import { OpenEditorCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/searchEditor/browser/constants';
 import { resolveResourcesForSearchIncludes } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/queryBuilder';
-import { SESSIONS_FILES_VIEW_ID } from '../../files/browser/filesView.js';
 
 KeybindingsRegistry.registerKeybindingRule({
     id: OpenEditorCommandId,
@@ -24,7 +23,7 @@ KeybindingsRegistry.registerKeybindingRule({
 MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
     command: {
         id: OpenEditorCommandId,
-        title: ( localize2(4581, "Search")),
+        title: ( localize2(5645, "Search")),
         icon: Codicon.search
     },
     group: "1_files",
@@ -34,7 +33,7 @@ MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
 MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
     command: {
         id: OpenEditorCommandId,
-        title: ( localize(4582, "&&Search"))
+        title: ( localize(5646, "&&Search"))
     },
     group: "4_auxbar",
     order: 1
@@ -43,7 +42,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "sessions.files.action.findInFolder",
-            title: ( localize2(4583, "Find in Folder...")),
+            title: ( localize2(5647, "Find in Folder...")),
             menu: {
                 id: MenuId.ExplorerContext,
                 group: "4_search",

package/vscode/src/vs/sessions/contrib/search/browser/searchEditorEmptyState.contribution.js

@@ -30,7 +30,7 @@ class SearchEditorEmptyStateContribution extends Disposable {
                 return;
             }
             const container = $(".sessions-search-empty-state");
-            renderSessionsEmptyState(container, ( localize(4584, "Search")), ( localize(4585, "Search for text in your files")));
+            renderSessionsEmptyState(container, ( localize(5648, "Search")), ( localize(5649, "Search for text in your files")));
             reader.store.add(editorObservable.createOverlayWidget({
                 domNode: container,
                 position: constObservable(null),

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparison.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparison.contribution.js

@@ -0,0 +1,33 @@
+
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { OPEN_SESSION_COMPARISON_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessionComparison/common/sessionComparison';
+import { SessionComparisonToolContribution } from './sessionComparisonTool.js';
+import { SessionComparisonGridController } from './sessionComparisonGridController.js';
+import './sessionComparisonViewService.js';
+import { ISessionComparisonViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessionComparison/browser/sessionComparisonViewService.service';
+
+registerWorkbenchContribution2(
+    SessionComparisonToolContribution.ID,
+    SessionComparisonToolContribution,
+    WorkbenchPhase.Eventually
+);
+registerWorkbenchContribution2(
+    SessionComparisonGridController.ID,
+    SessionComparisonGridController,
+    WorkbenchPhase.Eventually
+);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OPEN_SESSION_COMPARISON_COMMAND_ID,
+            title: ( localize2(5650, "Open Attempt Comparison")),
+            f1: false
+        });
+    }
+    async run(accessor, comparisonId) {
+        await accessor.get(ISessionComparisonViewService).open(comparisonId);
+    }
+});

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparisonGridController.d.ts

@@ -0,0 +1,30 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionComparisonService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison.service";
+export declare class SessionComparisonGridController extends Disposable implements IWorkbenchContribution {
+    private readonly sessionsService;
+    private readonly comparisonService;
+    private readonly layoutService;
+    static readonly ID = "workbench.contrib.sessionComparisonGridController";
+    private _comparisonGridActive;
+    private _isolatedJudgeSessionId;
+    private _keepSidePaneHidden;
+    private _pendingJudgeIsolationSessionId;
+    private readonly _partsHiddenByController;
+    constructor(sessionsPartService: ISessionsPartService, sessionsService: ISessionsService, comparisonService: ISessionComparisonService, layoutService: IAgentWorkbenchLayoutService, configurationService: IConfigurationService, accessibilityService: IAccessibilityService);
+    private _onDidFocusSession;
+    private _scheduleJudgeIsolation;
+    private _isolateJudge;
+    private _isComparisonGrid;
+    private _isAttemptComparisonGrid;
+    private _getJudgeSessionId;
+    private _getComparisonForVisibleSessions;
+    private _setSidePaneSuppressed;
+    private _hideSidePane;
+    private _restoreSidePane;
+}