Merge branch 'main' into codex/fix-agent-host-stateful-marker

Author: vritant24

.agents/skills/launch/SKILL.md

@@ -179,15 +179,42 @@ npx @playwright/cli -s=$PW_SESSION snapshot
 
 If a target looks stale after relaunching, run `npx @playwright/cli -s=$PW_SESSION close`, attach again with `$CDP`, and re-check `tab-list`.
 
-### Focusing the chat input (works on Code OSS, including the Agents window)
+### Focusing the chat input
+
+Use the `playwrightScripts/focus-chat-input.ts` script in both the regular
+workbench and the Agents window. It performs the complete focus flow in one
+Playwright call:
+
+1. If a visible chat input is already focused, it does nothing.
+2. If a visible chat input exists but is not focused, it focuses that input.
+3. Otherwise, it invokes the platform chat-focus chord, waits for the input,
+   and focuses it only if the chord did not already do so.
+
+The script detects the platform from the browser page, prefers the active
+Agents session, and excludes inline chat inputs. If the cloned profile has
+customized the default chord, it falls back to the surface-specific command
+through the Command Palette.
 
 ```bash
-# macOS
-npx @playwright/cli -s=$PW_SESSION press Control+Meta+i
-# Linux / Windows
-npx @playwright/cli -s=$PW_SESSION press Control+Alt+i
+LAUNCH_DIR=<dir-of-this-SKILL.md>
+FOCUS_CHAT="$LAUNCH_DIR/playwrightScripts/focus-chat-input.ts"
+npx @playwright/cli -s=$PW_SESSION run-code --filename="$FOCUS_CHAT"
+```
+
+```powershell
+$skillDir = '<dir-of-this-SKILL.md>'
+$focusChat = Join-Path $skillDir 'playwrightScripts\focus-chat-input.ts'
+npx @playwright/cli "-s=$pwSession" run-code "--filename=$focusChat"
 ```
 
+The script returns
+`{ focused, focusChanged, focusInvoked, shortcutInvoked, commandPaletteFallbackInvoked, selector }`.
+`focusChanged` reports whether this script invocation moved focus into Chat,
+while `focusInvoked` reports whether the script had to call `focus()` directly.
+Both are `false` when the chat input was already focused. If the script fails,
+take a fresh snapshot and resolve any blocking dialog or unavailable chat state
+before retrying.
+
 ### Typing into Monaco (chat input, editors)
 
 `fill` and `type` **silently fail** on Code OSS — Monaco's `native-edit-context` element doesn't react to Playwright's default input pipeline. Use one of these alternatives:
@@ -196,11 +223,12 @@ npx @playwright/cli -s=$PW_SESSION press Control+Alt+i
 
   ```bash
   LAUNCH_DIR=<dir-of-this-SKILL.md>           # the same dir that holds scripts/launch.sh
+  FOCUS_CHAT="$LAUNCH_DIR/playwrightScripts/focus-chat-input.ts"
   PASTE="$LAUNCH_DIR/scripts/monaco-paste.sh"
   export PW_SESSION                            # helper reads this env var
 
   # Send a prompt:
-  npx @playwright/cli -s=$PW_SESSION press Control+Meta+i  # focus chat input
+  npx @playwright/cli -s=$PW_SESSION run-code --filename="$FOCUS_CHAT"
   "$PASTE" 'Please run `pwd && ls` using your terminal tool.'
   npx @playwright/cli -s=$PW_SESSION press Enter
 
@@ -223,7 +251,7 @@ npx @playwright/cli -s=$PW_SESSION press Control+Alt+i
   **Why a helper script and not just docs:** the inline recipe involves a multi-line `node -e` heredoc with embedded JS template literals, which is exactly the kind of code that gets miscopied. There are also three non-obvious correctness traps the helper handles internally:
   1. Monaco's `native-edit-context` doesn't react to `fill` or `type`, only to actual paste events (or per-key `press`).
   2. Monaco renders ASCII spaces as U+00A0 (NBSP) in the view-line DOM, so verification has to normalize before comparing.
-  3. Monaco updates its DOM **asynchronously** after a paste event — a synchronous read-back inside the same `eval` returns stale state. The helper waits two `requestAnimationFrame` ticks before reading.
+  3. Monaco updates its DOM **asynchronously** after a paste event — a synchronous read-back inside the same `eval` returns stale state. The helper polls rendered view lines across paint cycles until the pasted prefix appears or verification times out.
 
 - **Per-key `press`** (universal but slow — each press is a separate CLI invocation with Node startup cost):
   ```bash
@@ -234,31 +262,38 @@ npx @playwright/cli -s=$PW_SESSION press Control+Alt+i
 
 - **Clipboard paste via `pbcopy`** (fast on macOS, **but `NSPasteboard` is system-wide so any concurrent shell that touches the pasteboard will collide**). Only use when nothing else on the machine is using the clipboard for the duration of the paste.
   ```bash
+  LAUNCH_DIR=<dir-of-this-SKILL.md>
+  FOCUS_CHAT="$LAUNCH_DIR/playwrightScripts/focus-chat-input.ts"
   printf '%s' "Your prompt here" | pbcopy
-  npx @playwright/cli -s=$PW_SESSION press Control+Meta+i
+  npx @playwright/cli -s=$PW_SESSION run-code --filename="$FOCUS_CHAT"
   npx @playwright/cli -s=$PW_SESSION press Meta+v
   npx @playwright/cli -s=$PW_SESSION press Enter
   ```
 
-The focus shortcut should leave `document.activeElement` on VS Code's `native-edit-context` editing surface. That is a useful sanity check when key presses appear to do nothing.
-
 ### Parallel multi-instance pattern
 
 Because the launch skill is built around isolation, the natural workload is **many agents on one machine, each driving their own Code OSS**. The pattern boils down to giving each agent a unique `PW_SESSION` and passing it everywhere:
 
 ```bash
+LAUNCH_DIR=<dir-of-this-SKILL.md>
+FOCUS_CHAT="$LAUNCH_DIR/playwrightScripts/focus-chat-input.ts"
+PASTE="$LAUNCH_DIR/scripts/monaco-paste.sh"
+export PW_SESSION
+
 # In agent A's shell:
 PW_SESSION="agent-A-$$"
 INFO=$("$LAUNCH" --agents -- --use-mock-keychain | tail -n1)
 CDP=$(jq -r .cdpPort <<<"$INFO")
 npx @playwright/cli -s=$PW_SESSION attach --cdp=http://127.0.0.1:$CDP
+npx @playwright/cli -s=$PW_SESSION run-code --filename="$FOCUS_CHAT"
 "$PASTE" "prompt for A"   # helper picks up $PW_SESSION
 
 # In agent B's shell (running concurrently):
 PW_SESSION="agent-B-$$"
 INFO=$("$LAUNCH" --agents -- --use-mock-keychain | tail -n1)
 CDP=$(jq -r .cdpPort <<<"$INFO")
 npx @playwright/cli -s=$PW_SESSION attach --cdp=http://127.0.0.1:$CDP
+npx @playwright/cli -s=$PW_SESSION run-code --filename="$FOCUS_CHAT"
 "$PASTE" "prompt for B"
 ```
 
@@ -276,10 +311,11 @@ document.querySelectorAll('.interactive-input-editor .view-line')
 
 // More useful checks in Agents.
 document.querySelectorAll('.view-line')
-document.activeElement?.className === 'native-edit-context'
+document.activeElement?.matches('.native-edit-context, textarea.inputarea')
 ```
 
-The `Control+Meta+i` / `Control+Alt+i` focus shortcut still works; only the DOM shape after focus differs.
+The focus script accounts for these DOM differences and prioritizes the active
+Agents session.
 
 ### Verifying and clearing chat text
 
@@ -306,7 +342,9 @@ npx @playwright/cli -s=$PW_SESSION press Control+a
 npx @playwright/cli -s=$PW_SESSION press Backspace
 ```
 
-If the keyboard shortcut cannot focus chat because the surface is not available yet, take a snapshot and navigate the UI into a state where chat exists before retrying. Avoid treating completed CLI commands as proof that text was entered.
+If the focus script cannot reach Chat because the surface is not available yet,
+take a snapshot and navigate the UI into a state where chat exists before
+retrying. Avoid treating completed CLI commands as proof that text was entered.
 
 ### Screenshots (paper trail)
 
@@ -392,5 +430,5 @@ Code OSS is a full Electron app and easily eats 1-4 GB. Always clean up.
 - **Built-in extension fails to load (`Cannot find module .../extensions/.../out/extension.js`)** - extensions weren't compiled. Run `npm run compile` (one-shot, also rebuilds all built-in extensions) or `npm run watch` (incremental). A common cause: you ran `npm run transpile-client` to satisfy unit tests, which populated `out/` but not `extensions/*/out/`, so preLaunch's "is `out/` missing?" check skipped the compile.
 - **`launch.sh` exits non-zero with a log tail** - either pre-launch failed, `code.sh` died before CDP came up, or CDP never opened within 90s. The tail printed to stderr is from `runDir/code.log` - read it to diagnose.
 - **Snapshot shows the wrong page or no expected controls** - use `tab-list`, switch with `tab-select <index>` if needed, then re-snapshot before interacting.
-- **CLI typing commands complete but the input stays empty** - focus chat with the platform shortcut, use `press` or clipboard paste rather than `fill` / `type`, then verify the input state before sending.
+- **CLI typing commands complete but the input stays empty** - run `playwrightScripts/focus-chat-input.ts`, use `press` or clipboard paste rather than `fill` / `type`, and verify the input state before sending.
 - **Auth missing in the launched window** - confirm the source profile is actually authed (`ls "$SOURCE_UDD"` should contain `User/`, and `ls "$SOURCE_UDD/User/globalStorage"` should show persisted extension state). **On Windows, check the shared-data-dir first**: the GitHub session blob lives in `%USERPROFILE%\.vscode-oss-shared\sharedStorage\state.vscdb`, not in the profile. The launcher logs `copying shared data: <src> -> <dst>` on stderr when it finds it, and warns `no shared-data-dir at <path>` when it doesn't. A missing or empty source shared-data-dir means signing in again against the source profile is what you need - see [Windows authentication](#windows-authentication).

.agents/skills/launch/playwrightScripts/focus-chat-input.ts

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* eslint-disable local/code-no-unused-expressions, @stylistic/semi -- playwright-cli requires a bare, unterminated function expression. */
+async page => {
+	const selectors = [
+		'.session-view.is-active .new-chat-input-area :is(.native-edit-context, textarea.inputarea)',
+		'.session-view.is-active .sessions-chat-editor :is(.native-edit-context, textarea.inputarea)',
+		'.session-view.is-active .interactive-session .chat-input-container :is(.native-edit-context, textarea.inputarea)',
+		'.monaco-workbench .interactive-session .chat-input-container :is(.native-edit-context, textarea.inputarea)'
+	];
+
+	const findVisibleChatInput = async () => {
+		let firstVisible;
+		for (const selector of selectors) {
+			const candidates = page.locator(selector);
+			for (let index = 0; index < await candidates.count(); index++) {
+				const candidate = candidates.nth(index);
+				const isExcluded = await candidate.evaluate(element => Boolean(element.closest('.inline-chat-widget, .automation-form-prompt-host')));
+				if (await candidate.isVisible() && !isExcluded) {
+					const match = { input: candidate, selector };
+					if (await candidate.evaluate(element => document.activeElement === element)) {
+						return match;
+					}
+					firstVisible ??= match;
+				}
+			}
+		}
+		return firstVisible;
+	};
+
+	const isFocused = input => input.evaluate(element => document.activeElement === element);
+	const focusIfNeeded = async input => {
+		if (await isFocused(input)) {
+			return false;
+		}
+		await input.focus();
+		if (!await isFocused(input)) {
+			throw new Error('Chat input did not retain focus');
+		}
+		return true;
+	};
+	const waitForVisibleChatInput = async attempts => {
+		for (let attempt = 0; attempt < attempts; attempt++) {
+			const match = await findVisibleChatInput();
+			if (match) {
+				return match;
+			}
+			await page.waitForTimeout(100);
+		}
+		return undefined;
+	};
+
+	let match = await findVisibleChatInput();
+	if (match) {
+		const focusInvoked = await focusIfNeeded(match.input);
+		return { focused: true, focusChanged: focusInvoked, focusInvoked, shortcutInvoked: false, commandPaletteFallbackInvoked: false, selector: match.selector };
+	}
+
+	const platform = await page.evaluate(() => navigator.userAgentData?.platform ?? navigator.platform);
+	const shortcut = /^mac/i.test(platform) ? 'Control+Meta+i' : 'Control+Alt+i';
+	await page.keyboard.press(shortcut);
+	match = await waitForVisibleChatInput(10);
+
+	let commandPaletteFallbackInvoked = false;
+	if (!match) {
+		commandPaletteFallbackInvoked = true;
+		const isAgentsWindow = await page.locator('.agent-sessions-workbench').count() > 0;
+		const commandId = isAgentsWindow ? 'sessions.focusActiveSession' : 'workbench.action.chat.open';
+		await page.keyboard.press('F1');
+		const commandPaletteInput = page.locator('.quick-input-widget .quick-input-box input');
+		try {
+			await commandPaletteInput.waitFor({ state: 'visible', timeout: 1000 });
+		} catch {
+			throw new Error('F1 did not open the Command Palette; check the cloned profile keybindings');
+		}
+		await commandPaletteInput.fill(`>${commandId}`);
+		await page.keyboard.press('Enter');
+		match = await waitForVisibleChatInput(50);
+	}
+
+	if (!match) {
+		throw new Error(`No visible chat input found after invoking ${shortcut} and the command palette fallback`);
+	}
+
+	const focusInvoked = await focusIfNeeded(match.input);
+	return { focused: true, focusChanged: true, focusInvoked, shortcutInvoked: true, commandPaletteFallbackInvoked, selector: match.selector };
+}

.agents/skills/launch/scripts/monaco-paste.sh

@@ -25,18 +25,17 @@
 # Stderr: diagnostic noise from @playwright/cli (suppressed unless caller wants it).
 # Exit code:
 #   0  success
-#   1  paste verify failed, eval failed, or the page had no native-edit-context
+#   1  paste verify failed, eval failed, or the page had no chat input editing surface
 #   2  argument/usage error (empty input, missing tools)
 #
 # Required tools on PATH: npx (with @playwright/cli reachable), node, jq.
 #
 # Assumes:
 #   - You have already run `npx @playwright/cli [-s=NAME] attach --cdp=http://127.0.0.1:$CDP`
 #     in the same session this script reads (--session arg, $PW_SESSION env, or "default").
-#   - The Agents window is open and a new-chat / chat view with a Monaco
-#     editor is on screen. The script auto-focuses the first
-#     `.new-chat-input-area .native-edit-context`, falling back to any
-#     `.native-edit-context`.
+#   - A chat view with a Monaco editor is on screen. The script preserves the
+#     focused chat input, then falls back to the active Agents session or a
+#     regular-workbench chat input.
 
 set -u
 umask 077
@@ -64,6 +63,8 @@ done
 SESSION="${PW_SESSION_OVERRIDE:-${PW_SESSION:-}}"
 PW_ARGS=()
 [[ -n "$SESSION" ]] && PW_ARGS=("-s=$SESSION")
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+FOCUS_CHAT="$SCRIPT_DIR/../playwrightScripts/focus-chat-input.ts"
 
 # Text: prefer the positional arg; otherwise read all of stdin.
 # Stdin is preferred for arbitrary text because it avoids any shell
@@ -97,48 +98,76 @@ case "${OSTYPE:-$(uname -s)}" in
 	*)               SELECT_ALL_MOD="Control" ;;
 esac
 
-# Step 1 (optional): clear the focused Monaco editor by select-all + delete.
+# Step 1: ensure the intended Chat input has focus before sending any keys.
+if ! npx @playwright/cli ${PW_ARGS[@]+"${PW_ARGS[@]}"} run-code --filename="$FOCUS_CHAT" >/dev/null 2>&1; then
+	echo '{"ok":false,"error":"failed to focus a visible chat input"}'
+	exit 1
+fi
+
+# Step 2 (optional): clear the focused Monaco editor by select-all + delete.
 # Done via the CLI's `press` so the keys flow through Monaco's real key
 # handler. Stays inside the CDP connection — no system clipboard.
 if [[ "$APPEND" != "1" ]]; then
 	npx @playwright/cli ${PW_ARGS[@]+"${PW_ARGS[@]}"} press "${SELECT_ALL_MOD}+a" >/dev/null 2>&1 || true
 	npx @playwright/cli ${PW_ARGS[@]+"${PW_ARGS[@]}"} press Backspace >/dev/null 2>&1 || true
 fi
 
-# Step 2: build the eval payload via node so JSON escaping is automatic.
-# The async IIFE waits two requestAnimationFrames after dispatch — Monaco
-# updates its view-line DOM asynchronously, so a same-tick read-back
-# returns stale state. Two rAFs = full paint cycle.
+# Step 3: build the eval payload via node so JSON escaping is automatic.
+# The async IIFE polls the rendered view lines after dispatch because Monaco
+# updates them asynchronously and Agents inputs can take longer than one paint.
 JS=$(node -e '
 	const text = process.argv[1];
 	const verify = process.argv[2] === "1";
 	console.log(`(async () => {
-		const root = document.querySelector(".new-chat-input-area .native-edit-context")
-				  || document.querySelector(".sessions-chat-editor .native-edit-context")
-				  || document.querySelector(".native-edit-context");
-		if (!root) return JSON.stringify({ ok: false, error: "no native-edit-context found on page" });
+		const selectors = [
+			".session-view.is-active .new-chat-input-area :is(.native-edit-context, textarea.inputarea)",
+			".session-view.is-active .sessions-chat-editor :is(.native-edit-context, textarea.inputarea)",
+			".session-view.is-active .interactive-session .chat-input-container :is(.native-edit-context, textarea.inputarea)",
+			".monaco-workbench .interactive-session .chat-input-container :is(.native-edit-context, textarea.inputarea)"
+		];
+		const isEligible = element => {
+			if (!element?.matches?.(".native-edit-context, textarea.inputarea")) return false;
+			if (!element.closest(".new-chat-input-area, .sessions-chat-editor, .interactive-session .chat-input-container")) return false;
+			if (element.closest(".inline-chat-widget, .automation-form-prompt-host")) return false;
+			const style = getComputedStyle(element);
+			return element.isConnected
+				&& element.getClientRects().length > 0
+				&& style.display !== "none"
+				&& style.visibility !== "hidden";
+		};
+		let root = isEligible(document.activeElement) ? document.activeElement : undefined;
+		for (const selector of selectors) {
+			root ||= Array.from(document.querySelectorAll(selector)).find(isEligible);
+		}
+		if (!root) return JSON.stringify({ ok: false, error: "no visible chat input editing surface found on page" });
 		root.focus();
 		const dt = new DataTransfer();
 		dt.setData("text/plain", ${JSON.stringify(text)});
 		root.dispatchEvent(new ClipboardEvent("paste", { clipboardData: dt, bubbles: true, cancelable: true }));
-		await new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)));
 		const editor = root.closest(".monaco-editor");
-		const viewLines = Array.from(editor.querySelectorAll(".view-line")).map(l => l.textContent);
 		// Monaco renders regular ASCII spaces as U+00A0 (NBSP) in view-lines for
 		// visual fidelity. Also, joining view-lines drops the logical newlines
 		// between them. Normalize both sides before comparing.
 		// (Note: \\u00A0 and \\r\\n are double-escaped because this string lives
 		// inside a node template literal that would otherwise resolve them.)
 		const norm = s => s.replace(/\\u00A0/g, " ").replace(/\\r?\\n/g, "");
-		const joined = norm(viewLines.join(""));
-		const actualLength = joined.length;
 		const expectedFull = norm(${JSON.stringify(text)});
 		const expectedPrefix = expectedFull.slice(0, Math.min(40, expectedFull.length));
-		const prefixMatched = joined.startsWith(expectedPrefix) || joined.includes(expectedPrefix.slice(0, 20));
 		const verifyEnabled = ${verify ? "true" : "false"};
+		let viewLines = [];
+		let joined = "";
+		let prefixMatched = false;
+		for (let attempt = 0; attempt < 20; attempt++) {
+			await new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)));
+			viewLines = Array.from(editor.querySelectorAll(".view-line")).map(l => l.textContent);
+			joined = norm(viewLines.join(""));
+			prefixMatched = joined.startsWith(expectedPrefix) || joined.includes(expectedPrefix.slice(0, 20));
+			if (!verifyEnabled || prefixMatched) break;
+			await new Promise(r => setTimeout(r, 100));
+		}
 		return JSON.stringify({
 			ok: !verifyEnabled || prefixMatched,
-			actualLength,
+			actualLength: joined.length,
 			expectedLength: ${JSON.stringify(text)}.length,
 			viewLineCount: viewLines.length,
 			firstViewLine: (viewLines[0] || "").slice(0, 80),
@@ -147,7 +176,7 @@ JS=$(node -e '
 	})()`);
 ' "$TEXT" "$VERIFY")
 
-# Step 3: run the eval. The CLI prints "### Result" then a JSON-encoded
+# Step 4: run the eval. The CLI prints "### Result" then a JSON-encoded
 # string on the next line, followed by "### Ran Playwright code" noise.
 RAW=$(npx @playwright/cli ${PW_ARGS[@]+"${PW_ARGS[@]}"} eval "$JS" 2>&1) || {
 	echo "{\"ok\":false,\"error\":\"@playwright/cli eval failed\"}"