fix(chat): every reveal of the chat view handles its own rejection

Follow-up to #76, which fixed the two instances in the code it introduced and left the
older ones alone to keep that review diff readable.

`executeCommand` returns a Thenable, so a bare call in a void context turns any rejection
into an unhandled promise rejection in the extension host — attributed to nothing, which
is the part that makes it useless.

SIX SITES, NOT SEVEN. The brief for this change listed the `levelcode.ai.focus`
registration as needing a `return`. It does not: `() => vscode.commands.executeCommand(…)`
is a concise arrow body, so it already returns the thenable and VS Code already reports its
failures. Left alone.

The other six are all BACKGROUND reveals — addSelection, addContext, resumeSession, the
editor panel's onDidDispose, the sessions view's newSession, and handleLaunch. In each the
accompanying work has already succeeded by the time the reveal runs, so failing that work
because the panel would not come forward would be worse than the panel not coming forward.
They route through one `focusChatView(why)` helper that logs and never rejects.

Logged, not swallowed: the complaint was "attributed to nothing", so `.catch(() => {})`
would answer the letter of it and none of the substance. `why` names the caller in the log.

ONE GUARD FOR THE WHOLE CLASS. Rather than six assertions naming six functions, the test
scans every occurrence of the call and accepts only returned / awaited / concise-arrow /
helper-wrapped / inline-handled forms. That covers the seventh site and the eighth nobody
has written yet — which matters, because this pattern reached six copies precisely because
nothing was watching for it.

Verified non-vacuous against develop: the same scan reports exactly the six bare sites
there (lines 423, 468, 1055, 2298, 2435, 2531) and zero here.

Bypasses, each reverted and confirmed to fail:
  - a single site returned to a bare call; the switch-case site returned to a bare call
  - the focus command wrapped in a block body so it stops returning (proves the guard
    protects the site that was already correct)
  - the helper swallowing silently; the log dropping its caller attribution

One assertion deliberately relaxed after bypassing it: pinning `.then(undefined, …)` over
`.catch(…)` failed a refactor with no behavioural difference. It now accepts either and
still fails when the handler stops logging.

23 tests in chatSurface, 32 suites green.

Author: ndemianc

extensions/levelcode-ai/extension.js

@@ -416,11 +416,33 @@ function captureSelection() {
 	};
 }
 
+/**
+ * Reveal the chat view for its side effect only, and never reject.
+ *
+ * `executeCommand` returns a Thenable, so a bare call in a void context turns any rejection into an
+ * unhandled promise rejection in the extension host — noisy, and attributed to nothing in particular,
+ * which is the part that makes it useless.
+ *
+ * Every caller here is a BACKGROUND reveal: the work it accompanies (a selection added, a session
+ * resumed, a login launched) has already succeeded by the time this runs. Failing that work because
+ * the panel would not come forward would be worse than the panel not coming forward.
+ *
+ * Logged, never swallowed. `.catch(() => {})` would hide the one failure that is genuinely hard to
+ * diagnose — a chat surface that silently never appears — so `why` names the caller in the log.
+ *
+ * NOT for a command handler whose whole job IS the reveal: `levelcode.ai.focus` returns the thenable
+ * instead, so VS Code reports the failure to the user who asked for it. See moveChatToSidebar.
+ */
+function focusChatView(why) {
+	return Promise.resolve(vscode.commands.executeCommand('levelcodeAi.chat.focus'))
+		.then(undefined, (e) => dbg('chat.focus.failed', { why, msg: String((e && e.message) || e) }));
+}
+
 function addSelection() {
 	const sel = captureSelection();
 	if (!sel) { vscode.window.showInformationMessage('LevelCode AI: select some code first.'); return; }
 	pendingContext = sel.block;
-	vscode.commands.executeCommand('levelcodeAi.chat.focus');
+	focusChatView('addSelection');
 	post({ type: 'context', label: sel.label });
 }
 
@@ -465,7 +487,7 @@ async function addContext() {
 			}
 		}
 	}
-	vscode.commands.executeCommand('levelcodeAi.chat.focus');
+	focusChatView('addContext');
 	postContextFiles();
 }
 
@@ -1052,7 +1074,7 @@ async function resumeSession(id) {
 	post({ type: 'sessionResumed', id, title: (r.entry && r.entry.title) || 'Session', note: r.note || '', tier: r.plan && r.plan.tier, turns });
 	postContextFiles();
 	refreshSessions();                          // the resumed session bumps to the top — keep both surfaces current
-	vscode.commands.executeCommand('levelcodeAi.chat.focus');
+	focusChatView('resumeSession');
 	dbg('sessions.resumed', { id, tier: r.plan && r.plan.tier, restored: agentMessages.length, shown: turns.length });
 }
 
@@ -2295,7 +2317,7 @@ async function openChatInEditor(opts) {
 			// resolveWebviewView then makes it live, and without this the chat would have no surface at all.
 			activeWebview = undefined;
 			pendingTranscriptReplay = 'Back in the sidebar';
-			vscode.commands.executeCommand('levelcodeAi.chat.focus');
+			focusChatView('editorClosed');
 		}
 		dbg('chat.closedEditor', {});
 	});
@@ -2432,7 +2454,7 @@ class SessionsViewProvider {
 				// The real session index for this workspace (empty on a fresh install — the view shows its
 				// own empty state). Posted to THIS view's webview, not the chat's.
 				case 'listSessions': view.webview.postMessage({ type: 'sessions', entries: sessionList() }); break;
-				case 'newSession': newChat(); vscode.commands.executeCommand('levelcodeAi.chat.focus'); break;
+				case 'newSession': newChat(); focusChatView('sessions.newSession'); break;
 				case 'sessionAction': await handleSessionAction(msg.action, msg.id); break;
 				// Memory tab (§M3): list the recorded outcomes + facts; act on them; open the file.
 				case 'listMemory': { const mm = sessionsManager(); view.webview.postMessage({ type: 'memoryList', items: mm ? mm.memoryItems() : [], facts: mm ? mm.factsList() : [] }); break; }
@@ -2528,7 +2550,7 @@ async function postAccount(open) {
 // second login and no interceptable code ever travels through the custom scheme.
 async function handleLaunch() {
 	dbg('account.launch', {});
-	vscode.commands.executeCommand('levelcodeAi.chat.focus');
+	focusChatView('account.launch');
 	const token = ctx ? await ctx.secrets.get(ACCOUNT_TOKEN_KEY) : null;
 	if (!token) { await accountSignIn(); }
 }

extensions/levelcode-ai/test/chatSurface.test.js

@@ -144,7 +144,9 @@ test('RESTORE: a sidebar that was never resolved is revealed rather than assumed
 	// If the container has not been opened this session, sidebarChatView is undefined — restoring by
 	// writing to it would throw, and doing nothing would leave the chat with no surface at all.
 	const open = fnBody(ext, 'openChatInEditor');
-	assert.match(open, /if \(sidebarChatView\) \{[\s\S]*\} else \{[\s\S]*levelcodeAi\.chat\.focus/,
+	// The reveal now goes through focusChatView() so its rejection cannot go unhandled; what this test
+	// cares about is unchanged — the else-branch must still reveal the view rather than assume it.
+	assert.match(open, /if \(sidebarChatView\) \{[\s\S]*\} else \{[\s\S]*focusChatView\(/,
 		'the never-resolved sidebar case is unhandled');
 });
 
@@ -310,4 +312,46 @@ test('MOVE BACK: there is a button on the tab, and it reuses the dispose hand-ov
 	assert.match(body, /levelcodeAi\.chat\.focus/, 'with no panel open the command must still reveal the chat, not do nothing');
 });
 
+test('FOCUS: no reveal of the chat view is left to reject unhandled', () => {
+	// One guard for the whole class, rather than six assertions that each name a function. `executeCommand`
+	// returns a Thenable, so a bare call in a void context makes any rejection an unhandled promise
+	// rejection in the extension host — attributed to nothing, which is what makes it useless.
+	//
+	// Scanning every call site means the NEXT one is covered too. That matters here: this pattern was
+	// copied into six places over time precisely because nothing was watching for it.
+	const CALL = "vscode.commands.executeCommand('levelcodeAi.chat.focus')";
+	const bare = [];
+	for (let i = ext.indexOf(CALL); i >= 0; i = ext.indexOf(CALL, i + 1)) {
+		const before = ext.slice(Math.max(0, i - 40), i);
+		const after = ext.slice(i + CALL.length, i + CALL.length + 40);
+		const handled = /\breturn\s+$/.test(before)         // returned — a command handler VS Code awaits
+			|| /\bawait\s+$/.test(before)                    // awaited by a caller that catches
+			|| /=>\s*$/.test(before)                         // concise arrow body: also a return
+			|| /Promise\.resolve\($/.test(before)            // wrapped by focusChatView
+			|| /^\s*\)?\s*\.(then|catch)\(/.test(after);     // handled inline
+		if (!handled) { bare.push('line ' + ext.slice(0, i).split('\n').length); }
+	}
+	assert.deepStrictEqual(bare, [],
+		'these reveals are fire-and-forget — a rejection becomes an unhandled promise rejection.\n'
+		+ 'Use focusChatView(why) for a background reveal, or `return` it when the command IS the reveal:\n  '
+		+ bare.join('\n  '));
+});
+
+test('FOCUS: the shared helper logs the failure and names who caused it', () => {
+	// The whole complaint was "attributed to nothing", so swallowing it silently would answer the letter
+	// of the review and none of it. A chat surface that never appears, with no trace, is the failure
+	// that costs an afternoon.
+	const body = fnBody(ext, 'focusChatView');
+	assert.match(body, /dbg\('chat\.focus\.failed'/, 'the failure is not logged — .catch(() => {}) is not a fix');
+	assert.match(body, /\bwhy\b/, 'the log must name the caller, or it is as unattributed as the rejection was');
+	assert.ok(!/\bthrow\b/.test(body), 'the helper must not rethrow — every caller uses it in a void context');
+	// Either `.then(undefined, …)` or `.catch(…)`. They are equivalent here and pinning one would fail a
+	// refactor that changes nothing; what must not disappear is the rejection handler itself.
+	assert.match(body, /\.then\(undefined,|\.catch\(/, 'no rejection handler — the helper can still reject');
+
+	// And it must be the thing the background callers actually use.
+	const callers = (ext.match(/focusChatView\('/g) || []).length;
+	assert.ok(callers >= 6, 'expected the background reveals to route through the helper, found ' + callers);
+});
+
 console.log('\nchatSurface: ' + n + ' tests passed.');