# Real-app command palette status measurement

Windows Server 2025 Datacenter (10.0.26100), 4 logical CPUs, 16 GiB RAM; Node 26.13.1; Playwright headless Chromium; 1440 × 1080; dark theme. Both commits ran on the same leased machine, each from its own checkout and T3 home. No copied production data and no paid provider.

Base: [e9d8ac5673](https://github.com/pingdotgg/t3code/commit/e9d8ac5673c54ddfb4efda196ee7ebaae15208c9).
Head: [3910b3ad6b](https://github.com/pingdotgg/t3code/commit/3910b3ad6b9b6c55b2de232abe1623365786b88b).

## Files and invocation

Place driver.cjs and measure.cjs together, with a `data` directory beneath them. Supply the two checkout locations as arguments; install each checkout with `vp i` first.

In separate terminals, start each side and wait for its web endpoint to respond:

```
node driver.cjs boot "<head-checkout>" "<artifact-directory>/data" head
node driver.cjs boot "<base-checkout>" "<artifact-directory>/data" base
```

Then seed both:

```
node driver.cjs seed "<head-checkout>" "<artifact-directory>/data" head
node driver.cjs seed "<base-checkout>" "<artifact-directory>/data" base
```

The seed makes a shared clone, sets main to base~30 and feature to base, and uses sparse checkout for README.md. It starts ten Replay multi-turn threads in separate worktrees through the real CLI/server. After they finish, it modifies README.md and adds newfile.txt in every worktree. Git's branch comparison retains the full thirty-commit history; the checkout itself is sparse. This differs from the original full-checkout driver benchmark.

Run the measurement from a Windows process that survives SSH disconnection (the Win32_Process launcher described in the task), redirecting its stdout to a private log:

```
node measure.cjs "<head-checkout>" "<base-checkout>" "<artifact-directory>/data" 8
```

The actual evidence includes every completed sample from two batches: five paired rounds before an SSH interruption, then three paired rounds. Order alternates within each batch. The JSON's batch and round fields identify all samples.

## What is timed

Every trial restarts the real dev stack, pairs a new browser context, opens General settings, presses Ctrl+K, and fills the palette search with `Palette row`. At this viewport, six rows acquire local-only status subscriptions despite ten matching threads. The driver requires six requests and six initial snapshots.

`statusBurstMs` starts at the first real browser WebSocket subscribeVcsStatus request with includeRemote:false and ends at the last of those initial snapshots. `keyboardToStatusMs` starts just before Ctrl+K. Startup, pairing, and initial compilation are excluded. Git Trace2 start events between the first request and last snapshot give the whole-window app process count; that count includes app overhead and is not the count per warm driver read.

The comparison preserves branch name, isRepo, hasWorkingTreeChanges, and the full workingTree file/totals payload after removing its absolute root path. It deliberately does not compare branchChanges, whose omission is the change under test. All sixteen normalized results are identical. The displayed Completed labels and branch names also match; relative age labels naturally differ.

## Artifacts

measurements.json contains every retained sample, including normalized returned status and palette text. summary.json contains medians, min/max, full ranges, and the comparison verdict. render-evidence.py renders the two measurement panels and annotates trial-one recordings from those data.

To run the renderer, put measurements.json, before-palette.png, after-palette.png and the trial-one raw recordings renamed base-raw.webm/head-raw.webm in one directory, then run `python render-evidence.py <directory>`. The raw recordings are produced by measure.cjs; their paths are saved in its output. Pillow, ffmpeg and DejaVu Sans are required. Uploaded MP4s are excerpts without pairing/startup or element screenshot capture; playback speed is unchanged. Their captions give the actual trial-one RPC measurement, not a video-derived duration.

Both original stills were identical to a second capture 500 ms later. The final panels and recordings were visually inspected before upload.

This proves initial real-client palette status delivery with completed Replay-seeded threads. It does not measure concurrent checkpoint capture, N=10/N=30 direct-driver bursts, full-checkout timings, or the claimed 3-versus-16 processes per warm driver read. It also does not claim the palette's first paint waits for status RPC completion.