Repository navigation
perf: send the same small request on every install and in a long chat - #35756
Conversation
Code change approver recommendation: A person should decideWhy: the decider thinks the change is probably fine but estimates a 20% chance that this change introduces a defect, above the 12% limit for approving on its own. Two changes. (1) Kiro Crew's own MCP servers can now defer under Tool Search when kiro-cli comes from KIROCREW_KIRO_BIN or is found only on PATH. The override uses main's existing sandboxed version read for the pin; the PATH install is read in the background under strict mode with require_crew_sandbox and a credential-free environment. Every unknown answer keeps the full list, and a tools-list refusal turns deferral off for the rest of the process, with warm-pool processes started before it discarded at claim. (2) The [REPLY FORMAT RULES] block is bound to the existing EssentialDelivery, so it is taken out at the wire only after this conversation (same identity, epoch and text) acknowledged it on a completed turn. Every existing reset path (compaction or clear frames, /compact, /clear, cancel, start, new incarnation, stale-compaction readers) re-arms it, and a bind forced on needs_reinjection covers compactions in agent-started turns. Harnesses outside the set and providers that do not say keep the block on every message. The edge cases I traced only remove text the same conversation already acknowledged, and the trust boundary holds. Tests are thorough. The main issue is descripti An automated recommendation, not a review: a maintainer still decides. It approves on its own only when the estimated chance of a defect is at most 12% and the change has at most 400 changed lines. Decider v3c (217fe607) · commit |
5cc331e to
049f0fa
Compare
GPT 6.1 Review — ✅ no blocking findingsGPT 6.1 completed its review of This comment is updated in place on each push. Review detailsNo findings. False positive or not applicable? A repository writer can comment: |
UX Review (Opus 5.5) — ⏭️ skippedRevision |
Design Review (Opus 5.5) — ✅ PASSDesign-level review of Design-Verdict: PASS Nothing blocks: both savings reuse seams that already exist (the Notes
[DESIGN-REVIEWED] 3a5eb31 Description read[DESCRIPTION-READ] 6efb779ca977b155913f3e50c0b52a11fc0b55a122f65cb6949603bd7a1878e2 That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
First Principles Review (Opus 5.5) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Nothing blocks. One note: Notes
What this change shipsInventory (8 items) — 7 justifiedIntent: Make every kiro-cli install send the small tool list, and stop resending the reply-format rules every turn. This is an ADDITION (perf).
[FIRST-PRINCIPLES-REVIEWED] 3a5eb31 Description read[DESCRIPTION-READ] aba4a62399b131f61d5cb10258e2746793539a84827bdb41fd611f7d47acac38 That sha256 names the PR description this verdict read. Recompute it with |
Opus 5.5 Review — ✅ no blocking findingsReviewed Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
049f0fa to
7fa08e4
Compare
7fa08e4 to
44c9737
Compare
|
Rebased: main moved in config-baseline.json, docs/architecture/mcp.md, docs/system-specs/modules/memory-skills-hooks.md, docs/system-specs/modules/metrics.md and src/kiro_crew/docs/configuration.md since this head went green (169429f -> 9ef0fc4); CI re-running. The previous head
|
|
Disposition for
Every required check is green on this head, every review lane is PASS, |
KiroCrewCaptain
left a comment
There was a problem hiding this comment.
Thanks. The change itself looks careful, but one test it adds breaks once it is merged with current main.
test/test_tool_deferral_install_shapes.py:225(TestOperatorOverride::test_a_replaced_override_is_judged_by_its_new_version). The test patcheskiro_cli.subprocess.run. #35731 landed on main after this branch's merge-base. It removedimport subprocessfromkiro_cli.py, andkiro_cli_version_atnow reads the version throughkiro_cli._sandboxed_probe. The textual merge is clean. On the merged tree this test fails withAttributeError: module 'kiro_crew.kiro_cli' has no attribute 'subprocess', so merging this head as it is would turn main red. Even if that name were still there, the stub would never run, soruns == [[binary, "--version"]]could not hold. The green readiness on this head comes from before #35731. Smallest fix: rebase on main, then stubkiro_cli._sandboxed_probethe way main's own tests do (for exampletest/test_kas_permissions.py). Make it return an okProcessResultwithkiro-cli 3.2.1, then2.20.0, and assert one probe per file identity.
Optional:
- While you rebase: the new paragraph in
docs/system-specs/modules/security.md(around line 4270), thekiro_cli_path_probe.pymodule docstring and the version-read table in the body all say the pinned andKIROCREW_KIRO_BINread runs outside the sandbox. Since #35731 that read is sandboxed, so these lines would describe a trust boundary wrongly. kiro_cli_path_probe._probe_and_recordcachesNoneon a timeout or a failed wrap. One slow read at boot then keeps the full tool list until the file changes or the gateway restarts. Main'skiro_cli_version_atdeliberately does not cache a sandbox failure. You could cache only a parsed version or a clean non-zero exit.- Deleting
self._reply_format_pending.pop(key, None)indelivery_records.py:347still leaves every test green. The sequence send (not settled), then a non-interactive send, then land, then an interactive send that must still carry the rules would pin it.
44c9737 to
0930fd0
Compare
KiroCrewCaptain
left a comment
There was a problem hiding this comment.
Thanks. Both earlier change requests are resolved on this head, but the new reply-format record has one runtime gap.
Earlier reviews:
44c97375, thekiro_cli.subprocess.runstub: fixed (it now stubskiro_cli._sandboxed_probe).00f25eb5, the record kept on harnesses that compact silently: fixed. The record is now kept only onACP_BACKENDS_COMPACTION_REPORTED, and the table test covers every selectable harness.00f25eb5optional items (stubwarm, pin the boot hook'swarm()call, the two stale comments): all fixed.
context_assembly/delivery_records.py:364(_reply_format_due, gated atcontext_assembly/turn_message.py:975). On the kiro backend,/clearis not answered locally: kiro is not inACP_BACKENDS_LOCAL_CLEAR, so the Kiro CLI runs the clear in the same ACP session. The confirmed frame reachesdashboard/chat_turn/session_events.py:165(_on_clear_status). That handler clears the slot, the replay lease and the first-turn history debt. It never callsmark_needs_reinjectionand never drops the builder's reply-format record. On the next ordinary turn,is_new_session,needs_reinjectionandconversation_resetare all False and the digest still matches, so the[REPLY FORMAT RULES]block (the[OPTIONS:]format and the ask_question, suggest_followup and card guidance) is left out. The engine conversation that held the rules was just wiped, so the cleared chat goes without them until a compaction, a new session or a rules change. On main the block rides every message. For an agent withincludeCrewContext: falsethis block is the only source of the[OPTIONS:]rule. The sent-image record already forgets on this same clear frame (_forget_sent_images()), andessential_delivery.pytreats a clear as invalidating.test/test_reply_format_once.pyhas no clear case. Smallest fix: when a clear the session owns is confirmed, drop that session's_reply_format_sentand_reply_format_pendingentries, or armmark_needs_reinjectionin_on_clear_status. Add a test: a turn lands, a native clear arrives, and the next warm build must carry the block. The test should fail without the fix.
Optional:
test/conftest.py:657stubs_sandboxed_version,_versions,_in_flightandwarm, but notkiro_cli_path_probe.version_if_known. On a host where kiro-cli is found only on PATH, a test that reachesmandatory_mcps_drop_allowedcan still start a real probe thread that outlives the test. Stubbing it in the same fixture would close that.- The
reports_compaction ... is Trueguard inturn_message.pyhas no mutation pin. Adding a provider whose attribute is a truthy non-bool (for example aMagicMock) to the parametrize intest_a_harness_that_is_not_known_gets_the_block_every_timewould catch a loosening tobool(...). - The body's table says the pinned install is "unchanged", but the process-wide tools-list refusal latch also applies to it. One line in the description would say so.
fd405f3 to
8183e97
Compare
|
Round 9, head The finding is right. A confirmed native clear empties the engine conversation, and nothing reset the builder's "the rules were sent" record. It is also the third finding of one kind on this PR: a second record of what a conversation holds goes stale whenever the conversation loses it and the builder is not told. So the record is removed instead of being given one more reset. What changed in the second commit.
The test asked for. The optional points.
Also in this push. On Windows the Measured (Linux, kiro-cli 3.2.1, 3 chats of 5 turns, engine request dumps, on this branch at CI on this head so far. |
Kiro Crew's own MCP servers deferred under Tool Search only on the pinned kiro-cli install. An install found through PATH only, or named by KIROCREW_KIRO_BIN, kept all of them resident: 125 tools and 243k characters per request against 15 and 93k. The decision is now made on the file the session is about to run. An absolute override is the pin, so it takes the answer the pin's version read already gives. A PATH file may sit in a directory an agent writes to, so its version is read inside the strict sandbox, through the readiness probe's own bounded runner, in the background, and never waited for; no answer keeps the servers resident, and only the file's own answer is cached, so a read that did not run or was cut off is asked again. Neither derives a sibling, so a POSIX launcher below 3.0.0 stays resident. The floor is measured, so a refusal above it is remembered: after the first request refused for a changed tools list, every spawn in the process sends the full list, and the rebuilt conversation starts on it.
build_message appended the [REPLY FORMAT RULES] block to every message, 1,347 characters each time, although the engine replays its own history and already holds it. The built message is unchanged: it still carries the block. On a turn with no member essentials, build_message now binds the block as the provider's delivery envelope (EssentialDelivery, the send-once writer the essentials already use), and the provider takes it out of the prompt at the wire while this conversation has acknowledged it. There is no second record: the delivery is the one place that knows when a conversation may have lost what it was sent (a start, a reload, a clear, a compaction, an agent switch, a cancel, a failed turn, another conversation), and it decides at the send. The bind is forced for the one event the delivery cannot see, a compaction in a turn the agent started by itself, which reaches only the session's re-injection flag. That rests on Kiro Crew hearing of every compaction, so the block is bound only on a harness whose compaction it sees: kiro, kas, codex and claude, the set the sent-picture record uses, read from the turn's provider. On every other harness, when the harness is not known, and on a member turn, whose essentials take the delivery's one envelope, the block goes out on every message as before.
8183e97 to
3a5eb31
Compare
|
Rebased: head Two things differ from
Checked on the rebased tree: the reply-format block that is bound as the delivery envelope is still byte-equal to the block in the built message with #35722's new |
Problem / Motivation
Goal: Kiro Crew sends the same small request on every install and keeps it small in a long chat.
Two things make a request bigger than it needs to be, and both ride on every request.
PATHonly, or is named byKIROCREW_KIRO_BIN, all of Kiro Crew's own tools stay in every request: 125 tools and 243,046 characters against 15 tools and 93,174 on a standard install.[REPLY FORMAT RULES]block is appended to every message, 1,347 characters each time, although the engine replays its own history and already holds it.Why it matters
The first costs about 54k tokens on every request of every session on such an install: a request 2.6 times as big, paid in model time and in credits.
KIROCREW_KIRO_BINis what Kiro Crew's own note tells aPATH-only install to set, so following the advice does not help today.The second makes every chat grow twice as fast as it has to. A short turn adds about 2,550 characters of history, of which more than half is the repeated block.
Not a goal
[REPLY FORMAT RULES]marker, the[RUNTIME]and[PROJECT]blocks, or the agent's system prompt.What changed (motivation → approach → change)
1. Every install gets the small request. Kiro Crew's own tools now stay out of the request (17 tools instead of 128) when kiro-cli is named by
KIROCREW_KIRO_BINor found only onPATH, not just on the pinned install. The decision is made on the file the session is about to run (src/kiro_crew/kiro_cli.py,mandatory_mcps_drop_allowed).The rule exists because an engine below 2.27.0 can refuse a request whose tools list changed under a signed thinking block. The version of the file the session runs answers that for every install:
kiro-cli-chatKIROCREW_KIRO_BINPATHNeither new shape derives a sibling, so a POSIX
kiro-clibelow 3.0.0, a launcher, stays resident there.A
PATHfile can sit in a directory an agent writes to, so one rule governs its read (src/kiro_crew/kiro_cli_path_probe.py): the probe never has more reach than the session's own launch of the same file. It runs through the readiness probe's own runner for an unverified candidate (kiro_prerequisite._run_process): the existing chokepoint,sandboxed_spawn_argv(mode="strict"), behind the systemenventry, with that probe's credential-free environment, its output captured up to the runner's 64 KB bound and its process tree ended on a timeout. One opt-in keyword on that runner,require_crew_sandbox(default off; no existing caller passes it), refuses the spawn with no child started when the wrap did not put it in Kiro Crew's own sandbox. It is not run on Windows, which has no sandbox backend. It is never waited for: it starts at gateway boot (src/kiro_crew/slack/gateway_runtime/process_entry.py) and on a spawn's first miss. Only the file's own answer is cached, by path and mtime: a read that did not run or was cut off (a timeout, a sandbox that could not be built, more output than the bound) is not kept, so the next spawn asks again. Every failure and every missing answer keeps the full list.The floor is measured, so a refusal above it is handled. The first request refused for a changed tools list on a kiro-cli backend is remembered for the life of the process. From then on every spawn keeps Kiro Crew's servers resident, on the pinned install too (the one way the table's first row changes), a warm-pool process started earlier is discarded at claim (
src/kiro_crew/session_pool.py), and the dashboard's existing one-time rebuild of the refused conversation starts on the full list. The refusal's wording is read inacp/thinking_binding_errors.py, moved whole out oftransport_errors.py, which was at the 2,000-line cap.2. A chat grows half as fast, on the harnesses whose compaction Kiro Crew sees. There the engine is sent the reply-format rules once per conversation instead of with every message. The built message does not change: it still carries the block, as on main. On a turn with no member essentials,
build_messagebinds the block as the provider's delivery envelope (EssentialDelivery, the send-once writer the member essentials already use), and the provider takes the block out of the prompt at the wire while this conversation has acknowledged it (context_assembly/turn_message.py: 42 added lines, no changed line;essential_delivery.pyand every provider stream are untouched).There is no second record of what was sent. The delivery is the one place that knows when a conversation may have lost it, and it decides at the send:
startinvalidates; a new provider has a new delivery/clear,/compact, a compaction Kiro Crew starts, a cancelThe bind is forced for that last event only, the one the delivery cannot see: such a turn is read without sending a prompt, so no delivery stream sees its compaction; it reaches only the session's re-injection flag, which the builder is handed. A new session is not forced, because the delivery sees it.
The first row of the first table is main's own set for the same question,
ACP_BACKENDS_SENT_IMAGE_RECORD, under the name of what it means,ACP_BACKENDS_COMPACTION_REPORTED(one list, defined from it): the harnesses whose compaction, started by Kiro Crew or by the harness itself, sends a frame this client reads. The builder asks the turn's provider (LLMProvider.reports_compaction, False unless the harness is in the set). opencode, goose and pi compact on their own and send nothing Kiro Crew reads, so they keep the block on every message.Limit. A chat with a crew member is unchanged by this PR: the delivery holds one envelope and the member's essentials take it, so every prompt there still carries the 1,347-character block. A second envelope slot in the delivery is the follow-up that would cover it. The sizes below are for a chat with no member.
Specs, operator help and the packaged guides say the same:
docs/architecture/mcp.mdandcontext-management.md, six files underdocs/system-specs/modules/(harness-parity.mdandproviders.mdamong them),config/sections_agent.py,config-baseline.json, andconfiguration.md,coming-from-kiro-cli.mdandfollowup-suggestions.mdundersrc/kiro_crew/docs/.Sensitive change review
This diff touches none of the paths the Sensitive Change Review gate watches, and it changes a rule that sits beside the install-trust boundary, so the template is filled in here and the change waits for a sign-off from a maintainer who is not the author.
The choice, in two lines: a
PATH-only kiro-cli is version-checked only inside the strict sandbox, never outside it, and never waited for; an override takes the answer the pin's own read already gives, which on main runs inside the sandbox at the configured tier. Anything that cannot be answered that way keeps today's full tool list.--versionread of aPATH-only kiro-cli; and one opt-in keyword on the readiness runner (_run_process(require_crew_sandbox=True)), which only refuses a spawn and changes nothing the sandbox seals, masks or wraps.PATH-only install can too, each judged by its own version; a refusal turns deferral off for the process.test_kiro_cli_path_probe.py; no credential or proxy variable reaches it; a wrap outside Kiro Crew's sandbox is refused before any spawn, on POSIX and on Windows, and the default path still spawns (test_kiro_prerequisite_process.py, red with the check removed); a planted file that prints four times the bound keeps 64 KB in the gateway and one that prints without end is cut off and its process group ended, both "unknown" and not cached; aPATHfile is never read on the pin's route (test_tool_deferral_install_shapes.py). No other read of, or wait on, a child is in this diff.ASBX_KIRO_MANDATORY_MCPSbehave as before; nothing main accepts is refused.a0e61957c7, this branch before its last rebase onto main (the two commits are patch-identical to the pushed ones), 11,761 tests pass across 163 named test files: this PR's own, their neighbours, every test file of the readiness runner and of its other callers, the harness-parity, backend-card and provider tests, and every test file that keeps a frozen inventory or contract of a module this PR touches. Five more could not pass on the test host: main's own intest_kas_cli_floor.pyneedsos.pidfd_open, which that host's Python lacks, and four (test_harness_parity.py::test_is_kiro_cli_is_positiveand three intest_acp_copilot_backend.py) are refused with the same message because that host's home holds a.mcp.json; the first of those four was run on main's tree there and fails the same way. Two tests that pinned "an override never defers" pin the new rule.ASBX_KIRO_MANDATORY_MCPSin the gateway's environment, which every spawn honours before any version check.Environment handed to the read on Linux, by name:
DBUS_SESSION_BUS_ADDRESS,HOME,LANG,LC_ALL,LOGNAME,NO_COLOR,PATH,TEMP,TERM,TMP,TMPDIR,USER,XDG_RUNTIME_DIR.mode="strict"does for this readenventry keeps a file namedkiro-clioff the path that delegates to the harness's own sandboxPATH-only install keeps the full list;KIROCREW_KIRO_BINis the way to the small request thereVerified here: everything above, on Linux. Not verified here: the wall time of the sandboxed read on a real gateway (a gateway started from inside an agent session is itself sandboxed, so the read declines there and the full list is kept; the gateway logs the time of each read), the read under the macOS sandbox, a live refusal on an engine above the floor (none could be produced on 3.2.1; the test feeds the provider's own wording), and the
chat_runtime_sharingpreview, where a rebuilt conversation can still land on a shared process that started before the refusal.Backwards compatibility
Compatible: no accepted input is refused, renamed or removed. An install that kept Kiro Crew's tools resident may now defer them, which the engine already does for every other server and for the pinned install; an operator's
ASBX_KIRO_MANDATORY_MCPSstill decides before anything else.Removes nothing: the reply-format rules are still delivered to every engine conversation, and every built message still carries them. On kiro, kas, codex and claude, in a chat with no member, the engine is sent them once instead of on every message, and again whenever the conversation may not hold them; on every other harness and in a chat with a crew member they are sent on every message, as before.
Tests
test/test_tool_deferral_install_shapes.py: each install shape (override new, old, unreadable, a 2.x launcher, another file spawned, an override that is not the pin, a replaced override, read once per file identity through main's sandboxed probe;PATH-only new, old, not answered yet, a 2.x launcher, a file the resolver did not choose, a file changed between read and spawn; no install); the provider's refusal is typed and remembered on both kiro backends and the next spawn names every Kiro Crew server; any other refusal and another harness's refusal are not remembered; a warm-pool process started before the refusal is discarded at claim.test/test_kiro_cli_path_probe.py: a miss answers "unknown" at once and starts one background read; the read goes through the readiness runner with one file, strict mode,require_crew_sandboxand the allowlisted environment; a non-zero exit, an unparsable line and Windows answer "unknown" and that answer is kept; a spawn refused for not being in Kiro Crew's sandbox, a missing wrapper, a timeout, a wrapper ended by a signal, a sandbox refusal and output at the bound leave no answer, so the next caller asks again (on Linux the launcher reports a file a signal killed as exit 1, so that one run is kept as "no version"); through the real runner, a planted file that prints past the bound and one that prints without end; a replaced file is read again; on Windows the log line says nothing was run and names no sandbox.test/test_kiro_prerequisite_process.py:require_crew_sandboxrefuses an unconfined wrap before any spawn and removes the wrap's launcher, refuses on Windows where the wrap is skipped, lets a spawn inside Kiro Crew's sandbox through, and the default still runs the spawn it ran before.test/test_acp_tool_search_spawn_env.py: the two tests of the override are rewritten to the new rule; the pinned-install cases are untouched and pass.test/test_reply_format_once.py: every assertion reads the prompt the transport was handed, through the realAcpProviderandAcpSessionProvider. Sent once and not again; the prompt without the block is the built message minus the block; a turn that did not complete (cancelled, no answer, cut off, raised) sends it again; changed rules send it again. A table of every event that can drop what a conversation was sent, 22 rows over both providers (a compaction seen on the stream, a native clear, an agent change,/compact,/clear, a compaction Kiro Crew starts, a cancel, a start, a reload, a fresh conversation, a replaced process, another engine session): the next prompt carries the rules and the one after does not. Acknowledged, then/clear: it comes back. A compaction in a turn the agent started: forced. A new-session flag alone: not sent again. A table over every selectable harness on both providers: in the set once, outside it every message. A provider that does not say, one with no delivery, one whose answer is truthy and notTrue, no provider, and one that cannot name its conversation: every message, and the build does not fail. A member turn, with essentials and with none built: every message, while its essentials are still sent once. The marker scrub neutralizes a forged marker with and without the block, and the same text typed by the person is left in the prompt.test/test_acp_bindings.py: the frozen inventory of the ACP provider's members lists the newreports_compactionproperty.test/spawn_audit_helpers.pylists the read where the other two drivers of the readiness runner are listed: it creates no process itself, the runner does;test/conftest.pystarts every test with no refusal on record and no probe answer, and with the boot hook's warm-up of the read turned off, so a test that boots a gateway starts no probe thread; one test pins that the boot hook calls that warm-up.Determinism: the new tests use no sleep, no real thread (the probe's thread is replaced by a recorder that runs it on demand), no network and no real subprocess; the cut-off test allows the read no time at all, so it does not wait on the clock.
python -m pytest -n0 test/test_flake_pattern_ratchet.pypasses. The five new and changed test files passed 20 runs at-n0, 10 runs at-n 4 --dist loadgroup --max-worker-restart=2beside two sibling files, and one shuffled order (seed 35741), last run on8183e978e5, the head before this one; the test files have not changed since.Manual verification
Linux, kiro-cli 3.2.1 with its v3 engine (3.2.1), model
claude-fable-5.2, sizes from the engine's own request dumps. Not timed runs. The three reply-format rows are from a default install, which runs kiro-cli's v3 engine (thekasbackend), a harness in the set above; a harness outside it sends what it sent before.KIROCREW_KIRO_BINset: tools (both backends)KIROCREW_KIRO_BINset: characters (both backends)The format check is the one rule the block carries that a script can judge: a reply that offers choices ends with exactly one
[OPTIONS: a | b | c]line, as the last line. It held on every turn with the block sent once, so no periodic re-send was added.The second commit was rebuilt after those runs (the block now stays in the built message and is taken out at the wire), so the request sizes were taken again, on this branch at
c23ab178a8against the head before it,fd405f3973: 3 chats of 5 turns each, same engine and model. The pushed head differs fromc23ab178a8in comments, docs, tests, one Windows log line, one import moved to the top of its module, and main's own commits.fd405f3973: message characters / carries the blockc23ab178a8: message characters / carries the blockfd405f3973: whole request, medianc23ab178a8: whole request, medianThe three chats of each build agree to the character on the message. The block rode 1 of 5 requests in every chat on both, and the reply format was kept on 15 of 15 turns on both. The 122 characters on turn 1 are session-start context: the two checkouts' own paths, the minute, and the 32 commits of main between the two.
MCP smoke test (each case a real tool call whose result is checked), cases 1 (a fast server's tool on the first prompt), 10 (Tool Search off) and 12 (Kiro Crew's own tools: the same names listed, one call of each server answers):
KIROCREW_KIRO_BINKIROCREW_KIRO_BINBefore is
mainat610c8616bf; after is this branch at855b6409b9, its first complete build. The first table and the smoke runs were not taken again after the rebases; since then the branch gained main's sandboxed read of the pinned install (#35731), the rule that a cut-offPATHread is not kept, and thePATHread's move onto the readiness runner. Case 12 lists the same tool names before and after in every row. One sample is not in the table: case 10 on the pinned shape with the default backend failed once after the change (the stand-in server that starts 25 s late never became callable in that run, on a path this change does not touch) and passed when that case was run again; both results are kept with the run.PATH-only is not in the table: the test gateway is started from inside a sandboxed session, where the read declines by design and the full list is kept, as before.Still required from someone with those machines: the smoke test and one
PATH-only start on macOS, and the smoke test on Windows.Related Issues
Closes #35741
Checklist
feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)