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

package/vscode/src/vs/sessions/contrib/sessions/browser/media/sessionsTitleBarWidget.css

@@ -68,15 +68,31 @@
 .command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-center {
 	display: flex;
 	align-items: center;
-	gap: 0;
+	gap: var(--vscode-spacing-size60);
 	height: 100%;
 	min-width: 0;
 	justify-content: flex-start;
 	cursor: pointer;
 	overflow: hidden;
 }
-/* Workspace name shown beside its icon. */
-.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-workspace {
+
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-separator {
+	flex-shrink: 0;
+}
+
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-workspace-group,
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-branch-group {
+	display: flex;
+	align-items: center;
+	flex: 0 1 auto;
+	min-width: 0;
+	height: 100%;
+	overflow: hidden;
+}
+
+/* Workspace and branch names shown beside their icons. */
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-workspace,
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-branch {
 	display: flex;
 	align-items: center;
 	flex: 0 1 auto;
@@ -87,7 +103,8 @@
 	white-space: nowrap;
 }
 
-.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-workspace-icon {
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-workspace-icon,
+.command-center .agent-sessions-titlebar-container .agent-sessions-titlebar-branch-icon {
 	display: flex;
 	align-items: center;
 	flex-shrink: 0;

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionDetailsAction.d.ts

@@ -1,2 +1,3 @@
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
-export declare function formatSessionDetails(allSessions: readonly ISession[]): string;
+export declare function formatSessionDetails(allSessions: readonly ISession[], labelService: ILabelService): string;

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionDetailsAction.js

@@ -6,6 +6,7 @@ import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls'
 import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
 import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -19,17 +20,20 @@ class ShowSessionDetailsAction extends Action2 {
     constructor() {
         super({
             id: ShowSessionDetailsAction.ID,
-            title: ( localize2(4643, "Show Session Details")),
+            title: ( localize2(5775, "Show Session Details")),
             category: Categories.Developer,
             f1: true,
             precondition: ( ContextKeyExpr.and(IsSessionsWindowContext, ChatContextKeys.enabled))
         });
     }
     async run(accessor) {
-        const contents = formatSessionDetails(accessor.get(ISessionsManagementService).getSessions());
+        const contents = formatSessionDetails(
+            accessor.get(ISessionsManagementService).getSessions(),
+            accessor.get(ILabelService)
+        );
         const resource = ( URI.from({
             scheme: Schemas.untitled,
-            path: ( localize(4644, "Session Details")),
+            path: ( localize(5776, "Session Details")),
             query: generateUuid()
         }));
         await accessor.get(IEditorService).openEditor({
@@ -43,7 +47,7 @@ class ShowSessionDetailsAction extends Action2 {
     }
 }
 registerAction2(ShowSessionDetailsAction);
-function formatSessionDetails(allSessions) {
+function formatSessionDetails(allSessions, labelService) {
     const sessions = allSessions.filter(
         session => !session.isArchived.get() && !(session.isAutomation?.get() ?? false)
     );
@@ -54,7 +58,7 @@ function formatSessionDetails(allSessions) {
     }
     for (const [index, session] of sessions.entries()) {
         const title = session.title.get() || getUntitledSessionTitle(session.isQuickChat?.get() ?? false);
-        const workingDirectories = session.workspace.get()?.folders.map(folder => formatWorkingDirectory(folder.workingDirectory)) ?? [];
+        const workingDirectories = session.workspace.get()?.folders.map(folder => formatWorkingDirectory(folder.workingDirectory, labelService)) ?? [];
         lines.push(`Session: ${title.replace(/\r\n?|\n/g, " ")}`);
         if (workingDirectories.length === 0) {
             lines.push("Working directory: (none)");
@@ -70,8 +74,8 @@ function formatSessionDetails(allSessions) {
     }
     return `${lines.join("\n")}\n`;
 }
-function formatWorkingDirectory(resource) {
-    return resource.scheme === Schemas.file ? resource.fsPath : ( resource.toString(true));
+function formatWorkingDirectory(resource, labelService) {
+    return resource.scheme === Schemas.file ? resource.fsPath : labelService.getUriLabel(resource);
 }
 
 export { formatSessionDetails };

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

@@ -1 +1,116 @@
-
+import { ConfigurationScope } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry";
+import { ExternalSessionApplicationBadgeMode, SessionsChatTabsMode } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionConfig";
+export declare const sessionsConfiguration: {
+    id: string;
+    properties: {
+        "sessions.sidebar.separateNavigation": {
+            type: "boolean";
+            tags: string[];
+            description: string;
+            default: boolean;
+            experiment: {
+                mode: "auto";
+                name: string;
+            };
+        };
+        "sessions.list.groupExternalSessions": {
+            type: "boolean";
+            tags: string[];
+            description: string;
+            default: boolean;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.list.externalApplicationBadge": {
+            type: "string";
+            tags: string[];
+            enum: ExternalSessionApplicationBadgeMode[];
+            enumDescriptions: string[];
+            description: string;
+            default: ExternalSessionApplicationBadgeMode;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.list.externalApplicationBadge.showFrom": {
+            type: "boolean";
+            tags: string[];
+            description: string;
+            default: boolean;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.list.showEmptyDefaultGroups": {
+            type: "boolean";
+            tags: string[];
+            description: string;
+            default: boolean;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.list.showUnreadInCollapsedSections": {
+            type: "boolean";
+            tags: string[];
+            description: string;
+            default: boolean;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.list.showArchivedByDefault": {
+            type: "boolean";
+            tags: string[];
+            description: string;
+            default: boolean;
+            scope: ConfigurationScope.APPLICATION;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.showChatTabs": {
+            type: "string";
+            tags: string[];
+            enum: SessionsChatTabsMode[];
+            enumDescriptions: string[];
+            description: string;
+            default: SessionsChatTabsMode;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.markAsDoneConfetti": {
+            type: "boolean";
+            description: string;
+            default: boolean;
+            experiment: {
+                mode: "auto";
+            };
+        };
+        "sessions.newSessionButton.style": {
+            type: "string";
+            enum: string[];
+            default: string;
+            scope: ConfigurationScope.APPLICATION;
+            included: false;
+            tags: string[];
+            experiment: {
+                mode: "auto";
+                name: string;
+            };
+            description: string;
+        };
+        "sessions.useWorktree": {
+            type: "boolean";
+            default: boolean;
+            scope: ConfigurationScope.APPLICATION;
+            description: string;
+            experiment: {
+                mode: "auto";
+                name: string;
+            };
+        };
+    };
+};

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

@@ -9,22 +9,22 @@ import { ViewPaneContainer } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
 import { SessionsTitleBarContribution } from './sessionsTitleBarWidget.js';
 import { SessionsTelemetryContribution } from './sessionsTelemetry.contribution.js';
-import { NEW_SESSION_BUTTON_STYLE_SETTING, NEW_SESSION_BUTTON_STYLE_TREATMENT, NewSessionActionViewItemContribution, SessionConversationActionsContribution } from './sessionsActions.js';
+import { SessionsAccountTelemetryContribution } from './sessionsAccountTelemetry.js';
+import { NEW_SESSION_BUTTON_STYLE_SETTING, NEW_SESSION_BUTTON_STYLE_TREATMENT, NewSessionActionViewItemContribution, SessionListActionsExperimentContribution, SessionConversationActionsContribution } from './sessionsActions.js';
 import { SessionsView, SessionsViewId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsView';
 import { AutomationsCustomViewContribution } from './views/automationsView.js';
 import './views/sessionsViewActions.js';
 import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
-import { Extensions as Extensions$1, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
-import { SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
-import { AUTOMATIONS_NEW_BADGE_STYLE_SETTING, AUTOMATIONS_NEW_BADGE_STYLE_TREATMENT } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/automationsNewBadge';
+import { ConfigurationScope, Extensions as Extensions$1 } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING, SESSIONS_LIST_SHOW_UNREAD_IN_COLLAPSED_SECTIONS_SETTING, SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
 import { SessionsMouseNavigationContribution } from './sessionsMouseNavigation.js';
 import './sessionDetailsAction.js';
-import { SESSIONS_ARCHIVE_SESSION_CONFETTI_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/sessionArchiveActions';
+import { SESSIONS_MARK_AS_DONE_CONFETTI_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/sessionArchiveActions';
 import { SessionsWindowNotifier } from './sessionsWindowNotifier.js';
-import { USE_WORKTREE_SETTING, USE_WORKTREE_SETTING_TREATMENT } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionConfig';
+import { USE_WORKTREE_SETTING, USE_WORKTREE_SETTING_TREATMENT, SESSIONS_CHAT_TABS_SETTING, SESSIONS_CHAT_TABS_DEFAULT, SessionsChatTabsMode, SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING, SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING, ExternalSessionApplicationBadgeMode, SESSIONS_LIST_GROUP_EXTERNAL_SESSIONS_SETTING, SESSIONS_SIDEBAR_SEPARATE_NAVIGATION_SETTING, SESSIONS_LIST_REARRANGE_TREATMENT } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionConfig';
 
-const agentSessionsViewIcon = registerIcon("chat-sessions-icon", Codicon.commentDiscussionSparkle, ( localize(4645, "Icon for Agent Sessions View")));
-const AGENT_SESSIONS_VIEW_TITLE = ( localize2(4646, "Sessions"));
+const agentSessionsViewIcon = registerIcon("chat-sessions-icon", Codicon.commentDiscussionSparkle, ( localize(5778, "Icon for Agent Sessions View")));
+const AGENT_SESSIONS_VIEW_TITLE = ( localize2(5779, "Sessions"));
 const SessionsContainerId = "agentic.workbench.view.sessionsContainer";
 const agentSessionsViewContainer = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
     id: SessionsContainerId,
@@ -38,7 +38,7 @@ const agentSessionsViewContainer = ( Registry.as(Extensions.ViewContainersRegist
     order: 6,
     openCommandActionDescriptor: {
         id: SessionsContainerId,
-        mnemonicTitle: ( localize(4647, "&&Sessions")),
+        mnemonicTitle: ( localize(5780, "&&Sessions")),
         keybindings: {
             primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyX
         },
@@ -60,14 +60,69 @@ const sessionsViewPaneDescriptor = {
     windowEnablement: WindowEnablement.Sessions
 };
 ( Registry.as(Extensions.ViewsRegistry)).registerViews([sessionsViewPaneDescriptor], agentSessionsViewContainer);
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+const sessionsConfiguration = {
     id: "sessions",
     properties: {
+        [SESSIONS_SIDEBAR_SEPARATE_NAVIGATION_SETTING]: {
+            type: "boolean",
+            tags: ["experimental"],
+            description: ( localize(
+                5781,
+                "Controls whether New Session, Automations, and Customizations are shown in a separate navigation list above the Sessions header. When disabled, Automations is shown inside the sessions tree, New Session remains a toolbar button, and Customizations remains a separate section."
+            )),
+            default: false,
+            experiment: {
+                mode: "auto",
+                name: SESSIONS_LIST_REARRANGE_TREATMENT
+            }
+        },
+        [SESSIONS_LIST_GROUP_EXTERNAL_SESSIONS_SETTING]: {
+            type: "boolean",
+            tags: ["preview"],
+            description: ( localize(
+                5782,
+                "Controls whether external sessions are shown in a separate External section instead of workspace or time groups. Pinned sessions and custom groups keep their placement."
+            )),
+            default: false,
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING]: {
+            type: "string",
+            tags: ["experimental"],
+            enum: [
+                ExternalSessionApplicationBadgeMode.Off,
+                ExternalSessionApplicationBadgeMode.Title,
+                ExternalSessionApplicationBadgeMode.Details
+            ],
+            enumDescriptions: [( localize(5783, "Do not show the creating application.")), ( localize(5784, "Show the creating application next to the session title.")), ( localize(5785, "Show the creating application first in the session details."))],
+            description: ( localize(
+                5786,
+                "Controls where external sessions created in another application show the creating application."
+            )),
+            default: ExternalSessionApplicationBadgeMode.Off,
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING]: {
+            type: "boolean",
+            tags: ["experimental", "advanced"],
+            description: ( localize(
+                5787,
+                "Controls whether external session application badges include the word 'From'."
+            )),
+            default: true,
+            experiment: {
+                mode: "auto"
+            }
+        },
         [SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING]: {
             type: "boolean",
             tags: ["preview"],
             description: ( localize(
-                4648,
+                5788,
                 "Controls whether the Chats group is shown in the sessions list even when it is empty."
             )),
             default: true,
@@ -75,27 +130,55 @@ const sessionsViewPaneDescriptor = {
                 mode: "auto"
             }
         },
-        [SESSIONS_ARCHIVE_SESSION_CONFETTI_SETTING]: {
+        [SESSIONS_LIST_SHOW_UNREAD_IN_COLLAPSED_SECTIONS_SETTING]: {
             type: "boolean",
             tags: ["preview"],
             description: ( localize(
-                4649,
-                "Controls whether a confetti animation is shown when archiving a session."
+                5789,
+                "Controls whether collapsed sections in the sessions list show needs-attention, CI-failure, or unread indicators for the unarchived sessions they contain."
             )),
-            default: false
+            default: false,
+            experiment: {
+                mode: "auto"
+            }
         },
-        [AUTOMATIONS_NEW_BADGE_STYLE_SETTING]: {
-            type: "string",
-            enum: ["accent", "soft", "outline", "unread"],
-            default: "outline",
+        [SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING]: {
+            type: "boolean",
+            tags: ["experimental", "advanced"],
+            description: ( localize(
+                5790,
+                "Controls whether the Done or Archived section is shown by default in the sessions list. This default is ignored after the corresponding filter is changed."
+            )),
+            default: false,
             scope: ConfigurationScope.APPLICATION,
-            included: false,
-            tags: ["experimental"],
             experiment: {
-                mode: "auto",
-                name: AUTOMATIONS_NEW_BADGE_STYLE_TREATMENT
-            },
-            description: ( localize(4650, "Controls the visual style of the Automations first-use badge."))
+                mode: "auto"
+            }
+        },
+        [SESSIONS_CHAT_TABS_SETTING]: {
+            type: "string",
+            tags: ["preview"],
+            enum: [SessionsChatTabsMode.Multiple, SessionsChatTabsMode.Single],
+            enumDescriptions: [( localize(5791, "Each chat is displayed as a tab in the session view.")), ( localize(5792, "The active chat is displayed as the session view."))],
+            description: ( localize(
+                5793,
+                "Controls whether chats in a session are shown as individual tabs or whether the active chat is shown as the session view."
+            )),
+            default: SESSIONS_CHAT_TABS_DEFAULT,
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [SESSIONS_MARK_AS_DONE_CONFETTI_SETTING]: {
+            type: "boolean",
+            description: ( localize(
+                5794,
+                "Controls whether a confetti animation is shown when marking a session as done."
+            )),
+            default: true,
+            experiment: {
+                mode: "auto"
+            }
         },
         [NEW_SESSION_BUTTON_STYLE_SETTING]: {
             type: "string",
@@ -108,15 +191,15 @@ const sessionsViewPaneDescriptor = {
                 mode: "auto",
                 name: NEW_SESSION_BUTTON_STYLE_TREATMENT
             },
-            description: ( localize(4651, "Controls the visual style of the New Session button."))
+            description: ( localize(5795, "Controls the visual style of the New Session button."))
         },
         [USE_WORKTREE_SETTING]: {
             type: "boolean",
-            default: true,
+            default: false,
             scope: ConfigurationScope.APPLICATION,
             description: ( localize(
-                4652,
-                "Controls whether New Worktree is checked when no previous isolation choice has been saved. Once a choice is saved, it is used across workspaces instead of this setting."
+                5796,
+                "Controls whether New Worktree is checked for a workspace that has not started a session before. Each workspace otherwise uses the choice from its last started session."
             )),
             experiment: {
                 mode: "auto",
@@ -124,7 +207,8 @@ const sessionsViewPaneDescriptor = {
             }
         }
     }
-});
+};
+( Registry.as(Extensions$1.Configuration)).registerConfiguration(sessionsConfiguration);
 registerWorkbenchContribution2(
     AutomationsCustomViewContribution.ID,
     AutomationsCustomViewContribution,
@@ -140,6 +224,11 @@ registerWorkbenchContribution2(
     NewSessionActionViewItemContribution,
     WorkbenchPhase.BlockRestore
 );
+registerWorkbenchContribution2(
+    SessionListActionsExperimentContribution.ID,
+    SessionListActionsExperimentContribution,
+    WorkbenchPhase.BlockRestore
+);
 registerWorkbenchContribution2(
     SessionsMouseNavigationContribution.ID,
     SessionsMouseNavigationContribution,
@@ -150,6 +239,11 @@ registerWorkbenchContribution2(
     SessionsTelemetryContribution,
     WorkbenchPhase.AfterRestored
 );
+registerWorkbenchContribution2(
+    SessionsAccountTelemetryContribution.ID,
+    SessionsAccountTelemetryContribution,
+    WorkbenchPhase.AfterRestored
+);
 registerWorkbenchContribution2(
     SessionsWindowNotifier.ID,
     SessionsWindowNotifier,
@@ -160,3 +254,5 @@ registerWorkbenchContribution2(
     SessionConversationActionsContribution,
     WorkbenchPhase.AfterRestored
 );
+
+export { sessionsConfiguration };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsAccountTelemetry.d.ts

@@ -0,0 +1,26 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ICodexAccountService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/browser/codexAccountService.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+/** Reports startup account context and later changes without fetching account or quota data. */
+export declare class SessionsAccountTelemetryContribution extends Disposable implements IWorkbenchContribution {
+    private readonly telemetryService;
+    private readonly chatEntitlementService;
+    private readonly codexAccountService;
+    private readonly logService;
+    private readonly defaultAccountService;
+    static readonly ID = "workbench.contrib.sessionsAccountTelemetry";
+    private lastSnapshot;
+    private initialDefaultAccountResolved;
+    private readonly startupDeadline;
+    constructor(telemetryService: ITelemetryService, chatEntitlementService: IChatEntitlementService, codexAccountService: ICodexAccountService, logService: ILogService, defaultAccountService: IDefaultAccountService);
+    private waitForInitialAccount;
+    private get copilotEntitlement();
+    private hasStartupData;
+    private get snapshot();
+    private onAccountChanged;
+}
+export declare function getSessionsTelemetryCopilotSku(chatEntitlementService: IChatEntitlementService): string;

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsAccountTelemetry.js

@@ -0,0 +1,160 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ICodexAccountService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/browser/codexAccountService.service';
+import { ChatEntitlement, getQuotaUsage, QuotaUsageKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+
+const STARTUP_ACCOUNT_TIMEOUT_MS = 30_000;
+let SessionsAccountTelemetryContribution = class SessionsAccountTelemetryContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsAccountTelemetry";
+    }
+    constructor(
+        telemetryService,
+        chatEntitlementService,
+        codexAccountService,
+        logService,
+        defaultAccountService
+    ) {
+        super();
+        this.telemetryService = telemetryService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.codexAccountService = codexAccountService;
+        this.logService = logService;
+        this.defaultAccountService = defaultAccountService;
+        this.initialDefaultAccountResolved = false;
+        this.startupDeadline = this._register(( new RunOnceScheduler(() => this.onAccountChanged(true), STARTUP_ACCOUNT_TIMEOUT_MS)));
+        const update = this._register(( new RunOnceScheduler(() => this.onAccountChanged(), 0)));
+        this._register(chatEntitlementService.onDidChangeEntitlement(() => update.schedule()));
+        this._register(chatEntitlementService.onDidChangeAnonymous(() => update.schedule()));
+        this._register(chatEntitlementService.onDidChangeQuotaRemaining(() => update.schedule()));
+        this._register(codexAccountService.onDidChangeAccount(() => update.schedule()));
+        this._register(defaultAccountService.onDidChangeDefaultAccount(() => update.schedule()));
+        this.startupDeadline.schedule();
+        void this.waitForInitialAccount(update).catch(
+            error => this.logService.error("[SessionsAccountTelemetry] Failed to resolve the initial account.", error)
+        );
+    }
+    async waitForInitialAccount(update) {
+        await this.defaultAccountService.getDefaultAccount();
+        if (!this._store.isDisposed) {
+            this.initialDefaultAccountResolved = true;
+            update.schedule();
+        }
+    }
+    get copilotEntitlement() {
+        const entitlement = this.chatEntitlementService.entitlement;
+        if (!this.initialDefaultAccountResolved || (entitlement === ChatEntitlement.Unknown && this.defaultAccountService.currentDefaultAccount !== null)) {
+            return ChatEntitlement.Unresolved;
+        }
+        return entitlement;
+    }
+    hasStartupData() {
+        const entitlement = this.copilotEntitlement;
+        if (entitlement === ChatEntitlement.Unresolved) {
+            return false;
+        }
+        const {
+            sku,
+            quotas
+        } = this.chatEntitlementService;
+        if (entitlement !== ChatEntitlement.Unknown && entitlement !== ChatEntitlement.Available && entitlement !== ChatEntitlement.Unavailable && (sku === undefined || (quotas.premiumChat === undefined && quotas.chat === undefined))) {
+            return false;
+        }
+        const account = this.codexAccountService.account;
+        return account.status !== "unknown" && account.status !== "downloading" && (account.status !== "signedIn" || account.rateLimits !== undefined || account.rateLimit !== undefined);
+    }
+    get snapshot() {
+        const entitlement = this.copilotEntitlement;
+        const copilotAccountState = entitlement === ChatEntitlement.Unknown ? "signedOut" : entitlement === ChatEntitlement.Unresolved ? "unknown" : "signedIn";
+        const now = Date.now();
+        return {
+            copilotSku: entitlement === ChatEntitlement.Unresolved ? "unknown" : getSessionsTelemetryCopilotSku(this.chatEntitlementService),
+            copilotAccountState,
+            copilotQuotaPercentRemaining: copilotAccountState === "signedIn" ? getCopilotQuotaPercentRemaining(
+                this.chatEntitlementService.quotas.premiumChat ?? this.chatEntitlementService.quotas.chat,
+                now,
+                this.logService
+            ) : undefined,
+            chatgptAccountState: this.codexAccountService.account.status,
+            chatgptQuotaPercentRemaining: getChatGPTQuotaPercentRemaining(this.codexAccountService.account, now, this.logService)
+        };
+    }
+    onAccountChanged(startupTimedOut = false) {
+        const previous = this.lastSnapshot;
+        if (!previous && !startupTimedOut && !this.hasStartupData()) {
+            return;
+        }
+        const current = this.snapshot;
+        this.lastSnapshot = current;
+        if (!previous) {
+            this.startupDeadline.cancel();
+            this.telemetryService.publicLog2("agents/accountState", current);
+            return;
+        }
+        const accountChanged = previous.copilotSku !== current.copilotSku || previous.copilotAccountState !== current.copilotAccountState || previous.chatgptAccountState !== current.chatgptAccountState;
+        const quotaResolved = (previous.copilotQuotaPercentRemaining === undefined && current.copilotQuotaPercentRemaining !== undefined) || (previous.chatgptQuotaPercentRemaining === undefined && current.chatgptQuotaPercentRemaining !== undefined);
+        if (!accountChanged && !quotaResolved) {
+            return;
+        }
+        this.telemetryService.publicLog2("agents/accountStateChanged", {
+            ...current,
+            changeReason: accountChanged ? "accountChanged" : "quotaResolved",
+            previousCopilotSku: previous.copilotSku,
+            previousCopilotAccountState: previous.copilotAccountState,
+            previousChatgptAccountState: previous.chatgptAccountState
+        });
+    }
+};
+SessionsAccountTelemetryContribution = ( __decorate([( __param(0, ITelemetryService)), ( __param(1, IChatEntitlementService)), ( __param(2, ICodexAccountService)), ( __param(3, ILogService)), ( __param(4, IDefaultAccountService))], SessionsAccountTelemetryContribution));
+function getSessionsTelemetryCopilotSku(chatEntitlementService) {
+    if (chatEntitlementService.entitlement === ChatEntitlement.Unknown && !chatEntitlementService.anonymous) {
+        return "signedOut";
+    }
+    if (chatEntitlementService.entitlement === ChatEntitlement.Unresolved) {
+        return "unknown";
+    }
+    return chatEntitlementService.sku ?? "unknown";
+}
+function getCopilotQuotaPercentRemaining(quota, now, logService) {
+    if (!quota || getQuotaUsage(quota)?.kind !== QuotaUsageKind.Percentage || !hasNotReset(quota.resetAt, now, logService)) {
+        return undefined;
+    }
+    return validPercentage(quota.percentRemaining, logService);
+}
+function getChatGPTQuotaPercentRemaining(account, now, logService) {
+    if (account.status !== "signedIn") {
+        return undefined;
+    }
+    const weeklyWindowMins = 7 * 24 * 60;
+    const weeklyLimit = account.rateLimits?.find(limit => limit.windowDurationMins === weeklyWindowMins) ?? (account.rateLimit?.windowDurationMins === weeklyWindowMins ? account.rateLimit : undefined);
+    if (!weeklyLimit || !hasNotReset(weeklyLimit.resetsAt, now, logService)) {
+        return undefined;
+    }
+    const usedPercent = validPercentage(weeklyLimit.usedPercent, logService);
+    return usedPercent !== undefined ? 100 - usedPercent : undefined;
+}
+function validPercentage(value, logService) {
+    if (!Number.isFinite(value) || value < 0 || value > 100) {
+        logService.warn("[SessionsAccountTelemetry] Ignoring an invalid quota percentage.");
+        return undefined;
+    }
+    return value;
+}
+function hasNotReset(resetsAt, now, logService) {
+    if (resetsAt === undefined) {
+        return true;
+    }
+    if (!Number.isFinite(resetsAt) || resetsAt <= 0) {
+        logService.warn("[SessionsAccountTelemetry] Ignoring a quota with an invalid reset time.");
+        return false;
+    }
+    return resetsAt * 1000 > now;
+}
+
+export { SessionsAccountTelemetryContribution, getSessionsTelemetryCopilotSku };