@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/onboardingTours/browser/newSessionViewV3Prompt.js

@@ -0,0 +1,1277 @@
+
+import { raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { format } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getGitHubRemoteInfo } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/utils';
+import { isOnboardingDeveloperModeEnabled, ONBOARDING_DEVELOPER_MODE_VARIATIONS_CONFIG, getOnboardingDeveloperModeVariation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/common/onboardingScenarioService';
+import { isAgentHostProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { NEW_SESSION_PROMPT_TYPING_DURATION_MS } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newSessionComposerService';
+import { getGitHubRepositoryFromUri } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/utils';
+import { GitHubAuthenticationError } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubApiClient';
+import { computeIssueIcon, GitHubIssueState, GitHubPullRequestState } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/types';
+import { resolveGitHubRepositoryFromGitConfig } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/gitHubRepositoryResolver';
+import { NEW_SESSION_VIEW_V3_TOUR_ID, NEW_SESSION_VIEW_V3_VARIATION_TREATMENT, NEW_SESSION_VIEW_V3_OPTIONS_VARIATION, NEW_SESSION_VIEW_V3_PROMPT_VARIATION, NEW_SESSION_VIEW_V3_GITHUB_PROMPT_VARIATION } from './tours/newSessionViewV3Tour.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { computePullRequestIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/chatPullRequest';
+
+const DEFAULT_GITHUB_LOOKUP_TIMEOUTS = {
+    totalMs: 10_000,
+    summaryMs: 4_000,
+    linkageMs: 1_500,
+    reviewMs: 3_000
+};
+const LOG_PREFIX = "[NewSessionViewV3Prompt]";
+const PROMPT_TEMPLATE_TREATMENT = "onb.newSessionViewV3.promptTemplate";
+const PLACEHOLDER_TREATMENT = "onb.newSessionViewV3.placeholder";
+const DEFAULT_TASK_PLACEHOLDER = ( localize(4095, "[describe the coding task]"));
+const DEFAULT_PROMPT_TEMPLATE = ( localize(
+    4096,
+    "Help me complete {0} in this project. First, inspect the relevant files and explain your approach briefly. Then implement the solution using existing project conventions, avoid unrelated changes, and run the most relevant tests or checks. If anything is unclear, make a reasonable assumption and state it. When finished, summarize what changed and mention any remaining issues."
+));
+const PROMPT_OPTION_COUNT = 3;
+const LOOKUP_STAGE_ORDER = ["repository", "issueSummary", "prSummary", "issueLinkage", "prReview"];
+const LOOKUP_STAGE_OUTCOME_SEVERITY = [
+    "notRun",
+    "skipped",
+    "success",
+    "cancelled",
+    "requestFailed",
+    "timeout",
+    "noAuthentication"
+];
+const NO_LOOKUP_TELEMETRY = {
+    gitHubOptionCount: 0,
+    candidatesFound: 0,
+    lookupDurationMs: 0,
+    repositoryMs: 0,
+    issueSummaryMs: 0,
+    issueLinkageMs: 0,
+    prSummaryMs: 0,
+    prReviewMs: 0,
+    issueSummaryOutcome: "notRun",
+    issueLinkageOutcome: "notRun",
+    prSummaryOutcome: "notRun",
+    prReviewOutcome: "notRun",
+    timedOutStage: "none"
+};
+class GitHubLookupDiagnostics {
+    constructor() {
+        this._startTime = Date.now();
+        this._durations = ( new Map());
+        this._outcomes = ( new Map());
+        this._pending = ( new Map());
+        this._timedOutStage = "none";
+    }
+    begin(stage) {
+        this._pending.set(stage, (this._pending.get(stage) ?? 0) + 1);
+    }
+    record(stage, outcome, durationMs) {
+        const pending = (this._pending.get(stage) ?? 1) - 1;
+        if (pending > 0) {
+            this._pending.set(stage, pending);
+        } else {
+            this._pending.delete(stage);
+        }
+        this._durations.set(stage, Math.max(this._durations.get(stage) ?? 0, durationMs));
+        const previous = this._outcomes.get(stage) ?? "notRun";
+        if (LOOKUP_STAGE_OUTCOME_SEVERITY.indexOf(outcome) > LOOKUP_STAGE_OUTCOME_SEVERITY.indexOf(previous)) {
+            this._outcomes.set(stage, outcome);
+        } else if (!( this._outcomes.has(stage))) {
+            this._outcomes.set(stage, previous);
+        }
+    }
+    markTimedOut() {
+        this._timedOutStage = [...LOOKUP_STAGE_ORDER].reverse().find(stage => ( this._pending.has(stage))) ?? "unknown";
+    }
+    summarize(candidatesFound, gitHubOptionCount) {
+        return {
+            gitHubOptionCount,
+            candidatesFound,
+            lookupDurationMs: Date.now() - this._startTime,
+            repositoryMs: this._durations.get("repository") ?? 0,
+            issueSummaryMs: this._durations.get("issueSummary") ?? 0,
+            issueLinkageMs: this._durations.get("issueLinkage") ?? 0,
+            prSummaryMs: this._durations.get("prSummary") ?? 0,
+            prReviewMs: this._durations.get("prReview") ?? 0,
+            issueSummaryOutcome: this._outcomes.get("issueSummary") ?? "notRun",
+            issueLinkageOutcome: this._outcomes.get("issueLinkage") ?? "notRun",
+            prSummaryOutcome: this._outcomes.get("prSummary") ?? "notRun",
+            prReviewOutcome: this._outcomes.get("prReview") ?? "notRun",
+            timedOutStage: this._timedOutStage
+        };
+    }
+}
+class NewSessionViewV3PromptRunner {
+    constructor(
+        _assignmentService,
+        _configurationService,
+        _sessionsService,
+        _newSessionComposerService,
+        _gitService,
+        _fileService,
+        _gitHubService,
+        _telemetryService,
+        _logService,
+        gitHubLookupTimeouts = {}
+    ) {
+        this._assignmentService = _assignmentService;
+        this._configurationService = _configurationService;
+        this._sessionsService = _sessionsService;
+        this._newSessionComposerService = _newSessionComposerService;
+        this._gitService = _gitService;
+        this._fileService = _fileService;
+        this._gitHubService = _gitHubService;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this._impressionId = generateUuid();
+        this._renderedPromptOptions = [];
+        this._gitHubLookupTimeouts = {
+            ...DEFAULT_GITHUB_LOOKUP_TIMEOUTS,
+            ...gitHubLookupTimeouts
+        };
+    }
+    async run(token) {
+        this._logService.info(`${LOG_PREFIX} Starting V3 prompt resolution.`);
+        this._impressionId = generateUuid();
+        this._renderedPromptOptions = [];
+        const configuredVariation = await this._resolveConfiguredVariation();
+        if (token.isCancellationRequested) {
+            this._logService.trace(
+                `${LOG_PREFIX} Prompt resolution was cancelled after resolving the configured variation.`
+            );
+            return false;
+        }
+        if (configuredVariation === "options" || configuredVariation === "unknown") {
+            return this._runPromptOptions(
+                configuredVariation,
+                token,
+                configuredVariation === "unknown" ? "unsupportedVariation" : undefined
+            );
+        }
+        const plan = configuredVariation === "githubPrompt" ? await this._resolveGitHubPromptWithFallback(token) : await this._resolvePrompt("none");
+        if (token.isCancellationRequested) {
+            this._logService.trace(`${LOG_PREFIX} Prompt resolution was cancelled before prompt insertion.`);
+            return false;
+        }
+        this._logService.info(
+            `${LOG_PREFIX} Resolved effective strategy '${plan.effectiveStrategy}' with fallback reason '${plan.fallbackReason}'.`
+        );
+        const shown = await this._animatePrompt(plan.prompt, plan.taskPlaceholder, token);
+        this._logService.info(`${LOG_PREFIX} Prompt insertion completed with shown=${shown}.`);
+        this._reportStrategy(configuredVariation, plan.effectiveStrategy, plan.fallbackReason, shown);
+        return shown;
+    }
+    async _resolveConfiguredVariation() {
+        const developerModeEnabled = isOnboardingDeveloperModeEnabled(this._configurationService, NEW_SESSION_VIEW_V3_TOUR_ID);
+        const developerVariations = this._configurationService.getValue(ONBOARDING_DEVELOPER_MODE_VARIATIONS_CONFIG);
+        const configuredDeveloperVariation = typeof developerVariations === "object" && developerVariations !== null ? developerVariations[NEW_SESSION_VIEW_V3_TOUR_ID] : undefined;
+        const developerVariation = getOnboardingDeveloperModeVariation(this._configurationService, NEW_SESSION_VIEW_V3_TOUR_ID);
+        if (configuredDeveloperVariation && !developerModeEnabled) {
+            this._logService.warn(
+                `${LOG_PREFIX} Ignoring developer variation '${configuredDeveloperVariation}' because developer mode is not enabled for '${NEW_SESSION_VIEW_V3_TOUR_ID}'.`
+            );
+        }
+        if (developerVariation) {
+            this._logService.info(`${LOG_PREFIX} Using developer variation '${developerVariation}'.`);
+            return this._normalizeVariation(developerVariation, "developer setting");
+        }
+        this._logService.trace(
+            `${LOG_PREFIX} No active developer variation; resolving treatment '${NEW_SESSION_VIEW_V3_VARIATION_TREATMENT}'.`
+        );
+        const treatmentVariation = await this._assignmentService.getTreatment(NEW_SESSION_VIEW_V3_VARIATION_TREATMENT);
+        this._logService.info(
+            `${LOG_PREFIX} Treatment variation resolved to '${treatmentVariation || NEW_SESSION_VIEW_V3_OPTIONS_VARIATION}'.`
+        );
+        return this._normalizeVariation(treatmentVariation, "treatment");
+    }
+    _normalizeVariation(variation, source) {
+        if (variation === undefined || variation === "" || variation === NEW_SESSION_VIEW_V3_OPTIONS_VARIATION) {
+            return "options";
+        }
+        if (variation === NEW_SESSION_VIEW_V3_PROMPT_VARIATION) {
+            return "prompt";
+        }
+        if (variation === NEW_SESSION_VIEW_V3_GITHUB_PROMPT_VARIATION) {
+            return "githubPrompt";
+        }
+        this._logService.warn(
+            `${LOG_PREFIX} Unsupported variation '${variation}' from ${source}; using '${NEW_SESSION_VIEW_V3_OPTIONS_VARIATION}'.`
+        );
+        return "unknown";
+    }
+    async _runPromptOptions(configuredVariation, token, configuredFallbackReason) {
+        const composer = this._getActiveComposer();
+        if (!composer) {
+            this._logService.warn(
+                `${LOG_PREFIX} Skipping prompt options because no active new-session composer is available.`
+            );
+            this._reportStrategy(configuredVariation, "options", "noComposer", false);
+            return false;
+        }
+        let latestPlan;
+        const resolveOptions = async (refreshToken, progress) => {
+            this._renderedPromptOptions = [];
+            const publishOptions = options => {
+                if (!this._hasRenderedPromptOptionsChanged(options)) {
+                    return;
+                }
+                if (progress?.({
+                    kind: "resolved",
+                    options
+                }) !== false) {
+                    this._renderedPromptOptions = options;
+                }
+            };
+            publishOptions(this._createPromptOptions([]));
+            latestPlan = await this._resolveGitHubPromptOptionsWithFallback(refreshToken, publishOptions);
+            publishOptions(latestPlan.options);
+            return {
+                kind: "resolved",
+                options: latestPlan.options
+            };
+        };
+        if (composer.setPromptOptionsController && composer.refreshPromptOptions) {
+            const controller = {
+                resolve: resolveOptions,
+                onDidSelectOption: option => this._reportPromptOptionInteraction("selected", option),
+                onDidClose: () => this._reportPromptOptionInteraction("closed")
+            };
+            composer.setPromptOptionsController(controller);
+            this._logService.info(`${LOG_PREFIX} Showing prompt option loading skeletons.`);
+            const shown = await composer.refreshPromptOptions(token);
+            const fallbackReason = configuredFallbackReason ?? latestPlan?.fallbackReason ?? (token.isCancellationRequested ? "requestFailed" : "noCandidate");
+            this._logService.info(
+                `${LOG_PREFIX} Prompt options completed with shown=${shown} and fallback reason '${fallbackReason}'.`
+            );
+            this._reportStrategy(configuredVariation, "options", fallbackReason, shown, latestPlan?.lookup);
+            return shown;
+        }
+        if (!composer.showPromptOptions({
+            kind: "loading"
+        })) {
+            this._logService.warn(
+                `${LOG_PREFIX} Skipping prompt options because the active new-session composer cannot show them.`
+            );
+            this._reportStrategy(configuredVariation, "options", "noComposer", false);
+            return false;
+        }
+        this._logService.info(`${LOG_PREFIX} Showing prompt option loading skeletons.`);
+        const state = await resolveOptions(token);
+        if (token.isCancellationRequested || this._newSessionComposerService.activeComposer.get() !== composer || this._sessionsService.activeSession.get()?.isCreated.get()) {
+            composer.showPromptOptions(undefined);
+            this._logService.trace(
+                `${LOG_PREFIX} Prompt option resolution was cancelled or its composer is no longer active.`
+            );
+            this._reportStrategy(
+                configuredVariation,
+                "options",
+                configuredFallbackReason ?? latestPlan?.fallbackReason ?? "requestFailed",
+                false,
+                latestPlan?.lookup
+            );
+            return false;
+        }
+        const shown = composer.showPromptOptions(state);
+        const fallbackReason = configuredFallbackReason ?? latestPlan?.fallbackReason ?? "noCandidate";
+        this._logService.info(
+            `${LOG_PREFIX} Prompt options completed with shown=${shown} and fallback reason '${fallbackReason}'.`
+        );
+        this._reportStrategy(configuredVariation, "options", fallbackReason, shown, latestPlan?.lookup);
+        return shown;
+    }
+    _hasRenderedPromptOptionsChanged(options) {
+        return this._renderedPromptOptions.length !== options.length || ( options.some((option, index) => this._renderedPromptOptions[index]?.id !== option.id));
+    }
+    _getActiveComposer() {
+        const activeSession = this._sessionsService.activeSession.get();
+        if (activeSession?.isCreated.get()) {
+            return undefined;
+        }
+        return this._newSessionComposerService.activeComposer.get();
+    }
+    async _resolveGitHubPromptOptionsWithFallback(token, reportOptions) {
+        this._logService.info(
+            `${LOG_PREFIX} Starting GitHub prompt option lookup with a ${this._gitHubLookupTimeouts.totalMs}ms total timeout.`
+        );
+        const operationCts = ( new CancellationTokenSource(token));
+        const diagnostics = ( new GitHubLookupDiagnostics());
+        let latestProgress;
+        let timedOut = false;
+        const createTimeoutPlan = () => {
+            const candidates = latestProgress && this._isCurrentRepositoryContext(latestProgress.context) ? [...latestProgress.issueCandidates, ...latestProgress.pullRequestCandidates] : [];
+            return this._createPromptOptionsPlan(
+                candidates,
+                candidates.length === PROMPT_OPTION_COUNT ? "none" : "timeout",
+                diagnostics
+            );
+        };
+        try {
+            const result = await raceTimeout(
+                this._resolveGitHubPromptOptions(operationCts.token, diagnostics, progress => {
+                    latestProgress = progress;
+                    reportOptions?.(
+                        this._createPromptOptions([...progress.issueCandidates, ...progress.pullRequestCandidates])
+                    );
+                }),
+                this._gitHubLookupTimeouts.totalMs,
+                () => {
+                    timedOut = true;
+                    diagnostics.markTimedOut();
+                    this._logService.warn(
+                        `${LOG_PREFIX} GitHub prompt option lookup timed out after ${this._gitHubLookupTimeouts.totalMs}ms; filling with standard options.`
+                    );
+                    operationCts.cancel();
+                }
+            );
+            if (timedOut || !result) {
+                return createTimeoutPlan();
+            }
+            if (result.kind === "fallback") {
+                return this._createPromptOptionsPlan([], result.reason, diagnostics);
+            }
+            const candidates = [...result.issueCandidates, ...result.pullRequestCandidates];
+            const fallbackReason = candidates.slice(0, PROMPT_OPTION_COUNT).length === PROMPT_OPTION_COUNT ? "none" : getLookupFallbackReason(result.failures);
+            return this._createPromptOptionsPlan(candidates, fallbackReason, diagnostics);
+        } catch (error) {
+            if (isCancellationError(error) && timedOut) {
+                return createTimeoutPlan();
+            }
+            if (isCancellationError(error) && token.isCancellationRequested) {
+                this._logService.trace(
+                    `${LOG_PREFIX} GitHub prompt option lookup was cancelled by the onboarding flow.`
+                );
+                return this._createPromptOptionsPlan([], "requestFailed", diagnostics);
+            }
+            if (error instanceof GitHubAuthenticationError) {
+                this._logService.warn(
+                    `${LOG_PREFIX} No existing GitHub authentication session is available; filling with standard options without requesting sign-in.`
+                );
+                return this._createPromptOptionsPlan([], "noAuthentication", diagnostics);
+            }
+            this._logService.error(
+                `${LOG_PREFIX} GitHub prompt option lookup failed; filling with standard options.`,
+                error
+            );
+            return this._createPromptOptionsPlan([], "requestFailed", diagnostics);
+        } finally {
+            operationCts.dispose();
+        }
+    }
+    async _resolveGitHubPromptOptions(token, diagnostics, reportProgress) {
+        while (!token.isCancellationRequested) {
+            diagnostics.begin("repository");
+            const repositoryStartTime = Date.now();
+            const context = await this._resolveGitHubRepository(token);
+            diagnostics.record(
+                "repository",
+                context ? "success" : "skipped",
+                Date.now() - repositoryStartTime
+            );
+            if (!context) {
+                this._logService.warn(`${LOG_PREFIX} Could not resolve a GitHub repository for prompt options.`);
+                return {
+                    kind: "fallback",
+                    reason: "noRepository"
+                };
+            }
+            const lookupCts = ( new CancellationTokenSource(token));
+            try {
+                const owner = context.repository.owner;
+                const repo = context.repository.repo;
+                let issueResult;
+                let pullRequestResult;
+                const publishProgress = () => {
+                    if (this._isCurrentRepositoryContext(context)) {
+                        reportProgress({
+                            context,
+                            issueCandidates: issueResult?.candidates ?? [],
+                            pullRequestCandidates: pullRequestResult?.candidates ?? [],
+                            failures: [...(issueResult?.failures ?? []), ...(pullRequestResult?.failures ?? [])]
+                        });
+                    }
+                };
+                publishProgress();
+                const resolveIssues = async () => {
+                    issueResult = await this._resolveIssuePromptOptionCandidates(owner, repo, lookupCts.token, diagnostics, candidates => {
+                        issueResult = {
+                            candidates,
+                            failures: []
+                        };
+                        publishProgress();
+                    });
+                    publishProgress();
+                    return issueResult;
+                };
+                const resolvePullRequests = async () => {
+                    pullRequestResult = await this._resolvePullRequestPromptOptionCandidates(owner, repo, lookupCts.token, diagnostics, candidates => {
+                        pullRequestResult = {
+                            candidates,
+                            failures: []
+                        };
+                        publishProgress();
+                    });
+                    publishProgress();
+                    return pullRequestResult;
+                };
+                const [issues, pullRequests] = await Promise.all([resolveIssues(), resolvePullRequests()]);
+                if (!this._isCurrentRepositoryContext(context)) {
+                    this._logService.info(
+                        `${LOG_PREFIX} The selected workspace changed during prompt option lookup; retrying for the current workspace.`
+                    );
+                    continue;
+                }
+                return {
+                    kind: "candidates",
+                    issueCandidates: issues.candidates,
+                    pullRequestCandidates: pullRequests.candidates,
+                    failures: [...issues.failures, ...pullRequests.failures]
+                };
+            } finally {
+                lookupCts.dispose(true);
+            }
+        }
+        return {
+            kind: "fallback",
+            reason: "noRepository"
+        };
+    }
+    async _resolveIssuePromptOptionCandidates(owner, repo, token, diagnostics, reportCandidates = () => undefined) {
+        const outcome = await this._resolveIssueCandidates(
+            owner,
+            repo,
+            token,
+            diagnostics,
+            issues => reportCandidates(toIssuePromptOptionCandidates(issues))
+        );
+        if (outcome.kind === "failure") {
+            return {
+                candidates: [],
+                failures: [outcome.reason]
+            };
+        }
+        return {
+            candidates: toIssuePromptOptionCandidates(outcome.value),
+            failures: []
+        };
+    }
+    async _resolvePullRequestPromptOptionCandidates(owner, repo, token, diagnostics, reportCandidates = () => undefined) {
+        const summary = await this._runGitHubLookup(
+            "authored pull request summaries",
+            this._gitHubLookupTimeouts.summaryMs,
+            token,
+            lookupToken => this._gitHubService.getRecentAuthoredPullRequests(owner, repo, lookupToken),
+            "prSummary",
+            diagnostics
+        );
+        if (summary.kind === "failure") {
+            return {
+                candidates: [],
+                failures: [summary.reason]
+            };
+        }
+        const pullRequests = [...summary.value].sort(compareUpdatedAtDescending);
+        const directCandidates = pullRequests.map((pullRequest, index) => ({
+            index,
+            candidate: toDirectPullRequestCandidate(pullRequest)
+        })).filter(entry => entry.candidate !== undefined);
+        const secondDirectCandidateIndex = directCandidates[1]?.index ?? pullRequests.length;
+        const reviewPullRequests = pullRequests.slice(0, secondDirectCandidateIndex).filter(pullRequest => !toDirectPullRequestCandidate(pullRequest));
+        const stableCandidates = getCandidatesInPullRequestOrder(pullRequests.slice(
+            0,
+            reviewPullRequests[0] ? pullRequests.indexOf(reviewPullRequests[0]) : secondDirectCandidateIndex
+        ), directCandidates.map(entry => entry.candidate)).slice(0, 2);
+        if (stableCandidates.length > 0) {
+            reportCandidates(stableCandidates);
+        }
+        const reviewLookup = await this._resolveReviewCandidates(owner, repo, reviewPullRequests, token, diagnostics);
+        const candidates = getCandidatesInPullRequestOrder(pullRequests, [
+            ...directCandidates.map(entry => entry.candidate),
+            ...reviewLookup.candidates
+        ]).slice(0, 2);
+        reportCandidates(candidates);
+        return {
+            candidates,
+            failures: reviewLookup.failures
+        };
+    }
+    async _resolveGitHubPromptWithFallback(token) {
+        this._logService.info(
+            `${LOG_PREFIX} Starting GitHub prompt lookup with a ${this._gitHubLookupTimeouts.totalMs}ms total timeout.`
+        );
+        const operationCts = ( new CancellationTokenSource(token));
+        let timedOut = false;
+        try {
+            const result = await raceTimeout(
+                this._resolveGitHubPrompt(operationCts.token),
+                this._gitHubLookupTimeouts.totalMs,
+                () => {
+                    timedOut = true;
+                    this._logService.warn(
+                        `${LOG_PREFIX} GitHub prompt lookup timed out after ${this._gitHubLookupTimeouts.totalMs}ms; using the prompt variation.`
+                    );
+                    operationCts.cancel();
+                }
+            );
+            if (timedOut) {
+                return this._resolvePrompt("timeout");
+            }
+            if (!result) {
+                return this._resolvePrompt("timeout");
+            }
+            if (result.kind === "fallback") {
+                this._logService.warn(
+                    `${LOG_PREFIX} GitHub prompt lookup requested fallback '${result.reason}'; using the prompt variation.`
+                );
+                return this._resolvePrompt(result.reason);
+            }
+            this._logService.info(
+                `${LOG_PREFIX} Selected GitHub candidate strategy '${result.candidate.strategy}'.`
+            );
+            return this._createGitHubPrompt(result.candidate);
+        } catch (error) {
+            if (isCancellationError(error) && timedOut) {
+                return this._resolvePrompt("timeout");
+            }
+            if (isCancellationError(error) && token.isCancellationRequested) {
+                this._logService.trace(`${LOG_PREFIX} GitHub prompt lookup was cancelled by the onboarding flow.`);
+                return this._resolvePrompt("requestFailed");
+            }
+            if (error instanceof GitHubAuthenticationError) {
+                this._logService.warn(
+                    `${LOG_PREFIX} No existing GitHub authentication session is available; using the prompt variation without requesting sign-in.`
+                );
+                return this._resolvePrompt("noAuthentication");
+            }
+            this._logService.error(
+                `${LOG_PREFIX} GitHub prompt lookup failed; using the prompt variation.`,
+                error
+            );
+            return this._resolvePrompt("requestFailed");
+        } finally {
+            operationCts.dispose();
+        }
+    }
+    async _resolveGitHubPrompt(token) {
+        while (!token.isCancellationRequested) {
+            const context = await this._resolveGitHubRepository(token);
+            if (!context) {
+                this._logService.warn(
+                    `${LOG_PREFIX} Could not resolve a GitHub repository for the selected workspace.`
+                );
+                return {
+                    kind: "fallback",
+                    reason: "noRepository"
+                };
+            }
+            const lookupCts = ( new CancellationTokenSource(token));
+            const owner = context.repository.owner;
+            const repo = context.repository.repo;
+            this._logService.info(
+                `${LOG_PREFIX} Starting independent GitHub lookups for '${owner}/${repo}'.`
+            );
+            const issuesLookup = this._resolveIssueCandidates(owner, repo, lookupCts.token);
+            try {
+                const pullRequestsLookup = await this._runGitHubLookup(
+                    "authored pull request summaries",
+                    this._gitHubLookupTimeouts.summaryMs,
+                    lookupCts.token,
+                    lookupToken => this._gitHubService.getRecentAuthoredPullRequests(owner, repo, lookupToken)
+                );
+                if (!this._isCurrentRepositoryContext(context)) {
+                    this._logService.info(
+                        `${LOG_PREFIX} The selected workspace changed during the GitHub lookup; retrying for the current workspace.`
+                    );
+                    continue;
+                }
+                const failures = [];
+                if (pullRequestsLookup.kind === "success") {
+                    const pullRequests = [...pullRequestsLookup.value].sort(compareUpdatedAtDescending);
+                    const directCandidates = pullRequests.map((pullRequest, index) => ({
+                        index,
+                        candidate: toDirectPullRequestCandidate(pullRequest)
+                    })).filter(entry => entry.candidate !== undefined);
+                    this._logService.info(
+                        `${LOG_PREFIX} Pull request summary lookup returned ${pullRequests.length} open authored pull request(s), including ${pullRequests.filter(pullRequest => pullRequest.hasMergeConflicts).length} with merge conflicts and ${pullRequests.filter(isFailingPullRequest).length} with failing CI.`
+                    );
+                    if (directCandidates[0]?.index === 0) {
+                        return {
+                            kind: "candidate",
+                            candidate: directCandidates[0].candidate
+                        };
+                    }
+                    const firstDirectCandidateIndex = directCandidates[0]?.index ?? pullRequests.length;
+                    const reviewPullRequests = pullRequests.slice(0, firstDirectCandidateIndex).filter(pullRequest => !toDirectPullRequestCandidate(pullRequest));
+                    const reviewLookup = await this._resolveReviewCandidates(owner, repo, reviewPullRequests, lookupCts.token);
+                    failures.push(...reviewLookup.failures);
+                    if (!this._isCurrentRepositoryContext(context)) {
+                        this._logService.info(
+                            `${LOG_PREFIX} The selected workspace changed during review lookup; retrying for the current workspace.`
+                        );
+                        continue;
+                    }
+                    const candidate = getCandidatesInPullRequestOrder(pullRequests, [
+                        ...directCandidates.map(entry => entry.candidate),
+                        ...reviewLookup.candidates
+                    ])[0];
+                    if (candidate) {
+                        return {
+                            kind: "candidate",
+                            candidate
+                        };
+                    }
+                } else {
+                    failures.push(pullRequestsLookup.reason);
+                }
+                const issues = await issuesLookup;
+                if (!this._isCurrentRepositoryContext(context)) {
+                    this._logService.info(
+                        `${LOG_PREFIX} The selected workspace changed during issue lookup; retrying for the current workspace.`
+                    );
+                    continue;
+                }
+                if (issues.kind === "success") {
+                    this._logService.info(
+                        `${LOG_PREFIX} Issue lookup returned ${issues.value.length} unlinked open issue(s) assigned to the user.`
+                    );
+                    const issue = [...issues.value].sort(compareUpdatedAtDescending)[0];
+                    if (issue) {
+                        return {
+                            kind: "candidate",
+                            candidate: {
+                                number: issue.number,
+                                title: issue.title,
+                                url: issue.url,
+                                strategy: "githubIssue"
+                            }
+                        };
+                    }
+                } else {
+                    failures.push(issues.reason);
+                }
+                this._logService.warn(
+                    `${LOG_PREFIX} No eligible GitHub candidate was available from the lookups that completed in time.`
+                );
+                return {
+                    kind: "fallback",
+                    reason: getLookupFallbackReason(failures)
+                };
+            } finally {
+                lookupCts.dispose(true);
+            }
+        }
+        this._logService.trace(`${LOG_PREFIX} GitHub prompt lookup stopped because it was cancelled.`);
+        return {
+            kind: "fallback",
+            reason: "noRepository"
+        };
+    }
+    async _resolveIssueCandidates(owner, repo, token, diagnostics, reportIssues) {
+        const issues = await this._runGitHubLookup(
+            "assigned issue summaries",
+            this._gitHubLookupTimeouts.summaryMs,
+            token,
+            lookupToken => this._gitHubService.getRecentAssignedIssues(owner, repo, lookupToken),
+            "issueSummary",
+            diagnostics
+        );
+        if (issues.kind === "failure" || issues.value.length === 0) {
+            diagnostics?.record("issueLinkage", "skipped", 0);
+            return issues;
+        }
+        reportIssues?.(issues.value);
+        const linkedIssues = await this._runGitHubLookup(
+            "issue pull request linkage",
+            this._gitHubLookupTimeouts.linkageMs,
+            token,
+            lookupToken => this._gitHubService.getIssuesWithLinkedPullRequests(owner, repo, issues.value.map(issue => issue.number), lookupToken),
+            "issueLinkage",
+            diagnostics
+        );
+        if (linkedIssues.kind === "success") {
+            const unlinkedIssues = issues.value.filter(issue => !( linkedIssues.value.has(issue.number)));
+            this._logService.info(
+                `${LOG_PREFIX} Issue linkage lookup excluded ${issues.value.length - unlinkedIssues.length} issue(s) with related pull requests.`
+            );
+            return {
+                kind: "success",
+                value: unlinkedIssues
+            };
+        }
+        if (linkedIssues.reason === "cancelled" && token.isCancellationRequested) {
+            return linkedIssues;
+        }
+        this._logService.warn(
+            `${LOG_PREFIX} Issue linkage was unavailable (${linkedIssues.reason}); treating all assigned issues as having no related pull request.`
+        );
+        return issues;
+    }
+    async _resolveReviewCandidates(owner, repo, pullRequests, token, diagnostics) {
+        const eligiblePullRequests = pullRequests.filter(pullRequest => !!pullRequest.latestCommitAt);
+        if (eligiblePullRequests.length === 0) {
+            this._logService.info(
+                `${LOG_PREFIX} No pull requests have a latest commit timestamp, so review-thread lookup is unnecessary.`
+            );
+            diagnostics?.record("prReview", "skipped", 0);
+            return {
+                candidates: [],
+                failures: []
+            };
+        }
+        this._logService.info(
+            `${LOG_PREFIX} Starting ${eligiblePullRequests.length} independent review-thread lookup(s).`
+        );
+        const results = await Promise.all(eligiblePullRequests.map(async pullRequest => {
+            const outcome = await this._runGitHubLookup(
+                `review threads for pull request #${pullRequest.number}`,
+                this._gitHubLookupTimeouts.reviewMs,
+                token,
+                lookupToken => this._gitHubService.getPullRequestReviewThreads(owner, repo, pullRequest.number, lookupToken),
+                "prReview",
+                diagnostics
+            );
+            if (outcome.kind === "success") {
+                const completedPullRequest = {
+                    ...pullRequest,
+                    reviewThreads: outcome.value
+                };
+                return {
+                    pullRequest: completedPullRequest,
+                    outcome
+                };
+            }
+            return {
+                pullRequest,
+                outcome
+            };
+        }));
+        const completedPullRequests = [];
+        const failures = [];
+        for (const result of results) {
+            if (result.outcome.kind === "success") {
+                completedPullRequests.push(result.pullRequest);
+            } else {
+                failures.push(result.outcome.reason);
+            }
+        }
+        const reviewPullRequests = completedPullRequests.sort(compareUpdatedAtDescending).filter(hasUnaddressedReviewComments);
+        this._logService.info(
+            `${LOG_PREFIX} Review-thread lookups completed for ${completedPullRequests.length} of ${eligiblePullRequests.length} pull request(s); ${reviewPullRequests.length} eligible pull request(s) were found.`
+        );
+        return {
+            candidates: reviewPullRequests.map(pullRequest => toCandidate(pullRequest, "githubReviewComments")),
+            failures
+        };
+    }
+    async _runGitHubLookup(label, timeoutMs, token, lookup, stage, diagnostics) {
+        const lookupCts = ( new CancellationTokenSource(token));
+        const startTime = Date.now();
+        let timedOut = false;
+        this._logService.trace(`${LOG_PREFIX} Starting ${label} lookup with a ${timeoutMs}ms timeout.`);
+        const record = outcome => {
+            const durationMs = Date.now() - startTime;
+            if (stage) {
+                diagnostics?.record(stage, outcome, durationMs);
+            }
+            return durationMs;
+        };
+        if (stage) {
+            diagnostics?.begin(stage);
+        }
+        try {
+            const value = await raceTimeout(lookup(lookupCts.token), timeoutMs, () => {
+                timedOut = true;
+                this._logService.warn(
+                    `${LOG_PREFIX} ${capitalize(label)} lookup timed out after ${timeoutMs}ms.`
+                );
+                lookupCts.cancel();
+            });
+            if (timedOut || value === undefined) {
+                record("timeout");
+                return {
+                    kind: "failure",
+                    reason: "timeout"
+                };
+            }
+            this._logService.info(
+                `${LOG_PREFIX} ${capitalize(label)} lookup completed in ${record("success")}ms.`
+            );
+            return {
+                kind: "success",
+                value
+            };
+        } catch (error) {
+            if (timedOut) {
+                record("timeout");
+                return {
+                    kind: "failure",
+                    reason: "timeout"
+                };
+            }
+            if (error instanceof GitHubAuthenticationError) {
+                this._logService.warn(
+                    `${LOG_PREFIX} ${capitalize(label)} lookup could not run because no existing GitHub authentication session is available.`
+                );
+                record("noAuthentication");
+                return {
+                    kind: "failure",
+                    reason: "noAuthentication"
+                };
+            }
+            if (isCancellationError(error) && token.isCancellationRequested) {
+                this._logService.trace(`${LOG_PREFIX} ${capitalize(label)} lookup was cancelled.`);
+                record("cancelled");
+                return {
+                    kind: "failure",
+                    reason: "cancelled"
+                };
+            }
+            this._logService.error(
+                `${LOG_PREFIX} ${capitalize(label)} lookup failed after ${record("requestFailed")}ms.`,
+                error
+            );
+            return {
+                kind: "failure",
+                reason: "requestFailed"
+            };
+        } finally {
+            lookupCts.dispose();
+        }
+    }
+    async _resolveGitHubRepository(token) {
+        while (!token.isCancellationRequested) {
+            const activeSession = this._sessionsService.activeSession.get();
+            if (!activeSession) {
+                this._logService.trace(
+                    `${LOG_PREFIX} No active draft session is available for repository resolution.`
+                );
+                return undefined;
+            }
+            if (activeSession.isCreated.get()) {
+                this._logService.trace(
+                    `${LOG_PREFIX} The active session is already created, so the V3 new-session prompt cannot resolve its repository.`
+                );
+                return undefined;
+            }
+            const workspace = activeSession.workspace.get();
+            const folder = workspace?.folders[0];
+            const enterpriseHost = this._gitHubService.enterpriseHost;
+            const supportedHosts = enterpriseHost ? [enterpriseHost] : undefined;
+            this._logWorkspaceSnapshot(activeSession);
+            if (!workspace || !folder) {
+                this._logService.trace(`${LOG_PREFIX} The active draft has no primary workspace folder.`);
+                return undefined;
+            }
+            const gitHubInfo = folder.gitRepository?.gitHubInfo.get();
+            if (!enterpriseHost && gitHubInfo) {
+                this._logService.info(
+                    `${LOG_PREFIX} Resolved GitHub repository '${gitHubInfo.owner}/${gitHubInfo.repo}' from session metadata.`
+                );
+                return this._createRepositoryContext(activeSession, ( workspace.uri.toString()), ( folder.workingDirectory.toString()), {
+                    owner: gitHubInfo.owner,
+                    repo: gitHubInfo.repo
+                });
+            }
+            const repositoryFromUri = enterpriseHost ? undefined : getGitHubRepositoryFromUri(folder.root) ?? getGitHubRepositoryFromUri(folder.workingDirectory) ?? (folder.gitRepository ? getGitHubRepositoryFromUri(folder.gitRepository.uri) : undefined);
+            if (repositoryFromUri) {
+                this._logService.info(
+                    `${LOG_PREFIX} Resolved GitHub repository '${repositoryFromUri.owner}/${repositoryFromUri.repo}' from the workspace URI.`
+                );
+                return this._createRepositoryContext(activeSession, ( workspace.uri.toString()), ( folder.workingDirectory.toString()), repositoryFromUri);
+            }
+            try {
+                const repositoryFromConfig = await resolveGitHubRepositoryFromGitConfig(this._fileService, folder.workingDirectory, supportedHosts);
+                if (repositoryFromConfig) {
+                    this._logService.info(
+                        `${LOG_PREFIX} Resolved GitHub repository '${repositoryFromConfig.owner}/${repositoryFromConfig.repo}' directly from .git/config.`
+                    );
+                    return this._createRepositoryContext(activeSession, ( workspace.uri.toString()), ( folder.workingDirectory.toString()), repositoryFromConfig);
+                }
+                this._logService.trace(
+                    `${LOG_PREFIX} No supported GitHub remote was found directly in .git/config.`
+                );
+            } catch (error) {
+                this._logService.warn(
+                    `${LOG_PREFIX} Reading Git repository metadata directly from the selected workspace failed.`,
+                    error
+                );
+            }
+            if (!enterpriseHost && isAgentHostProviderId(activeSession.providerId)) {
+                this._logService.info(`${LOG_PREFIX} Waiting for Agent Host git metadata for the active draft.`);
+                const result = await this._waitForAgentHostRepository(activeSession, token);
+                if (result.kind === "sessionChanged") {
+                    this._logService.info(
+                        `${LOG_PREFIX} The active draft changed while waiting for Agent Host git metadata; retrying.`
+                    );
+                    continue;
+                }
+                if (result.kind === "noGitHubRemote") {
+                    this._logService.info(
+                        `${LOG_PREFIX} Agent Host git metadata reports that the selected workspace has no GitHub remote.`
+                    );
+                    return undefined;
+                }
+                if (result.kind === "resolved") {
+                    this._logService.info(
+                        `${LOG_PREFIX} Resolved GitHub repository '${result.context.repository.owner}/${result.context.repository.repo}' from asynchronously published Agent Host metadata.`
+                    );
+                    return result.context;
+                }
+            }
+            this._logService.trace(
+                `${LOG_PREFIX} Session metadata, workspace URIs, and .git/config did not identify GitHub; inspecting Git extension remotes.`
+            );
+            const repository = await this._gitService.openRepository(folder.workingDirectory);
+            if (!repository) {
+                this._logService.trace(
+                    `${LOG_PREFIX} The selected workspace folder could not be opened through the Git extension.`
+                );
+                return undefined;
+            }
+            const repositoryFromRemote = getGitHubRemoteInfo(repository.state.get(), supportedHosts);
+            if (!repositoryFromRemote) {
+                this._logService.trace(
+                    `${LOG_PREFIX} The selected Git repository has no supported GitHub remote.`
+                );
+                return undefined;
+            }
+            this._logService.info(
+                `${LOG_PREFIX} Resolved GitHub repository '${repositoryFromRemote.owner}/${repositoryFromRemote.repo}' from Git extension remotes.`
+            );
+            return this._createRepositoryContext(activeSession, ( workspace.uri.toString()), ( folder.workingDirectory.toString()), repositoryFromRemote);
+        }
+        return undefined;
+    }
+    _waitForAgentHostRepository(activeSession, token) {
+        return ( new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const reaction = disposables.add(( new MutableDisposable()));
+            const finish = result => {
+                disposables.dispose();
+                resolve(result);
+            };
+            reaction.value = autorun(reader => {
+                if (this._sessionsService.activeSession.read(reader) !== activeSession || activeSession.isCreated.read(reader)) {
+                    finish({
+                        kind: "sessionChanged"
+                    });
+                    return;
+                }
+                const workspace = activeSession.workspace.read(reader);
+                const folder = workspace?.folders[0];
+                const gitRepository = folder?.gitRepository;
+                const gitHubInfo = gitRepository?.gitHubInfo.read(reader);
+                if (workspace && folder && gitHubInfo) {
+                    finish({
+                        kind: "resolved",
+                        context: this._createRepositoryContext(activeSession, ( workspace.uri.toString()), ( folder.workingDirectory.toString()), {
+                            owner: gitHubInfo.owner,
+                            repo: gitHubInfo.repo
+                        })
+                    });
+                    return;
+                }
+                if (gitRepository?.hasGitHubRemote === false) {
+                    finish({
+                        kind: "noGitHubRemote"
+                    });
+                }
+            });
+            disposables.add(token.onCancellationRequested(() => {
+                disposables.dispose();
+                reject(( new CancellationError()));
+            }));
+            if (token.isCancellationRequested) {
+                disposables.dispose();
+                reject(( new CancellationError()));
+            }
+        }));
+    }
+    _logWorkspaceSnapshot(activeSession) {
+        const workspace = activeSession.workspace.get();
+        const folder = workspace?.folders[0];
+        const gitRepository = folder?.gitRepository;
+        const gitHubInfo = gitRepository?.gitHubInfo.get();
+        this._logService.info(
+            `${LOG_PREFIX} Workspace snapshot: provider='${activeSession.providerId}', sessionType='${activeSession.sessionType}', workspace='${workspace?.uri.toString() ?? "none"}', root='${folder?.root.toString() ?? "none"}', workingDirectory='${folder?.workingDirectory.toString() ?? "none"}', gitRepository='${gitRepository?.uri.toString() ?? "none"}', hasGitHubRemote=${String(gitRepository?.hasGitHubRemote)}, gitHubRepository='${gitHubInfo ? `${gitHubInfo.owner}/${gitHubInfo.repo}` : "none"}'.`
+        );
+    }
+    _createRepositoryContext(session, workspaceUri, folderUri, repository) {
+        return {
+            session,
+            workspaceUri,
+            folderUri,
+            repository
+        };
+    }
+    _isCurrentRepositoryContext(context) {
+        const activeSession = this._sessionsService.activeSession.get();
+        const workspace = activeSession?.workspace.get();
+        return activeSession === context.session && workspace?.uri.toString() === context.workspaceUri && workspace.folders[0]?.workingDirectory.toString() === context.folderUri;
+    }
+    async _resolvePrompt(fallbackReason) {
+        const [promptTemplateTreatment, placeholderTreatment] = await Promise.all([
+            this._assignmentService.getTreatment(PROMPT_TEMPLATE_TREATMENT),
+            this._assignmentService.getTreatment(PLACEHOLDER_TREATMENT)
+        ]);
+        const hasTreatment = typeof promptTemplateTreatment === "string" && !!promptTemplateTreatment.trim() && typeof placeholderTreatment === "string" && !!placeholderTreatment.trim();
+        const promptTemplate = hasTreatment ? promptTemplateTreatment : DEFAULT_PROMPT_TEMPLATE;
+        const taskPlaceholder = hasTreatment ? placeholderTreatment : DEFAULT_TASK_PLACEHOLDER;
+        if (hasTreatment) {
+            this._logService.info(
+                `${LOG_PREFIX} Using prompt template and placeholder from paired treatments.`
+            );
+        } else {
+            this._logService.info(
+                `${LOG_PREFIX} Prompt treatments were not both set to non-empty strings; using the default prompt template and placeholder.`
+            );
+        }
+        return {
+            prompt: format(promptTemplate, taskPlaceholder),
+            taskPlaceholder,
+            effectiveStrategy: "prompt",
+            fallbackReason
+        };
+    }
+    _createPromptOptionsPlan(candidates, fallbackReason, diagnostics) {
+        const options = this._createPromptOptions(candidates);
+        return {
+            options,
+            fallbackReason,
+            lookup: diagnostics.summarize(candidates.length, Math.min(candidates.length, PROMPT_OPTION_COUNT))
+        };
+    }
+    _createPromptOptions(candidates) {
+        const gitHubOptions = candidates.slice(0, PROMPT_OPTION_COUNT).map(candidate => this._createGitHubPromptOption(candidate));
+        const standardOptions = this._createStandardPromptOptions();
+        return [
+            ...gitHubOptions,
+            ...standardOptions.slice(0, PROMPT_OPTION_COUNT - gitHubOptions.length)
+        ];
+    }
+    _createGitHubPromptOption(candidate) {
+        const plan = this._createGitHubPrompt(candidate);
+        const title = candidate.strategy === "githubIssue" ? ( localize(4097, "Tackle issue")) : candidate.strategy === "githubMergeConflict" ? ( localize(4098, "Resolve conflicts")) : candidate.strategy === "githubCiFailure" ? ( localize(4099, "Fix CI")) : ( localize(4100, "Address PR comments"));
+        const icon = candidate.strategy === "githubIssue" ? computeIssueIcon(GitHubIssueState.Open, undefined) : computePullRequestIcon(GitHubPullRequestState.Open, {
+            hasMergeConflicts: candidate.strategy === "githubMergeConflict",
+            hasFailingChecks: candidate.strategy === "githubCiFailure",
+            hasUnresolvedComments: candidate.strategy === "githubReviewComments"
+        });
+        return {
+            id: `${candidate.strategy}:${candidate.url}`,
+            title,
+            titleDetail: `#${candidate.number}`,
+            description: candidate.title,
+            prompt: plan.prompt,
+            placeholder: "",
+            icon
+        };
+    }
+    _createStandardPromptOptions() {
+        const implementFeaturePlaceholder = ( localize(4101, "[describe the feature]"));
+        const fixBugPlaceholder = ( localize(4102, "[describe the bug]"));
+        const fixCiPlaceholder = ( localize(4103, "[describe the CI failure or paste a link]"));
+        return [{
+            id: "standard:implementFeature",
+            title: ( localize(4104, "Implement a feature")),
+            description: ( localize(4105, "Describe what you want to build")),
+            prompt: ( localize(
+                4106,
+                "Help me implement {0} in this project. Ask me questions if anything is unclear regarding the intended behaviour.",
+                implementFeaturePlaceholder
+            )),
+            placeholder: implementFeaturePlaceholder,
+            icon: Codicon.lightbulbSparkleAutofix
+        }, {
+            id: "standard:fixBug",
+            title: ( localize(4107, "Fix a bug")),
+            description: ( localize(4108, "Describe the unexpected behavior")),
+            prompt: ( localize(
+                4109,
+                "Help me fix {0} in this project. Ask me questions if anything is unclear regarding the bug or the intended behaviour.",
+                fixBugPlaceholder
+            )),
+            placeholder: fixBugPlaceholder,
+            icon: Codicon.bug
+        }, {
+            id: "standard:fixCi",
+            title: ( localize(4110, "Fix CI")),
+            description: ( localize(4111, "Describe a failing check or paste a link")),
+            prompt: ( localize(
+                4112,
+                "Help me fix the failing CI for {0} in this project. Ask me questions if anything is unclear regarding the CI failure or how it should be fixed.",
+                fixCiPlaceholder
+            )),
+            placeholder: fixCiPlaceholder,
+            icon: Codicon.runErrors
+        }];
+    }
+    _createGitHubPrompt(candidate) {
+        const prompt = candidate.strategy === "githubMergeConflict" ? ( localize(
+            4113,
+            "The following pull request has merge conflicts: \"{0}\" ({1}). Resolve the conflicts and update the pull request.",
+            candidate.title,
+            candidate.url
+        )) : candidate.strategy === "githubCiFailure" ? ( localize(
+            4114,
+            "The following pull request has failing CI checks: \"{0}\" ({1}). Investigate the failures and resolve them.",
+            candidate.title,
+            candidate.url
+        )) : candidate.strategy === "githubReviewComments" ? ( localize(
+            4115,
+            "The following pull request has unresolved review comments that have not been addressed by a newer commit: \"{0}\" ({1}). Address the review comments and update the pull request.",
+            candidate.title,
+            candidate.url
+        )) : ( localize(
+            4116,
+            "Tackle the following issue and create a pull request for it: \"{0}\" ({1}).",
+            candidate.title,
+            candidate.url
+        ));
+        return {
+            prompt,
+            taskPlaceholder: "",
+            effectiveStrategy: candidate.strategy,
+            fallbackReason: "none"
+        };
+    }
+    _animatePrompt(prompt, taskPlaceholder, token) {
+        const activeSession = this._sessionsService.activeSession.get();
+        if (activeSession?.isCreated.get()) {
+            this._logService.warn(
+                `${LOG_PREFIX} Skipping prompt insertion because the active session was created before animation started.`
+            );
+            return false;
+        }
+        const composer = this._newSessionComposerService.activeComposer.get();
+        if (!composer) {
+            this._logService.warn(
+                `${LOG_PREFIX} Skipping prompt insertion because no active new-session composer is available.`
+            );
+            return false;
+        }
+        this._logService.trace(
+            `${LOG_PREFIX} Animating the resolved prompt in the active new-session composer.`
+        );
+        return composer.animatePrompt(prompt, NEW_SESSION_PROMPT_TYPING_DURATION_MS, taskPlaceholder, token);
+    }
+    _reportStrategy(
+        configuredVariation,
+        effectiveStrategy,
+        fallbackReason,
+        shown,
+        lookup = NO_LOOKUP_TELEMETRY
+    ) {
+        this._telemetryService.publicLog2("onboarding.promptStrategy", {
+            scenarioId: NEW_SESSION_VIEW_V3_TOUR_ID,
+            impressionId: this._impressionId,
+            configuredVariation,
+            effectiveStrategy,
+            fallbackReason,
+            shown,
+            ...lookup
+        });
+    }
+    _reportPromptOptionInteraction(interaction, option) {
+        this._telemetryService.publicLog2("onboarding.promptOptionInteraction", {
+            scenarioId: NEW_SESSION_VIEW_V3_TOUR_ID,
+            impressionId: this._impressionId,
+            interaction,
+            option: option ? getPromptOptionTelemetryKind(option) : "none",
+            optionIndex: option ? this._renderedPromptOptions.findIndex(candidate => candidate.id === option.id) : -1,
+            optionKindsShown: this._renderedPromptOptions.map(getPromptOptionTelemetryKind).join(",")
+        });
+    }
+}
+function isFailingPullRequest(pullRequest) {
+    return pullRequest.statusCheckRollupState === "FAILURE" || pullRequest.statusCheckRollupState === "ERROR";
+}
+function toDirectPullRequestCandidate(pullRequest) {
+    if (pullRequest.hasMergeConflicts) {
+        return toCandidate(pullRequest, "githubMergeConflict");
+    }
+    if (isFailingPullRequest(pullRequest)) {
+        return toCandidate(pullRequest, "githubCiFailure");
+    }
+    return undefined;
+}
+function hasUnaddressedReviewComments(pullRequest) {
+    const latestCommitAt = pullRequest.latestCommitAt ? Date.parse(pullRequest.latestCommitAt) : NaN;
+    if (!Number.isFinite(latestCommitAt)) {
+        return false;
+    }
+    return ( (pullRequest.reviewThreads ?? []).some(thread => {
+        const latestCommentAt = thread.latestCommentAt ? Date.parse(thread.latestCommentAt) : NaN;
+        return !thread.isResolved && Number.isFinite(latestCommentAt) && latestCommentAt > latestCommitAt;
+    }));
+}
+function getLookupFallbackReason(failures) {
+    if (failures.includes("noAuthentication")) {
+        return "noAuthentication";
+    }
+    if (failures.includes("timeout")) {
+        return "timeout";
+    }
+    if (failures.includes("requestFailed")) {
+        return "requestFailed";
+    }
+    return "noCandidate";
+}
+function compareUpdatedAtDescending(a, b) {
+    return Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+}
+function getCandidatesInPullRequestOrder(pullRequests, candidates) {
+    const candidatesByNumber = ( new Map(candidates.map(candidate => [candidate.number, candidate])));
+    return pullRequests.map(pullRequest => candidatesByNumber.get(pullRequest.number)).filter(candidate => candidate !== undefined);
+}
+function toCandidate(pullRequest, strategy) {
+    return {
+        number: pullRequest.number,
+        title: pullRequest.title,
+        url: pullRequest.url,
+        strategy
+    };
+}
+function toIssuePromptOptionCandidates(issues) {
+    return [...issues].sort(compareUpdatedAtDescending).slice(0, 2).map(issue => ({
+        number: issue.number,
+        title: issue.title,
+        url: issue.url,
+        strategy: "githubIssue"
+    }));
+}
+function getPromptOptionTelemetryKind(option) {
+    switch (option.id.split(":", 1)[0]) {
+    case "standard":
+        switch (option.id) {
+        case "standard:implementFeature":
+            return "implementFeature";
+        case "standard:fixBug":
+            return "fixBug";
+        case "standard:fixCi":
+            return "fixCI";
+        default:
+            return "unknown";
+        }
+    case "githubIssue":
+        return "githubIssue";
+    case "githubMergeConflict":
+        return "githubPRConflicts";
+    case "githubCiFailure":
+        return "githubPRCI";
+    case "githubReviewComments":
+        return "githubPRComments";
+    default:
+        return "unknown";
+    }
+}
+function capitalize(value) {
+    return value.length > 0 ? value[0].toUpperCase() + value.slice(1) : value;
+}
+
+export { NewSessionViewV3PromptRunner };