Thales
← research journal

An internal research document, published verbatim by the automated daily export — not written for an audience, and better for it. All performance discussed is simulated paper trading; nothing here is investment advice.

DGX-1 — the new weekly-email gate is blind to alarms the digest's own renderer prints: a failed VRP close, a corrupt option-position file, and "no readable beacon" all read as a quiet day

status: open · raised panel run 22 (2026-09-14, change-review catch on PR #163 — does NOT count toward the frontier cadence) · class: loudness (G2 time-to-loud) on the operator's ONLY push channel · effort ~0.5 pd · horizon: live from today — 2026-09-14 is the first weekday under email_policy: weekly


Plain-language summary for an owner reading one paragraph. Saturday's change did the right thing with a request that could have gone badly: asked for "one email a week instead of five", it cut the cadence for QUIET days only and kept every exception day mailing the same evening. The exception list it built is good. The problem is what feeds it. digest_exceptions() asks four questions, and for the VRP sleeve — the one live options sleeve — two of them cannot be answered, because the option sleeve's gather never produces the fields they read. The result: the digest can render 🔴 POSITION FILE CORRUPT or carry a failed close in its state, and the gate still returns "quiet day off-cadence" and withholds the mail until Friday. A third case is the routine-liveness probe: when it cannot read the beacons at all, it degrades to "unknown", and unknown is not an exception — so the dark-routine trigger goes silent exactly when its own data source breaks. The defect is a shape, not three bugs: the renderer and the gate were written from different sources of truth, and only the renderer knows what counts as red.

Mechanism — reproduced against the real functions at HEAD 18a510b

Every case below was executed, not read.

(1) A failed VRP order can never be an exception. digest_exceptions (fleet_digest.py:1157, the per-sleeve loop at :1181-1187) reads d["failed_orders"] / d["failed_standing"] per sleeve. Those keys are produced by digest.gather_digest (digest.py:247-249), which serves the weights sleeves. The VRP sleeve is gathered by _gather_option_sleeve (fleet_digest.py:68-172) — a different function whose return dict contains neither key. So n_failed and n_standing are both 0, 0 > 0 is False, and no option-sleeve failure of any age can make a day an exception. Executed:

vrp data = _gather_option_sleeve's exact key set, orders_today carrying
           {'status': 'failed', 'cause': 'vrp_close'}
digest_exceptions(f)             -> []
should_email(f,'weekly',5, Tue)  -> (False, 'quiet day off-cadence')

The body is silent too: _text_option_section (:799-827) and _html_option_section (:1053) render no failed-order line at all, so both failed_orders reads in the module (:781, :1034) are inside the weights sections. Nothing in the fleet email has ever shown a failed VRP order. Before #163 that was a rendering gap; #163 made it load-bearing.

Is it backstopped? Partly, and the gap is the standing case. A fresh failed close does red the run: option_intents.py:76-79 stamps action: "close", is_de_risking (failed_streaks.py:27-28) accepts action == "close", so cli.py:1176 raises Exit(4) and paper-trading-vrp.yml's _alert job fires. But from the second session onward the same symbol is in prev_failed — and note the symbol an option order carries is the underlying, "SPY" (option_intents.py:78), so the masking is coarser still — fresh is empty, the run exits 0 by FOS-1's deliberate design — and the ruling's stated reason is that "a standing streak is the digest's job — its streak line names it". For the option sleeve there is no such line and now no such email. A VRP close that keeps failing leaves a live short spread the book cannot exit, with green CI and no mail until Friday.

Why the digest specifically, for this sleeve. RUNBOOK.md:190-198 records incident 2026-07-24: GitHub reclaimed the VRP trade job's runner mid-run, so the workflow's own alert step could not execute — "the sleeve skipped a trading day holding an open short put spread and nothing paged; only the fleet digest noticed." That is the shop's own written finding that the digest is VRP's last-resort detector when the in-job path dies. The no_run half of that incident is covered by digest_exceptions. The failed-order half is the hole this row names.

Honest severity: latent, not active. Measured: data/state/vrp/ holds zero failed-order records across the sleeve's whole live history since 2026-07-13. This hole has never been exercised. It is filed as a loudness defect found before its first incident — which is the only time such a thing is cheap — not as a live outage. The contrast is meanrev's AVB, still failing its emergency exit on 2026-09-11, on the covered (weights) path.

(2) A corrupt VRP position file renders 🔴 and the gate calls it quiet. _gather_option_sleeve:160 emits corrupt_position; _text_option_section:805-806 prints 🔴 POSITION FILE CORRUPT — manual reconciliation required. digest_exceptions never reads the key, and any_red (:496-505) does not include it either. Executed: body prints the 🔴 line, gate returns (False, 'quiet day off-cadence'). Backstopped, and honestly so: vrp_daily._read_position (:82-93) raises RuntimeError on corruption, so the trading run itself reds and its own alert job fires. This instance is the cheapest proof of the shape, not the dangerous one — keep it as a test case, not as the argument.

This one was already known, at LOW, and #163 silently promoted it. TECH_DEBT.md:687-689 carries: "VRP corrupt-position renders a red section but is absent from the fleet red/subject rollup (LOW) — a corrupt vrp position wouldn't red the subject." That was accurate and fairly rated when the email went out every weekday: the cost was a subject line that under-sold its own body. Saturday's change re-used the same rollup as the send/withhold decision, so the cost is now the body not arriving for up to four days. Nobody did anything wrong — the LOW rating was correct for the world it was written in. This is the "a TECH_DEBT item that later work silently made urgent" case, and it is the single clearest argument for the structural fix in step 3 below: the next feature to read that rollup will inherit the same blind spot again.

(3) The dark-routine trigger fails quiet when the beacon probe fails. _gather_routine_liveness:311-325 sets missed = None whenever _last_beacon_date (:275-292, a gh api shell-out) returns None — which is every routine at once if gh fails (no token, rate limit, API outage) or a beacon branch is gone. _routine_liveness_lines:333-347 renders those as ? N routine(s) with no readable beacon; digest_exceptions:1174-1178 filters on r.get("missed"), and None is falsy. Executed with all six routines unreadable: body prints the ? line, digest_exceptions returns [], gate returns quiet. This one is latent, not active — the workflow does set GH_TOKEN with contents: read (fleet-digest.yml:88-89, :37), so the probe works today. It is the fail-quiet direction on a notification gate, which is the thing this shop has decided twice already it does not accept (exit 3 for the dead SMTP path; --fail-on-no-run for the rendered-only DID-NOT-RUN signal).

Why the new tests do not catch any of it

tests/test_execution/test_digest_cadence.py (9 tests, all green on this checkout — run, not assumed) is a good test file: it has a real negative control (the same quiet Tuesday sends under always), and test_a_standing_failure_alone_is_not_a_new_exception pins the AVB case the feature was built around. Its blind spot is structural, not sloppy — every payload is hand-built:

(_with(sleeves=[{"name": "meanrev", "ok": True, "data": {
    "failed_orders": [{"symbol": "AVB"}, {"symbol": "XYZ"}],
    "failed_standing": [{"symbol": "AVB"}]}}]), "1 NEW failed order"),

The fixture supplies exactly the two keys the code reads, so the tests verify the logic given the right shape and can never discover that one of the two real gathers does not produce that shape. No test in the file constructs a payload from _gather_option_sleeve, and none asserts anything about the option sleeve at all. A detector whose fixture is written from the consumer's expectations rather than the producer's output cannot fail in this direction — which is why step 3 below is the part worth building.

Prior art, checked before filing

  • research/queue/ (all four dirs) and the frozen research/RESEARCH_QUEUE.md: no dgx-* slug, and no row on digest_exceptions / should_email / the cadence policy — the feature is two days old.
  • TECH_DEBT.md: one hit, instance (2), quoted above at LOW; no entry for instance (1) or (3).
  • research/2026-08-01_quant_panel_suggestions.md reject ledger: no hit.
  • web/public/data/killlist.json: strategy kills only; not applicable.
  • Nearest neighbours are FOS-2 and FOS-3, discussed next. Neither covers this.

Why this is not FOS-2, and how they relate

FOS-2 is the weights renderer printing a flat failed-order count with no NEW/STANDING split. DGX-1 is the option sleeve having no failed-order path at all — gather, renderer, or gate — plus the gate/renderer divergence in (2) and (3). They share a diagnosis (a reporting feature built in one renderer and not the other, twice now: see the 2026-07-20 scar quoted at fleet_digest.py:777-779) and should be triaged together; the fix shapes compose. Neither subsumes the other.

Fix shape (propose-only — the panel does not implement)

One predicate, both consumers. The gate should not re-derive what is alarming; it should ask the same code the renderer asks. Concretely:

  1. Give _gather_option_sleeve the two keys the contract already implies — failed_orders (it already holds orders_today with status) and failed_standing (the same failed_streaks split the weights gather runs, which works on OCC symbols unchanged). That closes (1) at the source and gives the option section a failed-order line for free.
  2. Add corrupt_position and the missed is None ("liveness unknown") case to the exception set.
  3. The structural half: a test that walks the alarm conditions the renderers can emit (🔴, !!, the ?-liveness line) and asserts each one produces a non-empty digest_exceptions. A new red line added to a renderer without a matching exception must fail the suite — that is the detector that makes this class non-recurring, and it is the reason to treat this as one item rather than three patches.

Pre-registered kill criterion

This row is wrong and must be closed unbuilt if, at the time it is picked up, a fresh run of the three reproductions above returns a non-empty digest_exceptions() for any of: an option-sleeve payload carrying a failed order, corrupt_position: True, or all-routines-missed: None. One command, one run, no judgement. The reproductions are in this file verbatim so the check cannot drift into a re-argument.

Conversely it is built and done when those three payloads each return a non-empty exception list, the option section renders its failed orders, and the renderer/gate consistency test fails when a new 🔴 line is added to a renderer without a matching exception (show the negative control red).

Effort · horizon

~0.5 person-days (three gather/gate keys plus one consistency test; no trading-path code, observability tier only). Decidable immediately — this is live from today, the first weekday under email_policy: weekly.

Note for triage, disclosed

research/queue/open/ stands at 19 files against its pre-registered 12-file cap before this row. The panel is not pre-empting the overflow rule: rank this against the incumbents like anything else. The argument for it ranking high is only that it is two days old, it sits on the single channel every other alarm ultimately depends on, and it touches the live options sleeve.


Triage note — 2026-09-14 (annotation only; the body above is untouched)

FOS-2 IS FOLDED INTO THIS ROW as of today — same module, adjacent lines, same defect class (the digest's renderer and its send-gate read different sources of truth). FOS-2 was dismissed at the 12-item cap this run; body preserved verbatim at research/queue/dismissed/fos-2-fleet-email-missing-streak-split.md. What it adds here is small and composes exactly: fleet_digest.py:781-785 still renders the flat failed_orders count, while the payload already carries the NEW-vs-STANDING split (digest.py:247-249), so one shared formatter lifted from digest.py:515-528 _failed_detail closes it. Keep FOS-2's negative control in this row's test set: revert the fleet renderer to the flat line, assert red. Estimated ~0.5 pd → ~0.6 pd with the fold.

All three legs re-verified STILL PRESENT at HEAD 340bc5f by reading the full functions: _gather_option_sleeve (:68-172) returns neither failed_orders nor failed_standing (return block :151-172) while digest_exceptions (:1181-1187) reads exactly those two keys; corrupt_position appears nowhere in digest_exceptions (:1157-1189) nor in any_red (:495-505) though the renderer prints it (:805-806); and _gather_routine_liveness:311-325 sets "missed": None, which digest_exceptions:1174-1178 filters as falsy. TECH_DEBT.md:687-688 carries the second at LOW, so the body's "#163 silently promoted a LOW item" is confirmed.

All three legs are LATENT, measured — and that is the argument FOR building now, not against. data/state/vrp/order_log.jsonl holds 52 records with statuses {None: 41, PENDING_NEW: 11} and zero failed across the sleeve's entire life since 2026-07-13, so leg 1 has never been exercised; leg 2 is backstopped by vrp_daily._read_position raising on corruption; leg 3 is backstopped today by fleet-digest.yml's GH_TOKEN. Nothing has fired, which is precisely why this is cheap this week.

The folded FOS-2 half, by contrast, is ARMED — 15 consecutive AVB failed exits through 2026-09-11 render on the next email including meanrev.

Step 3 (a renderer↔gate consistency test) is what makes this defect class non-recurring and should not be dropped in favour of three key additions.


Correction — 2026-09-15, from the panel that filed this row (append only; nothing above rewritten)

Leg 3 as written above is WRONG, and wrong in the direction that understates it. The body says the dark-routine trigger "fails quiet when its own probe breaks" and calls it latent; the triage annotation repeats that as "backstopped today by GH_TOKEN". Both are incorrect. The dark-routine exception could never fire at all, on any day, with a perfectly healthy probe.

The daily audit found it on 2026-09-14 (open PR #168, "digest: the dark-routine exception could never fire (wrong key path)"). Re-verified here against main at cae5e6b:

  • _gather_routine_liveness is called inside _gather_pipeline_status, which writes out["routines"] (fleet_digest.py:423);
  • the top-level gather stores that whole dict under "pipeline" (:545);
  • both renderers read it correctly from there — pl.get("routines") at :884 and :979;
  • digest_exceptions reads f.get("routines") (:1174) — the top level, which the gather never populates. rows is therefore always [] and dark always empty.

It is not a hypothetical: on 2026-09-14 the digest printed "2 routine(s) DARK" and withheld the email as a quiet day — the renderer and the gate disagreeing in production, on the first weekday the weekly cadence was live.

How this row's own verification missed it, because the lesson is the point. The negative control run for leg 3 constructed its payload by hand:

f = {"fleet": {...}, "routines": rows, "sleeves": []}   # ← supplied the key the CONSUMER reads

That is precisely the fixture error this row criticizes in test_digest_cadence.py two sections above — building the payload from the consumer's expectations instead of the producer's output. A hand-built fixture can prove a logic defect (which it did: missed=None really is falsy) but is structurally incapable of revealing a key-path defect, because it satisfies the key path by construction. The panel reproduced the exact blind spot it was filing against, one layer up.

What this changes for whoever builds this row:

  1. Leg 3 is superseded by #168 — do not re-fix it. Once #168 merges, the missed=None sub-case in the body is still worth keeping as a test, but it is a nit beside the key path, not a finding.
  2. Legs 1 and 2 and the folded FOS-2 half are untouched by #168 and stand exactly as the triage annotation re-verified them.
  3. Step 3 gets stronger, and gains a requirement. The renderer↔gate consistency test must drive digest_exceptions from a payload produced by gather_fleet_digest (or a fixture built by calling the real gathers) — never from a literal. Had step 3 existed in that form, it would have caught #168's defect as well as legs 1 and 2. This is now the fourth instance of the same shape (the 2026-07-20 SATS scar, FOS-2, this row's legs 1–2, and #168), which retires any argument for closing it with three key additions and no test.

Annotation — 2026-09-21, panel run 27 (append only; body untouched; NOT a new row)

A fourth leg, found in the same five lines this row already cites (fleet_digest.py:1181-1187), and folded here rather than filed — it is strictly inside this row's ground and the 12-cap makes a near-twin the wrong trade.

The gate re-derives "NEW" by subtracting streaks from rows, while the producer already publishes the answer.

  • n_failed = len(d["failed_orders"]) counts today's order ROWS (digest.py:114, a flat status == "failed" filter);
  • n_standing = len(d["failed_standing"]) counts symbol STREAKS (digest.py:130, from split_new_and_standing);
  • failed_new — the correctly-typed symbol-level list — is published at digest.py:248 and read by digest.py:494 and :518, and digest_exceptions does not read it.

Executed against the shipped functions:

input: failed_orders=[AVB, AVB(market_replace_of)], failed_standing=[AVB streak=17], failed_new=[]
digest_exceptions(f)  -> ['meanrev: 1 NEW failed order(s)']
should_email(...)     -> (True, 'EXCEPTION: meanrev: 1 NEW failed order(s)')
failed_new (the producer's own answer) -> []

Two failed rows for one standing symbol fire an off-cadence email on a day carrying no new condition, labelled with a count that is wrong. The row sets genuinely differ: failed_streaks._index():60 skips market_replace_of re-logs; digest.py:114 does not — so the two sides of the subtraction are counted over different populations.

Direction, checked: one-directional false positive only. Streaks cover only symbols failing on the latest session, so n_standing <= distinct symbols failing today <= n_failed; a genuinely NEW failure is never missed. Severity is therefore low — an extra email and a wrong label — but over-alerting is the exact failure mode #163 was written to avoid, so it erodes the same channel from the other side.

Why it belongs here and nowhere else. The fix this row already names — "one shared formatter lifted from digest.py:515-528 _failed_detail" — reads failed_new. Anyone building DGX-1 is editing these five lines already; the change is len(d.get("failed_new") or []). Estimate unchanged at ~0.6 pd.

Add to this row's test set (step 3's renderer↔gate consistency sweep, which must drive digest_exceptions from a real gather, not a literal): two failed rows for one standing symbol must NOT produce an exception. tests/test_execution/test_digest_cadence.py parametrizes only the two-distinct-symbol case, so it cannot see this today.

Also recorded — one claim in the body above is now overtaken by events, and one binds harder than written:

  • OVERTAKEN. The folded FOS-2 half says the AVB streak "renders on the next email including meanrev" and calls that half ARMED. That email went out Friday 2026-09-18 at 18:39:54Z (run 35381395749, subject Thales fleet 9/18 ▸ $34,536 (+0.38%) ▸ 39 trades) — the first scheduled send under email_policy: weekly, and it worked. The rendering half is discharged.
  • BINDS HARDER. Today, Monday 2026-09-21, is the first day since the weekly policy went live on which digest_exceptions alone decides whether the owner hears anything (Friday sent on the cadence branch at :1209 without consulting the gate). Measured against committed state, today's 15:50Z run will withhold: the AVB failed emergency_exit is present on every session from 2026-08-17 through 2026-09-18 — 21 sessions, not the 15 the body records, so it is STANDING, n_failed (1) > n_standing (1) is False, and the day scores quiet. The renderer will describe a 21-session structural inability to exit a delisted name and the email will not be sent until Friday 09-25.
  • Leg 3 remains superseded by #168, still unmerged as of today — so the dark-routine exception still cannot fire on any input.

Prior-art check before folding rather than filing: no dgx-2/exc-* slug anywhere in research/queue/{open,approved,built,dismissed}/; nothing in the frozen research/RESEARCH_QUEUE.md; nearest neighbour is the already-folded FOS-2. The n_failed > n_standing design itself is FOS-1's deliberate anti-noise ruling (failed_streaks.py:9) and is not challenged here — only the mismatched units on its two operands.


TRIAGE ANNOTATION 2026-09-21 — leg 3's fix has been sitting unmerged for a week

Re-verified at HEAD a325c3c: _gather_option_sleeve (fleet_digest.py:151-172) still returns neither failed_orders nor failed_standing — the two keys digest_exceptions:1184-1185 reads — while it does emit "corrupt_position" at :160, which appears nowhere in digest_exceptions (:1157-1189) or any_red (:496-505) though _text_option_section:805 renders it 🔴. Legs 1, 2 and the folded FOS-2 half are untouched.

Leg 3 is still broken on main and is not "superseded". digest_exceptions:1174 still reads f.get("routines") where the gather stores the dict under "pipeline" (:545, written by _gather_pipeline_status at :423). PR #168 fixes it and has been open since 2026-09-14 — seven days, unmerged. The 15-09 correction note above is right that #168 supersedes the leg; it is wrong to read that as closed while #168 sits.

Today's context, recorded because it bears on the row's premise: the fleet digest did not run at all on 2026-09-21 — GitHub Actions refused every job in the repository on a billing failure. A gate that is blind to rendered alarms is a smaller problem than a renderer that cannot start, and this row's value assumes the digest runs. It does not change any leg; it does change the ordering argument, and honesty requires saying so.


Triage annotation — 2026-09-28 (annotation only; the body above is untouched)

All four legs present at HEAD 864da4e; two line references have drifted and are corrected here. Leg 1: fleet_digest.py:151-172 (_gather_option_sleeve) returns neither failed_orders nor failed_standing, which is exactly what digest_exceptions:1184-1185 reads. Leg 2: corrupt_position is emitted at :160, rendered 🔴 at :805-806, and absent from both digest_exceptions (:1157-1189) and any_red (:496-505, read in full — halts, kill-switch and no_run only). Leg 3: digest_exceptions:1174 still reads f.get("routines") while the gather writes out["routines"] at :423 nested under "pipeline" at :545; the renderers read pl.get("routines") at :861 and :960 (the body's 884/979 have drifted by line number only). Leg 4: failed_new is published at digest.py:248, consumed at digest.py:494/:518, and appears nowhere in fleet_digest.py. The test blind spot is intact — tests/test_execution/test_digest_cadence.py:21,25,55 still builds routines at the top level, the fixture shape that agrees with the bug.

Leg 1 is still never exercised, and the counter moved. data/state/vrp/order_log.jsonl is now 58 rows (52 on 09-14), statuses {None: 46, PENDING_NEW: 12}, zero failed. On the meanrev side order_log.jsonl holds 4,065 rows, 28 failed across 25 sessions, with AVB failed on 21 distinct sessions (last 09-18) — the body's "21 sessions" reproduces exactly.

THE BLOCKER IS NOW THE PR, AND IT HAS DOUBLED IN AGE. Leg 3's fix is PR #168, opened 2026-09-14T22:17Z — 14 days unmerged today, up from the 7 recorded on 09-21, with a base sha (c58ce68) now stale against HEAD. It is the repository's oldest open PR and it predates both implementer cycles since it was opened (09-16 and 09-23), which is this routine's own stalled-PR threshold. It cannot self-clear: auto-merge-records.yml is itself an Actions job and has had no runner since 09-21. Leg 3 should not be built until #168 merges or is closed, or the fix lands twice.

Premise partially suspended, stated so nobody mistakes silence for health. The digest has not run since 2026-09-18, so the row's prediction that "the email will not be sent until Friday 09-25" is moot — no digest ran at all, and a gate that never fires cannot be observed failing. The kill criterion is still a one-run check once the digest resumes.

Blocked on: the owner merging or closing #168 (leg 3); nothing formal for legs 1, 2 and 4. Effort unchanged at ~0.6 pd including the folded FOS-2 half.


Triage annotation — 2026-10-05 (annotation only; the body above is untouched)

All four legs present at HEAD 502690b in src/thales/execution/fleet_digest.py. Leg 1: _gather_option_sleeve (def :68) returns, at :151-171, neither failed_orders nor failed_standing — it emits date, no_run, equity, day_pnl, day_pct, equity_curve, position, corrupt_position, flat, twin, halted, orders_today, manage_rule, gate_days, gate_needed, dd_limit — while digest_exceptions reads exactly those two missing keys at :1184-1185. So a VRP failure still cannot become an exception. Leg 2: corrupt_position is emitted :160, rendered 🔴 at _text_option_section:806, and absent from both digest_exceptions (:1157-1189) and any_red (:496-505). Leg 3: digest_exceptions:1174 reads f.get("routines"), but the gather writes out["routines"] inside _gather_pipeline_status (:423) and the top level stores that dict under "pipeline" (:545); both renderers read it correctly via pl.get("routines") (:884, :979). Leg 4: failed_new is published at digest.py:248 and read at :494/:518 but not by digest_exceptions, whose n_failed > n_standing subtraction still mixes row counts against streak counts.

#168 IS NOW THE REPOSITORY'S OLDEST OPEN PR AT 21 DAYS (open, not draft, not merged; created 2026-09-14T22:17Z, last touched 2026-09-26T07:44Z; head audit/daily-2026-09-14). The 09-28 note said 14 days, the one before it 7. Leg 3 is the only leg that depends on it; legs 1, 2, 4 and the folded FOS-2 half are unblocked and buildable today.

EXPIRY — the live-bleed argument is GONE; all four legs are now latent. Leg 1's sample grew but stayed clean: data/state/vrp/order_log.jsonl holds 62 records, statuses {None: 49, PENDING_NEW: 13}, zero failed over the sleeve's whole life (the row says 52 / {None:41, PENDING_NEW:11}). More importantly the run-27 annotation's "21 consecutive sessions, so today scores quiet" no longer describes live state: the AVB failed-emergency_exit streak ended 2026-09-18, and data/state/meanrev/order_log.jsonl shows 25 failed-order days from 07-20 to 09-18 and zero failed orders since (164 records across 10-01/10-02/10-05, all PENDING_NEW). The row's shape — a renderer and a gate written from different sources of truth — is untouched, and fix step 3 (drive digest_exceptions from a real gather) is still the non-recurring fix.

WHY IT KEEPS ITS SLOT DESPITE GOING LATENT, and why it may be about to get more important rather than less. The tbx-win cutover (scheduled 2026-10-06 evening) moves trading off GitHub, and the four healthchecks that watched the trading and capture runs — thales-momentum, -meanrev, -vrp, -skew — were deleted on healthchecks.io 2026-10-02 (recorded in ops/windows-host/README.md, per PR #212). After the cutover the fleet digest's own exception list is the last automated thing standing between a dead runner and a silent week, and this row is a list of the alarms that list cannot see. A latent defect in the only surviving watcher is not a lower priority than a bleeding defect elsewhere. See this week's report, decide item #2.

Rank this week: 12 of 12 — the last slot under the cap, held on that argument alone. If a thirteenth row arrives before #168 moves, this is the one to re-examine first, and the question to ask then is whether legs 1/2/4 should be split out from leg 3's dependency. BLOCKED on: #168 for leg 3 only. 0.5 pd.


Panel annotation — 2026-10-08 (run 37; annotation only, the body above is untouched)

THE BLOCKER IS GONE. This row is now fully unblocked, and it said in advance that this is the moment to re-examine it. :516 reads "BLOCKED on: #168 for leg 3 only." #168 merged 2026-10-07 as 1ce2ab3, and leg 3's defect is fixed: fleet_digest.py:1307 now reads the nested ((f.get("pipeline") or {}).get("routines")), the path the gather actually writes. The buggy top-level read is provably inert — a {'routines': [...]} payload now returns []. :513-516 pre-registered that "if a thirteenth row arrives before #168 moves, this is the one to re-examine first, and the question to ask then is whether legs 1/2/4 should be split out from leg 3's dependency." #168 has moved, so that question is now answerable, and it is Monday's triage to answer — not this panel's.

BUT #168 DID NOT DISCHARGE FIX STEP 3, AND THE TEST FILE SAYS SO ITSELF. #168 added hermetic tests driving the real join (tests/test_execution/test_digest_cadence.py:173+), which is why this looks like step 3. It is not: test_digest_cadence.py:180-182 states its own scope — "this covers the ROUTINE-liveness leg only. It does not discharge DGX-1 step 3 as a whole (every renderer alarm line ↔ an exception)." So leg 3's wrong-key-path bug is fixed; step 3's general form — the test that walks every alarm line a renderer can emit and asserts each produces a non-empty digest_exceptions — is not built.

THE ROW SURVIVES ITS OWN KILL CRITERION, run verbatim at HEAD c251109. :490-497 pre-registered that this row is "wrong and must be closed unbuilt" if a fresh run returns a NON-empty digest_exceptions() for any of three payloads. All three return []:

(a) vrp sleeve carrying a failed order   -> []
(b) corrupt_position=True                -> []
(c) all routines missed=None (unknown)   -> []
    NEGATIVE CONTROL, steward genuinely DARK (beacon present, pings missed)
                                         -> ['1 routine(s) dark (steward)']

The control is the point: the dark path works once a beacon branch exists, so the surviving gap is precisely the unknown bucket and the two option-sleeve keys, not the detector as a whole. Legs 1, 2 and 4 all still present at HEAD (_gather_option_sleeve's return emits neither failed_orders nor failed_standing while digest_exceptions:1317-1318 reads exactly those; corrupt_position emitted, rendered, and absent from both the exception set and any_red; the n_failed > n_standing row-vs-streak subtraction unchanged).

NEW INSTANCE OF THE LIVENESS-UNKNOWN HALF — and it is the first one that is UNBACKSTOPPED. Fix step 2 names the missed is None case. On 2026-10-07 #226 created a seventh cloud routine, the steward, which now reads every alert the owner no longer receives. Three verified facts put it in exactly this row's blind spot:

  1. It is the only routine with no healthchecks.io check. routine-beacon.yml:56-61 lists six HEALTHCHECK_URL_* secrets; :81-85 gives the steward URL=""; NO_PING=1, and the comment states the substitution explicitly — "The beacon branch itself is the record: the fleet digest's DARK detection reads beacon/steward, as it reads every beacon."
  2. beacon/steward does not exist. git ls-remote --heads origin 'beacon/*' returns six branches (daily-audit, implementer, panel, research-audit, triage, weekly-audit) and no steward. Its first scheduled firing is tonight; the 2026-10-07 report was written interactively with the owner present, before the routine existed.
  3. So _last_beacon_date returns None → missed=None (:340) → the unknown bucket (:361, :369-371), rendered as a body-only "? 1 routine(s) with no readable beacon" — and digest_exceptions:1308 filters on truthy missed, so it is not an exception and gets no ⚠️ subject.

That makes ops/STEWARD.md:256-257 — "The fleet digest marks you DARK when it stops moving; that is the only thing that tells the owner you died" — false until the first successful beacon push. The substitution at routine-beacon.yml:81-85 is sound for the steady state (the negative control above proves it) and uncovered before the first ping.

HONEST SIZING, so nobody over-reads this: the steward's trigger exists, is enabled, and its next_run_at is 2026-10-08T23:00:30Z — tonight (control-plane read). If it fires, the exposure closes tonight and the DARK path takes over. It persists indefinitely only if the routine never fires once, and even then it is visible as a ? line in the body of a Friday digest the owner does read. This is a one-day window on a self-closing condition, recorded because the general gap — a routine that has never pinged can never be DARK — is this row's leg 2 and outlives the instance.

THE RANK ARGUMENT'S OTHER INPUT ALSO MOVED, against the row. :502-513 holds slot 12 on the argument that after the tbx-win cutover "the fleet digest's own exception list is the last automated thing standing between a dead runner and a silent week." The cutover has not happened — #206 is still open (created 2026-10-02; its 2026-10-08 timestamp is a Vercel preview-bot comment, not activity). So on current facts triage is re-ranking a three-leg row whose blocker is cleared and whose urgency premise is unlanded.

Panel run 37 opened no row and forced no eviction. This annotation is a records correction to an already-open item; it spends no registry row and no trial budget.


ANNOTATION 2026-10-16 (panel run 39) — A NEW LEG: on any day with a dark routine, the HTML twin drops BOTH the new ⏳ awaiting line and the pre-existing ? no readable beacon line, i.e. exactly on a compound-failure day

Plain-language summary. The HTML email — the one the owner actually reads — renders its own "routines DARK" line and then skips the shared liveness renderer entirely. So on any day where at least one routine is dark, the HTML email silently loses two other liveness lines: the ⏳ awaiting bucket #241 added on 2026-10-15, and the older ? N routine(s) with no readable beacon line. Those are precisely the lines that matter on a day when something is already wrong. The text twin keeps them.

The code, quoted verbatim at HEAD (src/thales/execution/fleet_digest.py:1200-1210):

        if "routines" in pl:
            rt = pl.get("routines")
            dark = [r for r in (rt or []) if r.get("missed")]
            if dark:
                ...
                rows.append(f"<b>⚠ {len(dark)} routine(s) DARK</b> — scheduled runs "
                            f"produced no beacon: {items}")
            else:
                rows.extend(ln.strip() for ln in _routine_liveness_lines(rt))

That else is the only path to _routine_liveness_lines, which is the sole producer of the ⏳ awaiting line (:435-438) and the ? … no readable beacon line (:431-433). The text twin has no such branch — it always calls the shared function (:1080-1081).

Measurement taken. One payload carrying 1 dark + 1 awaiting + 1 unknown routine, rendered through both twins at HEAD:

awaiting line        text=True  html=False
unknown line         text=True  html=False
dark line            text=True  html=True
exceptions: ['1 routine(s) dark (panel)']

The negative control is that there is nothing to revert. The defective behaviour is green on all 1776 tests — no test pins HTML/text parity for this block. Per ops/RESEARCH_PANEL.md "What matters here" #4, a detector that cannot fail is the finding.

This is live today, not hypothetical. Every routine beacon last moved on or before 2026-10-09 (four weekdays dark, 10-12 → 10-15), so tonight's digest renders with dark non-empty and the HTML twin takes the defective branch.

Severity sits with the unknown half, not the new one. ? no readable beacon means the liveness probe's own data source failed — and it is suppressed from the email exactly when something else is already dark. The awaiting half is milder by design (#241 deliberately raises nothing: it leaves digest_exceptions untouched), but it was added five days ago specifically to make a passed-slot visible, and in the HTML twin it is invisible on the days that matter.

Why this belongs here and not in a new slug. bcn-1:69 (dismissed) draws the boundary explicitly: "DGX-1 (open) holds the digest-gate blindness, including the missed=None 'no readable beacon' leg." So the unknown half is already this row's ground. But this row's structural fix (its step 3) is a test that every renderer-emittable alarm produces a non-empty digest_exceptions — which says nothing about one renderer dropping a line the other prints. nol-1 holds twin parity for NEEDS-OWNER: bullets only. grep -rliE "readable beacon|awaiting" across all four queue dirs returns only dgx-1, cqa-3, frz-1, bcn-1 and open/README.md — none on this surface. With open/ at 10 of its 12-file cap, a near-twin slug would be the wrong instrument.

Kill criterion for THIS leg (pre-registered). For a payload carrying at least one missed > 0 routine and at least one awaiting routine and at least one missed is None routine, every line _routine_liveness_lines emits appears in the HTML render as well as the text render — demonstrated with the negative control shown red (restore the if dark: early branch → the parity test fails). The leg dies unbuilt if a fresh run of that three-bucket payload already shows all lines in both twins.

Effort ~0.1 pd — collapse the HTML branch onto the shared function (or extend it with the two missing buckets), plus one parity test. Observability tier; cannot fail-close trading.


Triage annotation — 2026-10-19 (annotation only; the body above is untouched) — THIS ROW'S HARM MODEL IS FALSIFIED BY OWNER POLICY. The four code defects are real; the consequence the row argues cannot occur.

The claim that is dead. The row's stated harm, from its title down, is that digest_exceptions() returns "quiet day off-cadence" and therefore "withholds the mail until Friday". Under the live policy it cannot: config/fleet.yaml:61 is notifications.email: weekly_digest_only, and fleet_digest.py:1478-1486's should_email returns False on every non-Friday regardless of the exception list ("WITHHELD (owner policy: weekly digest only)"). An exception no longer buys an off-cadence email for anyone, so a missed exception no longer costs one. The 2026-10-05 annotation's slot-12 argument — "the exception list is the last automated thing between a dead runner and a silent week" — does not survive this: the exception list cannot page anybody.

What the four legs still cost, stated at its true size. (i) the missing ⚠️ prefix on the Friday subject (:1537-1540), and (ii) a missing line in the withheld-record email_reason that the steward reads in the owner's place. That is a real loss of signal on the one channel the owner reads and on the record his delegate reads — but it is a Friday-subject defect, not a silent week.

Leg status at HEAD, with the row's line cites re-pinned (all have drifted).

  • Leg 1 PRESENT — _gather_option_sleeve (:68) returns at :177-198 without failed_orders or failed_standing, which is what digest_exceptions reads at :1442-1443 (row cites :1184-1185).
  • Leg 2 PRESENT — corrupt_position emitted :185, rendered 🔴, absent from both digest_exceptions (:1400-1447) and any_red (:655-664).
  • Leg 3 DISCHARGED by #168 — :1427 now reads ((f.get("pipeline") or {}).get("routines")).
  • Leg 4 PRESENT — :1442-1445 still compares n_failed > n_standing (rows vs streaks); failed_new, published at digest.py:248, appears nowhere in fleet_digest.py.
  • Leg 5 PRESENT at :1221-1231 (the 10-16 annotation cites :1200-1210): the awaiting and unknown lines render in text and are dropped from HTML.

Why legs 1 and 2 are not zero. The vrp sleeve holds an open short SPY put spread today (data/state/vrp/vrp_position.json: entry 2026-10-19, expiry 2026-11-20, qty 1, width 1.0), and its order log is now 76 rows / 17 orders with zero failures ever — so leg 1's path has never been exercised, on the one sleeve where an unmanaged position is a money event rather than a reporting one.

Two of this row's factual claims are stale and are corrected here. The 10-08 annotation's "the steward has no beacon, so it can never be reported DARK" has closed — beacon/steward exists, last moved 2026-10-16. The 10-16 annotation's "every routine beacon last moved on or before 2026-10-09, four weekdays dark" is wrong: panel and weekly-audit moved 10-19, daily-audit and steward 10-16. Driving the real _gather_routine_liveness with today's actual beacon dates gives 2 DARK (queue triage, research implementer) and 0 unknown, 0 awaiting — so leg 5's defective HTML branch is taken today but drops nothing today. A new _last_beacon_date_git (:322-340, added 2026-10-19 for the box) makes the unknown bucket strictly less reachable than when the row was written.

Kill criterion re-run verbatim: the row SURVIVES — (a) a failed vrp order → []; (b) corrupt_position=True → []; (c) all routines missed=None → [].

Triage's disposition, stated plainly. Not dismissed, and the reason is narrow: the surviving consequence touches the live options sleeve's one alarm path, and BGS-1 (open PR #252) overlaps this row's territory but is not yet a file in queue/open/ — dismissing today would drop the row before its successor exists. This is now the lowest-ranked row in the tree and the named first eviction when queue/open/ next exceeds the 12-item cap (it is the largest file at 696 lines, every leg latent, no deadline, urgency DOWN). If BGS-1 merges and takes the free slot, this row goes without further argument.


ANNOTATION 2026-10-20 (panel run 41) — THIS ROW'S 2026-10-19 DOWNGRADE RATIONALE WAS INVALIDATED BY #249, MERGED 2 MINUTES 23 SECONDS EARLIER IN THE SAME STEWARD BATCH. There IS a non-Friday True path again, and this row is the named next eviction on the strength of the sentence that is now wrong

Annotation only; the body above is untouched.

What the 10-19 annotation says, and why it is no longer true

It states: "fleet_digest.py:1478-1486's should_email returns False on every non-Friday regardless of the exception list" and "An exception no longer buys an off-cadence email for anyone."

#249 (21d60d4, merged 2026-10-19T23:17:46Z) added one. should_email at src/thales/execution/fleet_digest.py:1498-1503 now returns

(True, "EXCEPTION (steward dark — owner exemption): " + "; ".join(exc))

off-cadence, under the owner's 2026-10-18 ruling. #254 — which carries the annotation above — merged at 23:20:15Z, 2m23s later, in the same hand-merge batch. The rationale was accurate when written and stale before the commit that carried it landed.

Measured against the live beacons today:

should_email 2026-10-20, live:          (False, 'WITHHELD (owner policy: weekly digest only): 1 routine(s) dark (research implementer)')
should_email 2026-10-20, stale steward: (True,  'EXCEPTION (steward dark — owner exemption): 2 routine(s) dark (steward, research implementer)')

What is and is not falsified — stated narrowly on purpose

The inference mostly survives. The new path is gated on steward_dark(f), not on digest_exceptions(f), so a missed exception still cannot cause an off-cadence email. That much of the downgrade stands.

What changes is the size of the loss. On a steward-dark day the ⚠️ prefix and the exception block are now rendered into an email that actually reaches the owner off-cadence, and it is built from the same digest_exceptions(f) this row shows is blind to failed vrp orders, corrupt_position and failed_new. So the loss is no longer "a Friday subject prefix and a line in a withheld record." It is also the off-cadence alarm the owner receives precisely on the day nobody else is reading — the live VRP sleeve's one alarm path, which is the exact reason triage declined to dismiss this row in the first place.

Why this is urgent rather than academic

Triage's 2026-10-19 report named this row "the lowest-ranked row in the tree and the named first eviction" on that rationale. This run's change reviewer surfaced a trading-safety finding (filed as LAB-1 leg 3) which is the row that would trigger that eviction. So the ranking that would evict DGX-1 rests on a sentence #249 falsified two minutes before it was committed, and it should be re-stated against post-#249 code before the cap binds on Monday 2026-10-26.

Negative control

The live-beacon exercise above (and #249's own three controls, recorded in this run's PR). Not executable as "revert and watch a test go red": no test asserts DGX-1's harm model — it is a queue claim, not a pin. That absence is worth noting on a row whose rank is decided by the claim.

Kill criterion for this annotation

Discharged once DGX-1's triage line names the steward-dark path and re-states the loss as {Friday subject prefix, withheld-record line, off-cadence steward-dark email body}. It is wrong, and should be dropped, if someone shows steward_dark(f) can be true only on a Friday.

Effort: zero code — a ranking correction.


ANNOTATION 2026-10-23 (panel run 43) — a THIRD measured instance of leg 1's shape, this time in code that has not merged yet, and it bears on Monday's eviction ranking

Body untouched. New evidence only.

Leg 1 of this row says _gather_option_sleeve returns neither failed_orders nor failed_standing while digest_exceptions reads exactly those keys, so the VRP sleeve is invisible to the cadence gate. Open PR #270 adds a third key with the identical defect, and adds it immediately above the two legs this row already owns.

#270 ("the terminal-status sweep is silent when it resolves nothing — and VRP has never had an order outcome recorded") ships unrecorded_outcomes and states in its body that the detector is "raised as a digest_exceptions line", with a calibration table asserting vrp: 1 on 2026-10-26 and the claim "It fires on the live defect and on nothing else."

Verified by execution against the PR head 842a06e7, in an isolated worktree (the chair and the change-reviewer lens reproduced this independently, and the adversarial reviewer a third time):

option gather mentions unrecorded_outcomes : False
A) vrp payload as production builds it     -> []
B) same payload with the key present       -> ['vrp: 1 order(s) with NO recorded outcome
                                               past the status sweep's window (oldest 2026-10-19)']

The chain: unrecorded_outcomes is written in exactly one place, digest.gather_digest (the weights gather). gather_fleet_digest routes contract == "order_intent" to _gather_option_sleeve (fleet_digest.py:627), whose single literal return carries 16 keys and not this one; nothing mutates entry["data"] afterwards. The sole reader (:1453) does d.get("unrecorded_outcomes") or {} → {} for vrp, permanently. Control B proves the reader is correct the instant the key exists — a wiring gap, not a logic bug, which is leg 1 exactly.

Three things sharpen it beyond the two instances already in this row:

  1. The PR names the defect in its own title — "VRP has never had an order outcome recorded" — and the alarm it ships for that defect cannot observe VRP.
  2. The justification sits directly above the blindness. The new comment at :1448-1452 reads "a week of silence about that is wrong on an options sleeve, where an unfilled CLOSE leaves a short put live", above a loop that cannot see the options sleeve. It then asserts "Only ever non-zero because a sweep could not account for it, so there is no quiet-day reading" — true for weights sleeves, false for vrp, where it is zero by construction.
  3. The green is manufactured. All six unrecorded_outcomes tests call status_sweep.unrecorded_outcomes(state, …) directly; the one digest-level test hand-builds {"name":"vrp","data":{"unrecorded_outcomes":{…}}}. No test ties _gather_option_sleeve's real output to digest_exceptions. A detector that cannot fail on the real path is this shop's standing finding, and here it ships with a calibration table.

This is why leg 3 matters. Leg 3 of this row is the structural test — assert every key digest_exceptions reads is produced by every gather — and it is the thing that would have caught #270 before review. Three instances in one function is no longer a coincidence; it is the absence of that test.

Ranking consequence, for the 2026-10-26 sweep. This row is triage's pre-declared first eviction, on a rationale its own 2026-10-20 annotation already records as falsified by #249 and flags as needing re-statement before the cap binds. This annotation is new input to that re-statement: the row's harm model has recurred twice since it was filed, the second time in unmerged code, and leg 3 is the only thing in the tree that prevents a fourth. Note also that dismissed/fos-2 reopens immediately if DGX-1 is dismissed, so evicting this row is net-zero on slots — it converts one open row into one reopened row.

Not a new row, and no new slug proposed: the mechanism is owned here, and the #270-specific half is a pre-merge matter raised on that PR rather than queued.


ANNOTATION 2026-10-26 (panel run 44) — #273 CLOSED THE PER-ROW HALF OF THIS DEFECT, AND THE NEW DETECTOR'S OWN GUARD EXCLUDES THE WORSE HALF

Still open; no sibling row. This is this row's named shape — the renderer and the gate written from different sources of truth — applied to a strictly more severe input, in code that landed in this delta.

#273 added a digest_exceptions branch at fleet_digest.py:1516:

if rows and all(r.get("missed") is None for r in rows):

That fires when every routine row's liveness is unknown. But _gather_routine_liveness returns None, not a list of unknowns, whenever the registry cannot be read: :471-474 returns None on any parse exception and on an empty parse, and _parse_routines_table:269-280 returns [] when ## Active is missing, when fewer than three table rows are found, or when any of three column names is renamed. The caller flattens that to [] at :1490 (rows = ((f.get("pipeline") or {}).get("routines")) or []). So rows is falsy, if rows and … short-circuits, and the new branch is skipped on the case where the registry is unreadable — while the renderer still speaks: _routine_liveness_lines:501-503 prints "routines: liveness unavailable (ops/ROUTINES.md unreadable)".

So the digest will say, in prose, that it cannot see any routine's liveness, and the exception gate that decides whether a non-Friday digest is worth sending will not count it. That is one layer worse than the per-row unknown case #273 fixed, because "I cannot read the registry at all" is the state in which every routine could be dark.

What to build when this row is picked up: a rows is None branch, not an extension of the all(...) predicate — the two states are different and the or [] at :1490 is what erases the distinction. The negative control is cheap and should be required: rename one column in ops/ROUTINES.md's ## Active table, confirm the renderer prints "liveness unavailable" and the exception gate fires.

And the only test that would catch a column rename cannot run on a normal day. tests/test_execution/test_fleet_digest.py:590 is the one test covering it, and that file carries a module-level pytestmark = pytest.mark.observability. Per BGS-1 (approved), fleet-digest.yml:245-247 gates the sole -m "observability or research" runner on needs.box.outputs.ran != 'true', so that tier is skipped every day the box succeeds. The detector, its gate and its test are all in places that do not run or cannot fail.

One sentence recorded here rather than anywhere that would look like a new item, because it is the same "the only enforcement lives where nothing runs" class: FRZ-1 (#280) put its two sentinel-hash tests in the trading gate — those are unmarked and genuinely enforced, verified this run — but its generalising phrase-scan meta-test, the one thing that would stop a future append-only pin from being added without a hash, is observability-marked and therefore in the same skipped tier.

Eviction note for triage, since this row is a standing eviction candidate: dismissing DGX-1 reopens dismissed/fos-2 immediately, so that trade is net-zero on slots. NOL-1 is today's zero-cost eviction; this row is not.

Kill criterion unchanged, plus one clause: this row also dies if a rows is None branch lands with the column-rename negative control above passing in a job that runs when the box succeeds.

Triage annotation — 2026-10-26 (annotation only; the body above is untouched) — MY "NAMED FIRST EVICTION" IS WITHDRAWN: THE MOVE IS NET-ZERO

Correction to this routine's 2026-10-19 report, which named DGX-1 "the named first eviction when the cap next binds." That was wrong on the slot arithmetic. research/queue/dismissed/fos-2-fleet-email-missing-streak-split.md:41-45 reads: "Reopen immediately if DGX-1 is dismissed, or if DGX-1 is built without a shared failed-order formatter reaching the fleet email body — the fold is only safe while DGX-1 carries it." FOS-2 was dismissed as "a fold, not a kill" into this row, so dismissing it reopens FOS-2, gains no slot, and loses the fold. FIN-4 takes the next-eviction role, named in its own file today.

Still lowest-ranked of the open rows, and still not dismissed. Every leg is latent and the row's headline harm stays falsified: should_email (fleet_digest.py:1576-1591) under weekly_digest_only (config/fleet.yaml:64) withholds every non-Friday exception except steward_dark, so a missed exception can no longer buy a lost email — the residual loss is the Friday ⚠️ prefix, the withheld-record line, and the steward-dark off-cadence body. Re-run of its kill criterion: it survives (all three payloads still render to []).

#273's new branch is real and still cannot see the worse case. fleet_digest.py:1516 now guards if rows and all(r.get("missed") is None …). But _gather_routine_liveness returns None at :473/:475, _parse_routines_table returns [] at :269/:272/:281 on a renamed column, and the caller flattens to [] at :1492 — while the renderer still speaks at :503. So the rows is None / rows == [] case the gate excludes is exactly the case its own renderer reports. Legs 1, 2 and 4 are unchanged: the option gather's return block (:178-199) has neither key digest_exceptions reads at :1527-1528; corrupt_position is emitted :186 and rendered :1087 but appears in neither digest_exceptions nor any_red (:720-730); and n_failed > n_standing still compares rows to streaks.

Measured, so the latency is not an assumption: data/state/vrp/order_log.jsonl statuses are {None: 64, PENDING_NEW: 17} — zero failures ever recorded, on a sleeve carrying an open SPY put spread to 2026-11-20. The rows is None branch alone is ~0.1 pd; the whole row with the FOS-2 fold is ~0.5–0.6 pd and overlaps BGS-1, which is already approved. Whoever picks up either should merge or explicitly split them first — they share fleet-digest.yml:266.


DISMISSED 2026-11-03 — queue triage, overflow under the pre-registered 12-cap

Fourth and last of the evictions owed (open/ stood at 16 against a cap of 12). I am reversing my own two previous reports on this row, and saying why.

All four legs reproduce at HEAD, and all four are latent. Leg 1: _gather_option_sleeve's return block (fleet_digest.py:178-199) carries neither failed_orders nor failed_standing, the two keys digest_exceptions reads at :1527-1528. Leg 2: corrupt_position is emitted at :186 and rendered at :1087 but appears in neither digest_exceptions nor any_red (:720-730). Leg 3: n_failed > n_standing at :1529 still compares a row count to a streak count. Leg 4: :1516 is still if rows and all(r.get("missed") is None for r in rows), while _gather_routine_liveness returns None on both a parse exception and an empty parse (:471-475), the caller flattens that to [] (:1492), and the renderer still speaks at :502-503 — the rows is None branch does not exist.

Its headline harm is structurally impossible under current policy, and re-verified by reading the gate. should_email (:1611-1643) under config/fleet.yaml:64 notifications.email: weekly_digest_only withholds every non-Friday exception except steward_dark. A missed exception therefore cannot cost an email. The whole residual loss is a Friday ⚠️ prefix and an off-cadence steward-dark body. Three of the payloads still render as [], so the row's own kill criterion survives — it is simply pointing at a reporting cosmetic while the queue carries four P0/P1 rows with dated fuses.

The slot arithmetic, stated honestly — and my previous reasoning on it was backwards. On 2026-10-19 I named DGX-1 the first eviction; on 2026-10-26 I withdrew that, because dismissed/fos-2's reopen condition reads "Reopen immediately if DGX-1 is dismissed" (FOS-2 was dismissed as "a fold, not a kill" into DGX-1), making the eviction net-zero on slots. That is arithmetic, not judgement, and I let it protect a row I had already measured as latent on every leg. A slot count is not a reason to keep a dead row. So: FOS-2's reopen condition is hereby FIRED and reported — dismissed → open is the steward's move, never mine, and the steward should decide whether FOS-2 comes back as a row in its own right. If it does, open/ returns to 12 with FOS-2 in DGX-1's place, which is the correct outcome: FOS-2's subject (the fleet email's missing streak split) at least concerns the one channel that still sends.

Reopen conditions (any one):

  1. notifications.email returns to all, or digest.email_policy returns to anything that mails non-Friday exception days. The headline harm — a withheld alarm costing a send — becomes live again the same day, and this row reopens at its original severity.
  2. Any of the three []-rendering payloads is observed non-empty on a Friday (failed_orders, failed_standing, corrupt_position): the exception gate would then have been wrong on a send that actually went out.
  3. _gather_routine_liveness returns None in production — a parse exception or empty parse on a real run, visible as a liveness section that speaks with no rows. This is leg 4, the worst leg, and ~0.1 pd on its own.
  4. FOS-2 is reopened by the steward and its streak-split work begins — the two are one change in fleet_digest.py; this row folds back in rather than being rebuilt.