fix(fpga): record the dry-run sweep's success in the flag its verdict reads (Closes #2304)

[gHashTag]

Closes #2304.

The build check had two causes; #2303 fixed one

#2303 correctly fixed the yosys ordering bug and the cli-tri build check stayed red. That is not a regression and not a second ordering bug — the job had two independent causes, and only one of them lived in the YAML.

In cli/tri/src/fpga.rs, dry_run_sweep_ok had exactly two mentions in the whole file:

6098:    let mut dry_run_sweep_ok = false;
6333:        && dry_run_sweep_ok

Declared false, read in the passed conjunction, never assigned true. The dry-run CCLK sweep runs, succeeds, and prints its OK line — but nothing recorded that it had, so smoke_gate() returned passed: false for every possible input.

The sibling flags survive this by being read guarded: (!run_verify_lean || verify_lean_ok) is vacuously true when the caller does not request that phase. && dry_run_sweep_ok is unguarded and has no such escape, so it failed the gate unconditionally.

Evidence — the post-#2303 master run names it by elimination

Run 32352361519, job 96374085002: every phase reports success, verdict still false.

[smoke-gate] dry-run sweep report OK (8 variants)
[smoke-gate] verify-lean OK (source=synthetic, theorems present)
[smoke-gate] yosys synthesis OK
[smoke-gate] complete (passed: false)

thread 'fpga::tests::test_smoke_gate_json_synthetic_verify_lean' panicked at cli/tri/src/fpga.rs:9977:9:
smoke-gate synthetic verify-lean path failed: Err(smoke-gate did not pass all phases)

test result: FAILED. 155 passed; 1 failed; 0 ignored

yosys synthesis OK is #2303 working as intended. With bit_config_result ok, verify_lean_ok true, theorem_matrix_ok a hardcoded true, and the validate_lean_standalone conjunct guarded off, dry_run_sweep_ok is the only remaining false term — and that one test is the only failure in the job.

The compiler had been printing the signature for all 12 runs:

warning: variable does not need to be mutable
    --> cli/tri/src/fpga.rs:6098:9
6098 |     let mut dry_run_sweep_ok = false;
     |         ----^^^^^^^^^^^^^^^^ help: remove this `mut`

Warnings are not denied in this job, so it never turned the build red on its own.

The fix mirrors verify_lean_ok; it is not a new pattern

Line 6167 already documents this exact defect for verify_lean_ok — it "stayed a declaration nothing ever set", restored from 494e659d8 after the #2228 batch merge dropped seven definitions. dry_run_sweep_ok went out in that same merge and was missed on that pass.

verify_lean_ok establishes success like this (6252-6267): bail on failure, then set the flag, then write the report entry, then print the OK line. This change places the identical three-step sequence at the sweep's own success point — after the variant-count bail, before its OK line, inside if bit_path.is_file():

dry_run_sweep_ok = true;
report["dry_run_sweep"] = serde_json::json!({
    "status": "ok",
    "variants": variant_count,
    "bitstream": bit_path.to_string_lossy().to_string(),
    "report_file": dry_report.to_string_lossy().to_string(),
});
println!("[smoke-gate] dry-run sweep report OK ({} variants)", variant_count);

The report entry is part of the fix, not extra scope. report["dry_run_sweep"] was written only on failure (6148); on success it kept the null from its initializer at 5967. Setting the flag alone would have moved the failure down two assertions instead of fixing it — the test walks ["bit_config", "dry_run_sweep", "verify_lean"] and requires each to be an object with status: "ok". Mirroring verify_lean supplies both halves because verify_lean sets flag and report together.

mut on 6098 stays, because the variable is now genuinely mutated.

Not compiled — and exactly what that leaves unverified

This was not compiled and no test was run locally. The authoring machine had ~148 MB of disk free, which is not enough to check out the repository or run cargo. The change was written and reviewed against origin/master through the GitHub contents API. Nothing below should be read as a claim that it was tested — CI is the first real compile, and it may find something this review could not.

What was verified, and how:

• Three mentions instead of two — dry_run_sweep_ok now appears at 6098 (declaration), 6160 (assignment), 6340 (the unchanged conjunction).
• Placement mirrors verify_lean_ok — both sit after their phase's bail and before their OK line, in flag-then-report order, inside the block that established success. The assignment stays inside if bit_path.is_file(), so a missing bitstream still yields dry_run_sweep: null and passed: false, matching the hand-built missing_bitstream_snapshot fixture.
• Both values are in scope — dry_report is bound at 6139, variant_count at 6143.
• The schema guard cannot trip — dry_run_sweep is an existing Option<serde_json::Value> field on SmokeGateReport; deny_unknown_fields applies to top-level keys only, and the nested object is free-form.
• Neither snapshot test is disturbed — check_smoke_gate_snapshot does a strict assert_eq! but has exactly one caller, fed a hand-built literal rather than live gate output; the other comparison, assert_report_superset, tolerates added fields by construction.
• The diff is a pure 7-line addition to fpga.rs, zero deletions.

What was deliberately not done

Deleting && dry_run_sweep_ok would have turned this check green in one keystroke by making the verdict verify less. That is the absence-is-not-a-value failure closed in #2285, #2287, and again in #2302's own note that a gate may not treat "I could not look" as "I looked and it was fine". The conjunction is unchanged and no phase was dropped. build was not added to the required contexts either.

Known follow-up, filed not fixed

validate_lean_standalone_ok (6100) has the same two-mention shape, and worse: the entire validate_lean_standalone phase body is absent from smoke_gate(), so the flag has no success point to attach to and cannot be repaired by mirroring. It is masked today only because its conjunct is guarded and both of its tests return early when lake is not on PATH. It will bite the moment a runner has lake. Out of scope here.

Note that build is not a required context, so this PR can merge before build finishes — as happened with #2303. The build run on the resulting master push is the actual verdict on this change, and will be reported.

[github-actions]

PR Dashboard

Generated at: 2026-08-20 09:22:51 UTC

• fix(fpga): record the dry-run sweep's success in the flag its verdict reads (Closes #2304) #2305 fix(fpga): record the dry-run sweep's success in the flag its verdict reads (Closes #2304) | Created: 2026-08-20 | Updated: 2026-08-20 | 16 failing / 25 total
• fix(ci): one NOW entry per file, and retire merge=union #2298 fix(ci): one NOW entry per file, and retire merge=union | Created: 2026-08-20 | Updated: 2026-08-20 | 6 failing / 34 total
• ci: eleven merge-critical gates were silent on stacked PRs #2169 ci: eleven merge-critical gates were silent on stacked PRs | Created: 2026-08-14 | Updated: 2026-08-14 | 5 failing / 30 total
• corpus: freeze the damage, patch one class at a time, and say where one rule stops #2161 corpus: freeze the damage, patch one class at a time, and say where one rule stops | Created: 2026-08-14 | Updated: 2026-08-20 | 0 failing / 9 total
• tri triage: five ordered classes, and blocked is tested before actionable (#2156) #2157 tri triage: five ordered classes, and blocked is tested before actionable (#2156) | Created: 2026-08-14 | Updated: 2026-08-14 | 0 failing / 17 total
• parser: nesting decides the separator, never the terminator (#2127) #2151 parser: nesting decides the separator, never the terminator (#2127) | Created: 2026-08-14 | Updated: 2026-08-14 | 2 failing / 26 total
• Unbreak FPGA CI and correct two unbacked hardware claims #2081 Unbreak FPGA CI and correct two unbacked hardware claims | Created: 2026-08-11 | Updated: 2026-08-20 | 5 failing / 27 total
• feat(igla): Wave Loop 898 — module-scope [615][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1900 feat(igla): Wave Loop 898 — module-scope [615][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• chore: civilian mesh positioning — drop drone wording (bpsk.t27) #1874 chore: civilian mesh positioning — drop drone wording (bpsk.t27) | Created: 2026-08-07 | Updated: 2026-08-07 | 2 failing / 25 total
• feat(igla): Wave Loop 897 — module-scope [613][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1858 feat(igla): Wave Loop 897 — module-scope [613][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• feat(igla): Wave Loop 896 — module-scope [611][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1856 feat(igla): Wave Loop 896 — module-scope [611][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• feat(igla): Wave Loop 895 — module-scope [609][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1854 feat(igla): Wave Loop 895 — module-scope [609][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• feat(igla): Wave Loop 894 — module-scope [607][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1852 feat(igla): Wave Loop 894 — module-scope [607][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• feat(igla): Wave Loop 893 — module-scope [605][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1850 feat(igla): Wave Loop 893 — module-scope [605][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• feat(igla): Wave Loop 892 — module-scope [603][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1847 feat(igla): Wave Loop 892 — module-scope [603][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 1 failing / 3 total
• feat(igla): Wave Loop 891 — module-scope [601][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1844 feat(igla): Wave Loop 891 — module-scope [601][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 0 failing / 4 total
• feat(igla): Wave Loop 890 — module-scope [599][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1842 feat(igla): Wave Loop 890 — module-scope [599][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-07 | Updated: 2026-08-07 | 0 failing / 4 total
• feat(igla): Wave Loop 883 — module-scope [585][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1815 feat(igla): Wave Loop 883 — module-scope [585][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-06 | Updated: 2026-08-06 | 0 failing / 1 total
• feat(igla): Wave Loop 882 — module-scope [583][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1813 feat(igla): Wave Loop 882 — module-scope [583][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-06 | Updated: 2026-08-06 | 0 failing / 12 total
• feat(igla): Wave Loop 881 — module-scope [581][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes #1810 feat(igla): Wave Loop 881 — module-scope [581][2]^6 Pt non-power-of-two outer-dimension array-of-struct variable from call with indexed signed writes | Created: 2026-08-06 | Updated: 2026-08-06 | 0 failing / 12 total

Summary

Status	Count
Total Open PRs	20
PRs with Failing Checks	5
PRs with All Checks Green	15
READY	7
FAILING	5
PENDING	0

Seal Status

• ⚠️ STALE -- sha256(compiler.rs)=cbbfac87dff3 != manifest seal=87e5cbd3ad94.
  The committed NMSE numbers were certified against an older compiler.rs.
  Run scripts/reseal-check.sh locally for the two-step reseal command (advisory; not a merge gate).

[github-actions]

📓 NotebookLM Notebook linked to this PR

• Notebook ID: b83263109fb055dc
• URL: https://notebooklm.google.com/notebook/b83263109fb055dc

This notebook contains session context, decisions, and artifacts for this work.