5 Commits

Include renames

Author	SHA1	Message	Date
OrcaWin	56874e6006	fix(bench): report counterbalanced WSL Git medians (#13474)	2026-08-29 22:34:03 -07:00
NeilandBrennan	c92f394cde	fix(pty): delete the reply-withholding scheduler (#15578) ... * fix(pty): answer a terminal colour query in its own turn Root-cause follow-up to #15559, which stopped a CPR overtaking a deferred colour reply but left the deferral itself in place. Orca answers terminal queries by writing to the PTY master, which a line discipline in ECHO copies straight back out as junk on a cooked prompt (#12112). The guard was to withhold the write until an `stty` subprocess proved ECHO clear — and forking is what forced the decision to be async. Any deferral, however short, lets a reply written later in the same turn overtake this one, so the async probe was the bug's root cause. Read the bit synchronously instead. Linux and the BSDs redirect a master's mode ioctls to the slave, so a `tcgetattr` on the master fd node-pty already owns answers for the slave with no fork: measured 0.26us against 2403us for the subprocess. With a verdict available inline, a querying program that already cleared ECHO — every raw-mode prober, including the colour probe behind the `gh auth login` report — is answered in its own turn and can never be reordered. The deferral stays for the genuinely cooked case, and the ordering guarantee stays underneath it: hosts whose node-pty predates this patch get no sync probe and fall back to the deferred path, which mixed client/host versions make a live production path. Reply routing is all-or-nothing: a payload needing neither containment nor ordering stays on the host's own path, so a CPR answered during shell startup cannot pass the daemon's post-ready flush gate and splice into the buffered startup command. Native side is fail-safe: a kernel that did not redirect would answer from the master's own termios, whose ECHO defaults set, so the degraded verdict is "echoing" — never a false "quiet". The JS half ships in the pnpm patch while the binding needs a source build, so ORCA_REQUIRE_NODE_PTY_ECHO_STATE=1 makes CI fail rather than silently skip when it is handed an upstream prebuild. Co-authored-by: Brennan <brennanb2025@users.noreply.github.com> * fix(pty): keep the flush ordered under synchronous re-entry Three defects found in external review of the reply-ordering work. node-pty delivers onData inside the master write, so a query can be answered while the queue is mid-flush. `flushPendingWrites` spliced the array off before writing, so that reply saw an empty queue, took the same-turn path, and landed ahead of entries the loop had not written yet — reproduced as 01, 99, 02, 03. It now shifts one entry at a time so a re-entrant reply queues behind the rest, bounded by the length at entry so a re-entrant push cannot spin the loop. An overflow flush can re-enter as far as teardown. `answer` did not re-check `closed` afterwards, so it queued behind a closed delivery, returned true, and the reply was never written and never reported. The payload router's ownership comment overstated its guarantee. The `any` semantics are deliberate — returning false after a constituent was already written would have the caller re-write the whole payload and duplicate it into the child's stdin — so the residual mixed-failure drop is now documented rather than implied away. * fix(pty): delete the reply-withholding scheduler Orca answered a terminal query by withholding the write until a probe proved the slave's ECHO bit was clear. That was the wrong mechanism, and it is now gone: replies are written in the caller's turn and their echo is contained on the output side, where it always was. Withholding never removed an echo. The wait was bounded and always ended in a write, so the output-side projections were doing the work the whole time — including the readline rewrite, which happens with the tty already raw and which therefore no reading of the ECHO bit can predict. What withholding did add was an asynchronous write path, and that is what let one reply overtake another and land in the next program's stdin (#15559), what produced a re-entrancy inversion inside its own flush, and what four rounds of regressions have lived in. The last thing it covered was the verbatim echo of a `stty -echoctl` tty. That shape is now projected directly. It starts with ESC, so it is matched only when complete and never held as a partial: holding it would take a bare trailing ESC from the query parser and an expired hold would release it raw, so a query torn at its own ESC would never be answered. Complete-match-only is what makes the shape safe to project at all. Measured on a real pty: a cooked-mode master write is both echoed AND delivered — ECHO copies the bytes without consuming them from the slave's input queue, so a program arming raw mode with TCSANOW/TCSADRAIN (libuv's setRawMode, hence every Node agent) still reads them. Only a TCSAFLUSH switcher discards it, which it does on every terminal, none of which gates a reply on termios state. Deletes the pending-write queue, the async stty probe, the poll budget and probe rate limit, the deadline-driven flush, and the answer/ answerInOrder split. Replies now leave in call order by construction. No packaging, native or CI surface is touched. * test(pty): restore stty-probe coverage and pin the duplicate-query retry Archaeology on how withholding got here, and what its tests were really protecting. Deleting the ECHO probe took four tests with it that were not about the probe at all: they cover createSttyProbe, which the shell-readiness line-editor probe still uses — in-flight sharing, the per-platform stty flag, and transient-versus-permanent failure latching. Restored against the line-editor probe, which is now their only caller. Also pins the property that answers the one case an immediate write cannot serve. A program that queries while cooked and then arms raw mode with TCSAFLUSH discards the reply with the rest of its input queue. Nothing can prevent that from the terminal side, and no terminal tries. What matters is that such a program re-queries after its own timeout: the ingress declines to answer an already-answered slot but forwards the duplicate downstream, so the renderer's emulator answers the retry, by which point the program is raw. The retry path is the recovery, not withholding. * ci(pty): keep the fish real-PTY test in the shell-contracts lane only Reverting pr.yml to main dropped the exclusion for the fish query-reply test, which this branch keeps, so it would have run in the sharded lane as well. Restores it to the shell-contracts include list and the shard exclude list, and drops the parallelism expectations for the deleted cooked-querier suite and the echo-state env guard. --------- Co-authored-by: Brennan <brennanb2025@users.noreply.github.com>	2026-08-20 02:15:42 -07:00
OrcaWinandOrcaWin	6e8da1df8d	fix(wsl): pass guest argv verbatim through --exec (#15039) ... * fix(wsl): pass guest argv verbatim through --exec `wsl.exe <...> -- <argv>` expands `$name` in every argument against the guest environment before the guest ever runs. It does this even when no shell is involved, so `-- /usr/bin/printf %s '$HOME'` prints /home/you. Every WSL invocation went through that preprocessor, so scripts arrived already rewritten: `awk '{print $2}'` lost its field reference, and a POSIX script asking for the literal `$HOME` got the expanded path. `escapeWslShCommandForWindows` tried to compensate by escaping `$`, but it skipped any `$` preceded by a backslash, so a script containing `\$` was still corrupted -- and half the call sites never applied it at all. Route every invocation through `--exec`, which passes argv through untouched, and delete the escaper. The direct-git path already used `--exec`, so this is not a new compatibility dependency. A guard test fails if the `--` form reappears anywhere in the tree. Net -50 lines of production code. * test(wsl): drop remaining escaped-dollar assertions * fix(wsl): cover the --exec migration's blind spots An audit of every wsl.exe invocation found sites the first pass missed, including two it actively broke: - config/scripts/wsl-git-shell-benchmark.mjs imported escapeWslShCommandForWindows, which no longer exists, so the script threw on startup. Its wslShellArgs helper also still used `--`; the file already had an --exec helper, so route both call sites there. - classifySubprocessCommand unwrapped `wsl.exe <...> -- <binary>` by breaking on `--` alone. With every Orca spawn now on --exec it never found the guest binary and bucketed all WSL subprocesses as plain "wsl", losing the git/gh/glab breakdown. Break on either separator, since foreign wsl.exe processes still use `--`. CliSkillRuntimeSetup builds its setup command as a template literal rather than an argv array, so no array-shaped search could see it. Its decoder accepts both separators so commands persisted before this change still decode. The guard now scans config/ and tests/ as well as src/, and checks the command-string spelling alongside the argv one — the two shapes that have each shipped a regression. It skips comment lines so prose about the old form stays allowed, and asserts it scanned a plausible file count so a bad root cannot make it vacuous. * fix(wsl): restore the guard's multi-line sensitivity The guard matched line by line, so `'--',\s*'bash'` could not span a newline -- and every argv array in this repo is formatted one element per line, which is exactly the shape it exists to catch. Measured against the pre-migration tree it caught 17 files before and 9 fewer after. It now strips comment lines and matches the rejoined text, with a case that pins the multi-line shape so this cannot silently return. The program list is wider than shells now, which surfaced a false positive: tmux takes a `--` separator followed by a program too (`split-window ... -- cat`). Matching is scoped to files that mention WSL rather than narrowing the list back. Also: - Replaced the `sed` regression case, which was vacuous. A backreference contains no `$`, so it returned `bac` under both separators and would have passed without the fix. The block claimed every case proved the bug. Swapped in a positional argument and a shell local, both measured to differ -- the positional is the shape `wslUncDirectoryExists` uses, where `--` blanked `$1` so every existing directory probed as missing. - windows-shell-args.test.ts derived its expected argv from buildWslExecArgs, the helper under test, so six assertions would still pass if it regressed to `--`. Spelled the expectation out. - Dropped two comments citing the removed `--` behavior as rationale. --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>	2026-08-18 02:12:21 -07:00
Neil	991a3fe963	chore(lint): update oxlint to 1.77 and enable no-op cleanup rules (#13901) ... Enable eleven oxlint rules that simplify code without changing behavior, and fix every existing violation. Each candidate was gated on measured cost rather than assumption, so rules that regressed runtime performance or type checking were dropped instead of suppressed. typescript/no-redundant-type-constituents is the largest addition: 113 sites, no autofix. Dead constituents are deleted. Where the redundant literal existed to document intent (`string | 'all'`), it is preserved as `(string & {})`, which keeps the autocomplete hint the original code was reaching for instead of flattening it away. The rule also caught a broken import — remote-shared-control-retirement-probe.ts pulled RuntimeStatus from src/shared/types, which does not export it, so the type silently degraded to `any`; no tsconfig covers that file, so tsc never saw it. oxlint stays at 1.77.0 rather than 1.78.0 because .npmrc sets minimum-release-age=4320 and 1.78.0 is younger than that window. Rules evaluated and rejected, with what disqualified each: - prefer-string-raw: String.raw is a runtime call, not a literal (184x slower) - prefer-string-replace-all: 26% slower - text-encoding-identifier-case: ~5% slower, reproducible - prefer-spread: [...str] is 110% slower than split('') and differs on surrogates - no-implicit-coercion: `!!x` narrows types and `Boolean(x)` does not (22 tsc errors) - prefer-arrow-callback: arrows are not constructible, breaking `new` on mocks - object-shorthand: rewrites source text asserted by a tracked reliability gate - switch-case-braces: pushes ten files past max-lines, which cannot be suppressed - no-useless-switch-case: drops `case undefined:` that switch-exhaustiveness-check needs - arrow-body-style: 115 violations have no fix, and it breaks max-lines - newline-after-import: false-positives on the leading-semicolon ASI idiom electron-vite-output-contract asserted on the literal Object.prototype.hasOwnProperty.call text; retarget it to Object.hasOwn, which rejects inherited keys identically.	2026-08-11 18:19:43 -07:00
OrcaWin	69ca0154b6	fix(git): bypass WSL login shells for status reads (#13207)	2026-08-09 14:41:40 -07:00