From fe91ca2fb669304b3cdfffabdab4269299672936 Mon Sep 17 00:00:00 2001 From: ualtinok <94532+ualtinok@users.noreply.github.com> Date: Tue, 3 Nov 2026 11:56:52 +0100 Subject: [PATCH 1/5] Flake batch 39: a deferred GitHub read fixture gets a 30 s completion wait github_read_restriction_responsiveness waited 1 s for a fixture read that completes on a worker thread, and main's Linux unit run timed out on it under load. The test checks that the read is deferred, not its latency, so this is a positive wait and takes the generous budget. Co-authored-by: alfonso-aft <289616620+alfonso-aft@users.noreply.github.com> --- .../aft-search/slice-descriptors/land-flake-batch-39.json | 8 ++++++++ .../integration/github_read_restriction_responsiveness.rs | 5 ++++- 2 files changed, 12 insertions(+), 1 deletion(-) create mode 100644 benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json diff --git a/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json b/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json new file mode 100644 index 0000000000..0660584a66 --- /dev/null +++ b/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json @@ -0,0 +1,8 @@ +{ + "slice_class": "non_ranking", + "targeted_mechanism": "none", + "kind": "harness", + "fixtures": [ + "harness-goldens" + ] +} diff --git a/crates/aft/tests/integration/github_read_restriction_responsiveness.rs b/crates/aft/tests/integration/github_read_restriction_responsiveness.rs index e4cabff328..da03ff5236 100644 --- a/crates/aft/tests/integration/github_read_restriction_responsiveness.rs +++ b/crates/aft/tests/integration/github_read_restriction_responsiveness.rs @@ -502,7 +502,10 @@ fn complete_deferred(start: GithubReadStart) -> GithubReadCompletion { let GithubReadStart::Deferred(deferred) = start else { panic!("network-bound GitHub read must return a deferred response"); }; - let deadline = Instant::now() + Duration::from_secs(1); + // A positive wait: the fixture read completes on a worker thread, which a + // loaded CI runner can schedule late. What this file checks is that the + // read is deferred at all (the panic above), not how fast it finishes. + let deadline = Instant::now() + Duration::from_secs(30); loop { if let Some(result) = deferred.try_complete() { return result.expect("fixture GitHub read completes"); From 77b412e7b17c38b9e64fb33c0fb082d8a39181e3 Mon Sep 17 00:00:00 2001 From: ualtinok <94532+ualtinok@users.noreply.github.com> Date: Tue, 3 Nov 2026 12:31:52 +0100 Subject: [PATCH 2/5] Flake: give the terminal-mirror stderr test a 30 s positive wait logging::tests::subc_terminal_mirror_does_not_wait_for_stderr waited 1 s for a log line to persist while stderr is held. A loaded Windows runner missed that (run 41624863622). stderr is released only after the wait, so a write that blocked on it still fails the test. Co-authored-by: alfonso-aft <289616620+alfonso-aft@users.noreply.github.com> --- crates/aft/src/logging.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/aft/src/logging.rs b/crates/aft/src/logging.rs index 8dfa880e12..36ec662a87 100644 --- a/crates/aft/src/logging.rs +++ b/crates/aft/src/logging.rs @@ -2882,7 +2882,11 @@ mod tests { let caller = thread::spawn(move || { let _ = done.send(write_terminal_log_sync("held-terminal-stderr-probe")); }); - let result = completed.recv_timeout(Duration::from_secs(1)); + // stderr stays held until after this wait, so a write that + // waited on it would time out here; the budget is generous + // because a loaded Windows runner can take over a second to + // persist the line. + let result = completed.recv_timeout(Duration::from_secs(30)); let _ = release.send(()); holder.join().unwrap(); caller.join().unwrap(); From 305d7dd194b4be8c7e64a75740636105489bfa0e Mon Sep 17 00:00:00 2001 From: ualtinok <94532+ualtinok@users.noreply.github.com> Date: Tue, 3 Nov 2026 12:33:23 +0100 Subject: [PATCH 3/5] Flake: give reads during a database open a 30 s client deadline subc::tests::failed_database_open_refuses_tools_and_rebind_retries_persistence sent its read with a 1 s client deadline; a loaded Windows runner admitted it after the deadline, so it was refused before running (run 41624863622). A read blocked behind the open would still never finish, so the check holds. Co-authored-by: alfonso-aft <289616620+alfonso-aft@users.noreply.github.com> --- crates/aft/src/subc/mod.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/aft/src/subc/mod.rs b/crates/aft/src/subc/mod.rs index 41d4348cc5..dcb48d6131 100644 --- a/crates/aft/src/subc/mod.rs +++ b/crates/aft/src/subc/mod.rs @@ -22898,7 +22898,11 @@ mod tests { } fn assert_read_works_during_database_open(executor: &Arc, fixture: &ConfiguredRoot) { - let body = database_wire_tool(executor, fixture, "read", Duration::from_secs(1)); + // A read waiting on a blocked or failed database open would never + // finish, whatever its deadline; the generous deadline only absorbs + // slow admission on a loaded Windows runner, which at 1 s refused the + // read before it ran. + let body = database_wire_tool(executor, fixture, "read", Duration::from_secs(30)); assert_eq!(body["success"], true, "{body}"); assert!(body.to_string().contains("function_0"), "{body}"); for name in [ From 8addbdc83d73f6e1daa07ac7bd37dbc1b2df4f76 Mon Sep 17 00:00:00 2001 From: ualtinok <94532+ualtinok@users.noreply.github.com> Date: Tue, 3 Nov 2026 13:01:54 +0100 Subject: [PATCH 4/5] Flake: generous waits for a refused backend probe and a consent frame status_names_an_unreachable_backend_before_the_build_reaches_it polled 5 s for the backend verdict; a refused connect on a loaded Windows runner took longer (run 41628184380). The consent fixture's next frame waited 10 s and a loaded macOS runner missed it. Both are positive waits: raised to 30 s. Co-authored-by: alfonso-aft <289616620+alfonso-aft@users.noreply.github.com> --- crates/aft/src/commands/semantic_search/mod.rs | 10 ++++++---- crates/aft/src/subc/consent_speech_end_tests.rs | 4 +++- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/crates/aft/src/commands/semantic_search/mod.rs b/crates/aft/src/commands/semantic_search/mod.rs index aaf9e061f6..3ed3b0fc65 100644 --- a/crates/aft/src/commands/semantic_search/mod.rs +++ b/crates/aft/src/commands/semantic_search/mod.rs @@ -11878,14 +11878,16 @@ mod tests { } /// The backend probe answers on its own thread, so a test repeats the - /// request until the verdict arrives (a refused local connect takes - /// milliseconds) and returns the first reply that carries it, or the last - /// reply after a few seconds so the caller's assertion shows what it got. + /// request until the verdict arrives and returns the first reply that + /// carries it, or the last reply once the deadline passes so the caller's + /// assertion shows what it got. A refused local connect takes milliseconds + /// on Linux and macOS but can take seconds on a loaded Windows runner, so + /// the deadline is generous. fn poll_for_backend_verdict( mut request: impl FnMut() -> serde_json::Value, arrived: impl Fn(&serde_json::Value) -> bool, ) -> serde_json::Value { - let deadline = std::time::Instant::now() + Duration::from_secs(5); + let deadline = std::time::Instant::now() + Duration::from_secs(30); loop { let reply = request(); if arrived(&reply) || std::time::Instant::now() >= deadline { diff --git a/crates/aft/src/subc/consent_speech_end_tests.rs b/crates/aft/src/subc/consent_speech_end_tests.rs index 4f62fb2b50..12faf073ba 100644 --- a/crates/aft/src/subc/consent_speech_end_tests.rs +++ b/crates/aft/src/subc/consent_speech_end_tests.rs @@ -63,7 +63,9 @@ impl ScopeEndControl { } async fn next(&mut self) -> WriterFrame { - let frame = tokio::time::timeout(Duration::from_secs(10), self.frames.recv()) + // A frame the program never sends still fails; the generous wait only + // absorbs a loaded macOS runner, which missed a 10 s budget. + let frame = tokio::time::timeout(Duration::from_secs(30), self.frames.recv()) .await .unwrap() .unwrap(); From 17d919c7a731e1d46aee1967c9969cdd1e057ec6 Mon Sep 17 00:00:00 2001 From: ualtinok <94532+ualtinok@users.noreply.github.com> Date: Tue, 3 Nov 2026 13:12:42 +0100 Subject: [PATCH 5/5] Search descriptor: flake batch 39 touches a fenced test helper only Co-authored-by: alfonso-aft <289616620+alfonso-aft@users.noreply.github.com> --- .../aft-search/slice-descriptors/land-flake-batch-39.json | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json b/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json index 0660584a66..6d3dae3ca1 100644 --- a/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json +++ b/benchmarks/aft-search/slice-descriptors/land-flake-batch-39.json @@ -1,8 +1,9 @@ { - "slice_class": "non_ranking", + "slice_class": "engine_unwired", "targeted_mechanism": "none", "kind": "harness", "fixtures": [ - "harness-goldens" - ] + "crates/aft/tests/integration/tool_call_parity_test.rs" + ], + "note": "Test-only: commands/semantic_search/mod.rs changes only the poll deadline of a #[cfg(test)] helper (poll_for_backend_verdict, 5 s to 30 s). No search code path, ranking input or reply changes, so ranked rows must remain byte-identical." }