Repository navigation
fix(dashboard): return a structured monitor on the legacy autonudge reads - #9474
Conversation
Design Review (Fable 5) — 🟡 CONCERNSDesign-level review of Design-Verdict: CONCERNS HEAD maps the cycle counters that the PR body, commit message, in-code comment and frontend comment all still say are withheld — every narrative surface describes the superseded revision. WatchThe entitlement-reduction design itself is sound (verbatim pass-through leaks wake instructions; total withholding lies via the "0 = ∞" default), and the mapped variant at HEAD is the best of the three. But the shipped code contradicts itself: Suggestions
[DESIGN-REVIEWED] b10f23b |
Opus 4.8 Review — ✅ no blocking findingsReviewed Review detailsNo BLOCKING findings; one advisory. FINDING — src/kiro_crew/dashboard/handlers/autonudge.py:283 — [OPUS-REVIEWED] b10f23b Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
First Principles Review (Fable 5) — 🟡 CONCERNSPremise-level review of All evidence is gathered. The code, module spec, and tests are internally coherent (the three cycle-accounting fields are mapped and published), while the PR description, the RFC hunk, and the frontend type comment shipped in the same diff all state those fields are withheld — that intra-diff contradiction is the main finding. The reduction itself sits on a named multi-human/network boundary, the defect has in-repo provenance (RFC step 0, PR #5186), and First-Principles-Verdict: CONCERNS The description, the RFC hunk, and the shipped TS comment all say cycle accounting is withheld; this PR's own code and tests publish it mapped. Not justified as shipped
What this change shipsInventory (9 items) — 7 justifiedIntent: let the goal popover see that a structured monitor is armed on a session, without leaking what it watches through the un-gated legacy reads — a FIX.
Watch
Subtractions
[FIRST-PRINCIPLES-REVIEWED] b10f23b |
8c5d967 to
15d978a
Compare
GPT 5.6 Review — ✅ no blocking findingsGPT 5.6 completed its review of This comment is updated in place on each push. Review detailsNo findings. False positive or not applicable? A repository writer can comment: |
15d978a to
b20cc49
Compare
Disposition recordsOne lane, one rationale per finding. Head DESIGN -- Watch: the wire contract diverges from One thing the finding did not weigh, and it is the load-bearing half: Stop already works. FIRST-PRINCIPLES -- Item 3: Declined for three reasons. Liveness is part of what this surface was required to answer -- what is armed, on what cadence, how far in, in what state -- and items 1 and 2 answer only the first two. FIRST-PRINCIPLES -- Item 5: the corrected docstring path rides along. ACCEPTED, kept. It is one word in a docstring this PR already rewrites, and the registered route really is FIRST-PRINCIPLES -- Watch: a point patch, with one unfixed sibling -- the newly entitled non-owner gets no websocket frame and so no re-read trigger. ACCEPTED, deferred by the lane's own second criterion. Sharp, and correct: the structured frame goes through PR Hygiene -- missing PR Readiness -- body references an issue with no closing keyword. FIXED, stated as The cancelled |
7e3e583 to
f10bf06
Compare
Disposition, First Principles round 2 (head
|
UX Review (Fable 5) — 🟡 CONCERNSUX-level review of The evidence is complete. Reconciling: the PR's core value — the chip appears and Stop works on a monitor-armed session — is confirmed in the frames and the blind reader identified both and dared to use them. But the popover the fix lights up still narrates the monitor as an editable nudge loop: fabricated default goal text (with a literal UX-Verdict: CONCERNS Chip and Stop now work for a running monitor, but the popover they open narrates it as an editable nudge loop with a fabricated goal. Watch
Evidence gaps
[UX-REVIEWED] b10f23b |
Disposition, round 3 (head
|
f10bf06 to
9e5512c
Compare
Disposition, round 4 (head
|
9e5512c to
9657f27
Compare
Disposition, round 5 (head
|
|
9657f27 to
318b93a
Compare
…t verbatim The goal popover reads GET /api/autonudge and its per-slot sibling. Both dropped a structured monitor -- the list filtered it out and the per-slot read answered loop: null -- so the popover reported nothing armed while a monitor was probing. Routing babysit through monitor_watch makes that a live regression, and the popover is the only place a person can see what is armed. Returning the record verbatim would have fixed one fault by committing a worse one. These two reads carry NO owner gate, while the structured record is owner-scoped everywhere else it is published: /api/monitors and its per-slot sibling sit behind _require_monitor_owner, and the autonudge_state websocket frame sends a structured loop through broadcast_ws_owners. The current bug hides information from someone entitled to see it; publishing the record here would show it to someone who is not. So the field list is decided by entitlement. The legacy reads now answer existence, cadence, liveness and state -- the loop's own fields plus a monitor_presence object carrying probe_count, wake_count and outcome, under a key of its own so a reduced reading cannot be mistaken for the full record. They withhold everything describing WHAT is watched. Withheld as owner-scoped: the whole monitor record; message, which on a structured monitor IS the wake instructions, since both arming paths set message=monitor.wake_instructions or "structured monitor"; banner, the same class of agent-authored text; and stop_sentinel_path. Withheld as unmaintained, their legacy reading being false rather than merely uninformative: max_cycles, cycle_count and last_fire_ts. _timer returns on its structured branch before every write and every read of them, so they say "no cycle cap, has not run yet" about a record bounded by monitor.budgets that has been observing. No withheld field is replaced by a null, an empty string or a plausible default. The reduction is enforced by never assembling the withheld fields rather than assembling and deleting them, so no intermediate payload holds the monitor for a later edit to leak.
318b93a to
b10f23b
Compare
…t verbatim (kirodotdev#9474) The goal popover reads GET /api/autonudge and its per-slot sibling. Both dropped a structured monitor -- the list filtered it out and the per-slot read answered loop: null -- so the popover reported nothing armed while a monitor was probing. Routing babysit through monitor_watch makes that a live regression, and the popover is the only place a person can see what is armed. Returning the record verbatim would have fixed one fault by committing a worse one. These two reads carry NO owner gate, while the structured record is owner-scoped everywhere else it is published: /api/monitors and its per-slot sibling sit behind _require_monitor_owner, and the autonudge_state websocket frame sends a structured loop through broadcast_ws_owners. The current bug hides information from someone entitled to see it; publishing the record here would show it to someone who is not. So the field list is decided by entitlement. The legacy reads now answer existence, cadence, liveness and state -- the loop's own fields plus a monitor_presence object carrying probe_count, wake_count and outcome, under a key of its own so a reduced reading cannot be mistaken for the full record. They withhold everything describing WHAT is watched. Withheld as owner-scoped: the whole monitor record; message, which on a structured monitor IS the wake instructions, since both arming paths set message=monitor.wake_instructions or "structured monitor"; banner, the same class of agent-authored text; and stop_sentinel_path. Withheld as unmaintained, their legacy reading being false rather than merely uninformative: max_cycles, cycle_count and last_fire_ts. _timer returns on its structured branch before every write and every read of them, so they say "no cycle cap, has not run yet" about a record bounded by monitor.budgets that has been observing. No withheld field is replaced by a null, an empty string or a plausible default. The reduction is enforced by never assembling the withheld fields rather than assembling and deleting them, so no intermediate payload holds the monitor for a later edit to leak.
Problem
The dashboard's goal popover reads
GET /api/autonudgeandGET /api/autonudge/slot/{slot_key}. Both dropped a structured monitor: the list filtered it out withif not is_structured_monitor_loop(lp), and the per-slot read nulled it out withlegacy = loop if loop is not None and not is_structured_monitor_loop(loop) else None. Structured state was published only on/api/session-monitor, which requires an authenticated session binding and is the agent-facing path behindmonitor_inspect.So while a structured monitor was running, the popover reported no loop. Read
is_structured_monitor_loopto see how narrow the distinction is -- a nudge loop, a gatedmonitor_startloop and amonitor_watchmonitor are the same record differing by two fields, and only the third satisfies that predicate.This is the repository's own step 0 in
docs/request-for-change/rfc-consolidated-monitor.md, the one item there with an external deadline. #5186 routes babysit throughmonitor_watch, so the moment it lands every babysit user sees "no loop" while one is running.Why this matters to the user
The popover is the only place a person can see what is armed on a session, and it is what they consult to decide whether to intervene -- stop a loop that is grinding, or leave one that is making progress. Reporting nothing armed while a monitor is probing does not degrade that decision, it removes the input for it. The user's own recourse, pressing Stop, is not reachable for a record the surface never shows.
How our fix solves it
The fix is a reduction, not a pass-through, and that is the load-bearing decision. Serializing the record into the shape the legacy reader already understands would have fixed one fault by committing a worse one. These two reads carry NO owner gate, while the structured record is owner-scoped everywhere else it is published:
/api/monitorsand its per-slot sibling sit behind_require_monitor_owner, and theautonudge_statewebsocket frame sends a structured loop throughbroadcast_ws_ownerswhile a plain loop goes to every connected client. The bug being fixed hides information from someone entitled to see it; publishing the record here would show it to someone who is not.So the field list is decided by entitlement. What the popover needs is existence and liveness: something is monitoring, on roughly this cadence, this many observations in, in this state. It does not need to know what is being watched. The routes now answer the first and withhold the second, and
/api/monitorsstays the only place the full record appears. No new endpoint: the two entitlement levels reconcile inside the existing ones, because existence and liveness require no owner-scoped data.Published
The loop's own entitled fields only:
id,slot_key,active,idle_secs(the probe cadence, which is genuinely what_timersleeps),created_ts,next_due_ts,max_runtime_secs,stopped_reason,approval_stalled,gate,self_armed."How far in is this monitor" is deliberately UNANSWERED, and that is a real gap rather than an oversight. A
monitor_presenceobject (probe_count,wake_count,outcome) was written for exactly that and then removed before merge. The deciding argument was not whether it is useful: it is that this PR's one unproven claim is precisely whether a consumer handles what these routes send it, so a field with no reader is unverifiable surface added to the PR whose weakest point is consumer handling. It belongs in the change that adds its reader, where one test can show it arriving AND being displayed. The gap is recorded in the issue text below.Consequence a reader must know: a reduced row carries no positive marker saying "this is a monitor". It is told apart by the ABSENCE of the withheld fields, which is weaker than a marker and is the other half of what the rendering change should add.
Withheld deliberately, and why
Stated here because the next person to touch this will otherwise read the omissions as oversight and helpfully add them back. Nothing withheld is replaced by a null, an empty string or a plausible default -- an absent field reads as "this surface does not carry that", where a faked one reads as fact.
Owner-scoped, because each describes the subject or the evidence:
monitormonitor_state_public_dict: target URL, objective, kind, budgets, wake instructions, the provider-controlled observation payload and every fingerprint.messagemessage=monitor.wake_instructions or "structured monitor", so the innocuous-looking legacy field is the one that would leak them. This is the leak a literal pass-through would have shipped.bannerstop_sentinel_path_timer's structured branch returns before the sentinel is ever tested.Unmaintained, their legacy reading being false rather than merely uninformative:
max_cycles,cycle_count_timerreturns on its structured branch BEFORE the cap test and the cycle bump, and so does every consumer of them (the[auto-nudge cycle N]body composers). Every structured arming call writesmax_cycles=0and no tick advancescycle_count, so the legacy reading is "no cycle cap" and "has not run yet" about a record that IS bounded, bymonitor.budgets, and HAS been observing.last_fire_tsA GATED prompt loop is in neither case and is untouched: it carries probe state but still delivers down the legacy path, so its message and its cycle accounting are real, and
is_structured_monitor_loopalready excludes it.The reduction is enforced by never assembling the withheld fields -- the projection filters
fields(NudgeLoop)-- rather than by assembling a full payload and deleting from it, so there is no intermediate dict holding the monitor for a later edit or an early return to leak.Six claims that went false were corrected rather than left. Three were found by a narrow grep of my own and three more by the First Principles lane grepping the wider pattern
exclude structured|prompt-loop record, which is the correction that matters: a universal claim about a behaviour change makes every missed sibling a mismatch, so the sweep has to be on the BEHAVIOUR's wording, not on the symptom I happened to remember. The six:api_autonudge_fire's docstring said the popover never sees a structured monitor becauseapi_autonudge_getfilters them out, the module spec described the list as every PROMPT-loop record, and the RFC index assertedapi_autonudge_getstill nulls one out. The per-slot docstring's path was also wrong (/api/autonudge/{slot_key}); the registered route is/api/autonudge/slot/{slot_key}.Testing
Extended
test/test_autonudge_handlers_cov80.py, which already covers these handlers, rather than adding a parallel file.The boundary tests come first, because they guard the contract rather than the feature:
test_legacy_reads_withhold_every_owner_scoped_monitor_fieldasserts owner-scoped fields are ABSENT, derived STRUCTURALLY frommonitor_state_public_dictminus_MONITOR_PRESENCE_FIELDSrather than from a hand-written list. Adding a field toMonitorStatetherefore cannot quietly widen this route: a new public field is owner-scoped here until someone deliberately adds it to the presence set. It also scans both serialized responses for the wake-instruction text, a fingerprint, the target, the objective and the kind.test_structured_legacy_row_carries_exactly_the_entitled_keyspins the surviving key set in both directions and asserts published + withheld covers everyNudgeLoopfield, so a NEW loop field cannot silently join this route either.Then the feature:
test_both_legacy_reads_return_a_monitor_armed_through_the_create_routearms one throughapi_monitor_createand asserts BOTH endpoints return it. The loop is built from the kwargs the create route actually hands the arming chokepoint, not from a fixture, so the values under test are the ones a real arm writes -- including themessagethat is really the wake instructions. It also asserts/api/monitorsstill carries the full record, so the reduction did not narrow the owner-gated route.test_a_terminal_monitor_reports_its_outcome_on_the_legacy_readcovers state, the fourth thing the popover needs.test_legacy_list_omits_cycle_accounting_only_for_structured_rowspins the unmaintained half on both sides at once, and that a monitor's liveness is answered byprobe_countinstead.test_prompt_gated_loop_remains_on_legacy_surfacegained assertions that a gated loop keeps its real cycle accounting -- the discriminating case.RED to GREEN verified by stashing only the handler change: 7 failed, 40 passed against the unfixed handler; 47 passed with it. Scoped runs, 575 passed: this file plus
test_autonudge.py,test_autonudge_stop_auth.py,test_autonudge_banner.py,test_monitor_controller.py,test_monitor_mcp.py,test_monitor_persistence.py,test_monitor_directive_apply.py,test_black_gate_contract.py,test_error_code_contract.py,test_docs_lint_fact_checks.py.black --checkandmypyclean on both changed Python files;scripts/docs_lint.pyreports all documentation checks passed. Its one report-only stale-baseline entry namesrfc-crew-agent-sdk-boundary.mdand reproduces identically on the base commit, so it is pre-existing.Blocked features
The popover still has to RENDER what it now receives, and #5185 owns that half; it does not touch
dashboard/handlers/autonudge.py, which is why this fix is still needed.One frontend file IS touched, and only its comment:
website/src/components/autoNudgeLoop.tsdocumentedGET /api/autonudgeas "every prompt-loop record", which this change falsifies. That file is NOT in #5185's diff, so declining it would have shipped a false description of this route that nothing else would correct. The TYPE declarations in the same file are left alone deliberately: turning four required fields optional is a compile-time contract change for every consumer, it belongs with the rendering that reads them, and verifying it needs atscrun this host cannot afford. No behaviour, styling or rendering is changed here.Interim behaviour with the SHIPPED popover, read off the source rather than assumed.
AutoNudgeLoopinwebsite/src/components/autoNudgeLoop.tsdeclaresmessage,max_cycles,cycle_countandlast_fire_tsas required, and a reduced monitor row omits all four. TypeScript is compile-time only, so at runtime each readsundefined:nextCycleTextrenders a correct countdown -- both readactiveandnext_due_ts, which the row carries.DELETE /api/autonudge/{loop_id}already routes a structured monitor through_require_monitor_ownerplusauthorize_and_stop_monitor, so the one affordance this fix exists to restore functions today with no frontend change.cycle 0, becausecycleTextfalls through toString(loop?.cycle_count ?? 0). The chip's own cycle text is suppressed, sinceloop.cycle_count > 0is false forundefined.loop?.message || DEFAULT_MSG.structured_monitor_requires_monitor_api, so a mis-seeded edit cannot be written onto a monitor.The list has THREE shipped readers, not one. An earlier revision of this section analysed only the popover, which was an incomplete enumeration of exactly the kind this PR elsewhere fixes. All three, verified at their call sites:
AutoNudgePopoverChatPage.tsxcycle 0, editor seeds the default goal template, Save 409sChatSidebargoal chipuseWebSocket.ts:455intosetGoalLoopsMembersPagepatrol badge and drawerMembersPage.tsx:590reads the list and stores RAW rows at :601lp.max_cycles > 0is false for an absent field, sopatrol_cycles_unlimitedinterpolates an empty{{n}}and renders a leading gap before the separator (:1032, :1438)Two review lanes reported the sidebar as the broken one. It is not, because of that
Number(...) || 0normalisation.MembersPageis the real one, and no sequenced PR owns it: #5185 touchesChatPage.tsxandChatSidebar.tsxbut notMembersPage.tsx. It is named here rather than fixed because the fix is frontend rendering, which this PR is scoped out of.Judged against the bug -- no chip, no countdown, no Stop -- this is the better state on the thing that matters, and the refusal makes the dead affordance safe rather than destructive. It is not the finished state: #5185 should mark the withheld fields optional on
AutoNudgeLoop, and suppress the cycle text and the goal-template editor on a row that carries nomessagerather than printingcycle 0and a fabricated goal.The two payloads compose. That PR seeds its automation store from
api.autonudgeListANDapi.monitorsListwithPromise.allSettled, and its normalizer discriminates on the presence of amonitorkey. This projection publishes nomonitorkey, so a reduced row is never mistaken for a malformed full record and never renders asblocked; an owner's full record still arrives from/api/monitorsand wins the merge, and a caller that cannot read that route gets a truthful "something is armed and live" instead of nothing.A consumer that wants the target, the objective or the budgets must read
/api/monitors. That is the design, not a gap.Other suggestions
Two remainders are now named as deferred in
rfc-consolidated-monitor.md's step 0, so neither reads as an oversight:autonudge_stateframe for a structured loop goes throughbroadcast_ws_owners, so that reader gets no invalidation and its view stays as fetched until it reconnects. Closing it means a reduced presence frame ridingbroadcast_wsinslack/gateway.py, out of scope here. An owner is unaffected.message,max_cyclesandcycle_countfor a structured monitor.messageis not a boundary crossing there, since the frame is owner-only, but the two counters mislead on the socket exactly as they did on the read.The RFC's second dashboard gap is untouched and still open: the armed-watch list is slot-scoped, so a watch that moves out of session becomes invisible.
Visual evidence -- captured, read, and scoped to what it proves
Captured on an ISOLATED throwaway pod for this worktree (
kirocrew pod, own port, ownKIROCREW_HOME, no crons, torn down with the teardown verified). The live gateway was never touched. The pod was necessary because this host cannot render the dashboard directly -- it replaces the page with aSandbox unavailablewall, sinceunshare(CLONE_NEWUSER)fails withEPERM. A Playwright spec armed the cases against the same popover so they are comparable, and every frame below was opened and read rather than filed.Control -- a plain auto-nudge loop, every field PRESENT:
A structured monitor with the three fields WITHHELD (the earlier revision):
The same monitor with the fields MAPPED (this revision):
What the frames show
Loop 0/24Loop 0(no denominator)Loop 0/7cycle 0/24cycle 0cycle 0/70-- reads as unlimited7-- the real turn budgetWhat the frames do NOT prove
Stated because a frame is easy to over-read. A frame is evidence for a field only where that field would visibly DIFFER had the mapping not worked. By that test, one of the three mapped fields is demonstrated here and two are not:
max_cyclesis demonstrated.0under a label reading "0 = infinity" becomes7. The two worlds are visibly different, so the frame discriminates between them.last_fire_tsis NOT demonstrated. The captured monitor has never fired, soneveris its truthful rendering -- andneveris also exactly what an absent field renders. The two worlds are visually identical, so this frame cannot distinguish them. Demonstrating it would need a monitor that has actually delivered a cycle, a larger capture than this change warrants.cycle_countis NOT demonstrated either, for the same reason. The0inLoop 0/7is what an absent field and a realagent_turns: 0both render. The7is proven; the0is not.The evidence for all three is
test_legacy_list_omits_cycle_accounting_only_for_structured_rows, which pins them against a monitor carrying values a component default cannot produce (max_agent_turns: 7,agent_turns: 3,last_completed_at: 1650.0).The entitlement boundary holds at the UI, not just in the payload. The monitor was armed with
wake_instructionsset to a sentinel string; neither it nor the watched target URL appears anywhere on screen, across every frame including the ones taken after three more fields began flowing. Asserted in the spec and confirmed by reading the frames.The chip is coherent in both revisions.
Loop 0renders with no blank, noNaN, noundefined, and the countdown (Next cycle in 14m 55s) is right. Where the popover previously reported nothing armed while a monitor was probing, it now shows the monitor and offers Stop.The one failing spec assertion, and why it is not a product defect
case-a-shows-its-own-goal-textfailed. The spec asserted the armed message appears indocument.body.innerText, andinnerTextdoes not include a React-controlled textarea's value. The control frame showsPLAIN LOOP GOAL TEXTrendered in that textarea, so the assertion was wrong, not the product. Every other row passed:The panel: one falsehood fixed and demonstrated, one fixed, one handed on
The shipped popover renders a structured monitor as an editable nudge loop, and in the withheld revision it stated three false things. Their disposition now differs, and the difference matters to a reviewer deciding what this PR is responsible for:
Max cycles (0 = infinity)showed0, asserting an unbounded monitor. FIXED HERE and visible in the frame above: it reads7, the monitor's realbudgets.max_agent_turns. Withholding the field was worse than an imprecise value, because the component's own label turns an absent field into a claim that the automation runs forever.Last fire: neveron a monitor that has been probing. FIXED HERE by mappinglast_completed_at, and covered by unit test rather than by frame, for the reason given above. Deliberately notlast_probe_at: a probe that woke nothing is not a fire.messageIS the wake instructions on a monitor, so it is withheld by entitlement, and the truthful rendering of an absentmessageis a frontend decision about what to show instead. Handed to #5185 and recorded in a follow-up issue.On item 3, one thing a reviewer should know rather than derive. #5185 routes the popover through a new
SessionAutomationPopoverwhose structured body does not mount this editor at all -- but that structured record comes from the owner-gated/api/monitors. A caller who cannot read that route sees only the reduced legacy row and gets the legacy body. So after #5185 the OWNER sees a correct panel and the NON-OWNER still sees the literal placeholder: the surviving falsehood is shown to the viewer least equipped to read it as a template artifact. #5185 leavesDEFAULT_MSGbyte-identical, so it relocates that falsehood rather than removing it.The panel's description text compounds item 3: "Kiro Crew sends the agent a nudge with that goal at the interval below until the goal is complete or the cycle limit is reached" describes a nudge loop, which this record is not. Also frontend, also #5185.
None of this leaks anything; the boundary holds. What is left is a truthfulness defect on one field of a surface a person consults to decide whether to intervene.
Pinned security statement: the delta, verbatim
docs/system-specs/modules/security.mdcarried a PINNED statement about these routes. This PR changes it, so both versions are here rather than left to be reconstructed from the diff. This change is NOT self-approved and is awaiting an explicit maintainer ruling.Before:
After:
The argument for it is in "How our fix solves it": plain loops already publish their full records on these un-gated routes, and the reduced row carries nothing owner-scoped. The asymmetry it leaves -- the websocket still keeps even presence owner-only -- is recorded as a deferred step-0 remainder. Whether that is sufficient to move a pinned security statement inside a fix PR is a maintainer call, and no further edits will be made to that line until it is ruled on.
Pattern harvest
Rule candidate: semgrep
Pattern: a serializer of
NudgeLoopthat publishesmessageon a surface with no owner gate, without branching onis_structured_monitor_loopOne field on that dataclass carries different content depending on whether a sibling field is set: on a structured monitor
messageholds the wake instructions, because both arming paths writemessage=monitor.wake_instructions or "structured monitor". A serializer author reading the field name has no way to know that, which is what made a literal "return the record" fix leak owner-scoped text through a field that looks innocuous. The generalizable smell is a dataclass field whose MEANING is conditional on another field, published by name.Rule candidate: review rule, not semgrep-expressible
Pattern: a read route answers "absent" for a record it is merely not entitled to disclose in full, so its empty answer means both "nothing exists" and "you may not see this"
That is the original defect here, and it is the same conflation as a fail-open protection reporting a state indistinguishable from healthy. The fix direction is to return the entitled projection, so the empty answer keeps exactly one meaning.
no linked issue: the defect is recorded as step 0 of
docs/request-for-change/rfc-consolidated-monitor.md, whose index entry verified it on base, rather than as a GitHub issue. The PR references #5185 and #5186 as the sibling tracks it composes with, not as issues to close.