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 frozenresearch/RESEARCH_QUEUE.md: nodgx-*slug, and no row ondigest_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.mdreject 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:
- Give
_gather_option_sleevethe two keys the contract already implies —failed_orders(it already holdsorders_todaywithstatus) andfailed_standing(the samefailed_streakssplit 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. - Add
corrupt_positionand themissed is None("liveness unknown") case to the exception set. - The structural half: a test that walks the alarm conditions the
renderers can emit (
🔴,!!, the?-liveness line) and asserts each one produces a non-emptydigest_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_livenessis called inside_gather_pipeline_status, which writesout["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:884and:979; digest_exceptionsreadsf.get("routines")(:1174) — the top level, which the gather never populates.rowsis therefore always[]anddarkalways 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:
- Leg 3 is superseded by #168 — do not re-fix it. Once #168 merges, the
missed=Nonesub-case in the body is still worth keeping as a test, but it is a nit beside the key path, not a finding. - Legs 1 and 2 and the folded FOS-2 half are untouched by #168 and stand exactly as the triage annotation re-verified them.
- Step 3 gets stronger, and gains a requirement. The renderer↔gate
consistency test must drive
digest_exceptionsfrom a payload produced bygather_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 flatstatus == "failed"filter);n_standing = len(d["failed_standing"])counts symbol STREAKS (digest.py:130, fromsplit_new_and_standing);failed_new— the correctly-typed symbol-level list — is published atdigest.py:248and read bydigest.py:494and:518, anddigest_exceptionsdoes 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 underemail_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_exceptionsalone decides whether the owner hears anything (Friday sent on the cadence branch at:1209without consulting the gate). Measured against committed state, today's 15:50Z run will withhold: the AVB failedemergency_exitis 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:
- It is the only routine with no healthchecks.io check.
routine-beacon.yml:56-61lists sixHEALTHCHECK_URL_*secrets;:81-85gives the stewardURL=""; 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." beacon/stewarddoes 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.- So
_last_beacon_datereturns None →missed=None(:340) → theunknownbucket (:361,:369-371), rendered as a body-only "? 1 routine(s) with no readable beacon" — anddigest_exceptions:1308filters on truthymissed, 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-198withoutfailed_ordersorfailed_standing, which is whatdigest_exceptionsreads at:1442-1443(row cites:1184-1185). - Leg 2 PRESENT —
corrupt_positionemitted:185, rendered 🔴, absent from bothdigest_exceptions(:1400-1447) andany_red(:655-664). - Leg 3 DISCHARGED by #168 —
:1427now reads((f.get("pipeline") or {}).get("routines")). - Leg 4 PRESENT —
:1442-1445still comparesn_failed > n_standing(rows vs streaks);failed_new, published atdigest.py:248, appears nowhere infleet_digest.py. - Leg 5 PRESENT at
:1221-1231(the 10-16 annotation cites:1200-1210): theawaitingandunknownlines 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:
- 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.
- The justification sits directly above the blindness. The new comment at
:1448-1452reads "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. - The green is manufactured. All six
unrecorded_outcomestests callstatus_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 todigest_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):
notifications.emailreturns toall, ordigest.email_policyreturns 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.- 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. _gather_routine_livenessreturns 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.- 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.