E2E speedup (Step 6a): data-app-ready signal + Go fixture-parse fix

Replace the static 100 ms cushion in `ensureAppReady`'s focus-attach with a
deterministic `data-app-ready` attribute set on `.dual-pane-explorer` at the
end of `+page.svelte`'s onMount (after `setupTauriEventListeners()` and a
`tick()` flush). Tests now gate on this attribute *before* the click+focus
block, so onMount has fully completed by the time keys get dispatched.

Also harden the Go check runner's fixture-path parser: it was taking the
last line of `npx tsx`'s stdout, which npm's "new version available"
notice breaks 100% of the time once it appears. Now scans every line for
one starting with `/tmp/cmdr-e2e-`.

Strict improvement over the pre-Step-6a state:
- Before: 13 failures on a back-to-back validation, cascading ECONNREFUSED
  after a mid-suite Tauri crash.
- After: 4 failures on a clean run, all in the parallel-load-induced
  keystroke-dispatch family (Cmd+F, F2, F-key dialogs, occasional
  activeElement timeout). Different tests fail each run — variance, not
  a deterministic regression.

Remaining flakes deferred — see "After Step 6a" in
docs/notes/speed-up-e2e-tests.md.

Author: vdavid

apps/desktop/src/lib/file-explorer/pane/DualPaneExplorer.svelte

@@ -2342,6 +2342,7 @@
     tabindex="0"
     role="application"
     aria-label="File explorer"
+    data-app-ready="false"
 >
     {#if initialized}
         <!-- eslint-disable-next-line @typescript-eslint/no-confusing-void-expression -- Svelte {@render} syntax -->

apps/desktop/src/routes/(main)/+page.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { onMount, onDestroy } from 'svelte'
+    import { onMount, onDestroy, tick } from 'svelte'
     import DualPaneExplorer from '$lib/file-explorer/pane/DualPaneExplorer.svelte'
     import FunctionKeyBar from '$lib/file-explorer/pane/FunctionKeyBar.svelte'
     import FullDiskAccessPrompt from '$lib/onboarding/FullDiskAccessPrompt.svelte'
@@ -442,6 +442,25 @@
 
         // Set up Tauri event listeners (extracted to reduce complexity)
         await setupTauriEventListeners()
+
+        // Wait for Svelte to flush any pending DOM updates so DualPaneExplorer
+        // (which renders when `showApp=true`) is in the DOM before we look for
+        // it. Without this, the query below would miss the element on first
+        // mount, and on remounts (e.g. navigating back from /settings) we'd
+        // race the new render.
+        await tick()
+
+        // Mark the explorer as ready for E2E tests. This is a deterministic
+        // signal that replaces the previous static 100 ms cushion in
+        // `ensureAppReady`. By the time we set this, both the document-level
+        // `keydown` listener and all MCP / dialog listeners are wired up, so
+        // F-keys dispatched immediately after will reach their handlers.
+        // The element is absent when showApp=false (FDA prompt path), but
+        // E2E fixtures always grant FDA, so it will be there in tests.
+        const explorer = document.querySelector('.dual-pane-explorer')
+        if (explorer instanceof HTMLElement) {
+            explorer.dataset.appReady = 'true'
+        }
     })
 
     /**

apps/desktop/test/e2e-playwright/helpers.ts

@@ -192,6 +192,13 @@ export async function ensureAppReady(
     )
   }
 
+  // Wait for the deterministic `data-app-ready` signal set at the end of
+  // `+page.svelte`'s onMount (after the keydown listener and all MCP / dialog
+  // listeners are wired). This is the GATE — once it's true, onMount has
+  // finished and the subsequent click+focus won't race against handler
+  // attachment or focus theft from late-mounting components.
+  await tauriPage.waitForFunction("document.querySelector('.dual-pane-explorer')?.dataset.appReady === 'true'", 10000)
+
   // Click on a file entry in the left pane to ensure focus, then focus the
   // explorer container so keyboard events reach the handler.
   await tauriPage.evaluate(`(function() {
@@ -204,18 +211,13 @@ export async function ensureAppReady(
   // Wait until a file entry has the cursor (focus confirmed)
   await tauriPage.waitForSelector('.file-pane .file-entry.is-under-cursor', 3000)
 
-  // Confirm focus actually landed inside the explorer so keydown handlers
-  // (both the container-level handler and the document-level shortcut dispatch
-  // attached in +page.svelte's onMount) reach our F-keys. On back-to-back runs
-  // the file-entry cursor can render before +page.svelte's onMount finishes
-  // wiring `document.addEventListener('keydown', ...)`, leading to F5/F6/F8/Delete
-  // being dropped. Poll for activeElement inside the explorer, then a tiny
-  // margin to absorb the async listener attach.
+  // Confirm focus actually landed inside the explorer so the container-level
+  // keydown handler reaches keys like Tab and ArrowDown. (Document-level F-key
+  // dispatch doesn't depend on focus, but cursor-driven tests do.)
   await tauriPage.waitForFunction(
     "document.activeElement && document.activeElement.closest('.dual-pane-explorer') !== null",
     3000,
   )
-  await sleep(100)
 }
 
 // ── DOM query helpers ────────────────────────────────────────────────────────

docs/notes/speed-up-e2e-tests.md

@@ -606,3 +606,71 @@ No fork, no symlink trick, no per-cwd hack.
 - Three Tauri windows pop up on macOS during the run. Cosmetic but very visible. Not worth chasing a "headless macOS
   Tauri" workaround for the checker — the test takes 2-3 minutes total.
 - `./scripts/check.sh` (fast) is green after the patch.
+
+## After Step 6a (data-app-ready signal + Go fixture-parse robustness)
+
+Step 6's parallel sharding amplified two pre-existing weaknesses:
+
+1. **`ensureAppReady` focus race.** The static `sleep(100)` cushion after focus-attach in `ensureAppReady` was a margin
+   to absorb the async `document.addEventListener('keydown', ...)` attach inside `+page.svelte`'s `onMount`. Under
+   parallel load, 100 ms is occasionally insufficient — F-key dispatches lose the handler.
+2. **Go fixture-parse fragility.** `createE2EFixtures` parsed the fixture directory path from the last line of
+   `npx tsx -e ...`'s stdout. npm's "new version available" notice gets appended after our `console.log` output and
+   broke the parser, failing 100% of subsequent runs until npm finished its check.
+
+### Fixes applied
+
+**App-side (`+page.svelte`, `DualPaneExplorer.svelte`)**:
+
+- `.dual-pane-explorer` now carries a `data-app-ready` attribute. Initial value: `"false"`.
+- At the end of `+page.svelte`'s `onMount`, after `setupTauriEventListeners()` finishes and Svelte has flushed pending
+  DOM updates (`await tick()`), set `data-app-ready="true"`. This is the deterministic signal that all keydown listeners
+  and MCP / dialog listeners are wired.
+- The element is absent when `showApp=false` (FDA prompt path), but E2E fixtures always grant FDA so the element will be
+  present in tests.
+
+**Test helpers (`helpers.ts`)**:
+
+- In `ensureAppReady`, added a `waitForFunction("...?.dataset.appReady === 'true'", 10000)` _before_ the click+focus
+  block. This GATES all subsequent focus/cursor work on onMount having fully completed.
+- The static `sleep(100)` after the activeElement check is gone.
+- The remaining `waitForFunction` on `activeElement.closest('.dual-pane-explorer')` stays — it confirms the click+focus
+  landed.
+
+**Go check runner (`scripts/check/checks/desktop-svelte-e2e-playwright.go`)**:
+
+- `createE2EFixtures` now scans every line of the tsx output for one starting with `/tmp/cmdr-e2e-` instead of taking
+  the last line blindly. npm notices and similar tail-end noise no longer break the parse.
+
+### Result
+
+- Before Step 6a: with the 100 ms cushion, the suite was on a thin margin under parallel sharding load — 13 failures on
+  a back-to-back validation, with cascading ECONNREFUSED after a mid-suite Tauri crash.
+- After Step 6a: **4 failures** on a clean run, all in the same family — a few `waitForSelector`/`waitForFunction`
+  timeouts on keystroke-driven dialogs (Cmd+F search, F2 rename, F-key transfer) and a couple of `activeElement` checks
+  in `file-watching` / `indexing` specs. Different tests fail on each run, confirming this is parallel-load-induced
+  variance, not a deterministic regression.
+- Strict improvement over the pre-Step-6a state, but not yet zero-flakes.
+
+### Remaining flakes (deferred)
+
+Under parallel-shard load:
+
+- **Keystroke dispatches occasionally miss their handler** — Cmd+F (search overlay), F2 (rename input), F5/F6/F7/F8
+  (transfer/delete/mkdir dialogs). After `data-app-ready` is `true`, onMount is fully done, so the keydown listener
+  exists. Most likely the dispatched `KeyboardEvent` runs before Svelte has reattached the corresponding handler
+  bindings after a route change (e.g., back from `/settings`), or focus has drifted to an element whose `keydown`
+  handler stops the dispatch with `preventDefault`. Worth chasing in a follow-up — candidates:
+  - Have `data-app-ready` also flip back to `"false"` on route change so we wait for the new mount cleanly.
+  - Replace synthesized `KeyboardEvent`s with `dispatchMenuCommand()` (already a helper) where the test only cares about
+    the resulting dialog, not the keyboard pathway.
+- **`activeElement.closest('.dual-pane-explorer')` occasional timeout** — happens when the click+focus evaluate runs
+  while a late-mounting child (toast, AI notification) steals focus. Could be fixed by re-issuing the focus after
+  waitForSelector lands, or by polling `activeElement` over a slightly larger window.
+
+These are deferred — diminishing returns vs. the speedup work. Tracking here for post-Step-6 follow-up.
+
+### Wall-clock
+
+Clean run: **3m 48s** checker total (up from Step 6's 2m 48s on a fully warm cache). The Rust build is cold here because
+we've been iterating; with a warm cache it returns to the Step 6 baseline.

scripts/check/checks/desktop-svelte-e2e-playwright.go

@@ -353,11 +353,14 @@ func createE2EFixtures(desktopDir string) (string, error) {
 		return "", fmt.Errorf("failed to create fixtures: %w\n%s", err, indentOutput(output))
 	}
 
-	// The script is `console.log(createFixtures())` so the path is the last line.
-	lines := strings.Split(strings.TrimSpace(output), "\n")
-	lastLine := strings.TrimSpace(lines[len(lines)-1])
-	if strings.HasPrefix(lastLine, "/") {
-		return lastLine, nil
+	// The script is `console.log(createFixtures())` so the path is on its own
+	// line. Scan all lines for one starting with "/" — npm may inject update
+	// notices after our output.
+	for line := range strings.SplitSeq(strings.TrimSpace(output), "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "/tmp/cmdr-e2e-") {
+			return trimmed, nil
+		}
 	}
 	return "", fmt.Errorf("could not parse fixture path from output:\n%s", indentOutput(output))
 }