τ out-of-window arrival is refused as low SNR, not as window edge, since #368's gate ordering

[mkovero]

Found while designing #350. Synthetic only, not rig-confirmed.

What happens. In analyse_tau_leg (ac-daemon/src/handlers/calibrate/tau/measure.rs), #368 put the SNR gate in front of the edge-margin check. Take a τ arrival that lands more than about 50 samples past the far edge of the window (96 kHz, calibrate's own ESS, 50 ms half-window). Its in-window skirt reads a pre-impulse SNR of 17–23.6 dB, so LowSnrRefusal fires first. The operator then reads "the deconvolution did not find a peak distinguishable from noise". The actual situation is a clean cable whose arrival lies outside the window. EdgeRefusal exists to say exactly that, but it is never reached.

Evidence (synthetic). Calibrate's stimulus (tau_sweep_params(96000)) was delayed by d samples, amplitude 0.03, with white noise from none up to −20 dBFS, run through the same inverse_sweep → deconvolve_full → extract_irs(…, 1, 9600) → ir_peak → pre_impulse_snr_db chain:

• d = 4799–4850 (arrival 0–50 samples past the edge): the peak pins at the last sample with SNR 24.6–28.5 dB, so EdgeRefusal fires.
• d ≥ 4860: SNR is 23.6 dB or lower, so LowSnrRefusal fires.
• d = 4880–4890: the peak lands 148–218 samples inside the edge with SNR 20–22.8 dB. LowSnrRefusal fires. The margin would have caught these too.

The 2026-08-22 rig pass 3 (work/rig/rig-2026-08-22-tau-window-350-results.md) saw EdgeRefusal on hardware, but it ran before #368 existed. Nobody has run an out-of-window arrival on hardware since the gate was added.

Why it matters. Per "name what to check, not why": the refusal text asserts a cause, noise, when the likelier cause is the window. No wrong number is returned, because both paths refuse. The fault is the reason the operator reads.

Out of scope for #350. #350's acceptance criteria say that no refusal text or ordering changes. Any fix here changes what the operator sees, so it needs UX.

[mkovero]

Scope label set: tier-1. Whether a τ arrival is classified as a window edge or as low SNR follows the onset/arrival rules that measurement/sweep.rs implements (same pattern as #351).

[mkovero]

spec

type: bug

problem statement
ac calibrate's τ measurement has two ways to refuse an arrival: a low-SNR refusal ("the deconvolution did not find a peak distinguishable from noise") and a window-edge refusal (the arrival lies at or outside the analysis window). Since #368 (PR #384), the low-SNR gate runs before the edge-margin check. A clean loopback whose arrival falls more than about 50 samples past the far edge of the window therefore reads as a low-SNR failure. The edge refusal, which exists to describe exactly this case, is never reached. Both paths refuse, so no wrong τ is stored. The problem is the reason the operator reads: it blames noise, so they check levels and cabling instead of the window or the latency. That goes against the repo rule "name what to check, not why". The evidence so far is synthetic (numbers below). No out-of-window arrival has been run on hardware since #368 landed. The 2026-08-22 rig pass that saw EdgeRefusal came before #368.

acceptance criteria

• A clean synthetic τ arrival (amplitude 0.03, added white noise from none up to −20 dBFS, calibrate's own 96 kHz ESS, 50 ms half-window) delayed so it lands past the far window edge is refused with the window-edge reason, not the low-SNR reason. This covers delays d = 4860 samples and above, which today get the low-SNR reason — provenance: measured (synthetic chain run, reported in issue body)
• The existing out-of-window case d = 4799–4850 (peak pinned at the last sample) is still refused with the window-edge reason — provenance: measured (synthetic)
• An arrival whose peak lands inside the edge margin with in-window SNR below the gate (issue's d = 4880–4890 case: peak 148–218 samples inside the edge, SNR 20–22.8 dB) is refused with the window-edge reason — provenance: measured (synthetic)
• A truly noisy arrival well inside the window, with no edge involvement, is still refused with the low-SNR reason. The low-SNR gate's threshold is unchanged.
• A clean, in-window arrival still passes and returns the same τ as before the change (no regression on the accept path).
• When an arrival is both near or past the edge and below the SNR gate, the reason the operator sees is the one architect and UX define. A test pins that choice.
• A test fails if the two checks' order or precedence goes back to the calibrate's ±2 dB unity gate refuses correct loopbacks, and calls it "loopback not detected" #368 behaviour. It must be checked to go red against the current ordering, not only to pass after the fix.
• Any edge-behaviour test pinned by PR fix: record τ window constants' provenance and pin edge behaviour #495 (Derive TAU_MIN_HALF_WINDOW_S / TAU_EDGE_MARGIN_FRAC against rig noise floor (AC3/AC4 of #340) #350) is checked against this change. If it pinned the current precedence, it is updated deliberately, and the PR says so.
• The refusal text for each reason matches what UX specifies.

out of scope

• The value of the SNR gate threshold and its stimulus dependence (ir_stats' PRE_IMPULSE_SNR_MIN_DB may have the same stimulus-dependence #471 found on the reference leg #474, Default ac plot ir fails its own pre-impulse SNR gate on a clean 96 kHz loopback #501)
• The window half-width and edge-margin constants (Derive TAU_MIN_HALF_WINDOW_S / TAU_EDGE_MARGIN_FRAC against rig noise floor (AC3/AC4 of #340) #350, closed)
• Making τ reach arrivals outside the current window (widening or re-centring the window)
• Other τ trust work under epic EPIC: make τ trustworthy — every consumer of an absolute latency can be one quantum wrong, undetectably #475

files likely affected

• ac-rs/ac-daemon/src/handlers/calibrate/tau/measure.rs — analyse_tau_leg, where the two checks run (named in the issue)
• ac-rs/ac-core/src/measurement/ (sweep / IR stats), for the arrival and SNR rules the checks rely on. Exact module unknown.
• unknown — where the refusal text is produced and printed (daemon and/or ac-cli). If a refusal kind changes on the wire, ac-cli and ac-view are affected.

needs architect review
yes. The architect needs to rule on which reason wins when both conditions hold, and whether an arrival that is below the SNR gate and outside the window can be told apart from a truly silent or noisy capture at all. The architect should also check whether PR #495 pinned the current precedence. UX then specifies the operator-facing text.

rig check

• Quantity: the refusal reason ac calibrate τ reports for a clean loopback whose arrival lies outside the analysis window.
• Configuration: 96 kHz loopback on the rig, typed drive level within standing consent (≤ −40 dBFS), with the arrival placed past the window's far edge. How it gets placed there (added delay or other means) is the rig session's choice, and should be recorded.
• Falsifier: after the fix, a clean loopback with its arrival past the far edge still refuses with the noise / low-SNR reason. Control: the same loopback with the arrival moved back in range passes, which shows the capture is clean. Also record the pre-impulse SNR the daemon reports, to test the synthetic 17–23.6 dB skirt figure against hardware.
• This fix will not change whether τ can be measured in this case. The run still refuses. Only the reason should change.

estimated complexity
medium: 2–8h

[mkovero]

what this output must communicate

1. Primary value: no τ was stored, and which of the two things the daemon actually observed made it refuse. Those two things are where the peak sat relative to the analysis window, and the peak's pre-impulse SNR against its threshold. When both hold, the operator sees both.
2. Necessary context: the peak position and the window bounds in the same units, so "at the edge" can be checked by eye. The edge margin, because a peak 183 samples inside the window is still refused. The SNR with its threshold. Which reading of the two refused. The places to check. The observation, not a cause.
3. Serves neither: today the edge refusal reaches the operator as the EdgeRefusal Display string, nested inside tau_error: one 275-column line that restates window size three ways and ends with an asserted cause ("the arrival is likely outside the window"). The low-SNR line ends with threshold derived, which is false for calibrate. measure_tau passes SnrGate::Constant, so the threshold is the fixed 24 dB constant.

precedence, as seen by the operator

The operator-facing rule does not depend on which check runs first. Once deconvolution has run, the refusal prints every gate the peak failed:

peak inside edge margin	SNR below threshold	headline
yes	no	peak at window edge
no	yes	peak SNR below threshold
yes	yes	peak at window edge, peak SNR below threshold

For the combined case, the architect asked whether a skirt peak can be told apart from a silent or noisy capture that happens to peak inside the margin. With both-observation wording, the operator does not need that answer. The text asserts neither cause, and the check list covers both. The window-side places come first because the edge observation is the more specific of the two. The order is not a claim about the cause. This row is what AC "reason when both hold" pins.

proposed output: ac calibrate, τ leg (96 kHz, period 1024)

Edge only (issue's d = 4820: peak pinned at the last sample, SNR clears):

  Delay:  not measured (peak at window edge)
          reading 1 of 2 refused, nothing stored
          peak      +4799 samples   +49.9896 ms
          window    -4800 to +4799 samples (±50 ms), edge margin 480 samples
          peak SNR  26.41 dB pre-impulse, threshold 24.00 dB
          check: interface buffer size, loopback routing,
                 delay devices in the loopback path

Both (issue's d = 4885: skirt peak 183 samples inside the edge, SNR 21.34 dB). This is the case that reads as noise today:

  Delay:  not measured (peak at window edge, peak SNR below threshold)
          reading 1 of 2 refused, nothing stored
          peak      +4616 samples   +48.0833 ms
          window    -4800 to +4799 samples (±50 ms), edge margin 480 samples
          peak SNR  21.34 dB pre-impulse, threshold 24.00 dB
          check: interface buffer size, loopback routing,
                 delay devices in the loopback path,
                 loopback cable, output level, input gain

Low SNR only (noisy capture, peak well inside the window):

  Delay:  not measured (peak SNR below threshold)
          reading 2 of 2 refused, nothing stored
          peak SNR  17.28 dB pre-impulse, threshold 24.00 dB
          check: loopback cable, output level, input gain

Worst-case width: the window line is 76 columns. A 75 ms half-window override is the same width. At 384 kHz, five-digit offsets make it 78. The widest headline (both) is 70. Everything fits in 80 columns.

proposed output: ac plot ir, ref latency line (#460 reference leg, same analyse_tau_leg)

The same precedence bug reaches this line, because the reference leg shares the gate code. The edge-only and low-SNR-only reason strings keep their #460 shape. The only change is 2-decimal SNR (see justifications). The combined case is new:

  ref latency   unavailable — peak at reference window edge,
                              SNR 21.34 dB, need 24.00 dB
                check: reference loopback routing, capture tail,
                       reference loopback cable, ref input gain

  ref latency   unavailable — peak SNR 17.28 dB, need 24.00 dB
                check: reference loopback cable, ref input gain

Reason string for the combined case: peak at reference window edge, SNR 21.34 dB, need 24.00 dB; check: reference loopback routing, capture tail, reference loopback cable, ref input gain. The unwrapped observation line would be 87 columns. So reference_latency_lines needs a display rule: when the observation or check: line would exceed 79 columns, wrap at , boundaries, with a hanging indent under the first item (column 30 for the observation, column 23 for check:). The rule is display-only. Reasons stored in older reports are unchanged and render through the same rule.

field justifications

• headline reason: the grep-able answer to "why no τ". It names observations only, and every failed gate appears.
• reading N of 2 refused, nothing stored: if reading 2 refuses after reading 1 passed, the path changed between lifecycles, which points to different places. Today the low-SNR line loses the reading number entirely. nothing stored confirms that tau_history is untouched, in the same wording register as refused_xrun.
• peak (samples, ms): the observation that makes "edge" checkable. It uses the Delay: line's units and 4-decimal ms so the two read alike. It is labelled peak, never Delay, under a not measured headline, so it cannot be mistaken for a τ.
• peak omitted in the low-SNR-only case: a noise argmax's position has no meaning, and printing it would only invite someone to read it as a τ.
• window bounds as exact offsets (-4800 to +4799): the window is asymmetric by one sample, and a pinned peak sits exactly on +4799. ±4800 would put the peak one sample inside a bound that does not exist. (±50 ms) gives the scale in the unit the operator configures.
• edge margin 480 samples: without it, the d = 4885 peak at +4616 looks 183 samples clear of the edge, and the refusal looks arbitrary.
• peak SNR with threshold, 2 decimals: a refused 23.96 against 24.00 would print as 24.0 … threshold 24.0 at 1 decimal and read as a contradiction. Precision is kept so the refusal is legible. The same applies to the ref latency reason, whose derived threshold is not a round number.
• threshold derived removed: calibrate judges against the constant, so the word is false there.
• check: list: places only, per "name what to check, not why". Edge: buffer size and routing set the round trip that must land within ±50 ms. Low SNR: the path level. Combined: both lists, window side first. The list wraps at , with a 17-column hanging indent.

before / after

Current output was reconstructed from origin/main @ 26f59085 code (render_tau_leg's "error" arm with EdgeRefusal's Display string). No PR exists yet.

before (edge, d = 4820):
  Delay:  not measured (τ measurement failed (reading 1 of 2): τ peak at sample 9599 of a 9600-sample window (half-width 4800 samples) sits within 480 samples of the window edge — the arrival is likely outside the window rather than at this position, so no value is reported)

before (d = 4885, today's precedence):
  Delay:  not measured (peak SNR 21.34 dB, need 24.00 dB, threshold derived)

after: see renderings above

• removed: the τ measurement failed wrapper, because the measurement ran and a gate refused it. Also the restated window size, the asserted cause "likely outside the window", "so no value is reported" (said once, as nothing stored), and threshold derived (false for this path).
• added: a peak position in samples and ms; window bounds and edge margin; the SNR on edge refusals (the daemon has it and prints nothing today); the reading number on low-SNR refusals; check: lists; and the combined headline.
• changed: one 275-column line becomes 4–8 lines of 80 columns or less, in the Delay: evidence layout that measured already uses (value line, evidence indented to column 10). The edge refusal leaves the generic error state (see open questions).

daemon-side strings

EdgeRefusal and LowSnrRefusal Display strings still reach logs and any caller that formats the error. They should drop the cause clauses. Suggested:

• τ peak at offset +4799 samples is within the 480-sample edge margin of a -4800 to +4799 sample window; no value reported
• τ peak pre-impulse SNR 21.34 dB is below the 24.00 dB threshold; no value reported

open questions

1. Wire shape (architect). Today the edge refusal travels as tau_state: "error" with a prose tau_error, so the CLI cannot render the layout above without parsing prose. Proposal: a typed tau_state: "not_measured_window_edge" carrying tau_peak_offset_samples, tau_window_first_offset_samples, tau_window_last_offset_samples, tau_edge_margin_samples, the existing tau_pre_impulse_snr_db / tau_snr_threshold_db, and a daemon-computed tau_snr_below_threshold: bool for the combined headline. The daemon should compute that flag so the CLI's < cannot drift from the gate's. Also tau_refused_reading: 1 | 2 on both refusal states. The alternative is one combined state versus two flags on a single not_measured_* state. The operator output is identical either way. ZMQ.md's tau_state table changes regardless, and an older CLI falls through to not measured (state: not_measured_window_edge), which is honest.
2. Reading 1's τ when reading 2 hits the edge. If reading 1 measured +43.7500 ms and reading 2 pinned at the edge, printing reading 1 would show the jump directly. That needs another wire field and is not required for this issue. Architect's call on whether to add it now or file it.
3. What this will not change: the run still refuses, and no τ is reached beyond ±50 ms (out of scope). The rig check should expect the headline to change, not the outcome.

[mkovero]

design decision

core question
When a τ leg fails both the edge check and the SNR gate, which refusal does analyse_tau_leg return, and how does that refusal reach the CLI? Today an edge refusal travels as tau_state: "error" with a prose tau_error, so the CLI cannot print UX's layout without parsing prose.

Answer to triage's second question: no, not from the observations alone. A skirt peak and a noise-only argmax that lands in the margin look the same. For white noise with no arrival, the chance of that is about 2·480/9600 ≈ 10 %. UX's wording names both observations and asserts no cause, so this ruling does not need to tell the two apart. It only has to make sure the edge observation is never dropped.

evidence gathered for this decision (synthetic, 96 kHz, calibrate's ESS, amplitude 0.03, same inverse_sweep → deconvolve_full → extract_irs(…, 1, 9600) → ir_peak → pre_impulse_snr_db chain as the #495 tests; throwaway probe on origin/main @ 26f59085, not committed)

Arrival placed past samples beyond the far edge. Classification: EDGE means the peak is inside the 480-sample margin. LOW means gate SNR < 24 dB.

noise (white, RMS)	seeds	past range probed	result
none	1	0–400 (step 5), 450–3000 (step 50), 3500–14000 (step 500)	every point is EDGE. 0–55: EDGE only. 60 and above: EDGE+LOW. Deepest peak 237 samples inside the edge.
−40 dBFS	3	same	EDGE (± LOW) for every past ≤ 1750. From 1800 on, some seeds put the argmax 480–3700 samples inside, giving LOW only.
−20 dBFS	3	same	EDGE (± LOW) for every past ≤ 400. From 450 on, LOW only for some seeds.

No probe point produced an accepted τ.

Consequence for AC1 (explicit disagreement, not a silent change): no gate ordering can meet "d ≥ 4860 … noise up to −20 dBFS" when d has no upper bound. Once the arrival is far enough out, the in-window IR is only noise and residue. Its argmax is a noise draw, and that capture really is indistinguishable from one with no arrival at all. So LOW-only is the honest observation there. This design meets AC1 over the following bounded range, and the tests pin that range:

• noise none through −20 dBFS: d = 4860–5200 (past 60–400) — provenance: measured (synthetic probe above)
• noiseless: past up to 14 000 samples — provenance: measured (synthetic probe above)

Past those limits the reason stays peak SNR below threshold. That is correct, not a regression. An electrical loopback sits far below −40 dBFS of noise, so the noiseless row is the one the rig resembles.

option A — edge first; the edge refusal carries the SNR observation; typed wire state (UX's open question 1, as proposed)

• analyse_tau_leg evaluates both gates on the one peak. If the edge check fails, it returns EdgeRefusal, which now also carries the SNR, the threshold and a below_threshold flag. It returns LowSnrRefusal only when the peak is clear of the margin.
• measure_tau_twice recovers EdgeRefusal by downcast, the same way it already recovers LowSnrRefusal. That gives a new TauAttempt/TauOutcome variant and a new wire state, not_measured_window_edge, with typed numeric fields.
• The combined case is the edge state with tau_snr_below_threshold: true.

tradeoffs: this is the smallest change to the existing downcast sites (tau/mod.rs, audio/plot.rs), and each state keeps one meaning. The daemon computes the combined flag, so the CLI's comparison cannot drift from the gate. Cost: the cal_done schema grows one state and six keys.

option B — one GateRefusal { edge: Option<…>, low_snr: Option<…> } replacing both types; single not_measured_gates state with two flags
tradeoffs: symmetric, and the operator output would be identical. But it replaces a wire state (not_measured_low_snr) that ac-cli and the IT suite already key on, and every downcast site changes shape. It is more churn for nothing the operator can see.

option C — keep error + prose tau_error, only reorder
Rejected. The CLI would have to parse prose to print UX's layout, and #368 already typed LowSnrRefusal for exactly this reason.

recommendation
Option A, because it follows the pattern #368 set: a gate refusal is a typed error, recovered by downcast, and reported as its own tau_state with numeric fields. It also leaves not_measured_low_snr meaning exactly what it means today, minus the edge cases it was wrongly absorbing.

Rulings on UX's open questions:

1. Wire shape: option A, with the fields UX named (listed under interface changes).
2. Reading 1's τ when reading 2 hits the edge: not in this issue. The developer files a follow-up.
3. Adopted as written: the run still refuses; only the reason changes.

Additional ruling (not covered by UX): a lifecycle that crossed an xrun still skips the SNR gate (#368/#369 precedence unchanged). If it then hits the edge, the result is not_measured_window_edge without the SNR pair or the flag, the same absence rule as refused_xrun. The CLI omits the peak SNR line when the pair is absent. The edge headline also does not mention the xrun. That is a pre-existing gap: today the same case is a prose error that says nothing about the xrun either. The developer files a follow-up for it. It is not fixed here.

affected modules

• ac-daemon / handlers/calibrate/tau/measure.rs: gate evaluation order, EdgeRefusal payload, rewritten reasoning in the doc comments, tests.
• ac-daemon / handlers/calibrate/tau/mod.rs: new TauAttempt/TauOutcome variant, reading number on both refusal states, write_frame.
• ac-daemon / handlers/calibrate/mod.rs: re-export any new type that plot.rs names.
• ac-daemon / handlers/audio/plot.rs: combined reference reason, SNR to 2 decimals.
• ac-cli / commands/calibrate.rs: render_tau_leg arms per UX.
• ac-cli / commands/plot.rs: reference_latency_lines wrap rule per UX.
• ZMQ.md: cal_done schema, state table, presence and precedence prose, reference_latency example reason.
• ac-core, ac-scene, ac-view: no change. ir_peak and pre_impulse_snr_db are untouched, and ReferenceLatency::Unavailable.reason is already a free String.

file manifest
ac-rs/crates/ac-daemon/src/handlers/calibrate/tau/measure.rs
ac-rs/crates/ac-daemon/src/handlers/calibrate/tau/mod.rs
ac-rs/crates/ac-daemon/src/handlers/calibrate/mod.rs
ac-rs/crates/ac-daemon/src/handlers/audio/plot.rs
ac-rs/crates/ac-daemon/tests/it_protocol/calibrate/tau.rs
ac-rs/crates/ac-daemon/tests/it_protocol/plot_ir.rs
ac-rs/crates/ac-cli/src/commands/calibrate.rs
ac-rs/crates/ac-cli/src/commands/plot.rs
ac-rs/ZMQ.md

interface changes
cal_done (PUB) changes. All of them are additive:

• tau_state gains the value "not_measured_window_edge".
• New keys, present only on not_measured_window_edge:
  • tau_peak_offset_samples (int, signed: peak_idx − half)
  • tau_window_first_offset_samples (int, −half)
  • tau_window_last_offset_samples (int, half − 1)
  • tau_edge_margin_samples (int)
  • tau_snr_below_threshold (bool). Present only together with the SNR pair.
• tau_pre_impulse_snr_db / tau_snr_threshold_db are now also present on not_measured_window_edge, whenever the refusing lifecycle had no xrun. On that state they are the refusing lifecycle's own values, not the worse of two.
• New key tau_refused_reading (int, 1 or 2), present on not_measured_window_edge and not_measured_low_snr.
• tau_error is not present on not_measured_window_edge. error no longer carries edge refusals.

Other changes:

• plot_ir report: no schema change. reference_latency.reason gains the combined-case text, and SNR figures go to 2 decimals (UX strings).
• CLI flags: none. Cargo features: none.
• Crate-internal (pub(crate)): EdgeRefusal gains SNR fields. check_peak_within_window may return a typed Result<(), EdgeRefusal> so analyse_tau_leg can attach the SNR. Existing .is_err()/.is_ok() tests keep compiling.

ZMQ protocol impact
Yes. One new tau_state value and new optional keys on cal_done.

• ac-cli, old CLI with new daemon: falls through render_tau_leg's _ arm to not measured (state: not_measured_window_edge). That is honest and verified on origin/main.
• ac-cli, new CLI with old daemon: an edge refusal still arrives as error prose and renders through the unchanged error arm.
• ac-view: consumes no tau_* or reference_latency field (git grep on origin/main: zero hits). No change and no breakage.

implementation notes for developer

• measure.rs → analyse_tau_leg (after threshold_db is computed). Evaluate the edge observation and the SNR observation (the latter only when xruns == 0) on the same peak_idx. Return in this order: edge refusal carrying the SNR observation, then LowSnrRefusal, then Ok. Nothing before threshold_db changes. The accept path must return the same TauLegReading bit for bit (AC5). tau_arrival_inside_the_margin_is_located_exactly_and_refused and the accept tests already bound it.

• Replace reasoning, don't delete it. Rewrite these three doc comments, which argue for the old order:

  • check_peak_snr ("a peak that isn't real shouldn't be judged against the edge margin at all")
  • the "Arrivals further past the edge than that are refused by TAU_SNR_THRESHOLD_DB first … (τ out-of-window arrival is refused as low SNR, not as window edge, since #368's gate ordering #494)" sentence in the TAU_MIN_HALF_WINDOW_S doc
  • the "second net under the SNR gate" framing in the TAU_EDGE_MARGIN_FRAC doc

  The new reasoning is the probe table above: the margin is what classifies a past-edge skirt, the gate still refuses it, and both observations are reported.

• EdgeRefusal / LowSnrRefusal Display: use UX's "daemon-side strings" section verbatim, with no cause clauses.

• tau/mod.rs → measure_tau_twice, the two match e.downcast_ref::<LowSnrRefusal>() blocks. Add an EdgeRefusal arm to each, and pass the reading number (1 or 2) into both refusal attempts. tau_result maps the new attempt to the new outcome. write_frame: the new state's keys go in the existing presence-rule match. Model the new unit test on tau_result_low_snr_reports_new_state_and_fields.

• PR fix: record τ window constants' provenance and pin edge behaviour #495 pinned the old precedence (AC8). tau_skirt_peak_past_the_edge_is_inside_the_shipped_margin asserts LowSnrRefusal at half + 85. Change it deliberately to expect EdgeRefusal with below_threshold == true, and say so in the PR body. It then fails against today's order, which satisfies AC7; confirm that red by running it against origin/main's analyse_tau_leg. Also update tau_arrival_just_past_the_edge_is_refused_by_the_edge_check_alone: assert below_threshold == false, and drop the "cannot catch a reorder" sentence from its doc comment.

• New unit test for AC1–AC3. Sweep past over 60..=400 with noise none, −40 and −20 dBFS (seeded, reuse the xorshift in tau_skirt_peak_never_lands_deeper_than_the_margin_floor). Every point must give EdgeRefusal. Add a noiseless spot check at a far past (for example 5000). Put the explicit d = 4799–4850 and 4880–4890 cases from the issue in the same test or a sibling.

• AC4. Keep the existing noise-only low-SNR coverage. it_protocol/calibrate/tau.rs::calibrate_reports_not_measured_low_snr_on_muted_fake_loopback becomes order-sensitive, because its comment says the default 32-sample delay lands the noise argmax inside the margin. Confirm that 800 still lands clear under the new order. Assert tau_refused_reading there.

• New IT test. Model it on the same file. Use AC_FAKE_TAU_DELAY_SAMPLES_OVERRIDE to put the fake's arrival past its 48 kHz window (half = 2400), and assert tau_state == "not_measured_window_edge", the offset and window keys, and the absence of tau_error.

• audio/plot.rs → reference_unavailable_reason. Add an EdgeRefusal branch that reads below_threshold and emits UX's combined string, and move SNR formatting to {:.2}. Pin the combined string in a pure unit test beside it; the fake reference may not reach the combined case reliably. Update the expected strings in it_protocol/plot_ir.rs (…_reference_peak_at_the_window_edge_as_unavailable stays edge-only unless its SNR falls below the derived threshold; check and pin whichever holds).

• ac-cli/commands/calibrate.rs → render_tau_leg:

  • new "not_measured_window_edge" arm and a rewritten "not_measured_low_snr" arm per UX's three renderings
  • fall back to not measured (state: …) when the required keys are absent (the existing low-SNR fallback is the model)
  • fixtures go next to the existing tau_state JSON fixtures in mod tests (around the refused_xrun ones)

• ac-cli/commands/plot.rs → reference_latency_lines, the unavailable closure. Apply UX's display-only wrap rule: over 79 columns, wrap at , with a hanging indent under the first item. Existing fixture strings near the reference_latency_lines tests (search peak SNR 9.3 dB) must still render unwrapped.

• ZMQ.md → topic: cal_done block and the tau_state table: add the row and the new keys. Amend the presence paragraph ("present on every state where at least one lifecycle reached deconvolution") and the table's "refused_xrun … takes precedence over not_measured_low_snr" row so it also covers the new state. Change the example reason in the reference_latency section (peak SNR 9.3 dB, need 24.0 dB) to 2 decimals.

scope
tier-1. Unchanged from triage. Note: no ac-core/measurement/ file changes. The rule lives in the daemon's τ gate, and sweep.rs / peak.rs are used as they are.

risks

• Noise-only captures whose argmax falls in the margin (≈10 %) now read peak at window edge, peak SNR below threshold instead of low SNR only. Mitigation: UX's combined check list names both sets of places, and the text asserts no cause. AC4 ("well inside the window") is unaffected.
• AC1 cannot hold for arbitrarily far arrivals under noise (probe above). Mitigation: bounded tests; this comment records the bound; the reason past it is truthfully peak SNR below threshold.
• Xrun plus edge gives an edge headline with no SNR line and no xrun mention. This is pre-existing and is filed as a follow-up. This fix will not fix it.
• Existing IT test calibrate_reports_not_measured_low_snr_on_muted_fake_loopback may flip to the edge state under the new order. Mitigation: verify its 800-sample delay, and re-probe if needed rather than weakening the assertion.
• Wire drift between daemon and CLI on the combined flag. Mitigation: the daemon computes tau_snr_below_threshold, and the CLI never compares numbers.

rig check

• Quantity: the tau_state and headline ac calibrate reports for a clean electrical loopback whose arrival lies past the far window edge; also the reported tau_pre_impulse_snr_db for each run.
• Configuration:
  • pupu, FF400 at 96 kHz, electrical loopback, typed drive ≤ −40 dBFS (standing consent).
  • Daemon built with --features tau-window-override. The rig cannot move τ continuously, so move the window instead, as Derive TAU_MIN_HALF_WINDOW_S / TAU_EDGE_MARGIN_FRAC against rig noise floor (AC3/AC4 of #340) #350 did.
• Procedure:
  1. Control: default window. Run ac calibrate τ and record T, the measured round trip in samples. It must be measured. If T is above the 4318-sample accepted ceiling, raise AC_TAU_HALF_WINDOW_S until the control measures.
  2. For each k in {20, 85, 300}, set AC_TAU_HALF_WINDOW_S so that ceil(h·96000) = T − k. That places the arrival k samples past the far edge.
  3. Run 3 times per k. Re-run the control before each k set, because each calibrate reading is a fresh JACK client; if T moved, re-derive h.
• Expected:
  • every run is not_measured_window_edge
  • k = 20: tau_snr_below_threshold false (synthetic SNR ≈ 27.2 dB)
  • k = 85 and k = 300: tau_snr_below_threshold true (synthetic ≈ 22.4 / 22.5 dB)
  • Record the SNRs against these synthetic figures as a readout, not a gate.
• Falsifier: any run in steps 2–3 returning not_measured_low_snr.
• Not a falsifier: k = 20 showing the combined headline. That only means the hardware skirt SNR sits lower than the synthetic value. Record it.
• What stays unmeasured: out-of-window arrivals under capture noise near −20 dBFS. An electrical loopback does not reach that without injection, and the synthetic probe already says LOW-only is expected there beyond about 400 samples.
• This will not change: whether τ can be measured in this case. Every step-2 run still refuses; only the reason changes.

requires-rig stays on the issue.