@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentSessionProjectionService.js

@@ -0,0 +1,319 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as agentsessionprojection from './media/agentsessionprojection.css';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
+import { IAgentTitleBarStatusService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentTitleBarStatusService.service';
+import { inAgentSessionProjection } from './agentSessionProjection.js';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { isSessionInProgressStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+registerCss(agentsessionprojection);
+const AGENT_SESSION_PROJECTION_ENABLED_PROVIDERS = ( new Set(( Object.values(AgentSessionProviders))));
+let AgentSessionProjectionService = class AgentSessionProjectionService extends Disposable {
+    get isActive() {
+        return this._isActive;
+    }
+    get activeSession() {
+        return this._activeSession;
+    }
+    constructor(
+        contextKeyService,
+        configurationService,
+        editorGroupsService,
+        editorService,
+        logService,
+        chatWidgetService,
+        chatSessionsService,
+        layoutService,
+        commandService,
+        chatEditingService,
+        agentTitleBarStatusService,
+        agentSessionsService
+    ) {
+        super();
+        this.configurationService = configurationService;
+        this.editorGroupsService = editorGroupsService;
+        this.editorService = editorService;
+        this.logService = logService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatSessionsService = chatSessionsService;
+        this.layoutService = layoutService;
+        this.commandService = commandService;
+        this.chatEditingService = chatEditingService;
+        this.agentTitleBarStatusService = agentTitleBarStatusService;
+        this.agentSessionsService = agentSessionsService;
+        this._isActive = false;
+        this._isExiting = false;
+        this._onDidChangeProjectionMode = this._register(( new Emitter()));
+        this.onDidChangeProjectionMode = this._onDidChangeProjectionMode.event;
+        this._onDidChangeActiveSession = this._register(( new Emitter()));
+        this.onDidChangeActiveSession = this._onDidChangeActiveSession.event;
+        this._sessionWorkingSets = ( new Map());
+        this._wasAuxiliaryBarMaximized = false;
+        this._inProjectionModeContextKey = inAgentSessionProjection.bindTo(contextKeyService);
+        this._register(this.editorService.onDidCloseEditor(() => this._checkForEmptyEditors()));
+        this._register(
+            this.agentSessionsService.model.onDidChangeSessions(() => this._checkForInProgressSession())
+        );
+    }
+    _isEnabled() {
+        return this.configurationService.getValue(ChatConfiguration.AgentSessionProjectionEnabled) === true;
+    }
+    _checkForEmptyEditors() {
+        if (!this._isActive || this._isExiting) {
+            return;
+        }
+        const hasVisibleEditors = this.editorService.visibleEditors.length > 0;
+        if (!hasVisibleEditors) {
+            this.logService.trace("[AgentSessionProjection] All editors closed, exiting projection mode");
+            this.exitProjection();
+        }
+    }
+    _checkForInProgressSession() {
+        if (!this._isActive || !this._activeSession) {
+            return;
+        }
+        const updatedSession = this.agentSessionsService.getSession(this._activeSession.resource);
+        if (!updatedSession) {
+            return;
+        }
+        if (isSessionInProgressStatus(updatedSession.status)) {
+            this.logService.trace(
+                "[AgentSessionProjection] Active session transitioned to in-progress, exiting projection mode"
+            );
+            this.exitProjection({
+                startNewChat: false
+            });
+        }
+    }
+    async _openSessionInChatPanel(session) {
+        session.setRead(true);
+        await this.chatSessionsService.activateChatSessionItemProvider(session.providerType);
+        await this.chatWidgetService.openSession(session.resource, ChatViewPaneTarget, {
+            title: {
+                preferred: session.label
+            },
+            revealIfOpened: true
+        });
+    }
+    async _openSessionFiles(session) {
+        this.logService.trace(`[AgentSessionProjection] Opening files for session '${session.label}'`, {
+            hasChanges: !!session.changes,
+            isArray: Array.isArray(session.changes),
+            changeCount: Array.isArray(session.changes) ? session.changes.length : 0
+        });
+        if (session.changes && Array.isArray(session.changes) && session.changes.length > 0) {
+            const diffResources = ( session.changes.filter(change => change.originalUri).map(change => ({
+                originalUri: change.originalUri,
+                modifiedUri: change.modifiedUri
+            })));
+            this.logService.trace(
+                `[AgentSessionProjection] Found ${diffResources.length} files with diffs to display`
+            );
+            if (diffResources.length > 0) {
+                await this.editorGroupsService.applyWorkingSet("empty", {
+                    preserveFocus: true
+                });
+                await this.commandService.executeCommand("_workbench.openMultiDiffEditor", {
+                    multiDiffSourceUri: session.resource.with({
+                        scheme: session.resource.scheme + "-agent-session-projection"
+                    }),
+                    title: ( localize(5005, "{0} - All Changes", session.label)),
+                    resources: diffResources
+                });
+                this.logService.trace(`[AgentSessionProjection] Multi-diff editor opened successfully`);
+                const sessionKey = ( session.resource.toString());
+                const newWorkingSet = this.editorGroupsService.saveWorkingSet(`agent-session-projection-${sessionKey}`);
+                this._sessionWorkingSets.set(sessionKey, newWorkingSet);
+                return true;
+            } else {
+                this.logService.trace(
+                    `[AgentSessionProjection] No files with diffs to display (all changes missing originalUri)`
+                );
+                return false;
+            }
+        } else {
+            this.logService.trace(`[AgentSessionProjection] Session has no changes to display`);
+            return false;
+        }
+    }
+    async enterProjection(session) {
+        if (!this._isEnabled()) {
+            this.logService.trace("[AgentSessionProjection] Agent Session Projection is disabled");
+            return;
+        }
+        if (!( AGENT_SESSION_PROJECTION_ENABLED_PROVIDERS.has(session.providerType))) {
+            this.logService.trace(
+                `[AgentSessionProjection] Provider type '${session.providerType}' does not support agent session projection`
+            );
+            return;
+        }
+        const isAuxBarMaximized = this.layoutService.isAuxiliaryBarMaximized();
+        this.logService.trace("[AgentSessionProjection] enterProjection auxiliary bar state", {
+            isAuxiliaryBarMaximized: isAuxBarMaximized
+        });
+        if (isSessionInProgressStatus(session.status)) {
+            this.logService.trace(
+                "[AgentSessionProjection] Session is in progress, opening chat without projection mode"
+            );
+            await this._openSessionInChatPanel(session);
+            return;
+        }
+        let hasUndecidedChanges = true;
+        if (session.providerType === AgentSessionProviders.Local) {
+            const editingSession = this.chatEditingService.getEditingSession(session.resource);
+            hasUndecidedChanges = editingSession?.entries.get().some(e => e.state.get() === ModifiedFileEntryState.Modified) ?? false;
+            if (!hasUndecidedChanges) {
+                this.logService.trace(
+                    "[AgentSessionProjection] Local session has no undecided changes, opening chat without projection mode"
+                );
+            }
+        }
+        if (hasUndecidedChanges) {
+            if (!this._isActive && !this._preProjectionWorkingSet) {
+                const visibleEditorsBefore = this.editorService.visibleEditors.length;
+                this._preProjectionWorkingSet = this.editorGroupsService.saveWorkingSet("agent-session-projection-backup");
+                this.logService.trace("[AgentSessionProjection] saved pre-projection working set", {
+                    id: this._preProjectionWorkingSet.id,
+                    visibleEditorsBefore
+                });
+            }
+            if (this._isActive && this._activeSession) {
+                const previousSessionKey = ( this._activeSession.resource.toString());
+                const previousWorkingSet = this.editorGroupsService.saveWorkingSet(`agent-session-projection-${previousSessionKey}`);
+                this._sessionWorkingSets.set(previousSessionKey, previousWorkingSet);
+            }
+            let filesOpened = false;
+            if (session.providerType === AgentSessionProviders.Local) {
+                await this.editorGroupsService.applyWorkingSet("empty", {
+                    preserveFocus: true
+                });
+                filesOpened = true;
+            } else {
+                filesOpened = await this._openSessionFiles(session);
+            }
+            if (!filesOpened) {
+                this.logService.trace(
+                    "[AgentSessionProjection] No files to display, opening chat without projection mode"
+                );
+                if (!this._isActive && this._preProjectionWorkingSet) {
+                    await this.editorGroupsService.applyWorkingSet(this._preProjectionWorkingSet);
+                    this.editorGroupsService.deleteWorkingSet(this._preProjectionWorkingSet);
+                    this._preProjectionWorkingSet = undefined;
+                }
+            } else {
+                const wasActive = this._isActive;
+                this._isActive = true;
+                this._activeSession = session;
+                this._inProjectionModeContextKey.set(true);
+                this.layoutService.mainContainer.classList.add("agent-session-projection-active");
+                if (!wasActive) {
+                    this._wasAuxiliaryBarMaximized = isAuxBarMaximized;
+                    this.logService.trace("[AgentSessionProjection] captured auxiliary bar maximized state", {
+                        wasAuxiliaryBarMaximized: this._wasAuxiliaryBarMaximized
+                    });
+                }
+                this.agentTitleBarStatusService.enterSessionMode(session.resource, session.label);
+                if (!wasActive) {
+                    this._onDidChangeProjectionMode.fire(true);
+                }
+                this._onDidChangeActiveSession.fire(session);
+            }
+        }
+        await this._openSessionInChatPanel(session);
+        if (session.providerType === AgentSessionProviders.Local && hasUndecidedChanges) {
+            await this.commandService.executeCommand("chatEditing.viewChanges");
+        }
+        if (this._wasAuxiliaryBarMaximized) {
+            this.logService.trace(
+                "[AgentSessionProjection] hiding maximized auxiliary bar during projection"
+            );
+            this.layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+        }
+    }
+    async exitProjection(options) {
+        if (!this._isActive || this._isExiting) {
+            return;
+        }
+        const startNewChat = options?.startNewChat ?? true;
+        this._isExiting = true;
+        this.logService.trace("[AgentSessionProjection] exitProjection start", {
+            hasPreProjectionWorkingSet: !!this._preProjectionWorkingSet,
+            activeSession: this._activeSession?.label,
+            startNewChat,
+            wasAuxiliaryBarMaximized: this._wasAuxiliaryBarMaximized
+        });
+        if (this._activeSession) {
+            const sessionKey = ( this._activeSession.resource.toString());
+            const workingSet = this.editorGroupsService.saveWorkingSet(`agent-session-projection-${sessionKey}`);
+            this._sessionWorkingSets.set(sessionKey, workingSet);
+        }
+        for (const group of this.editorGroupsService.groups) {
+            await group.closeAllEditors();
+        }
+        this.logService.trace("[AgentSessionProjection] exitProjection closed editors", {
+            visible: this.editorService.visibleEditors.length
+        });
+        if (this._preProjectionWorkingSet) {
+            await this.editorGroupsService.applyWorkingSet(this._preProjectionWorkingSet);
+            this.logService.trace(
+                "[AgentSessionProjection] exitProjection applied pre-projection working set",
+                {
+                    visible: this.editorService.visibleEditors.length,
+                    id: this._preProjectionWorkingSet.id
+                }
+            );
+            this.editorGroupsService.deleteWorkingSet(this._preProjectionWorkingSet);
+            this._preProjectionWorkingSet = undefined;
+        } else {
+            await this.editorGroupsService.applyWorkingSet("empty", {
+                preserveFocus: true
+            });
+            this.logService.trace(
+                "[AgentSessionProjection] exitProjection no pre-working set, applied empty"
+            );
+        }
+        this._isActive = false;
+        this._activeSession = undefined;
+        this._inProjectionModeContextKey.set(false);
+        const shouldRestoreMaximized = this._wasAuxiliaryBarMaximized;
+        this._wasAuxiliaryBarMaximized = false;
+        this.layoutService.mainContainer.classList.remove("agent-session-projection-active");
+        this.agentTitleBarStatusService.exitSessionMode();
+        this._onDidChangeProjectionMode.fire(false);
+        this._onDidChangeActiveSession.fire(undefined);
+        if (startNewChat) {
+            await this.commandService.executeCommand(ACTION_ID_NEW_CHAT);
+        }
+        if (shouldRestoreMaximized) {
+            this.logService.trace("[AgentSessionProjection] restoring auxiliary bar maximized state");
+            this.layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
+            await this.commandService.executeCommand("workbench.action.maximizeAuxiliaryBar");
+        }
+        this.logService.trace("[AgentSessionProjection] exitProjection complete");
+        this._isExiting = false;
+    }
+};
+AgentSessionProjectionService = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IConfigurationService)), ( __param(2, IEditorGroupsService)), ( __param(3, IEditorService)), ( __param(4, ILogService)), ( __param(5, IChatWidgetService)), ( __param(6, IChatSessionsService)), ( __param(7, IWorkbenchLayoutService)), ( __param(8, ICommandService)), ( __param(9, IChatEditingService)), ( __param(10, IAgentTitleBarStatusService)), ( __param(11, IAgentSessionsService))], AgentSessionProjectionService));
+
+export { AGENT_SESSION_PROJECTION_ENABLED_PROVIDERS, AgentSessionProjectionService };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentSessionsExperiments.contribution.d.ts

@@ -0,0 +1 @@
+

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentSessionsExperiments.contribution.js

@@ -0,0 +1,215 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { registerAction2, MenuRegistry, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { AGENT_SESSION_PROJECTION_ENABLED_PROVIDERS } from './agentSessionProjectionService.js';
+import { IAgentSessionProjectionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentSessionProjectionService.service';
+import { EnterAgentSessionProjectionAction, ExitAgentSessionProjectionAction, ToggleAgentStatusAction, ToggleUnifiedAgentsBarAction } from './agentSessionProjectionActions.js';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { AgentTitleBarStatusRendering } from './agentTitleBarStatusWidget.js';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentTitleBarStatusService';
+import { IAgentTitleBarStatusService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentTitleBarStatusService.service';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ProductQualityContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
+import { ChatAgentLocation, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import './unifiedQuickAccessActions.js';
+import { isSessionInProgressStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let AgentSessionReadyContribution = class AgentSessionReadyContribution extends Disposable {
+    static {
+        this.ID = "chat.agentSessionReady";
+    }
+    constructor(
+        chatWidgetService,
+        configurationService,
+        agentTitleBarStatusService,
+        agentSessionsService,
+        agentSessionProjectionService,
+        chatEditingService
+    ) {
+        super();
+        this.chatWidgetService = chatWidgetService;
+        this.configurationService = configurationService;
+        this.agentTitleBarStatusService = agentTitleBarStatusService;
+        this.agentSessionsService = agentSessionsService;
+        this.agentSessionProjectionService = agentSessionProjectionService;
+        this.chatEditingService = chatEditingService;
+        this._widgetDisposables = this._register(( new DisposableStore()));
+        this._suppressSessionReady = false;
+        for (const widget of this.chatWidgetService.getAllWidgets()) {
+            if (widget.location === ChatAgentLocation.Chat) {
+                this._watchWidget(widget);
+            }
+        }
+        this._register(this.chatWidgetService.onDidAddWidget(widget => {
+            if (widget.location === ChatAgentLocation.Chat) {
+                this._watchWidget(widget);
+            }
+        }));
+        this._register(this.agentSessionProjectionService.onDidChangeProjectionMode(isActive => {
+            if (!isActive) {
+                this._suppressSessionReady = true;
+                this._clearEntriesWatcher();
+                this.agentTitleBarStatusService.exitSessionReadyMode();
+            }
+        }));
+        this._register(autorun(reader => {
+            this.chatEditingService.editingSessionsObs.read(reader);
+            const currentWidget = this.chatWidgetService.getAllWidgets().find(w => w.location === ChatAgentLocation.Chat);
+            if (currentWidget) {
+                this._checkSession(currentWidget.viewModel?.sessionResource);
+            }
+        }));
+    }
+    _watchWidget(widget) {
+        this._widgetDisposables.clear();
+        this._checkSession(widget.viewModel?.sessionResource);
+        this._widgetDisposables.add(widget.onDidChangeViewModel(() => {
+            this._checkSession(widget.viewModel?.sessionResource);
+        }));
+    }
+    _checkSession(sessionResource) {
+        if (sessionResource?.toString() !== this._watchedSessionResource?.toString()) {
+            this._suppressSessionReady = false;
+        }
+        this._updateSessionReadyState(sessionResource);
+    }
+    _clearEntriesWatcher() {
+        this._entriesWatcher?.dispose();
+        this._entriesWatcher = undefined;
+        this._watchedSessionResource = undefined;
+    }
+    _updateSessionReadyState(sessionResource) {
+        const isEnabled = this.configurationService.getValue(ChatConfiguration.AgentSessionProjectionEnabled);
+        if (!isEnabled) {
+            this._clearEntriesWatcher();
+            this.agentTitleBarStatusService.exitSessionReadyMode();
+            return;
+        }
+        if (this.agentSessionProjectionService.isActive) {
+            this._clearEntriesWatcher();
+            this.agentTitleBarStatusService.exitSessionReadyMode();
+            return;
+        }
+        if (!sessionResource) {
+            this._clearEntriesWatcher();
+            this.agentTitleBarStatusService.exitSessionReadyMode();
+            return;
+        }
+        const session = this.agentSessionsService.getSession(sessionResource);
+        if (!session) {
+            this._clearEntriesWatcher();
+            this.agentTitleBarStatusService.exitSessionReadyMode();
+            return;
+        }
+        if (!( AGENT_SESSION_PROJECTION_ENABLED_PROVIDERS.has(session.providerType))) {
+            this._clearEntriesWatcher();
+            this.agentTitleBarStatusService.exitSessionReadyMode();
+            return;
+        }
+        if (isSessionInProgressStatus(session.status)) {
+            this._clearEntriesWatcher();
+            this.agentTitleBarStatusService.exitSessionReadyMode();
+            return;
+        }
+        let hasPendingChanges = false;
+        if (session.providerType === AgentSessionProviders.Local) {
+            const editingSession = this.chatEditingService.getEditingSession(sessionResource);
+            if (!editingSession) {
+                this._clearEntriesWatcher();
+                this.agentTitleBarStatusService.exitSessionReadyMode();
+                return;
+            }
+            const entries = editingSession.entries.get();
+            hasPendingChanges = ( entries.some(entry => entry.state.get() === ModifiedFileEntryState.Modified));
+            if (hasPendingChanges && !this._suppressSessionReady) {
+                this.agentTitleBarStatusService.enterSessionReadyMode(session.resource, session.label);
+                if (!this._watchedSessionResource || ( this._watchedSessionResource.toString()) !== ( sessionResource.toString())) {
+                    this._clearEntriesWatcher();
+                    this._watchedSessionResource = sessionResource;
+                    this._entriesWatcher = autorun(reader => {
+                        const currentEntries = editingSession.entries.read(reader);
+                        const stillHasChanges = ( currentEntries.some(entry => entry.state.read(reader) === ModifiedFileEntryState.Modified));
+                        if (!stillHasChanges) {
+                            this.agentTitleBarStatusService.exitSessionReadyMode();
+                        }
+                    });
+                }
+            } else {
+                this._clearEntriesWatcher();
+                this.agentTitleBarStatusService.exitSessionReadyMode();
+            }
+        } else {
+            this._clearEntriesWatcher();
+            const changeCount = Array.isArray(session.changes) ? session.changes.filter(change => !!change.originalUri).length : 0;
+            hasPendingChanges = changeCount > 0;
+            if (hasPendingChanges && !this._suppressSessionReady) {
+                this.agentTitleBarStatusService.enterSessionReadyMode(session.resource, session.label);
+            } else {
+                this.agentTitleBarStatusService.exitSessionReadyMode();
+            }
+        }
+    }
+};
+AgentSessionReadyContribution = ( __decorate([( __param(0, IChatWidgetService)), ( __param(1, IConfigurationService)), ( __param(2, IAgentTitleBarStatusService)), ( __param(3, IAgentSessionsService)), ( __param(4, IAgentSessionProjectionService)), ( __param(5, IChatEditingService))], AgentSessionReadyContribution));
+registerAction2(EnterAgentSessionProjectionAction);
+registerAction2(ExitAgentSessionProjectionAction);
+registerAction2(ToggleAgentStatusAction);
+registerAction2(ToggleUnifiedAgentsBarAction);
+registerWorkbenchContribution2(
+    AgentTitleBarStatusRendering.ID,
+    AgentTitleBarStatusRendering,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentSessionReadyContribution.ID,
+    AgentSessionReadyContribution,
+    WorkbenchPhase.AfterRestored
+);
+MenuRegistry.appendMenuItem(MenuId.CommandCenter, {
+    submenu: MenuId.AgentsTitleBarControlMenu,
+    title: ( localize(5006, "Agents")),
+    icon: Codicon.chatSparkle,
+    when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(( ContextKeyExpr.has(`config.${ChatConfiguration.AgentStatusEnabled}`)), ( ContextKeyExpr.has(`config.${ChatConfiguration.UnifiedAgentsBar}`)))))),
+    order: 10002
+});
+MenuRegistry.appendMenuItem(MenuId.TitleBar, {
+    submenu: MenuId.ChatTitleBarMenu,
+    title: ( localize(5007, "Chat")),
+    group: "navigation",
+    icon: Codicon.chatSparkle,
+    when: ( ContextKeyExpr.and(ChatContextKeys.supported, ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.disabled.negate()))), ( ContextKeyExpr.has(`config.${ChatConfiguration.AgentStatusEnabled}`)), ( ( ContextKeyExpr.has("config.window.commandCenter")).negate()))),
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.AgentsTitleBarControlMenu, {
+    command: {
+        id: "workbench.action.chat.toggle",
+        title: ( localize(5008, "Open Chat"))
+    },
+    when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(( ContextKeyExpr.has(`config.${ChatConfiguration.AgentStatusEnabled}`)), ( ContextKeyExpr.has(`config.${ChatConfiguration.UnifiedAgentsBar}`)))))),
+    group: "a_open",
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.AgentsTitleBarControlMenu, {
+    command: {
+        id: `toggle.${ChatConfiguration.UnifiedAgentsBar}`,
+        title: ( localize(5009, "Agent Quick Input (Experimental)")),
+        toggled: ( ContextKeyExpr.has(`config.${ChatConfiguration.UnifiedAgentsBar}`))
+    },
+    when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ProductQualityContext.notEqualsTo("stable")))),
+    group: "z_experimental",
+    order: 10
+});