@codingame/monaco-vscode-api 37.6.1 → 38.0.1

package/vscode/src/vs/sessions/services/sessions/common/session.js

@@ -5,6 +5,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { localize } from '../../../../nls.js';
 import '../../../../base/common/codicons.js';
 import { isIChatSessionFileChange2 } from '../../../../workbench/contrib/chat/common/chatSessionsService.js';
+export { SessionCustomizationKind } from '../../../../workbench/contrib/chat/common/sessionChatCustomizations.js';
 
 var SessionTypeAuthRequirement;
 (function(SessionTypeAuthRequirement) {
@@ -34,11 +35,11 @@ function isActiveSessionStatus(status) {
 function getSessionStatusMessage(status, description) {
     switch (status) {
     case SessionStatus.InProgress:
-        return description ?? ( localize(5027, "Working..."));
+        return description ?? ( localize(6343, "Working..."));
     case SessionStatus.NeedsInput:
-        return description ?? ( localize(5028, "Input needed"));
+        return description ?? ( localize(6344, "Attention needed"));
     case SessionStatus.Error:
-        return description ?? ( localize(5029, "Failed"));
+        return description ?? ( localize(6345, "Failed"));
     default:
         return undefined;
     }
@@ -46,6 +47,7 @@ function getSessionStatusMessage(status, description) {
 var ChatInteractivity;
 (function(ChatInteractivity) {
     ChatInteractivity["Full"] = "full";
+    ChatInteractivity["DraftOnly"] = "draft-only";
     ChatInteractivity["ReadOnly"] = "read-only";
     ChatInteractivity["Hidden"] = "hidden";
 })(ChatInteractivity || (ChatInteractivity = {}));
@@ -79,16 +81,6 @@ var SessionArtifactKind;
     SessionArtifactKind["File"] = "file";
     SessionArtifactKind["Resource"] = "resource";
 })(SessionArtifactKind || (SessionArtifactKind = {}));
-var SessionCustomizationKind;
-(function(SessionCustomizationKind) {
-    SessionCustomizationKind["Agent"] = "agent";
-    SessionCustomizationKind["Skill"] = "skill";
-    SessionCustomizationKind["Instruction"] = "instruction";
-    SessionCustomizationKind["Hook"] = "hook";
-    SessionCustomizationKind["Prompt"] = "prompt";
-    SessionCustomizationKind["McpServer"] = "mcpServer";
-    SessionCustomizationKind["Plugin"] = "plugin";
-})(SessionCustomizationKind || (SessionCustomizationKind = {}));
 function getGitHubPullRequestRefs(gitHubInfo) {
     if (gitHubInfo?.pullRequests?.length) {
         return gitHubInfo.pullRequests;
@@ -136,6 +128,7 @@ var ChatOriginKind;
 })(ChatOriginKind || (ChatOriginKind = {}));
 const DEFAULT_CHAT_CAPABILITIES = {
     canRename: true,
+    canArchive: false,
     canDelete: true
 };
 var ChatModelSource;
@@ -143,34 +136,28 @@ var ChatModelSource;
     ChatModelSource["Chosen"] = "chosen";
     ChatModelSource["CarriedOver"] = "carriedOver";
 })(ChatModelSource || (ChatModelSource = {}));
+function isSideChatOf(chat, parentChat) {
+    return chat.origin?.kind === ChatOriginKind.SideChat && !!chat.origin.parentChat && isEqual(chat.origin.parentChat, parentChat);
+}
 function getChatCapabilities(chat, session, reader) {
     const own = chat.capabilities?.read(reader) ?? DEFAULT_CHAT_CAPABILITIES;
     if (session && isEqual(chat.resource, session.mainChat.read(reader).resource)) {
-        return own.canDelete ? {
+        return own.canArchive || own.canDelete ? {
             ...own,
+            canArchive: false,
             canDelete: false
         } : own;
     }
     return own;
 }
-function sessionHasChanges(session, reader) {
-    if (( session.chats.read(reader).some(chat => chat.changes.read(reader).length > 0))) {
-        return true;
-    }
-    const changesSummary = session.changesSummary?.read(reader);
-    if (changesSummary !== undefined) {
-        return changesSummary.files > 0;
-    }
-    return session.changes.read(reader).length > 0;
-}
 function toSessionId(providerId, resource) {
     return `${providerId}:${( resource.toString())}`;
 }
-const SESSION_WORKSPACE_GROUP_LOCAL = ( localize(5030, "Local"));
-const SESSION_WORKSPACE_GROUP_GITHUB = ( localize(5031, "GitHub"));
-const SESSION_WORKSPACE_GROUP_REMOTE = ( localize(5032, "Remote"));
+const SESSION_WORKSPACE_GROUP_LOCAL = ( localize(6346, "Local"));
+const SESSION_WORKSPACE_GROUP_GITHUB = ( localize(6347, "GitHub"));
+const SESSION_WORKSPACE_GROUP_REMOTE = ( localize(6348, "Remote"));
 function getUntitledSessionTitle(isQuickChat) {
-    return isQuickChat ? ( localize(5033, "New Chat")) : ( localize(5034, "New Session"));
+    return isQuickChat ? ( localize(6349, "New Chat")) : ( localize(6350, "New Session"));
 }
 function sessionFileChangesEqual(a, b) {
     if (a === b) {
@@ -213,7 +200,7 @@ function sessionFileChangesEqual(a, b) {
 }
 function sessionTurnFileChangesEqual(a, b) {
     return sessionFileChangesEqual(a, b) && a.every(
-        (change, index) => change.isOutsideWorkspace === b[index].isOutsideWorkspace
+        (change, index) => change.isOutsideWorkspace === b[index].isOutsideWorkspace && isEqual(change.renamedFromUri, b[index].renamedFromUri)
     );
 }
 function gitHubInfoEqual(a, b) {
@@ -228,11 +215,11 @@ function gitHubInfoEqual(a, b) {
     return a.owner === b.owner && a.repo === b.repo && arrayEquals(
         a.pullRequests ?? [],
         b.pullRequests ?? [],
-        (x, y) => x.owner === y.owner && x.repo === y.repo && x.number === y.number && isEqual(x.uri, y.uri) && x.state === y.state && x.liveState === y.liveState && x.title === y.title && x.createdByThisSession === y.createdByThisSession && (x.icon === y.icon || (!!x.icon && !!y.icon && ThemeIcon.isEqual(x.icon, y.icon)))
+        (x, y) => x.owner === y.owner && x.repo === y.repo && x.number === y.number && isEqual(x.uri, y.uri) && x.state === y.state && x.liveState === y.liveState && x.title === y.title && x.recordedReferenceId === y.recordedReferenceId && x.createdByThisSession === y.createdByThisSession && (x.icon === y.icon || (!!x.icon && !!y.icon && ThemeIcon.isEqual(x.icon, y.icon)))
     ) && a.pullRequest?.number === b.pullRequest?.number && isEqual(a.pullRequest?.uri, b.pullRequest?.uri) && a.pullRequest?.state === b.pullRequest?.state && a.pullRequest?.liveState === b.pullRequest?.liveState && (aIcon === bIcon || (!!aIcon && !!bIcon && ThemeIcon.isEqual(aIcon, bIcon))) && a.pullRequest?.title === b.pullRequest?.title && a.pullRequest?.baseRefOid === b.pullRequest?.baseRefOid && a.pullRequest?.headRefOid === b.pullRequest?.headRefOid && arrayEquals(
         a.issues ?? [],
         b.issues ?? [],
-        (x, y) => x.owner === y.owner && x.repo === y.repo && x.number === y.number && isEqual(x.uri, y.uri) && x.title === y.title
+        (x, y) => x.owner === y.owner && x.repo === y.repo && x.number === y.number && isEqual(x.uri, y.uri) && x.title === y.title && x.recordedReferenceId === y.recordedReferenceId
     );
 }
 function sessionWorkspaceEqual(a, b) {
@@ -259,7 +246,7 @@ function sessionGitRepositoryEqual(a, b) {
     if (!a || !b) {
         return false;
     }
-    return isEqual(a.uri, b.uri) && isEqual(a.workTreeUri, b.workTreeUri) && a.isRepository?.get() === b.isRepository?.get() && a.branchName === b.branchName && a.baseBranchName === b.baseBranchName && a.baseBranchProtected === b.baseBranchProtected && a.hasGitHubRemote === b.hasGitHubRemote && a.upstreamBranchName === b.upstreamBranchName && a.incomingChanges === b.incomingChanges && a.outgoingChanges === b.outgoingChanges && a.uncommittedChanges === b.uncommittedChanges && a.hasGitOperationInProgress === b.hasGitOperationInProgress && gitHubInfoEqual(a.gitHubInfo.get(), b.gitHubInfo.get());
+    return isEqual(a.uri, b.uri) && isEqual(a.workTreeUri, b.workTreeUri) && a.isRepository?.get() === b.isRepository?.get() && a.branchName === b.branchName && a.baseBranchName === b.baseBranchName && a.baseBranchProtected === b.baseBranchProtected && a.hasGitRemote === b.hasGitRemote && a.hasGitHubRemote === b.hasGitHubRemote && a.upstreamBranchName === b.upstreamBranchName && a.defaultBranchName === b.defaultBranchName && a.defaultRemoteBranchName === b.defaultRemoteBranchName && a.incomingChanges === b.incomingChanges && a.outgoingChanges === b.outgoingChanges && a.uncommittedChanges === b.uncommittedChanges && a.hasGitOperationInProgress === b.hasGitOperationInProgress && gitHubInfoEqual(a.gitHubInfo.get(), b.gitHubInfo.get());
 }
 
-export { BRANCH_CHANGES_CHANGESET_ID, ChatInteractivity, ChatModelSource, ChatOriginKind, DEFAULT_CHAT_CAPABILITIES, GITHUB_REMOTE_FILE_SCHEME, SESSION_CHANGES_CHANGESET_ID, SESSION_WORKSPACE_GROUP_GITHUB, SESSION_WORKSPACE_GROUP_LOCAL, SESSION_WORKSPACE_GROUP_REMOTE, SessionArtifactKind, SessionChangesetOperationScope, SessionChangesetOperationStatus, SessionCustomizationKind, SessionRemoteConnectionFailureReason, SessionStatus, SessionTypeAuthRequirement, SessionWorkspaceKind, TURN_CHANGES_CHANGESET_ID, UNCOMMITTED_CHANGES_CHANGESET_ID, effectiveChatInteractivity, getChatCapabilities, getGitHubPullRequestRefs, getSessionOwnedGitHubPullRequestRefs, getSessionStatusMessage, getSessionWorkspaceKind, getUntitledSessionTitle, gitHubInfoEqual, isActiveSessionStatus, sessionFileChangesEqual, sessionFolderEqual, sessionGitRepositoryEqual, sessionHasChanges, sessionTurnFileChangesEqual, sessionWorkspaceEqual, toSessionId };
+export { BRANCH_CHANGES_CHANGESET_ID, ChatInteractivity, ChatModelSource, ChatOriginKind, DEFAULT_CHAT_CAPABILITIES, GITHUB_REMOTE_FILE_SCHEME, SESSION_CHANGES_CHANGESET_ID, SESSION_WORKSPACE_GROUP_GITHUB, SESSION_WORKSPACE_GROUP_LOCAL, SESSION_WORKSPACE_GROUP_REMOTE, SessionArtifactKind, SessionChangesetOperationScope, SessionChangesetOperationStatus, SessionRemoteConnectionFailureReason, SessionStatus, SessionTypeAuthRequirement, SessionWorkspaceKind, TURN_CHANGES_CHANGESET_ID, UNCOMMITTED_CHANGES_CHANGESET_ID, effectiveChatInteractivity, getChatCapabilities, getGitHubPullRequestRefs, getSessionOwnedGitHubPullRequestRefs, getSessionStatusMessage, getSessionWorkspaceKind, getUntitledSessionTitle, gitHubInfoEqual, isActiveSessionStatus, isSideChatOf, sessionFileChangesEqual, sessionFolderEqual, sessionGitRepositoryEqual, sessionTurnFileChangesEqual, sessionWorkspaceEqual, toSessionId };

package/vscode/src/vs/sessions/services/sessions/common/sessionChangesStatsCache.d.ts

@@ -1,7 +1,7 @@
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { IReader } from "../../../../base/common/observable.js";
 import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
-import { ISession } from "./session.js";
+import { IChat, ISession } from "./session.js";
 import { ISessionChangesStatsCache } from "./sessionChangesStatsCache.service.js";
 /** The aggregate diff counts the changes pill reports for a session. */
 export interface ISessionChangesStats {
@@ -14,12 +14,13 @@ export interface ISessionChangesStats {
  * while the session has not reported any changes data yet.
  *
  * The provider-supplied {@link ISession.changesSummary} is the authoritative
- * aggregate; without it the changes of the default changeset (or the session's
- * top-level changes when no changeset is default) are aggregated. A session with
- * neither a summary nor any changeset has not reported yet — an empty changeset
- * list, in contrast, is a reported "no changes".
+ * aggregate; without it the main chat's changes are aggregated. The main chat
+ * catalogue distinguishes an unresolved session from one that has
+ * authoritatively reported no changes.
  */
 export declare function readSessionChangesStats(session: ISession, reader: IReader | undefined): ISessionChangesStats | undefined;
+/** The active chat's changes as represented by the preferred or default changeset. */
+export declare function readChatChangesStats(chat: IChat, reader: IReader | undefined, preferredChangesetId?: string): ISessionChangesStats | undefined;
 /** How many sessions are remembered; the oldest entry is evicted beyond this. */
 export declare const MAX_CACHED_SESSION_CHANGES_STATS = 30;
 /** Exported for direct instantiation in tests; consumers should depend on {@link ISessionChangesStatsCache}. */

package/vscode/src/vs/sessions/services/sessions/common/sessionChangesStatsCache.js

@@ -17,12 +17,31 @@ function readSessionChangesStats(session, reader) {
             deletions: summary.deletions
         };
     }
-    const changesets = session.changesets.read(reader);
-    const defaultChangeset = changesets?.find(changeset => changeset.isDefault.read(reader));
-    const changes = defaultChangeset?.changes.read(reader) ?? session.changes.read(reader);
-    if (changesets === undefined && changes.length === 0) {
+    const mainChat = session.mainChat.read(reader);
+    const changes = mainChat.changes.read(reader);
+    if (changes.length === 0 && mainChat.changesets.read(reader) === undefined) {
         return undefined;
     }
+    return readFileChangesStats(changes);
+}
+function readChatChangesStats(chat, reader, preferredChangesetId) {
+    return readChangesStats(
+        chat.changesets.read(reader),
+        chat.changes.read(reader),
+        reader,
+        preferredChangesetId
+    );
+}
+function readChangesStats(changesets, fallbackChanges, reader, preferredChangesetId) {
+    const preferredChangeset = preferredChangesetId ? changesets?.find(changeset => changeset.id === preferredChangesetId) : undefined;
+    const defaultChangeset = preferredChangeset ?? changesets?.find(changeset => changeset.isDefault.read(reader));
+    const changes = defaultChangeset?.changes.read(reader) ?? fallbackChanges;
+    if (changesets === undefined && fallbackChanges.length === 0) {
+        return undefined;
+    }
+    return readFileChangesStats(changes);
+}
+function readFileChangesStats(changes) {
     let insertions = 0, deletions = 0;
     for (const change of changes) {
         insertions += change.insertions;
@@ -127,4 +146,4 @@ let SessionChangesStatsCache = class SessionChangesStatsCache extends Disposable
 };
 SessionChangesStatsCache = ( __decorate([( __param(0, IStorageService))], SessionChangesStatsCache));
 
-export { MAX_CACHED_SESSION_CHANGES_STATS, SessionChangesStatsCache, readSessionChangesStats };
+export { MAX_CACHED_SESSION_CHANGES_STATS, SessionChangesStatsCache, readChatChangesStats, readSessionChangesStats };

package/vscode/src/vs/sessions/services/sessions/common/sessionComparison.d.ts

@@ -0,0 +1,134 @@
+import { URI } from "../../../../base/common/uri.js";
+import { IChatRequestVariableEntry } from "../../../../workbench/contrib/chat/common/attachments/chatVariableEntries.js";
+export declare enum SessionComparisonParticipantRole {
+    Coordinator = "coordinator",
+    Attempt = "attempt",
+    Judge = "judge",
+    Synthesis = "synthesis"
+}
+export declare enum SessionComparisonValidationState {
+    Passed = "passed",
+    Failed = "failed",
+    NotRun = "notRun",
+    NotApplicable = "notApplicable",
+    Unknown = "unknown"
+}
+export declare enum SessionComparisonValidationSource {
+    AttemptReport = "attemptReport",
+    JudgeRun = "judgeRun",
+    NotApplicable = "notApplicable",
+    Unavailable = "unavailable"
+}
+export type SessionComparisonValidationEvidence = {
+    readonly state: SessionComparisonValidationState.Passed | SessionComparisonValidationState.Failed;
+    readonly source: SessionComparisonValidationSource.AttemptReport | SessionComparisonValidationSource.JudgeRun;
+} | {
+    readonly state: SessionComparisonValidationState.NotRun | SessionComparisonValidationState.Unknown;
+    readonly source: SessionComparisonValidationSource.AttemptReport | SessionComparisonValidationSource.JudgeRun | SessionComparisonValidationSource.Unavailable;
+} | {
+    readonly state: SessionComparisonValidationState.NotApplicable;
+    readonly source: SessionComparisonValidationSource.NotApplicable;
+};
+export interface ISessionComparisonHarness {
+    readonly providerId: string;
+    readonly sessionTypeId: string;
+    readonly label: string;
+    readonly modelId?: string;
+    readonly modelLabel?: string;
+    readonly modelConfiguration?: Readonly<Record<string, string | number | boolean | null>>;
+    readonly modelConfigurationLabel?: string;
+    readonly modeId?: string;
+    readonly permissionId?: string;
+    readonly permissionLabel?: string;
+}
+export interface ISessionComparisonAttemptConfiguration {
+    readonly id: string;
+    readonly harness: ISessionComparisonHarness;
+}
+export interface ISessionComparisonParticipant {
+    readonly id: string;
+    readonly role: SessionComparisonParticipantRole;
+    readonly harness: ISessionComparisonHarness;
+    readonly sessionResource?: URI;
+    readonly launchError?: string;
+    readonly missingSession?: boolean;
+    readonly completion?: {
+        readonly elapsedMs?: number;
+        readonly tokenCount?: number;
+        /** Whether the token count includes every model call; false means it is a lower bound. */
+        readonly tokenCountIsComplete?: boolean;
+    };
+}
+export interface ISessionComparisonAttemptVerdict {
+    readonly participantId: string;
+    readonly summary: string;
+    readonly validation: {
+        readonly tests: SessionComparisonValidationEvidence;
+        readonly build: SessionComparisonValidationEvidence;
+        readonly lint: SessionComparisonValidationEvidence;
+        readonly diagnostics: SessionComparisonValidationEvidence;
+    };
+    readonly unresolvedIssues: readonly string[];
+    readonly notableDifferences: readonly string[];
+}
+export interface ISessionComparisonRationale {
+    readonly comparison: string;
+    readonly validation: string;
+    readonly codeQuality: string;
+    readonly solution: string;
+}
+export interface ISessionComparisonVerdict {
+    readonly recommendedParticipantId: string;
+    readonly explanation: string;
+    /** Undefined for verdicts persisted before categorized rationale was introduced. */
+    readonly rationale?: ISessionComparisonRationale;
+    readonly conflicts: readonly string[];
+    readonly attempts: readonly ISessionComparisonAttemptVerdict[];
+}
+export declare const SESSION_COMPARISON_MANIFEST_TEXT_MAX_LENGTH = 1000;
+export declare const SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS = 32;
+export declare const SESSION_COMPARISON_SYNTHESIS_INSTRUCTIONS_MAX_LENGTH = 4000;
+export declare const SESSION_COMPARISON_MAX_ATTEMPTS = 10;
+export declare const COMPARE_AGENTS_ENABLED_SETTING = "sessions.chat.compareAgents.enabled";
+export declare function getBoundedSessionComparisonManifestText(value: string): string;
+export declare function getBoundedSessionComparisonManifestList(values: readonly string[]): readonly string[];
+export interface ISessionComparisonSynthesisPlan {
+    readonly instructions?: string;
+}
+export interface ISessionComparison {
+    readonly id: string;
+    readonly groupId: string;
+    readonly title: string;
+    readonly createdAt: number;
+    readonly workspace: URI;
+    readonly prompt: string;
+    /** Transient while the initial attempt sessions are still being created. */
+    readonly launching?: boolean;
+    readonly attachedContext?: readonly IChatRequestVariableEntry[];
+    readonly branch?: string;
+    /** Retained for comparisons persisted before execution presets were introduced. */
+    readonly permissionLevel?: string;
+    readonly judgeHarness?: ISessionComparisonHarness;
+    readonly synthesisHarness?: ISessionComparisonHarness;
+    readonly participants: readonly ISessionComparisonParticipant[];
+    readonly cancelledAt?: number;
+    readonly archivedAt?: number;
+    readonly selectedParticipantId?: string;
+    readonly verdict?: ISessionComparisonVerdict;
+    readonly synthesisPlan?: ISessionComparisonSynthesisPlan;
+}
+export interface IStartSessionComparisonOptions {
+    readonly workspace: URI;
+    readonly prompt: string;
+    readonly attachedContext?: readonly IChatRequestVariableEntry[];
+    readonly attempts: readonly ISessionComparisonAttemptConfiguration[];
+    readonly judgeHarness?: ISessionComparisonHarness;
+    readonly synthesisHarness?: ISessionComparisonHarness;
+    readonly permissionLevel?: string;
+    readonly branch?: string;
+}
+export declare function getSessionComparisonWorkspaceError(branch: string | undefined, hasGitRemote: boolean | undefined): string | undefined;
+export declare function getSessionComparisonHarnessLabel(participant: ISessionComparisonParticipant): string;
+export declare function getSessionComparisonAttemptLabel(participant: ISessionComparisonParticipant, attemptNumber: number): string;
+export declare function getSessionComparisonHarnessDisplayLabel(harness: ISessionComparisonHarness): string;
+export declare function getSessionComparisonParticipantsInDisplayOrder(participants: readonly ISessionComparisonParticipant[]): readonly ISessionComparisonParticipant[];

package/vscode/src/vs/sessions/services/sessions/common/sessionComparison.js

@@ -0,0 +1,95 @@
+
+import { localize } from '../../../../nls.js';
+import { ReasoningEffortConfigKey, isReasoningEffortLevel, getReasoningEffortLabel } from '../../../../platform/agentHost/common/reasoningEffort.js';
+
+var SessionComparisonParticipantRole;
+(function(SessionComparisonParticipantRole) {
+    SessionComparisonParticipantRole["Coordinator"] = "coordinator";
+    SessionComparisonParticipantRole["Attempt"] = "attempt";
+    SessionComparisonParticipantRole["Judge"] = "judge";
+    SessionComparisonParticipantRole["Synthesis"] = "synthesis";
+})(
+    SessionComparisonParticipantRole || (SessionComparisonParticipantRole = {})
+);
+var SessionComparisonValidationState;
+(function(SessionComparisonValidationState) {
+    SessionComparisonValidationState["Passed"] = "passed";
+    SessionComparisonValidationState["Failed"] = "failed";
+    SessionComparisonValidationState["NotRun"] = "notRun";
+    SessionComparisonValidationState["NotApplicable"] = "notApplicable";
+    SessionComparisonValidationState["Unknown"] = "unknown";
+})(
+    SessionComparisonValidationState || (SessionComparisonValidationState = {})
+);
+var SessionComparisonValidationSource;
+(function(SessionComparisonValidationSource) {
+    SessionComparisonValidationSource["AttemptReport"] = "attemptReport";
+    SessionComparisonValidationSource["JudgeRun"] = "judgeRun";
+    SessionComparisonValidationSource["NotApplicable"] = "notApplicable";
+    SessionComparisonValidationSource["Unavailable"] = "unavailable";
+})(
+    SessionComparisonValidationSource || (SessionComparisonValidationSource = {})
+);
+const SESSION_COMPARISON_MANIFEST_TEXT_MAX_LENGTH = 1000;
+const SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS = 32;
+const SESSION_COMPARISON_SYNTHESIS_INSTRUCTIONS_MAX_LENGTH = 4000;
+const SESSION_COMPARISON_MAX_ATTEMPTS = 10;
+const COMPARE_AGENTS_ENABLED_SETTING = "sessions.chat.compareAgents.enabled";
+function getBoundedSessionComparisonManifestText(value) {
+    return value.length <= SESSION_COMPARISON_MANIFEST_TEXT_MAX_LENGTH ? value : value.slice(0, SESSION_COMPARISON_MANIFEST_TEXT_MAX_LENGTH);
+}
+function getBoundedSessionComparisonManifestList(values) {
+    return values.slice(0, SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS).map(getBoundedSessionComparisonManifestText);
+}
+function getSessionComparisonWorkspaceError(branch, hasGitRemote) {
+    if (!branch) {
+        return localize(6351, "Comparisons require a Git repository with at least one commit.");
+    }
+    if (hasGitRemote !== true) {
+        return localize(6352, "Comparisons require a Git remote.");
+    }
+    return undefined;
+}
+function getSessionComparisonHarnessLabel(participant) {
+    return getSessionComparisonHarnessDisplayLabel(participant.harness);
+}
+function getSessionComparisonAttemptLabel(participant, attemptNumber) {
+    return localize(
+        6353,
+        "Attempt {0} ({1})",
+        attemptNumber,
+        getSessionComparisonHarnessLabel(participant)
+    );
+}
+function getSessionComparisonHarnessDisplayLabel(harness) {
+    const harnessLabel = harness.modelLabel ? ( localize(6354, "{0} · {1}", harness.label, harness.modelLabel)) : harness.label;
+    const reasoningEffort = harness.modelConfiguration?.[ReasoningEffortConfigKey];
+    const configurationLabel = typeof reasoningEffort === "string" && isReasoningEffortLevel(reasoningEffort) ? getReasoningEffortLabel(reasoningEffort) : harness.modelConfigurationLabel;
+    return configurationLabel ? ( localize(6355, "{0} · {1}", harnessLabel, configurationLabel)) : harnessLabel;
+}
+function getSessionComparisonParticipantsInDisplayOrder(participants) {
+    const rolePriority = role => {
+        switch (role) {
+        case SessionComparisonParticipantRole.Synthesis:
+            return 0;
+        case SessionComparisonParticipantRole.Judge:
+            return 1;
+        case SessionComparisonParticipantRole.Attempt:
+            return 2;
+        default:
+            return 3;
+        }
+    };
+    return participants.map((participant, index) => ({
+        participant,
+        index
+    })).sort(
+        (a, b) => rolePriority(a.participant.role) - rolePriority(b.participant.role) || a.index - b.index
+    ).map((
+        {
+            participant
+        }
+    ) => participant);
+}
+
+export { COMPARE_AGENTS_ENABLED_SETTING, SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS, SESSION_COMPARISON_MANIFEST_TEXT_MAX_LENGTH, SESSION_COMPARISON_MAX_ATTEMPTS, SESSION_COMPARISON_SYNTHESIS_INSTRUCTIONS_MAX_LENGTH, SessionComparisonParticipantRole, SessionComparisonValidationSource, SessionComparisonValidationState, getBoundedSessionComparisonManifestList, getBoundedSessionComparisonManifestText, getSessionComparisonAttemptLabel, getSessionComparisonHarnessDisplayLabel, getSessionComparisonHarnessLabel, getSessionComparisonParticipantsInDisplayOrder, getSessionComparisonWorkspaceError };

package/vscode/src/vs/sessions/services/sessions/common/sessionComparison.service.d.ts

@@ -0,0 +1,22 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI } from "../../../sessions.web.main.internal.js";
+import { ISessionComparison, IStartSessionComparisonOptions, ISessionComparisonVerdict, ISessionComparisonSynthesisPlan } from "./sessionComparison.js";
+export interface ISessionComparisonService {
+    readonly _serviceBrand: undefined;
+    readonly comparisons: IObservable<readonly ISessionComparison[]>;
+    startComparison(options: IStartSessionComparisonOptions, token?: CancellationToken): Promise<ISessionComparison>;
+    getComparison(comparisonId: string): ISessionComparison | undefined;
+    getComparisonForSession(resource: URI): ISessionComparison | undefined;
+    cancelComparison(comparisonId: string): void;
+    archiveComparison(comparisonId: string): void;
+    /** Restores an automatically removed comparison group for bulk archive Undo and returns its group ID. */
+    restoreComparison(comparisonId: string): string;
+    selectAttempt(comparisonId: string, participantId: string): void;
+    submitVerdict(comparisonId: string, verdict: ISessionComparisonVerdict): void;
+    canRetryJudge(comparisonId: string): boolean;
+    retryJudge(comparisonId: string): void;
+    setSynthesisPlan(comparisonId: string, plan: ISessionComparisonSynthesisPlan | undefined): void;
+    synthesize(comparisonId: string): Promise<void>;
+}
+export declare const ISessionComparisonService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ISessionComparisonService>;

package/vscode/src/vs/sessions/services/sessions/common/sessionComparison.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ISessionComparisonService = ( createDecorator("sessionComparisonService"));
+
+export { ISessionComparisonService };

package/vscode/src/vs/sessions/services/sessions/common/sessionPickerVisibility.d.ts

@@ -0,0 +1,26 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { ISessionInputPickerVisibility } from "./sessionPickerVisibility.service.js";
+export interface ISessionPickerVisibility {
+    readonly workspace: boolean;
+    readonly harness: boolean;
+    readonly isolation: boolean;
+}
+export declare const noSessionPickerVisibility: ISessionPickerVisibility;
+export declare class SessionInputPickerVisibility extends Disposable implements ISessionInputPickerVisibility {
+    readonly _serviceBrand: undefined;
+    private readonly _visibility;
+    readonly visibility: IObservable<ISessionPickerVisibility>;
+    setVisible(picker: keyof ISessionPickerVisibility, visible: boolean): void;
+    dispose(): void;
+}
+/** Projects the same view-owned state into either its local scope or the active view's global scope. */
+export declare class SessionPickerVisibilityContextKeys extends Disposable {
+    private readonly _contextKeyService;
+    private readonly _workspace;
+    private readonly _harness;
+    private readonly _isolation;
+    constructor(_contextKeyService: IContextKeyService);
+    set(visibility: ISessionPickerVisibility): void;
+}

package/vscode/src/vs/sessions/services/sessions/common/sessionPickerVisibility.js

@@ -0,0 +1,43 @@
+
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import { SessionWorkspacePickerVisibleContext, SessionHarnessPickerVisibleContext, SessionIsolationPickerVisibleContext } from '../../../common/contextkeys.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+
+const noSessionPickerVisibility = { workspace: false, harness: false, isolation: false };
+class SessionInputPickerVisibility extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._visibility = observableValue(this, noSessionPickerVisibility);
+        this.visibility = this._visibility;
+    }
+    setVisible(picker, visible) {
+        const current = this._visibility.get();
+        if (current[picker] !== visible) {
+            this._visibility.set({ ...current, [picker]: visible }, undefined);
+        }
+    }
+    dispose() {
+        this._visibility.set(noSessionPickerVisibility, undefined);
+        super.dispose();
+    }
+}
+class SessionPickerVisibilityContextKeys extends Disposable {
+    constructor(_contextKeyService) {
+        super();
+        this._contextKeyService = _contextKeyService;
+        this._workspace = SessionWorkspacePickerVisibleContext.bindTo(_contextKeyService);
+        this._harness = SessionHarnessPickerVisibleContext.bindTo(_contextKeyService);
+        this._isolation = SessionIsolationPickerVisibleContext.bindTo(_contextKeyService);
+        this._register(toDisposable(() => this.set(noSessionPickerVisibility)));
+    }
+    set(visibility) {
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._workspace.set(visibility.workspace);
+            this._harness.set(visibility.harness);
+            this._isolation.set(visibility.isolation);
+        });
+    }
+}
+
+export { SessionInputPickerVisibility, SessionPickerVisibilityContextKeys, noSessionPickerVisibility };

package/vscode/src/vs/sessions/services/sessions/common/sessionPickerVisibility.service.d.ts

@@ -0,0 +1,9 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { ISessionPickerVisibility } from "./sessionPickerVisibility.js";
+export declare const ISessionInputPickerVisibility: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ISessionInputPickerVisibility>;
+/** Composer-owned rendering state shared with its contributed pickers, independently of context-key scopes. */
+export interface ISessionInputPickerVisibility {
+    readonly _serviceBrand: undefined;
+    readonly visibility: IObservable<ISessionPickerVisibility>;
+    setVisible(picker: keyof ISessionPickerVisibility, visible: boolean): void;
+}

package/vscode/src/vs/sessions/services/sessions/common/sessionPickerVisibility.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ISessionInputPickerVisibility = ( createDecorator("sessionInputPickerVisibility"));
+
+export { ISessionInputPickerVisibility };

package/vscode/src/vs/sessions/services/sessions/common/sessionsManagement.d.ts

@@ -1,8 +1,8 @@
 import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IAutomationSessionTemplate } from "../../../../workbench/contrib/chat/common/automations/automation.js";
-import { IChat, ISession, ISessionType } from "./session.js";
-import { IAutomationSessionConfiguration, ISendRequestOptions as ISessionsProviderSendRequestOptions } from "./sessionsProvider.js";
+import { IChat, ISession, ISessionCreationReference, ISessionType } from "./session.js";
+import { IAutomationSessionConfiguration, ISessionConfigurationSnapshot, ISendRequestOptions as ISessionsProviderSendRequestOptions } from "./sessionsProvider.js";
 import { ISessionsManagementService } from "./sessionsManagement.service.js";
 /** Raised when unattended session creation targets a workspace that requires trust. */
 export declare class WorkspaceNotTrustedError extends Error {
@@ -59,12 +59,21 @@ export interface ICreateNewSessionOptions {
     readonly sessionTypeId?: string;
     /** Initial provider metadata to associate with the session. */
     readonly metadata?: Record<string, unknown>;
+    /** Session that created this session, when it should be presented as a child. */
+    readonly createdBySession?: ISessionCreationReference;
     /**
      * Optional model identifier to apply to the new session via
      * {@link ISessionsProvider.setModel}. If the provider throws, the
      * stranded draft is disposed and the error propagates.
      */
     readonly modelId?: string;
+    /**
+     * Optional model-specific primitive values to scope to this session.
+     * Requires {@link modelId} and provider support.
+     */
+    readonly modelConfiguration?: Readonly<Record<string, string | number | boolean | null>>;
+    /** Provider-owned permission option applied before the first request. */
+    readonly permissionId?: string;
     /**
      * Optional chat mode identifier (typically a value from `ChatModeKind`)
      * to apply via {@link ISessionsProvider.setMode}. Skipped if the
@@ -94,20 +103,17 @@ export interface ICreateNewSessionOptions {
      */
     readonly branch?: string;
     /**
-     * Optional branch tracking preference to apply via
-     * {@link ISessionsProvider.setWorktreeBranchTrack}. This is intended for
-     * programmatic session creation and is not surfaced in the new-session UI.
-     */
-    readonly worktreeBranchTrack?: boolean;
-    /**
-     * Whether to create a generated worktree branch from {@link branch}.
+     * Optional URL of a pull request in the workspace's repository. The session
+     * is created from it, so it is associated with the pull request from the
+     * start; the agent host checks the pull request out into an isolated
+     * worktree, so it supersedes {@link isolationMode} and {@link branch}.
      */
-    readonly worktreeCreateNewBranch?: boolean;
+    readonly pullRequestUrl?: string;
     /**
      * Invoked after the provider creates the provisional session, before its
-     * configuration and first request are applied.
+     * configuration and first request are applied. Asynchronous preparation is awaited.
      */
-    readonly onSessionCreated?: (session: ISession) => void;
+    readonly onSessionCreated?: (session: ISession) => void | Promise<void>;
 }
 /**
  * Options for {@link ISessionsManagementService.createNewChatInSession}.
@@ -136,6 +142,8 @@ export interface ISendRequestSentEvent {
     readonly chat: IChat;
     readonly isNewSession: boolean;
     readonly isNewChat: boolean;
+    /** Provider configuration captured before preparation can replace the draft. Values may be sensitive and must not be logged wholesale. */
+    readonly newSessionConfig?: ISessionConfigurationSnapshot;
     /**
      * The exact options object the send was started with, so callers can
      * correlate a fire-and-forget (background) send with its completion.
@@ -150,6 +158,11 @@ export interface IToggleSessionStickinessEvent {
     /** The session's stickiness state after the toggle. */
     readonly sticky: boolean;
 }
+export interface IChatDeletedEvent {
+    readonly session: ISession;
+    readonly sessionResource: URI;
+    readonly chatResource: URI;
+}
 /**
  * An active session extends {@link ISession} with the currently focused chat.
  */
@@ -192,6 +205,11 @@ export interface IRecentlyOpenedSessions {
     /** Sessions never opened in this workspace, most recently updated first. */
     readonly other: ISession[];
 }
+/** Controls automatic read transitions for an active main chat. */
+export interface IMarkSessionReadOptions {
+    /** Preserve a user-requested unread state until the active chat advances. */
+    readonly preserveExplicitUnread?: boolean;
+}
 /**
  * The `providerId`/`sessionTypeId` to seed a new session with when carrying the
  * harness over from an existing session, or an empty object when it should not