Fix vacuous bounds test and stale/circular comments from the settle

Replace the self-comparing render-window loop with a genuinely discriminating
floor-vs-exact check; correct two stale claims; mark the Auto/Manual floor-parity
premise as unverified; drop the STARTPOS/ENDPOS comment's circular justification.

docs/VERIFICATION.md

@@ -27,7 +27,7 @@ Checks for Θ, Ξ, and Ψ work that no unit test can close. Build **Release**, i
 - [ ] One razor-union case (two disjoint areas, one track) — lands the requested window, no `ReaSampler capture failed:` line (`PLAN.md:2137`)
 - [ ] Capture an item whose extent already equals the window — still lands, unchanged (the byte-identity regression floor) (`docs/COMPLETED.md:829`)
 - [ ] **The millisecond floor — SETTLED, nothing to re-run for `TailMode::None`.** The floor lives in the custom-time-bounds field (`RENDER_BOUNDSFLAG=0`), not in the render engine. Two live 48 kHz `TailMode::None` renders on `RENDER_BOUNDSFLAG=2` (time selection, handed over via `GetSet_LoopTimeRange`) came back exact — 97627 frames against 97627 — the second over a window whose START carried a sub-millisecond remainder, with no floored model of that window able to reproduce the count. Time selection is now the only bounds mode a capture can reach; the console verdict line and the `RENDER_STARTPOS`/`ENDPOS` read-back probe that answered this are gone. Full observation: `src/core/capture/render_settings.h`'s `kRenderBoundsTimeSelection`
-- [ ] **Still open — Auto and Manual tail.** `checkRenderedBounds` judges `TailMode::None` only (Auto/Manual add frames by design), so the settled result covers those two by INFERENCE, not observation: the floor applied to the bounds identically on all three tail modes, and all three now hand the window over the same way. What would establish it: repeat an off-grid-start capture at **Manual** over a source that is loud right to the window's end, and check the landed file's frames against window + `tailMs` — a floored edge shows up in that count. **Auto** cannot be checked by count (it trims trailing silence), so it needs the null test by ear/inversion against the source instead
+- [ ] **Still open — Auto and Manual tail.** `checkRenderedBounds` judges `TailMode::None` only (Auto/Manual add frames by design), so the settled result covers those two by INFERENCE, not observation, and the inference rests on an unverified PREMISE too: that the (retired) floor applied to the bounds identically across all three tail modes, and that all three now hand the window over the same way. Neither is measured — both live short renders that settled the bounds mode were `TailMode::None`; no Auto or Manual capture has been observed at all. **On Auto/Manual, the ONLY automatic check left is the 0-byte gate (`checkRenderedFileNotEmpty`)** — there is no automatic bounds signal for those two modes at all until this bullet is closed by hand. What would establish it: repeat an off-grid-start capture at **Manual** over a source that is loud right to the window's end, and check the landed file's frames against window + `tailMs` — a floored edge shows up in that count. **Auto** cannot be checked by count (it trims trailing silence), so it needs the null test by ear/inversion against the source instead
 - [ ] `[verify — DAW]` A tail is assumed to render PAST the window end — the SDK header (`:3048`) confirms only that `RENDER_TAILMS` is a length in ms, not that it extends past the end. If that assumption is wrong, a tail capture is silently SHORTER than its window with no detector at all. Report whether either tail capture comes up short against the source
 - [ ] A refused render is kept for diagnosis at `<project folder>/reasampler_refused/` (the refusal line names the path; a failed move leaves it unindexed in the bank folder and says so). Delete the folder when done — nothing in the bank references it
 - [ ] **If a capture is refused for a short render**, report the refusal line verbatim. A message naming `floored to the millisecond` means the floor is back on a mode measured escaping it; a shortfall of one or two frames with no such sentence may be the gate's own edge-convention tolerance rather than the render (`render_window.h`'s `renderHonoredBounds`)

src/shell/capture/capture.cpp

@@ -464,11 +464,9 @@ CaptureResult OfflineRenderBackend::capture(const CaptureRequest& request) {
     // millisecond (render_settings.h's kRenderBoundsTimeSelection).
     //
     // RENDER_STARTPOS/ENDPOS are written anyway, to the same window. The header
-    // (~3045-3046) documents them as mode-0-only, but the DAW run that settled this
-    // channel had both stores holding the identical window, so it cannot distinguish
-    // "mode 2 ignored them" from "mode 2 read them and they happened to agree". Writing
-    // them keeps the two stores agreeing rather than resting exactness on that
-    // distinction; a stale leftover here could only ever misalign a render silently.
+    // (~3045-3046) documents them as mode-0-only, so on mode 2 this is a cheap,
+    // fully-restored (ScopedRenderSettings) defensive write against that
+    // documentation being an incomplete account of what the renderer reads.
     GetSetProjectInfo(proj, "RENDER_BOUNDSFLAG",
                       static_cast<double>(kRenderBoundsTimeSelection), true);
     GetSetProjectInfo(proj, "RENDER_STARTPOS", request.startSeconds, true);

tests/test_render_settings.cpp

@@ -65,9 +65,11 @@ static void testRealtimeIsUnsupportedOffline() {
 }
 
 static void testEveryRenderSourceLabelIsPinnedVerbatim() {
-    // docs/VERIFICATION.md asks Daniel to report the refusal's `Render source:` line
-    // back verbatim, so every label is pinned to its literal — a typo in any of them
-    // breaks the report that quotes it, and only a literal catches that.
+    // docs/VERIFICATION.md's short-render bullet asks Daniel to report the refusal
+    // line back verbatim, and that line always carries the render source
+    // (render_bounds_gate.cpp appends "Render source: <label>."), so every label
+    // is pinned to its literal — a typo in any of them breaks the report that
+    // quotes it, and only a literal catches that.
     CHECK(std::strcmp(renderSourceLabel(SourceMode::MasterMix), "master mix") == 0);
     CHECK(std::strcmp(renderSourceLabel(SourceMode::TimeSelection), "master mix") == 0);
     CHECK(std::strcmp(renderSourceLabel(SourceMode::SelectedTracks),
@@ -81,9 +83,10 @@ static void testEveryRenderSourceLabelIsPinnedVerbatim() {
 static void testLabelsSeparateExactlyWhatTheRenderSeparates() {
     // The labels partition the offline modes the way RENDER_SETTINGS does, and no
     // finer: same bits => same words (MasterMix/TimeSelection both render the master
-    // mix, custom-time-bounded), different bits => different words. Naming two modes
-    // apart that render identically would put a distinction in a bug report that does
-    // not exist in the render.
+    // mix, unqualified — both hand their window over the same time-selection bounds
+    // mode), different bits => different words. Naming two modes apart that render
+    // identically would put a distinction in a bug report that does not exist in
+    // the render.
     const SourceMode offline[] = {
         SourceMode::MasterMix, SourceMode::TimeSelection, SourceMode::SelectedTracks,
         SourceMode::SelectedItems, SourceMode::RazorArea,

tests/test_render_window.cpp

@@ -408,14 +408,17 @@ static void testOnAndOffGridWindowsAreHonoredIdentically() {
     CHECK(on  == 48000);
     CHECK(off == 48000);
 
-    // The discriminating half: the off-grid window is one a flooring render WOULD get
-    // wrong (47992 against 48000) while the on-grid one is untouched by a floor. The
-    // gate's verdict must not notice that difference at any delta.
-    CHECK(msFlooredEndFrameCount(offStart, offEnd, 48000) == 47992);
-    CHECK(msFlooredEndFrameCount(onStart,  onEnd,  48000) == on);
-    for (long long delta = -3; delta <= 3; ++delta)
-        CHECK(renderHonoredBounds(on, on + delta) ==
-              renderHonoredBounds(off, off + delta));
+    // The discriminating half: a render that landed the FLOORED count would be
+    // refused on the off-grid window (47992 against the required 48000, an
+    // 8-frame gap) but honored on the on-grid one, where flooring changes
+    // nothing. If the floor ever came back on the settled path, this is what
+    // would start failing.
+    const long long offFloored = msFlooredEndFrameCount(offStart, offEnd, 48000);
+    const long long onFloored  = msFlooredEndFrameCount(onStart,  onEnd,  48000);
+    CHECK(offFloored == 47992);
+    CHECK(onFloored  == on);
+    CHECK(!renderHonoredBounds(off, offFloored));
+    CHECK(renderHonoredBounds(on, onFloored));
 }
 
 static void testOnAndOffGridAt44100WhereAMillisecondIsNotWholeFrames() {
@@ -428,11 +431,14 @@ static void testOnAndOffGridAt44100WhereAMillisecondIsNotWholeFrames() {
     const long long off = frameCountFor(offStart, offEnd, 44100);
     CHECK(on  == 44100);
     CHECK(off == 44100);
-    CHECK(msFlooredEndFrameCount(offStart, offEnd, 44100) == 44092);
-    CHECK(msFlooredEndFrameCount(onStart,  onEnd,  44100) == on);
-    for (long long delta = -3; delta <= 3; ++delta)
-        CHECK(renderHonoredBounds(on, on + delta) ==
-              renderHonoredBounds(off, off + delta));
+    const long long offFloored = msFlooredEndFrameCount(offStart, offEnd, 44100);
+    const long long onFloored  = msFlooredEndFrameCount(onStart,  onEnd,  44100);
+    CHECK(offFloored == 44092);
+    CHECK(onFloored  == on);
+    // Same discriminating pair as the 48 kHz case: the floor would be caught
+    // off-grid and invisible on-grid, even where the grid itself isn't frame-aligned.
+    CHECK(!renderHonoredBounds(off, offFloored));
+    CHECK(renderHonoredBounds(on, onFloored));
 }
 
 int main() {