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

package/vscode/src/vs/sessions/services/sessions/browser/sessionComparisonService.js

@@ -0,0 +1,1135 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { parse, stringify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { withSessionComparisonMetadata } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { createSessionComparisonJudgePrompt } from '../../../../platform/agentHost/common/sessionComparisonPrompts.js';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IChatRequestVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { aggregateChatUsage } from '../../../../workbench/contrib/chat/common/chatUsage.js';
+import { SessionStatus, isActiveSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionGroupsService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { SESSION_COMPARISON_MAX_ATTEMPTS, SessionComparisonParticipantRole, getSessionComparisonHarnessLabel, SESSION_COMPARISON_SYNTHESIS_INSTRUCTIONS_MAX_LENGTH, getSessionComparisonAttemptLabel, SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS, getBoundedSessionComparisonManifestText } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { hashSessionIdForTelemetry, logSessionComparisonAttemptCompleted, logSessionComparisonModelOutcome, getSessionsTelemetryModelId, getSessionsTelemetryAgentId, getSessionsTelemetryProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+var SessionComparisonService_1;
+function getAttemptUnavailableMessage() {
+    return localize(6315, "The attempt session is no longer available.");
+}
+let SessionComparisonService = class SessionComparisonService extends Disposable {
+    static {
+        SessionComparisonService_1 = this;
+    }
+    static {
+        this.STORAGE_KEY = "sessions.comparisons";
+    }
+    static {
+        this.ATTEMPT_TELEMETRY_STORAGE_KEY = "sessions.comparisonAttemptTelemetry";
+    }
+    constructor(
+        sessionsManagementService,
+        sessionGroupsService,
+        storageService,
+        logService,
+        chatService,
+        telemetryService
+    ) {
+        super();
+        this.sessionsManagementService = sessionsManagementService;
+        this.sessionGroupsService = sessionGroupsService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.chatService = chatService;
+        this.telemetryService = telemetryService;
+        this._comparisons = observableValue(this, []);
+        this.comparisons = this._comparisons;
+        this._judgeStarting = ( new Set());
+        this._synthesisStarting = ( new Set());
+        this._migratingAttemptTitles = ( new Set());
+        this._migratedAttemptTitles = ( new Set());
+        this._reportedAttemptTelemetry = ( new Set());
+        this._comparisonIdsBySession = ( new Map());
+        this._loadAttemptTelemetryState();
+        const comparisons = this._load();
+        this._comparisons.set(comparisons, undefined);
+        for (const comparison of comparisons) {
+            this._indexComparisonSessions(comparison);
+        }
+        this._archiveComparisonsWithMissingGroups();
+        this._pruneAttemptTelemetryState(( new Set(
+            this._comparisons.get().filter(comparison => comparison.archivedAt === undefined).map(comparison => comparison.id)
+        )));
+        this._ensureComparisonGroupMembership(this._comparisons.get());
+        this._migrateLegacyAttemptTitles(this._comparisons.get());
+        this._register(this.sessionsManagementService.onDidChangeSessions(event => {
+            const comparisons = this._getComparisonsForSessionChanges(event);
+            const reconciled = comparisons.map(comparison => this._reconcileSessionAvailability(comparison, event));
+            this._archiveFullyArchivedComparisons(reconciled);
+            const activeComparisons = reconciled.filter(comparison => this.getComparison(comparison.id)?.archivedAt === undefined);
+            this._ensureComparisonGroupMembership(activeComparisons);
+            this._migrateLegacyAttemptTitles(activeComparisons);
+            this._checkComparisons(activeComparisons);
+        }));
+        this._register(
+            this.sessionsManagementService.onDidDeleteSession(session => this._markParticipantDeleted(session))
+        );
+        this._register(this.sessionGroupsService.onDidChange(event => {
+            if (event.groupsChanged) {
+                this._archiveComparisonsWithMissingGroups();
+            }
+        }));
+        this._checkComparisons(this._comparisons.get());
+    }
+    async startComparison(options, token = CancellationToken.None) {
+        if (options.attempts.length < 2 || options.attempts.length > SESSION_COMPARISON_MAX_ATTEMPTS) {
+            throw ( new Error("A session comparison requires between two and ten attempts."));
+        }
+        if (options.synthesisHarness && !options.judgeHarness) {
+            throw ( new Error("A synthesis model requires a Judge model."));
+        }
+        if (( new Set(options.attempts.map(attempt => attempt.id))).size !== options.attempts.length) {
+            throw ( new Error("Session comparison attempt identifiers must be unique."));
+        }
+        const id = generateUuid();
+        const attachedContext = options.attachedContext ? snapshotAttachedContext(options.attachedContext) : undefined;
+        const title = comparisonTitle(options.prompt);
+        const group = this.sessionGroupsService.createGroup(title);
+        const attempts = options.attempts.map(attempt => ({
+            id: attempt.id,
+            role: SessionComparisonParticipantRole.Attempt,
+            harness: attempt.harness
+        }));
+        let comparison = {
+            id,
+            groupId: group.id,
+            title,
+            createdAt: Date.now(),
+            workspace: options.workspace,
+            prompt: options.prompt,
+            launching: true,
+            attachedContext,
+            branch: options.branch,
+            permissionLevel: options.permissionLevel,
+            judgeHarness: options.judgeHarness,
+            synthesisHarness: options.synthesisHarness,
+            participants: attempts
+        };
+        this._addComparison(comparison);
+        const attemptPromises = attempts.map(async (participant, index) => {
+            const harness = participant.harness;
+            try {
+                const session = await this.sessionsManagementService.createAndSendNewChatRequest(options.workspace, {
+                    query: options.prompt,
+                    attachedContext: comparison.attachedContext ? [...comparison.attachedContext] : undefined,
+                    title: getSessionComparisonHarnessLabel(participant),
+                    background: true
+                }, {
+                    ...this._createOptions(harness, options, id, index),
+                    onSessionCreated: createdSession => {
+                        this._updateComparisonParticipant(id, participant.id, currentParticipant => ({
+                            ...currentParticipant,
+                            sessionResource: createdSession.resource,
+                            launchError: undefined
+                        }));
+                    }
+                }, token);
+                return {
+                    ...participant,
+                    sessionResource: session?.resource,
+                    ...(!session ? {
+                        launchError: ( localize(6316, "The session did not start."))
+                    } : {})
+                };
+            } catch (error) {
+                return {
+                    ...participant,
+                    launchError: isCancellationError(error) ? ( localize(6317, "The attempt was cancelled before it started.")) : error instanceof Error ? error.message : String(error)
+                };
+            }
+        });
+        const launchedAttempts = await Promise.all(attemptPromises);
+        const current = this.getComparison(comparison.id);
+        if (!current) {
+            throw ( new Error("Session comparison was removed while attempts were launching."));
+        }
+        const launchedById = ( new Map(launchedAttempts.map(participant => [participant.id, participant])));
+        comparison = {
+            ...current,
+            launching: undefined,
+            participants: current.participants.map(participant => launchedById.get(participant.id) ?? participant)
+        };
+        this._ensureComparisonGroupMembership([comparison]);
+        this._replaceComparison(comparison);
+        this._checkComparison(comparison);
+        const successfulAttemptCount = launchedAttempts.filter(participant => participant.sessionResource).length;
+        if (successfulAttemptCount < 2) {
+            this._removeComparison(comparison.id);
+            this.sessionGroupsService.deleteGroup(comparison.groupId);
+            const launchFailures = launchedAttempts.filter(participant => participant.launchError).map(
+                participant => `${getSessionComparisonHarnessLabel(participant)}: ${participant.launchError}`
+            ).join("; ");
+            throw ( new Error(( localize(
+                6318,
+                "Only {0} of {1} comparison attempts started. At least two must start successfully. Failed attempts: {2}",
+                successfulAttemptCount,
+                attempts.length,
+                launchFailures
+            ))));
+        }
+        return comparison;
+    }
+    getComparison(comparisonId) {
+        return this._comparisons.get().find(comparison => comparison.id === comparisonId);
+    }
+    getComparisonForSession(resource) {
+        const comparisonId = this._comparisonIdsBySession.get(( resource.toString()));
+        return comparisonId ? this.getComparison(comparisonId) : undefined;
+    }
+    cancelComparison(comparisonId) {
+        const comparison = this._requireComparison(comparisonId);
+        if (comparison.cancelledAt !== undefined) {
+            return;
+        }
+        this._replaceComparison({
+            ...comparison,
+            cancelledAt: Date.now(),
+            synthesisPlan: undefined
+        });
+    }
+    archiveComparison(comparisonId) {
+        const comparison = this._requireComparison(comparisonId);
+        if (comparison.archivedAt !== undefined) {
+            return;
+        }
+        this._replaceComparison({
+            ...comparison,
+            archivedAt: Date.now()
+        });
+        this._pruneAttemptTelemetryState(( new Set(
+            this._comparisons.get().filter(candidate => candidate.archivedAt === undefined).map(candidate => candidate.id)
+        )));
+    }
+    selectAttempt(comparisonId, participantId) {
+        const comparison = this._requireComparison(comparisonId);
+        const participant = comparison.participants.find(
+            candidate => candidate.id === participantId && candidate.role === SessionComparisonParticipantRole.Attempt && candidate.sessionResource
+        );
+        if (!participant) {
+            throw ( new Error(`Comparison attempt '${participantId}' was not found.`));
+        }
+        this._replaceComparison({
+            ...comparison,
+            selectedParticipantId: participantId
+        });
+    }
+    submitVerdict(comparisonId, verdict) {
+        const comparison = this._requireComparison(comparisonId);
+        if (comparison.cancelledAt !== undefined) {
+            throw ( new Error(`Comparison '${comparisonId}' was cancelled.`));
+        }
+        if (comparison.verdict) {
+            throw ( new Error(`A verdict has already been submitted for comparison '${comparisonId}'.`));
+        }
+        const attemptIds = ( new Set(comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt && participant.sessionResource
+        ).map(participant => participant.id)));
+        if (!( attemptIds.has(verdict.recommendedParticipantId))) {
+            throw ( new Error(
+                `Recommended comparison attempt '${verdict.recommendedParticipantId}' was not found.`
+            ));
+        }
+        if (( verdict.attempts.some(attempt => !( attemptIds.has(attempt.participantId))))) {
+            throw ( new Error("The comparison verdict contains an unknown attempt."));
+        }
+        const updated = {
+            ...comparison,
+            verdict,
+            synthesisPlan: undefined
+        };
+        this._replaceComparison(updated);
+        this._reportOutcomeTelemetry(comparison, verdict);
+        this._checkComparison(updated);
+    }
+    canRetryJudge(comparisonId) {
+        const comparison = this.getComparison(comparisonId);
+        return !!comparison && !!comparison.judgeHarness && comparison.cancelledAt === undefined && comparison.archivedAt === undefined && !( this._judgeStarting.has(comparisonId)) && ( comparison.participants.some(
+            participant => participant.role === SessionComparisonParticipantRole.Judge && !participant.sessionResource
+        ));
+    }
+    retryJudge(comparisonId) {
+        if (!this.canRetryJudge(comparisonId)) {
+            return;
+        }
+        const comparison = this._requireComparison(comparisonId);
+        const failedJudgeIds = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Judge && !participant.sessionResource
+        ).map(participant => participant.id);
+        const updated = {
+            ...comparison,
+            participants: comparison.participants.filter(participant => !failedJudgeIds.includes(participant.id))
+        };
+        this._replaceComparison(updated);
+        this._checkComparison(updated);
+    }
+    setSynthesisPlan(comparisonId, plan) {
+        const comparison = this._requireComparison(comparisonId);
+        if (comparison.cancelledAt !== undefined) {
+            throw ( new Error(`Comparison '${comparisonId}' was cancelled.`));
+        }
+        if (!plan) {
+            this._replaceComparison({
+                ...comparison,
+                synthesisPlan: undefined
+            });
+            return;
+        }
+        if (plan.instructions !== undefined && (plan.instructions.trim().length === 0 || plan.instructions.length > SESSION_COMPARISON_SYNTHESIS_INSTRUCTIONS_MAX_LENGTH)) {
+            throw ( new Error("The synthesis plan contains invalid additional instructions."));
+        }
+        this._replaceComparison({
+            ...comparison,
+            synthesisPlan: {
+                instructions: plan.instructions
+            }
+        });
+    }
+    async synthesize(comparisonId) {
+        if (( this._synthesisStarting.has(comparisonId))) {
+            return;
+        }
+        const comparison = this._requireComparison(comparisonId);
+        if (comparison.cancelledAt !== undefined) {
+            throw ( new Error(`Comparison '${comparisonId}' was cancelled.`));
+        }
+        if (comparison.archivedAt !== undefined) {
+            throw ( new Error(`Comparison '${comparisonId}' was archived.`));
+        }
+        if (( comparison.participants.some(
+            participant => participant.role === SessionComparisonParticipantRole.Synthesis
+        ))) {
+            return;
+        }
+        const recommendedId = comparison.selectedParticipantId ?? comparison.verdict?.recommendedParticipantId;
+        const recommended = comparison.participants.find(
+            participant => participant.id === recommendedId && participant.role === SessionComparisonParticipantRole.Attempt && participant.sessionResource
+        );
+        if (!recommended) {
+            throw ( new Error("A selected or recommended attempt is required before synthesis."));
+        }
+        const harness = comparison.synthesisHarness;
+        if (!harness || !comparison.verdict) {
+            throw ( new Error(
+                "A configured synthesis model and a Judge verdict are required before synthesis."
+            ));
+        }
+        const synthesisParticipantId = generateUuid();
+        this._synthesisStarting.add(comparisonId);
+        try {
+            const otherAttemptStrengthsPrompt = this._getOtherAttemptStrengthsPrompt(comparison);
+            const synthesisPlanPrompt = this._getSynthesisPlanPrompt(comparison);
+            const session = await this.sessionsManagementService.createAndSendNewChatRequest(comparison.workspace, {
+                query: ( localize(
+                    6319,
+                    "Synthesize the strongest parts of comparison `{0}` into a new implementation.\n\n## Process\n1. Call `#readAttemptComparison` exactly once with this comparison ID.\n2. Read implementation code only from the authoritative worktrees in the manifest. If `changedFilesStatus` is unavailable, read the Git diff from that worktree.\n3. Treat additional instructions below and in the manifest as explicit user requirements. Reconcile the strongest approaches coherently instead of copying hunks mechanically.\n4. When provided, consider the strong points from other attempts below and incorporate them when they improve the solution without conflicting with user requirements.\n5. Call `get_session_context` only with an exact `sessionContextTarget` returned by the manifest and only for rationale or validation evidence. Never recover implementation code or paths from a transcript.\n6. Do not inspect another checkout, discover sessions, or guess references. Preserve correct behavior and resolve the Judge's reported conflicts.\n\n## Judge recommendation\n{1}{2}{3}\n\n## Completion\n- Run the relevant validation.\n- Respond concisely with **Changes**, **Validation**, and **Remaining issues** sections using bullet points.",
+                    comparison.id,
+                    this._getVerdictRecommendation(comparison),
+                    otherAttemptStrengthsPrompt,
+                    synthesisPlanPrompt
+                )),
+                attachedContext: comparison.attachedContext?.slice(),
+                title: ( localize(6320, "Synthesis: {0}", comparison.title)),
+                background: true
+            }, {
+                providerId: harness.providerId,
+                sessionTypeId: harness.sessionTypeId,
+                modelId: harness.modelId,
+                modelConfiguration: harness.modelConfiguration,
+                ...this._permissionOptions(harness, comparison.permissionLevel),
+                isolationMode: "worktree",
+                branch: comparison.branch,
+                metadata: withSessionComparisonMetadata(undefined, {
+                    id: hashSessionIdForTelemetry(comparison.id),
+                    role: "synthesis",
+                    attemptCount: comparison.participants.filter(
+                        participant => participant.role === SessionComparisonParticipantRole.Attempt
+                    ).length
+                }),
+                onSessionCreated: createdSession => {
+                    const current = this.getComparison(comparisonId);
+                    if (!current || current.archivedAt !== undefined) {
+                        return;
+                    }
+                    const synthesis = {
+                        id: synthesisParticipantId,
+                        role: SessionComparisonParticipantRole.Synthesis,
+                        harness,
+                        sessionResource: createdSession.resource
+                    };
+                    this._replaceComparison({
+                        ...current,
+                        participants: [...current.participants, synthesis]
+                    });
+                }
+            });
+            const current = this.getComparison(comparisonId);
+            if (!current || current.archivedAt !== undefined) {
+                if (current?.participants.some(participant => participant.id === synthesisParticipantId)) {
+                    this._replaceComparison({
+                        ...current,
+                        participants: current.participants.filter(participant => participant.id !== synthesisParticipantId)
+                    });
+                }
+                if (session) {
+                    await this._cancelAndDeleteSessions([session], "orphaned synthesis cleanup");
+                }
+                return;
+            }
+            if (session) {
+                this.sessionGroupsService.addToGroup(session.sessionId, current.groupId);
+            }
+            const synthesis = {
+                id: synthesisParticipantId,
+                role: SessionComparisonParticipantRole.Synthesis,
+                harness,
+                sessionResource: session?.resource,
+                ...(!session ? {
+                    launchError: ( localize(6321, "The synthesis session did not start."))
+                } : {})
+            };
+            const registered = ( current.participants.some(participant => participant.id === synthesisParticipantId));
+            const updated = {
+                ...current,
+                participants: registered ? current.participants.map(
+                    participant => participant.id === synthesisParticipantId ? synthesis : participant
+                ) : [...current.participants, synthesis]
+            };
+            this._replaceComparison(updated);
+            this._checkComparison(updated);
+        } catch (error) {
+            const current = this.getComparison(comparisonId);
+            if (current?.participants.some(participant => participant.id === synthesisParticipantId)) {
+                this._replaceComparison({
+                    ...current,
+                    participants: current.participants.filter(participant => participant.id !== synthesisParticipantId)
+                });
+            }
+            throw error;
+        } finally {
+            this._synthesisStarting.delete(comparisonId);
+        }
+    }
+    _updateComparisonParticipant(comparisonId, participantId, update) {
+        const comparison = this.getComparison(comparisonId);
+        if (!comparison) {
+            return undefined;
+        }
+        let changed = false;
+        const participants = comparison.participants.map(participant => {
+            if (participant.id !== participantId) {
+                return participant;
+            }
+            const updatedParticipant = update(participant);
+            changed = true;
+            return updatedParticipant;
+        });
+        if (!changed) {
+            return comparison;
+        }
+        const updated = {
+            ...comparison,
+            participants
+        };
+        this._replaceComparison(updated);
+        this._ensureComparisonGroupMembership([updated]);
+        return updated;
+    }
+    _createOptions(harness, options, comparisonId, attemptIndex) {
+        return {
+            providerId: harness.providerId,
+            sessionTypeId: harness.sessionTypeId,
+            modelId: harness.modelId,
+            modelConfiguration: harness.modelConfiguration,
+            ...this._permissionOptions(harness, options.permissionLevel),
+            isolationMode: "worktree",
+            branch: options.branch,
+            metadata: withSessionComparisonMetadata(undefined, {
+                id: hashSessionIdForTelemetry(comparisonId),
+                role: "attempt",
+                attemptIndex,
+                attemptCount: options.attempts.length
+            })
+        };
+    }
+    _permissionOptions(harness, legacyPermissionLevel) {
+        if (harness.permissionId) {
+            return {
+                ...(harness.modeId ? {
+                    modeId: harness.modeId
+                } : {}),
+                permissionId: harness.permissionId
+            };
+        }
+        if (legacyPermissionLevel) {
+            return {
+                permissionLevel: legacyPermissionLevel
+            };
+        }
+        return {};
+    }
+    _requireComparison(comparisonId) {
+        const comparison = this.getComparison(comparisonId);
+        if (!comparison) {
+            throw ( new Error(`Session comparison '${comparisonId}' was not found.`));
+        }
+        return comparison;
+    }
+    _checkComparisons(comparisons) {
+        for (const comparison of comparisons) {
+            this._checkComparison(comparison);
+        }
+    }
+    _checkComparison(comparison) {
+        if (comparison.cancelledAt !== undefined || comparison.archivedAt !== undefined) {
+            return;
+        }
+        comparison = this._captureTerminalAttemptMetrics(comparison);
+        if (( this._judgeStarting.has(comparison.id)) || ( comparison.participants.some(participant => participant.role === SessionComparisonParticipantRole.Judge))) {
+            return;
+        }
+        const harness = this._getJudgeHarness(comparison);
+        if (!harness) {
+            return;
+        }
+        const attempts = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        let terminalAttemptCount = 0;
+        let completedAttemptCount = 0;
+        for (const participant of attempts) {
+            if (participant.missingSession) {
+                return;
+            }
+            if (participant.launchError) {
+                continue;
+            }
+            if (!participant.sessionResource) {
+                return;
+            }
+            const session = this.sessionsManagementService.getSession(participant.sessionResource);
+            if (!session) {
+                return;
+            }
+            const status = session.status.get();
+            if (status === SessionStatus.Completed) {
+                terminalAttemptCount++;
+                completedAttemptCount++;
+                continue;
+            }
+            if (status === SessionStatus.Error) {
+                terminalAttemptCount++;
+                continue;
+            }
+            return;
+        }
+        if (terminalAttemptCount < 2 || completedAttemptCount === 0) {
+            return;
+        }
+        const judgeParticipantId = generateUuid();
+        const pendingJudge = {
+            id: judgeParticipantId,
+            role: SessionComparisonParticipantRole.Judge,
+            harness
+        };
+        const pendingComparison = {
+            ...comparison,
+            participants: [...comparison.participants, pendingJudge]
+        };
+        this._replaceComparison(pendingComparison);
+        this._judgeStarting.add(comparison.id);
+        void this._startJudge(pendingComparison, judgeParticipantId).catch(error => {
+            this.logService.error("[SessionComparisonService] Failed to start the comparison judge.", error);
+            this._updateComparisonParticipant(comparison.id, judgeParticipantId, participant => ({
+                ...participant,
+                sessionResource: participant.sessionResource && this.sessionsManagementService.getSession(participant.sessionResource) ? participant.sessionResource : undefined,
+                launchError: error instanceof Error ? error.message : String(error)
+            }));
+        }).finally(() => this._judgeStarting.delete(comparison.id));
+    }
+    _captureTerminalAttemptMetrics(comparison) {
+        const attempts = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        let comparisonChanged = false;
+        let telemetryChanged = false;
+        const completions = ( new Map());
+        for (const [attemptIndex, participant] of attempts.entries()) {
+            if (!participant.sessionResource) {
+                continue;
+            }
+            const session = this.sessionsManagementService.getSession(participant.sessionResource);
+            const status = session?.status.get();
+            if (!session || (status !== SessionStatus.Completed && status !== SessionStatus.Error)) {
+                continue;
+            }
+            const requests = this.chatService.getSession(session.mainChat.get().resource)?.getRequests() ?? [];
+            const firstTurnElapsedMs = requests[0]?.response?.elapsedMs;
+            const storedElapsedMs = participant.completion?.elapsedMs;
+            const elapsedMs = typeof firstTurnElapsedMs === "number" && Number.isFinite(firstTurnElapsedMs) && firstTurnElapsedMs >= 0 ? firstTurnElapsedMs : typeof storedElapsedMs === "number" && storedElapsedMs > 0 ? storedElapsedMs : undefined;
+            const usage = aggregateChatUsage(requests.map(request => request.response?.usage));
+            const completion = {
+                elapsedMs,
+                tokenCount: usage ? usage.inputTokens + usage.outputTokens : participant.completion?.tokenCount,
+                tokenCountIsComplete: usage?.isComplete ?? participant.completion?.tokenCountIsComplete
+            };
+            completions.set(participant.id, completion);
+            if (participant.completion?.elapsedMs !== completion.elapsedMs || participant.completion?.tokenCount !== completion.tokenCount || participant.completion?.tokenCountIsComplete !== completion.tokenCountIsComplete) {
+                comparisonChanged = true;
+            }
+            const key = `${comparison.id}/${participant.id}`;
+            if (( this._reportedAttemptTelemetry.has(key)) || completion.elapsedMs === undefined) {
+                continue;
+            }
+            logSessionComparisonAttemptCompleted(this.telemetryService, {
+                comparisonId: hashSessionIdForTelemetry(comparison.id),
+                attemptIndex,
+                elapsedMs: completion.elapsedMs
+            });
+            this._reportedAttemptTelemetry.add(key);
+            telemetryChanged = true;
+        }
+        if (telemetryChanged) {
+            this._saveAttemptTelemetryState();
+        }
+        if (!comparisonChanged) {
+            return comparison;
+        }
+        const updated = {
+            ...comparison,
+            participants: comparison.participants.map(participant => {
+                const completion = completions.get(participant.id);
+                return completion && (participant.completion?.elapsedMs !== completion.elapsedMs || participant.completion?.tokenCount !== completion.tokenCount || participant.completion?.tokenCountIsComplete !== completion.tokenCountIsComplete) ? {
+                    ...participant,
+                    completion
+                } : participant;
+            })
+        };
+        this._replaceComparison(updated);
+        return updated;
+    }
+    _reportOutcomeTelemetry(comparison, verdict) {
+        const attempts = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        const judge = comparison.participants.find(participant => participant.role === SessionComparisonParticipantRole.Judge);
+        if (!judge) {
+            return;
+        }
+        const judgeSession = judge.sessionResource ? this.sessionsManagementService.getSession(judge.sessionResource) : undefined;
+        for (const [attemptIndex, participant] of attempts.entries()) {
+            if (!participant.sessionResource) {
+                continue;
+            }
+            const session = participant.sessionResource ? this.sessionsManagementService.getSession(participant.sessionResource) : undefined;
+            logSessionComparisonModelOutcome(this.telemetryService, {
+                comparisonId: hashSessionIdForTelemetry(comparison.id),
+                attemptIndex,
+                attemptCount: attempts.length,
+                providerId: getSessionsTelemetryProviderId(participant.harness.providerId),
+                agentId: getSessionsTelemetryAgentId(participant.harness.sessionTypeId),
+                modelId: getSessionsTelemetryModelId(
+                    participant.harness.sessionTypeId,
+                    session?.modelId.get() ?? participant.harness.modelId
+                ),
+                recommended: verdict.recommendedParticipantId === participant.id,
+                judgeProviderId: getSessionsTelemetryProviderId(judge.harness.providerId),
+                judgeAgentId: getSessionsTelemetryAgentId(judge.harness.sessionTypeId),
+                judgeModelId: getSessionsTelemetryModelId(
+                    judge.harness.sessionTypeId,
+                    judgeSession?.modelId.get() ?? judge.harness.modelId
+                )
+            });
+        }
+    }
+    restoreComparison(comparisonId) {
+        const comparison = this._requireComparison(comparisonId);
+        const group = this.sessionGroupsService.getGroup(comparison.groupId) ?? this.sessionGroupsService.createGroup(comparison.title);
+        this._replaceComparison({
+            ...comparison,
+            groupId: group.id,
+            archivedAt: undefined
+        });
+        return group.id;
+    }
+    async _startJudge(comparison, judgeParticipantId) {
+        const judge = comparison.participants.find(
+            participant => participant.id === judgeParticipantId && participant.role === SessionComparisonParticipantRole.Judge
+        );
+        if (!judge) {
+            return;
+        }
+        const harness = judge.harness;
+        const session = await this.sessionsManagementService.createAndSendNewChatRequest(comparison.workspace, {
+            query: createSessionComparisonJudgePrompt(comparison.id),
+            attachedContext: comparison.attachedContext?.slice(),
+            title: ( localize(6322, "Judge: {0}", comparison.title)),
+            background: true
+        }, {
+            providerId: harness.providerId,
+            sessionTypeId: harness.sessionTypeId,
+            modelId: harness.modelId,
+            modelConfiguration: harness.modelConfiguration,
+            ...this._permissionOptions(harness, comparison.permissionLevel),
+            isolationMode: "worktree",
+            branch: comparison.branch,
+            metadata: withSessionComparisonMetadata(undefined, {
+                id: hashSessionIdForTelemetry(comparison.id),
+                role: "judge",
+                attemptCount: comparison.participants.filter(
+                    participant => participant.role === SessionComparisonParticipantRole.Attempt
+                ).length
+            }),
+            onSessionCreated: createdSession => {
+                this._updateComparisonParticipant(comparison.id, judgeParticipantId, participant => ({
+                    ...participant,
+                    sessionResource: createdSession.resource,
+                    launchError: undefined
+                }));
+            }
+        });
+        const current = this.getComparison(comparison.id);
+        if (!current || current.archivedAt !== undefined) {
+            if (current) {
+                this._replaceComparison({
+                    ...current,
+                    participants: current.participants.filter(participant => participant.id !== judgeParticipantId)
+                });
+            }
+            if (session) {
+                await this._cancelAndDeleteSessions([session], "orphaned Judge cleanup");
+            }
+            return;
+        }
+        if (session) {
+            this.sessionGroupsService.addToGroup(session.sessionId, comparison.groupId);
+        }
+        const updated = {
+            ...current,
+            participants: current.participants.map(participant => participant.id === judgeParticipantId ? {
+                ...participant,
+                sessionResource: session?.resource,
+                ...(!session ? {
+                    launchError: ( localize(6323, "The judge session did not start."))
+                } : {})
+            } : participant)
+        };
+        this._replaceComparison(updated);
+        this._checkComparison(updated);
+    }
+    async _cancelAndDeleteSessions(sessions, context) {
+        const activeSessions = sessions.filter(session => isActiveSessionStatus(session.status.get()));
+        const cancellationResults = await Promise.allSettled(
+            activeSessions.map(session => this.sessionsManagementService.cancelCurrentRequest(session))
+        );
+        for (const result of cancellationResults) {
+            if (result.status === "rejected") {
+                this.logService.error(
+                    `[SessionComparisonService] Failed to cancel a session during ${context}.`,
+                    result.reason
+                );
+            }
+        }
+        const deletionResults = await Promise.allSettled(
+            sessions.map(session => this.sessionsManagementService.deleteSession(session))
+        );
+        for (const result of deletionResults) {
+            if (result.status === "rejected") {
+                this.logService.error(
+                    `[SessionComparisonService] Failed to delete a session during ${context}.`,
+                    result.reason
+                );
+            }
+        }
+    }
+    _getSynthesisPlanPrompt(comparison) {
+        const plan = comparison.synthesisPlan;
+        if (!plan) {
+            return "";
+        }
+        return plan.instructions ? ( localize(6324, "\n\n## Additional synthesis instructions\n{0}", plan.instructions)) : "";
+    }
+    _getOtherAttemptStrengthsPrompt(comparison) {
+        const verdict = comparison.verdict;
+        if (!verdict) {
+            return "";
+        }
+        const findings = ( new Map(verdict.attempts.map(attempt => [attempt.participantId, attempt])));
+        const attempts = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        const strengths = attempts.flatMap((attempt, index) => {
+            if (attempt.id === verdict.recommendedParticipantId) {
+                return [];
+            }
+            const finding = findings.get(attempt.id);
+            if (!finding) {
+                return [];
+            }
+            const attemptLabel = getSessionComparisonAttemptLabel(attempt, index + 1);
+            return finding.notableDifferences.map(strength => strength.trim()).filter(strength => strength.length > 0).map(strength => ({
+                attemptLabel,
+                strength
+            }));
+        }).slice(0, SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS).map((
+            {
+                attemptLabel,
+                strength
+            }
+        ) => ( localize(
+            6325,
+            "- **{0}**: {1}",
+            attemptLabel,
+            getBoundedSessionComparisonManifestText(strength)
+        )));
+        return strengths.length ? ( localize(
+            6326,
+            "\n\n## Strong points from other attempts\n{0}",
+            strengths.join("\n")
+        )) : "";
+    }
+    _getVerdictRecommendation(comparison) {
+        const verdict = comparison.verdict;
+        if (!verdict) {
+            return localize(
+                6327,
+                "No Judge explanation is available; use the selected attempt as the base."
+            );
+        }
+        const attempts = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        const winnerIndex = attempts.findIndex(attempt => attempt.id === verdict.recommendedParticipantId);
+        const winner = attempts[winnerIndex];
+        const winnerLabel = winner ? getSessionComparisonAttemptLabel(winner, winnerIndex + 1) : ( localize(6328, "Winning attempt"));
+        if (!verdict.rationale) {
+            return `${winnerLabel}\n${verdict.explanation}`;
+        }
+        return [winnerLabel, ( localize(6329, "Comparison: {0}", verdict.rationale.comparison)), ( localize(6330, "Validation: {0}", verdict.rationale.validation)), ( localize(6331, "Code quality: {0}", verdict.rationale.codeQuality)), ( localize(6332, "Solution: {0}", verdict.rationale.solution))].join("\n");
+    }
+    _getJudgeHarness(comparison) {
+        return comparison.judgeHarness;
+    }
+    _ensureComparisonGroupMembership(comparisons) {
+        for (const comparison of comparisons) {
+            if (comparison.archivedAt !== undefined) {
+                continue;
+            }
+            const sessionIds = comparison.participants.map(
+                participant => participant.sessionResource ? this.sessionsManagementService.getSession(participant.sessionResource)?.sessionId : undefined
+            ).filter(
+                sessionId => sessionId !== undefined && !this.sessionGroupsService.getGroupOfSession(sessionId) && !this.sessionGroupsService.isExplicitlyUngrouped(sessionId)
+            );
+            this.sessionGroupsService.addToGroup(sessionIds, comparison.groupId);
+        }
+    }
+    _archiveComparisonsWithMissingGroups() {
+        const comparisons = this._comparisons.get();
+        const archivedAt = Date.now();
+        let changed = false;
+        const updated = comparisons.map(comparison => {
+            if (comparison.archivedAt !== undefined || this.sessionGroupsService.getGroup(comparison.groupId)) {
+                return comparison;
+            }
+            changed = true;
+            return {
+                ...comparison,
+                archivedAt
+            };
+        });
+        if (!changed) {
+            return;
+        }
+        this._comparisons.set(updated, undefined);
+        this._save();
+        this._pruneAttemptTelemetryState(( new Set(
+            updated.filter(comparison => comparison.archivedAt === undefined).map(comparison => comparison.id)
+        )));
+    }
+    _archiveFullyArchivedComparisons(comparisons) {
+        for (const comparison of comparisons) {
+            if (comparison.archivedAt !== undefined) {
+                continue;
+            }
+            const participantResources = comparison.participants.map(participant => participant.sessionResource).filter(resource => resource !== undefined);
+            const sessions = participantResources.map(resource => this.sessionsManagementService.getSession(resource)).filter(session => session !== undefined);
+            if (sessions.length === 0 || sessions.length !== participantResources.length || ( sessions.some(session => !session.isArchived.get()))) {
+                continue;
+            }
+            this.archiveComparison(comparison.id);
+            this.sessionGroupsService.deleteGroup(comparison.groupId);
+        }
+    }
+    _migrateLegacyAttemptTitles(comparisons) {
+        for (const comparison of comparisons) {
+            const attempts = comparison.participants.filter(
+                participant => participant.role === SessionComparisonParticipantRole.Attempt
+            );
+            for (const [index, participant] of attempts.entries()) {
+                const session = participant.sessionResource ? this.sessionsManagementService.getSession(participant.sessionResource) : undefined;
+                if (!session || ( this._migratingAttemptTitles.has(session.sessionId)) || ( this._migratedAttemptTitles.has(session.sessionId))) {
+                    continue;
+                }
+                const title = getSessionComparisonHarnessLabel(participant);
+                const legacyTitle = ( localize(6333, "Attempt {0}: {1}", index + 1, title));
+                const permissionTitle = participant.harness.permissionId && participant.harness.permissionId !== "default" && participant.harness.permissionLabel ? ( localize(6334, "{0} · {1}", title, participant.harness.permissionLabel)) : undefined;
+                const currentTitle = session.title.get();
+                if (currentTitle !== legacyTitle && currentTitle !== permissionTitle && currentTitle !== (permissionTitle ? ( localize(6333, "Attempt {0}: {1}", index + 1, permissionTitle)) : undefined)) {
+                    continue;
+                }
+                this._migratingAttemptTitles.add(session.sessionId);
+                void this.sessionsManagementService.renameSession(session, title).then(() => {
+                    this._migratedAttemptTitles.add(session.sessionId);
+                }, error => {
+                    this.logService.warn("[SessionComparisonService] Failed to migrate an attempt title.", error);
+                }).finally(() => {
+                    this._migratingAttemptTitles.delete(session.sessionId);
+                });
+            }
+        }
+    }
+    _addComparison(comparison) {
+        this._indexComparisonSessions(comparison);
+        this._comparisons.set([...this._comparisons.get(), comparison], undefined);
+        this._save();
+    }
+    _replaceComparison(comparison) {
+        const previous = this.getComparison(comparison.id);
+        if (previous) {
+            this._unindexComparisonSessions(previous);
+        }
+        this._indexComparisonSessions(comparison);
+        this._comparisons.set(
+            this._comparisons.get().map(candidate => candidate.id === comparison.id ? comparison : candidate),
+            undefined
+        );
+        this._save();
+    }
+    _removeComparison(comparisonId) {
+        const comparison = this.getComparison(comparisonId);
+        if (comparison) {
+            this._unindexComparisonSessions(comparison);
+        }
+        this._comparisons.set(
+            this._comparisons.get().filter(comparison => comparison.id !== comparisonId),
+            undefined
+        );
+        this._save();
+        this._pruneAttemptTelemetryState(( new Set(
+            this._comparisons.get().filter(comparison => comparison.archivedAt === undefined).map(comparison => comparison.id)
+        )));
+    }
+    _indexComparisonSessions(comparison) {
+        for (const participant of comparison.participants) {
+            if (participant.sessionResource) {
+                this._comparisonIdsBySession.set(( participant.sessionResource.toString()), comparison.id);
+            }
+        }
+    }
+    _unindexComparisonSessions(comparison) {
+        for (const participant of comparison.participants) {
+            if (participant.sessionResource && this._comparisonIdsBySession.get(( participant.sessionResource.toString())) === comparison.id) {
+                this._comparisonIdsBySession.delete(( participant.sessionResource.toString()));
+            }
+        }
+    }
+    _getComparisonsForSessionChanges(event) {
+        const comparisonIds = ( new Set());
+        for (const session of [...event.added, ...event.removed, ...event.changed]) {
+            const comparisonId = this._comparisonIdsBySession.get(( session.resource.toString()));
+            if (comparisonId) {
+                comparisonIds.add(comparisonId);
+            }
+        }
+        return [...comparisonIds].flatMap(comparisonId => {
+            const comparison = this.getComparison(comparisonId);
+            return comparison ? [comparison] : [];
+        });
+    }
+    _markParticipantDeleted(session) {
+        const comparison = this.getComparisonForSession(session.resource);
+        const participant = comparison?.participants.find(candidate => candidate.sessionResource?.toString() === ( session.resource.toString()));
+        if (!comparison || comparison.archivedAt !== undefined || !participant) {
+            return;
+        }
+        const updated = this._updateComparisonParticipant(comparison.id, participant.id, current => ({
+            ...current,
+            missingSession: undefined,
+            launchError: current.launchError ?? getAttemptUnavailableMessage()
+        }));
+        if (updated) {
+            this._checkComparison(updated);
+        }
+    }
+    _reconcileSessionAvailability(comparison, event) {
+        const availableResources = ( new Set([...event.added, ...event.changed].map(session => ( session.resource.toString()))));
+        const missingResources = ( new Set(event.removed.filter(
+            session => !session.isArchived.get() && !this.sessionsManagementService.getSession(session.resource)
+        ).map(session => ( session.resource.toString()))));
+        let changed = false;
+        const participants = comparison.participants.map(participant => {
+            const resource = participant.sessionResource?.toString();
+            if (!resource) {
+                return participant;
+            }
+            if (participant.missingSession && ( availableResources.has(resource))) {
+                changed = true;
+                return {
+                    ...participant,
+                    missingSession: undefined,
+                    launchError: undefined
+                };
+            }
+            if (!participant.launchError && ( missingResources.has(resource))) {
+                changed = true;
+                return {
+                    ...participant,
+                    missingSession: true,
+                    launchError: getAttemptUnavailableMessage()
+                };
+            }
+            return participant;
+        });
+        if (!changed) {
+            return comparison;
+        }
+        const updated = {
+            ...comparison,
+            participants
+        };
+        this._replaceComparison(updated);
+        return updated;
+    }
+    _load() {
+        const raw = this.storageService.get(SessionComparisonService_1.STORAGE_KEY, StorageScope.PROFILE);
+        if (!raw) {
+            return [];
+        }
+        try {
+            const stored = parse(raw);
+            return stored.map(comparison => ({
+                ...comparison,
+                judgeHarness: comparison.judgeHarness ?? (comparison.version === undefined ? comparison.participants.find(
+                    participant => participant.role === SessionComparisonParticipantRole.Coordinator
+                )?.harness ?? comparison.participants.find(
+                    participant => participant.role === SessionComparisonParticipantRole.Attempt && participant.sessionResource
+                )?.harness : undefined),
+                synthesisPlan: comparison.synthesisPlan?.instructions ? {
+                    instructions: comparison.synthesisPlan.instructions
+                } : undefined,
+                verdict: comparison.verdict ? {
+                    recommendedParticipantId: comparison.verdict.recommendedParticipantId,
+                    explanation: comparison.verdict.explanation,
+                    rationale: comparison.verdict.rationale,
+                    conflicts: comparison.verdict.conflicts,
+                    attempts: comparison.verdict.attempts
+                } : undefined,
+                launching: undefined,
+                workspace: ( URI.parse(comparison.workspace)),
+                attachedContext: comparison.attachedContext?.map(IChatRequestVariableEntry.fromExport),
+                participants: comparison.participants.map(participant => ({
+                    ...participant,
+                    sessionResource: participant.sessionResource ? ( URI.parse(participant.sessionResource)) : undefined,
+                    ...(comparison.launching && participant.role === SessionComparisonParticipantRole.Attempt && !participant.sessionResource && !participant.launchError ? {
+                        launchError: ( localize(6335, "The attempt was interrupted before it started."))
+                    } : {})
+                }))
+            }));
+        } catch (error) {
+            this.logService.error("[SessionComparisonService] Failed to restore comparisons.", error);
+            return [];
+        }
+    }
+    _save() {
+        const stored = this._comparisons.get().map(comparison => ({
+            ...comparison,
+            version: 1,
+            workspace: ( comparison.workspace.toString()),
+            attachedContext: comparison.attachedContext?.map(IChatRequestVariableEntry.toExport),
+            participants: comparison.participants.map(participant => ({
+                ...participant,
+                sessionResource: participant.sessionResource?.toString()
+            }))
+        }));
+        this.storageService.store(
+            SessionComparisonService_1.STORAGE_KEY,
+            stringify(stored),
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+    _loadAttemptTelemetryState() {
+        const raw = this.storageService.get(
+            SessionComparisonService_1.ATTEMPT_TELEMETRY_STORAGE_KEY,
+            StorageScope.PROFILE
+        );
+        if (!raw) {
+            return;
+        }
+        try {
+            const keys = JSON.parse(raw);
+            for (const key of keys) {
+                this._reportedAttemptTelemetry.add(key);
+            }
+        } catch (error) {
+            this.logService.error(
+                "[SessionComparisonService] Failed to restore comparison attempt telemetry state.",
+                error
+            );
+        }
+    }
+    _saveAttemptTelemetryState() {
+        this.storageService.store(
+            SessionComparisonService_1.ATTEMPT_TELEMETRY_STORAGE_KEY,
+            JSON.stringify([...this._reportedAttemptTelemetry]),
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+    _pruneAttemptTelemetryState(comparisonIds) {
+        let changed = false;
+        for (const key of [...this._reportedAttemptTelemetry]) {
+            const separator = key.indexOf("/");
+            if (separator < 0 || !( comparisonIds.has(key.slice(0, separator)))) {
+                this._reportedAttemptTelemetry.delete(key);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this._saveAttemptTelemetryState();
+        }
+    }
+};
+SessionComparisonService = SessionComparisonService_1 = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionGroupsService)), ( __param(2, IStorageService)), ( __param(3, ILogService)), ( __param(4, IChatService)), ( __param(5, ITelemetryService))], SessionComparisonService));
+function snapshotAttachedContext(attachedContext) {
+    const stored = attachedContext.map(IChatRequestVariableEntry.toExport);
+    return parse(stringify(stored)).map(IChatRequestVariableEntry.fromExport);
+}
+function comparisonTitle(prompt) {
+    const firstLine = prompt.trim().split(/\r?\n/, 1)[0];
+    return firstLine.length > 60 ? `${firstLine.slice(0, 57)}...` : firstLine;
+}
+
+export { SessionComparisonService };