sessions: measure and unblock V3 onboarding GitHub personalization (#334696)

The V3 new-session onboarding personalizes its 3 prompt options with GitHub
items, falling back to standard options. Telemetry from experiment f716301b
showed 61% of impressions timed out with zero GitHub options, and the existing
events could not measure partial success: `fallbackReason` was only 'none' when
all 3 slots were GitHub, so 2 real issues logged identically to zero.

Telemetry (additive; existing field names and values unchanged):
- promptStrategy gains gitHubOptionCount, candidatesFound, lookupDurationMs,
  per-stage durations and outcomes, and timedOutStage.
- promptOptionInteraction gains optionIndex and optionKindsShown, so per-option
  CTR is computable rather than confounded with availability.
- Both gain a shared impressionId, replacing lossy DevDeviceId joins.
- New 'noComposer' fallback reason splits the infra-bug meaning out of the
  overloaded 'noCandidate'.
- Bounded categories and counts only: no titles, URLs, numbers, repository
  names or prompt text.

Latency, without raising the 10s total budget:
- Publish issue candidates before the linkage lookup, which only filters out
  issues that already have linked pull requests and so must never hide them.
- Keep review-thread enrichment off the critical path; it produced the least
  picked option while being the most expensive stage.
- Rebalance sub-budgets to 4000/1500/3000 so the concurrent chains fit.
- Stream options into the composer: paint the standard options immediately and
  replace slots as lookups land, instead of blocking first paint on the lookup.

INewSessionPromptOptionsController.resolve gains an optional progress callback
that reports whether an update was rendered, so the composer can refuse late
updates while the user is acting on the options and telemetry still describes
what was actually shown.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: benibenj

src/vs/sessions/contrib/chat/browser/newChatInput.ts

@@ -456,6 +456,7 @@ export class NewChatInputWidget extends Disposable implements IHistoryNavigation
 	private _promptOptionsState: NewSessionPromptOptionsState | undefined;
 	private _promptOptionsController: INewSessionPromptOptionsController | undefined;
 	private _promptOptionsDismissed = false;
+	private _promptOptionsSelected = false;
 
 	// Send button
 	private _sendButton: Button | undefined;
@@ -677,6 +678,9 @@ export class NewChatInputWidget extends Disposable implements IHistoryNavigation
 
 		this._promptOptionsWidget.value = this.instantiationService.createInstance(NewSessionPromptOptionsWidget, chatInputContainer, {
 			selectOption: async (option, expectedInput, animate) => {
+				// Mark the selection as it begins: the widget only reports it once the prompt
+				// animation completes, and a streamed update in between would clear it.
+				this._promptOptionsSelected = true;
 				this.focus();
 				const inserted = animate
 					? await this.animatePrompt(option.prompt, NEW_SESSION_PROMPT_TYPING_DURATION_MS, option.placeholder, CancellationToken.None, expectedInput)
@@ -1762,13 +1766,15 @@ export class NewChatInputWidget extends Disposable implements IHistoryNavigation
 		this._cancelPromptOptionsRefresh(false);
 		this._promptOptionsController = controller;
 		this._promptOptionsDismissed = false;
+		this._promptOptionsSelected = false;
 	}
 
 	preparePromptOptionsRefresh(): boolean {
 		if (!this._promptOptionsController || this._promptOptionsDismissed) {
 			return false;
 		}
 		this._cancelPromptOptionsRefresh();
+		this._promptOptionsSelected = false;
 		this.showPromptOptions({ kind: 'loading' });
 		return true;
 	}
@@ -1809,9 +1815,17 @@ export class NewChatInputWidget extends Disposable implements IHistoryNavigation
 		}
 		const cts = new CancellationTokenSource(token);
 		this._promptOptionsRefresh.value = cts;
+		// Options resolved after a first paint must not replace ones the user is already working with:
+		// re-rendering clears the selection and moves focus out of the options.
+		const canRerender = () => !this._promptOptionsSelected && !this._promptOptionsWidget.value?.hasFocusedOption();
 		let state: NewSessionPromptOptionsState;
 		try {
-			state = await controller.resolve(cts.token);
+			state = await controller.resolve(cts.token, progressState => {
+				if (this._promptOptionsRefresh.value !== cts || cts.token.isCancellationRequested || !canRerender()) {
+					return false;
+				}
+				return this.showPromptOptions(progressState);
+			});
 		} catch (error) {
 			if (this._promptOptionsRefresh.value === cts) {
 				this._promptOptionsRefresh.clear();
@@ -1831,6 +1845,9 @@ export class NewChatInputWidget extends Disposable implements IHistoryNavigation
 			return false;
 		}
 		this._promptOptionsRefresh.clear();
+		if (!canRerender()) {
+			return true;
+		}
 		return this.showPromptOptions(state);
 	}
 

src/vs/sessions/contrib/chat/browser/newSessionComposerService.ts

@@ -36,8 +36,23 @@ export const enum NewSessionWorkspacePreselectionSource {
 	Unknown = 'unknown',
 }
 
+/**
+ * Reports an intermediate prompt-option state while {@link INewSessionPromptOptionsController.resolve}
+ * is still running, so options can be rendered before the controller has settled on its final set.
+ *
+ * Returns whether the state was rendered. Implementers may refuse a late update, for example while
+ * the user is already acting on the options on screen.
+ */
+export type NewSessionPromptOptionsProgress = (state: NewSessionPromptOptionsState) => boolean;
+
 export interface INewSessionPromptOptionsController {
-	resolve(token: CancellationToken): Promise<NewSessionPromptOptionsState>;
+	/**
+	 * Resolves the final prompt options. Single-shot per refresh.
+	 *
+	 * @param progress Optional sink for intermediate states. Implementers may ignore it; callers that
+	 * pass it must tolerate it never being invoked and must apply the returned state regardless.
+	 */
+	resolve(token: CancellationToken, progress?: NewSessionPromptOptionsProgress): Promise<NewSessionPromptOptionsState>;
 	onDidSelectOption(option: INewSessionPromptOption): void;
 	onDidClose(): void;
 }

src/vs/sessions/contrib/chat/browser/newSessionPromptOptions.ts

@@ -122,6 +122,11 @@ export class NewSessionPromptOptionsWidget extends Disposable {
 		this._updateButtons();
 	}
 
+	/** Whether focus is inside the rendered options, where re-rendering would move focus to the body. */
+	hasFocusedOption(): boolean {
+		return dom.isAncestorOfActiveElement(this._optionsContainer);
+	}
+
 	shouldClearInputForRefresh(): boolean {
 		const selectedOption = this._buttons.find(candidate => candidate.option.id === this._selectedOptionId)?.option;
 		return this._selecting || this._inputValue.length === 0 || matchesGeneratedPrompt(selectedOption, this._inputValue);

src/vs/sessions/contrib/chat/test/browser/newSessionPromptOptions.test.ts

@@ -13,12 +13,14 @@ import { mock } from '../../../../../base/test/common/mock.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
 import { IHoverService } from '../../../../../platform/hover/browser/hover.js';
 import { NewChatInputWidget } from '../../browser/newChatInput.js';
-import { INewSessionPromptOption, INewSessionPromptOptionsController, NewSessionPromptOptionsState } from '../../browser/newSessionComposerService.js';
+import { INewSessionPromptOption, INewSessionPromptOptionsController, NewSessionPromptOptionsProgress, NewSessionPromptOptionsState } from '../../browser/newSessionComposerService.js';
 import { NewSessionPromptOptionsWidget } from '../../browser/newSessionPromptOptions.js';
 
 interface IPromptOptionsRefreshHarness {
 	readonly _promptOptionsRefresh: MutableDisposable<CancellationTokenSource>;
 	readonly _promptOptionsController: INewSessionPromptOptionsController;
+	_promptOptionsSelected: boolean;
+	readonly _promptOptionsWidget: { readonly value: { hasFocusedOption(): boolean } | undefined };
 	preparePromptOptionsRefresh(): boolean;
 	showPromptOptions(state: NewSessionPromptOptionsState | undefined): boolean;
 }
@@ -234,6 +236,8 @@ suite('NewSessionPromptOptionsWidget', () => {
 		const refresh = disposables.add(new MutableDisposable<CancellationTokenSource>());
 		const harness: IPromptOptionsRefreshHarness = {
 			_promptOptionsRefresh: refresh,
+			_promptOptionsSelected: false,
+			_promptOptionsWidget: { value: undefined },
 			_promptOptionsController: {
 				resolve: token => {
 					tokens.push(token);
@@ -272,6 +276,79 @@ suite('NewSessionPromptOptionsWidget', () => {
 		});
 	});
 
+	test('starts selectOption before reporting the selection so consumers can guard the in-flight window', async () => {
+		const container = document.createElement('div');
+		const events: string[] = [];
+		const inserting = new DeferredPromise<boolean>();
+		const widget = disposables.add(new NewSessionPromptOptionsWidget(container, {
+			selectOption: async () => {
+				events.push('selectOption');
+				return inserting.p;
+			},
+			onDidSelectOption: () => events.push('onDidSelectOption'),
+			onDidClose: () => undefined,
+		}, new TestHoverService()));
+
+		widget.setState({ kind: 'resolved', options: [option('feature', 'Implement a feature')] });
+		widget.element.querySelector<HTMLElement>('.monaco-button.new-session-prompt-option')?.click();
+		await timeout(0);
+		const duringInsertion = [...events];
+		inserting.complete(true);
+		await timeout(0);
+
+		assert.deepStrictEqual({ duringInsertion, afterInsertion: events }, {
+			duringInsertion: ['selectOption'],
+			afterInsertion: ['selectOption', 'onDidSelectOption'],
+		});
+	});
+
+	test('applies streamed prompt options until the user acts on them', async () => {
+		const result = new DeferredPromise<NewSessionPromptOptionsState>();
+		const states: NewSessionPromptOptionsState[] = [];
+		const refresh = disposables.add(new MutableDisposable<CancellationTokenSource>());
+		let reportProgress: NewSessionPromptOptionsProgress | undefined;
+		const harness: IPromptOptionsRefreshHarness = {
+			_promptOptionsRefresh: refresh,
+			_promptOptionsSelected: false,
+			_promptOptionsWidget: { value: undefined },
+			_promptOptionsController: {
+				resolve: (_token, progress) => {
+					reportProgress = progress;
+					return result.p;
+				},
+				onDidSelectOption: () => undefined,
+				onDidClose: () => undefined,
+			},
+			preparePromptOptionsRefresh: () => {
+				states.push({ kind: 'loading' });
+				return true;
+			},
+			showPromptOptions: state => {
+				if (state) {
+					states.push(state);
+				}
+				return true;
+			},
+		};
+
+		const refreshing = refreshPromptOptions.call(harness);
+		const applied = [
+			reportProgress?.({ kind: 'resolved', options: [option('feature', 'Implement a feature')] }),
+			(harness._promptOptionsSelected = true, reportProgress?.({ kind: 'resolved', options: [option('bug', 'Fix a bug')] })),
+		];
+		result.complete({ kind: 'resolved', options: [option('ci', 'Fix CI')] });
+
+		assert.deepStrictEqual({
+			shown: await refreshing,
+			applied,
+			states: states.map(state => state.kind === 'loading' ? 'loading' : state.options[0].id),
+		}, {
+			shown: true,
+			applied: [true, false],
+			states: ['loading', 'feature'],
+		});
+	});
+
 	test('replaces a generated prompt immediately', () => {
 		let value = 'old prompt';
 		let placeholder: string | undefined;
@@ -312,6 +389,8 @@ suite('NewSessionPromptOptionsWidget', () => {
 		const refresh = disposables.add(new MutableDisposable<CancellationTokenSource>());
 		const harness: IPromptOptionsRefreshHarness = {
 			_promptOptionsRefresh: refresh,
+			_promptOptionsSelected: false,
+			_promptOptionsWidget: { value: undefined },
 			_promptOptionsController: {
 				resolve: () => result.p,
 				onDidSelectOption: () => undefined,
@@ -346,6 +425,8 @@ suite('NewSessionPromptOptionsWidget', () => {
 		let resolveCount = 0;
 		const harness: IPromptOptionsRefreshHarness = {
 			_promptOptionsRefresh: disposables.add(new MutableDisposable<CancellationTokenSource>()),
+			_promptOptionsSelected: false,
+			_promptOptionsWidget: { value: undefined },
 			_promptOptionsController: {
 				resolve: async () => {
 					resolveCount++;