{#- Reason overflow (ADR-0024): a node's reasons clamped to a *line budget*. The block
    shows at most ``cap`` lines (settings.yaml ``reason_cap``: short reasons ⇒ that
    many reasons, a wrapped reason uses more of the budget); the overflow stays in
    the DOM, clipped by CSS (never cut mid-HTML, ADR-0018) and faded. A header
    chevron (reasons.js) reveals it in place and survives the ~10s fragment swap —
    ▼ when clipped, ▲ when open. The leaf detail page (check.html) stays full; the
    JSON envelope is untouched. -#}
{#- Each line also carries the ``reason.actions`` slot (ADR-0034) — the place a
    dependent package hangs a local interaction off *this* reason, e.g. "raise a
    ticket for it". The slot is offered on every reason of every node and the filler
    decides where it applies; core passes the **unshortened** reason, since the
    400-character clamp is a display budget and an action wants the whole text.
    Rendered server-side like the rest, so it survives the ~10s fragment swap. -#}
{#- Reasons are keyed entries (ADR-0036), so a line can be pinned on its own. A
    quiet line is **shown**, in the maintenance tint (ADR-0032 rule 5) — hiding it
    would be the suppression covering its own tracks — and the node states how many
    are quiet, because the clamp above can put the pinned line below the fold and
    the count is then the only thing that always shows. -#}
{#- What is being silenced (ADR-0032 rule 5: a transformed contribution is visible
    and attributable). A card that says only "maintenance" hides the transform —
    *we are silencing an error* is the thing worth knowing, and before the keystone
    it was not merely hidden but destroyed. Shown wherever a node's own status has
    been derived away from a countable reading, by a node pin or by every member
    being pinned; a check that reported ``MAINTENANCE`` itself has nothing to add.
    And only where the node **shows** *maintenance*: one whose lines are all
    silenced shows what the nodes beneath it roll up to, and has no *maintenance*
    for the reading to stand under (ADR-0124) — its silenced lines and their count
    say it there. ``word`` includes the status word for surfaces that do not
    already print it.

    **A damping counter is the same kind of fact and takes the same slot**: the node
    shows what it read and its parent is still counting the quieter value, so the
    card says how many readings are in and how many the deployment asked for. A red
    leaf under a green parent is what a broken roll-up looks like, and this is the
    sentence that tells the two apart. Same ink as the maintenance suffix — the
    transform is one idea and it should not look like two. -#}
{% macro reported_suffix(node, word=False) -%}
{%- if node.code.name == 'MAINTENANCE' and node.own_code.name == 'MAINTENANCE' and node.reported_code.name not in ('MAINTENANCE', 'UNDEFINED') %} <span class="status-reported">{% if word %}maintenance {% endif %}· {{ node.reported_code.name.lower() }}</span>{% endif -%}
{%- if node.damping %} <span class="status-reported">· {{ node.damping.seen }} of {{ node.damping.needed }} to escalate</span>{% endif -%}
{%- endmacro %}
{#- Why the node is blue: the pin's block (ADR-0104 decisions 1 and 2), as the node's
    own page states it — who silenced it, until when and what is left, its note in
    full, and for an admin *Edit* and *Clear*. It stands **above** the reason block
    and outside the ``reason_cap`` clamp, so the reason for the color can never be
    the thing that gets clipped — the placement rule the quiet count already
    follows — and it paints its own maintenance tint, like every other maintenance
    surface, so it does not depend on the card fill under it. A card's head names
    the node, so the sentence opens with what was done to it (`bare`).

    ``pinning`` is what every pin on the page shares: whether the reader may write
    one, the address a write comes back to, and the count that gives each editor
    ids of its own — a wall carries an editor for each card, and a label finds its
    field by id. -#}
{% macro pin_stated(node, pinning) -%}
{%- if node.maintenance_entry -%}
{%- set pinning.count = pinning.count + 1 -%}
{{ pin_block(node.maintenance_entry, 'node', node.path, '', 'pin-' ~ pinning.count, pinning.may, next=pinning.back, of=node.path, bare=true) }}
{%- endif -%}
{%- endmacro %}
{#- The **viewed** node's own state, above its children.

    A subtree page is a dashboard *of the children*, which left the one node you
    actually navigated to as the only one on the page that never said anything about
    itself. `depth=0` already drew the viewed node as a card; this is the same thing
    at every other depth, which also ends the page disagreeing with itself as the
    depth control moves.

    **The node's pin stands here** (ADR-0104 decisions 2 and 3): its block, above the
    children it covers, and for an admin the one control that sets it — *Set
    maintenance*, which opens its editor where the block will stand. The form posts
    the page's own `branch`, as a leaf's page does. The card at the foot of the page
    said the pin a second time, in different words and to an admin only; it went
    when the head took this over.

    **So does a pin above it** (ADR-0104 decision 2): a pin on a node above this
    one silences it with everything else beneath that node, and the head states each
    such pin as its block, outermost first, without buttons — it is edited where it
    stands — and the node's own pin, under one, is *also silenced on its own*.

    Silent when the node has nothing of its own to add, no pin above it **and the
    reader cannot pin**: a container with no reading, no reasons and no pin is
    exactly the page that should open with its children. An admin gets the head on every branch's page, because
    the control needs its place. The caller decides (`head_drawn`, where the page is
    drawn), since what the head shows is also what the cards beneath it suppress.
    Rendered as a `status-node` so it takes the same fill and ink as any box, and kept
    **inside `#status-grid`** so it refreshes on the ~10s poll — which waits while an
    editor in it is open (decision 7).

    **It says what the node rolls up to** (ADR-0123 decision 1): the status its card
    says on the page above and its one card says at depth 0, so a node is one status
    wherever it is read. Saying the node's **own** status here, on the ground that
    the children right below say theirs, headed a page green over a child in error
    while the page above drew the same node red.

    **Whose the status is, the fill says**, as a card's does (decision 2): pale where
    it comes from beneath the node — `derived`, the snapshot's one answer to that —
    because the node that makes it so is right below, and vivid where the node counts
    it for itself: a failure of its own, or its own reading gone stale. A node that
    declares nothing is the plain case of the first. Its `UNDEFINED` is a container's,
    which the roll-up skips (ADR-0039), so whatever it shows comes from beneath it,
    and that is also the code a kept reading records for it (ADR-0087 decision 8); a
    roll-up of nothing is `UNDEFINED`, the node's own again, and vivid. What the node
    says of itself is its lines, and the period of its own status, on the Time card
    beneath the children.

    **Its lines are listed as a leaf's page lists them** (`own_lines`, ADR-0036
    decision 12): in full rather than clamped to `reason_cap` — this
    is the node's own page, where a reader comes when its card is not enough — each
    with its record, and for an admin with the pin control at its end, so a line of
    a node above others is silenced where it is read, without the node's pin that
    silences everything beneath it. -#}
{% macro viewed_head(node, reason_cap, pinning, branch) -%}
<div class="status-node viewed-head s-{{ node.code | status_slug }}{% if node.derived %} dim{% endif %}">
    <div class="status-node__self" data-path="{{ node.path }}">
        {{ status_cue(node.code) }}<span class="status-node__name">{{ node.name }}</span>
        {%- if node.stale %} <span class="status-stale">stale{% if not node.children %} · {{ node.age_seconds | elapsed }} ago{% endif %}</span>{% endif %}
        {#- The head is the topmost visible node of this view, so the observation
            time shows here and the cards below suppress an identical one
            (ADR-0044): seven aspect cards repeating one check's run time invite a
            reader to think the seven were checked separately. -#}
        <span class="viewed-head__state">{{ card_time(node) }}{{ node.code.name.lower() }}{{ reported_suffix(node) }}</span>
        {%- set above = pins_above | length %}
        {{ pins_above_stated(pins_above, 'head-above-maintenance-') }}
        {%- if node.maintenance_entry %}
        {{ pin_block(node.maintenance_entry, 'node', branch, '', 'head-maintenance', pinning.may, next=pinning.back, also=above > 0) }}
        {%- elif pinning.may %}
        {#- What the pin would cover, as its editor's first sentence says it: the
            node whose page this is, and with it every node beneath — which a pin
            above it silences already, until that one ends. -#}
        {%- set covers %}
            {%- if above -%}
                It keeps everything beneath it silenced when the {{ 'pin' if above == 1 else 'pins' }} above it {{ 'ends' if above == 1 else 'end' }}: nothing under here will alarm before this pin expires. Its checks keep running, their colors stay visible here, and they count again when every pin on them has cleared.
            {%- else -%}
                It silences everything beneath it: nothing under here will alarm before the pin expires. Its checks keep running, their colors stay visible here, and they count again when the pin clears.
            {%- endif -%}
        {%- endset %}
        <details class="maintenance-editor-disclosure rule-setter">
            <summary class="rule-button rule-setter__toggle">{{ rule_mark('maintenance') }}Set maintenance</summary>
            {{ pin_new('node', covers, branch, '', 'head-maintenance', next=pinning.back) }}
        </details>
        {%- endif %}
        {{ own_lines(node, branch, pinning.may, focus, focus_orphan,
                     beneath=node.path in containers, back=pinning.back,
                     surface='grid', prefix='head-line-maintenance-',
                     muted=false, covered=above) }}
    </div>
</div>
{%- endmacro %}
{#- A coded line (ADR-0042) carries the entry's **own** claim: its state class, a
    small labeled cue (a line has no status word, so the cue is its accessible name),
    and its state's own tint — every coded line paints one, because a mixed list
    sits on a *vivid* card fill, where a surfaceless passed line would read as more
    of the problem (the is-quiet lesson: ink-on-whatever fails the bar). A quiet
    (pinned) line keeps the maintenance tint whatever its code says: suppression is
    the louder fact. `is-running` marks work in flight — italic, display only; the
    line's words still say it, so no meaning rides on the italic alone. -#}
{% macro reason_block(node, cap) -%}
{%- if node.reasons -%}
{%- set total = node.reasons | length -%}
<div class="reason-block" style="--reason-lines: {{ cap }}"
     data-reason-node="{{ node.path }}" data-reason-total="{{ total }}">
{%- for line in node.reasons %}
    <div class="status-node__reason md-body{% if line.code %} is-coded s-{{ line.code | status_slug }}{% endif %}{% if line.running %} is-running{% endif %}{% if line.quiet %} is-quiet{% endif %}"><span class="reason-actions">{{ slot('reason.actions', node=node, reason=line.text, line=line, index=loop.index0, surface='grid') }}</span>{% if line.code %}{{ status_cue(line.code, labeled=true) }}{% endif %}{{ line.text | shorten(400) | markdown }}</div>
{%- endfor %}
</div>
{#- Under a **node** pin everything here is silenced already, so this count is not
    the reason the card is blue — the pin's block is. It says what will still be
    quiet once the node pin is cleared. -#}
{%- if node.quiet_reasons %}<div class="reason-quiet-count">{{ node.quiet_reasons }} of {{ total }} {% if node.maintenance %}also pinned individually{% else %}in maintenance{% endif %}</div>{% endif -%}
{%- endif -%}
{%- endmacro %}
{#- The shape cue lives in its own partial (_status_cue.html) so the leaf detail
    page can import it without executing this template's body; the rationale and
    the labeling rule are documented there. -#}
{% from '_status_cue.html' import status_cue %}
{% from '_next_update.html' import next_update %}
{#- A pin's block and its editor are the rule's own (ADR-0104), imported with the
    context for the deployment's default window and its timezone that an editor's
    fields print — so the refresh's fragment is handed both, as the page is. -#}
{% from '_rule_block.html' import pin_block, pin_new, pins_above_stated, rule_mark with context %}
{#- A node's own lines as its own page lists them — a leaf's and, here, a branch's
    head and its depth-0 card: in full, each with its record and for an admin the
    pin control at its end (ADR-0036 decision 12). -#}
{% from '_own_lines.html' import own_lines with context %}
{#- Maintenance pip: a click-to-open marker on a card whose subtree holds a
    pinned node but which is not itself pinned — a glance at any depth shows where to
    drill, and a click opens a popover (maintenance.js) listing that card's pins as
    links. A real <button> (keyboard-reachable, announced as a popup control); the
    hidden <template> carries the card-scoped pin list the popover clones. Solid
    maintenance-blue so it reads on any card fill. -#}
{#- Observation time (ADR-0027): *when* beside *what*. Shown only when the node has
    an unambiguous answer to "when did the check behind this node run?" — its own
    last write, or the run time of the single check below it — and rendered as a
    time of day at **minute precision** — seconds saved no information worth the row
    width — so a wall of cards stays scannable. A
    container above two or more checks has no single answer, so it shows **nothing**
    rather than a placeholder: absence is the signal. The time shows on the
    **topmost node visible in the current view** and is suppressed below, where it
    would be identical (ADR-0044) — safe because an ancestor carries a stamp only
    where a single check owns everything beneath it, so an identical value below can
    only be the same run; ``shown`` is the ancestor's displayed rendering, compared
    at display precision. It sits inside the poll fragment, so it refreshes with
    the grid; the freshness *alarm* stays the stale badge (ADR-0005), normalized
    per node against the tolerance the server applied rather than against an absolute
    age — a check's period implies one, and a node with no period may state one
    (ADR-0081). -#}
{% macro card_time(node, shown="") -%}
{%- if node.timestamp -%}
{%- set moment = node.timestamp | localtime("%H:%M") -%}
{%- if moment != shown %}<span class="status-card__time">{{ moment }}{{ next_update(node.run.next_run_at if node.run else none, moment) }}</span>{% endif -%}
{%- endif -%}
{%- endmacro %}
{#- One popover row: **one node**, never one line (ADR-0036). The popover is capped,
    so a node with twenty pinned findings contributes one row carrying a count — the
    same thing its card says in the grid — rather than twenty rows that would evict
    every other node from the list. The count is what makes "maintenance under this
    card" honest for an entry pin: without it the pip would claim a node is pinned
    when it is not. `quiet` is zero on a plain node pin, and that picks the wording.

    An entry row links with `?reason=<slug>` (ADR-0036 decision 12's addressing
    shape) and the fixed `#pinned-reason` anchor the page puts on the line it was
    asked for — one id, only when asked, and never the slug in a fragment, which is
    not fragment-safe. Only a **sole** entry pin can carry it; several have no one
    line to point at. -#}
{% macro maintenance_row(row) -%}
{%- set href = url_for('status', branch=row.path | url_branch, reason=row.slug) ~ '#pinned-reason' if row.slug else url_for('status', branch=row.path | url_branch) -%}
<li class="maintenance-pop__item"><span class="maintenance-pop__row"><a class="maintenance-pop__path" href="{{ href }}">{{ row.path }}</a>{% if row.quiet %} <span class="maintenance-pop__lines">{% if row.pinned %}+ {{ row.quiet }} reason{{ 's' if row.quiet != 1 else '' }}{% elif row.quiet >= row.total %}all {{ row.total }} reason{{ 's' if row.total != 1 else '' }}{% else %}{{ row.quiet }} of {{ row.total }} reasons{% endif %}</span>{% endif %} <span class="maintenance-pop__left">{% if row.quiet > 1 and not row.pinned %}next {% endif %}{{ row.remaining }}</span></span>{% if row.note and row.note != 'maintenance' %}<span class="maintenance-pop__reason">{{ row.note | markdown_inline }}</span>{% endif %}{% if row.set_by %}<span class="maintenance-pop__by">{{ row.set_by }}</span>{% endif %}</li>
{%- endmacro %}
{% macro maintenance_pip(card_path, rows) -%}
<button type="button" class="maintenance-pip" aria-haspopup="true" aria-expanded="false" aria-label="show maintenance under {{ card_path }}"><svg viewBox="0 0 16 16" width="12" height="12" aria-hidden="true" focusable="false"><rect x="4" y="3.5" width="2.7" height="9" rx="0.7" fill="currentColor"/><rect x="9.3" y="3.5" width="2.7" height="9" rx="0.7" fill="currentColor"/></svg></button><template class="maintenance-pop-src" data-pop-for="{{ card_path }}"><ul class="maintenance-pop__list">
{%- for row in rows if row.path.startswith(card_path ~ '/') %}
{{ maintenance_row(row) }}
{%- endfor %}
</ul></template>
{%- endmacro %}
{#- An admin's way to pin a card (ADR-0104 decision 3): a pause mark in the card's
    head that opens the pin's editor **in the card**, where its block will stand. The
    browser's own disclosure, so it works without script, and the mark is its
    summary. Quiet until the card is hovered (CSS), always visible to keyboard
    focus. Cards only, deliberately: a box inside a card states the pin it has, and
    is pinned from its own page, one step away. A pinned card has no mark; its block
    carries *Edit* and *Clear*.

    The editor's first sentence says what the pin covers, and a pin on a node covers
    everything beneath it whether or not this page shows it. ``containers`` is read
    before *hide ok* or *hide idle* drops a child, so a card the filter left with
    no children still says *and everything beneath it*. -#}
{% macro pin_setter(node, pinning, containers) -%}
{%- set pinning.count = pinning.count + 1 -%}
<details class="maintenance-editor-disclosure pin-setter">
    <summary class="pin-control" title="Set maintenance" aria-label="set maintenance for {{ node.path }}"><svg viewBox="0 0 16 16" width="12" height="12" aria-hidden="true" focusable="false"><rect x="4" y="3.5" width="2.7" height="9" rx="0.7" fill="none" stroke="currentColor" stroke-width="1.5"/><rect x="9.3" y="3.5" width="2.7" height="9" rx="0.7" fill="none" stroke="currentColor" stroke-width="1.5"/></svg></summary>
    {{ pin_new('node', '', node.path, '', 'pin-' ~ pinning.count, what=node.name ~ (' and everything beneath it' if node.path in containers else ''), next=pinning.back) }}
</details>
{%- endmacro %}
{#- Branch density (ADR-0024): render one level of a card's descendants — a quiet
    leaf as an inline chip, everything else as a box — and, in the dense view, cap the
    quiet (non-warn/error) *boxes* this branch shows. Surplus quiet boxes are marked
    ``is-extra`` (kept in the DOM, hidden by CSS) and the level grows a "+N more"
    control that branches.js reveals in place and re-applies across the ~10s poll swap.
    A warn/error box is never capped, so nothing urgent hides; with density off,
    ``branch_cap`` does nothing and every node renders as a box. ``depth0`` carries the
    render-depth ceiling (``max_depth``) down the recursion. The render constants are
    passed explicitly so the macro never depends on call-site context. -#}
{#- A node that **declined the density trade** (ADR-0063, ``show_when_quiet``) is
    exempt from both compactions exactly the way a warn/error node is: never a chip,
    and never counted a surplus quiet box. Both, or the field lies — kept out of the
    chip and then folded, it would show *less* than the chip did. It is a claim about
    the node's lines (an inventory is read *because* everything is fine), so it reads
    the node, never the viewer: density off and *hide idle* are untouched, and the
    stable flow profile never saw chip-versus-box in the first place, so no card
    moves. The condition appears three times below because the chip-run wrapper has
    to agree with it about the neighbors, or a declared node between two chips would
    leave the run's ``<span>`` open. -#}
{% macro render_nodes(children, depth0, parent_path, dense, max_depth, branch_cap, reason_cap, pinning, shown_time="") -%}
{%- set ns = namespace(quiet_boxes=0) -%}
{%- for child in children -%}
{%- if dense and not child.children and child.code.name not in ('WARN', 'ERROR')
      and not child.show_when_quiet -%}
    {#- Consecutive chips share a full-row wrapper. At a mixed level that wrapper
        becomes one grid item while two or more full boxes can still form columns;
        inside it the chips retain their compact wrapping flow and source order. -#}
    {%- if loop.first or loop.previtem.children
          or loop.previtem.code.name in ('WARN', 'ERROR')
          or loop.previtem.show_when_quiet -%}
    <span class="leaf-chip-run">
    {%- endif -%}
    <a class="leaf-chip s-{{ child.code | status_slug }}"
       href="{{ url_for('status', branch=child.path | url_branch) }}"
       data-path="{{ child.path }}"><span class="leaf-chip__name">{{ child.name }}</span>{% set shown = child | node_title %}{% if shown %}<span class="node-title">{{ shown | markdown_inline }}</span>{% endif %}</a>
    {%- if loop.last or loop.nextitem.children
          or loop.nextitem.code.name in ('WARN', 'ERROR')
          or loop.nextitem.show_when_quiet -%}
    </span>
    {%- endif -%}
{%- else -%}
    {%- set has_kids = child.children and depth0 < max_depth - 2 -%}
    {%- set node_dim = child.code.name == 'OK' or (child.derived and has_kids) -%}
    {#- Foldable = quiet **and** not declared. A declared node is not merely never
        marked ``is-extra``; it is not counted at all, which is the same exemption a
        warn/error box already has — counting it would spend a quiet sibling's place
        in the cap on a box that was never going to fold. -#}
    {%- set foldable = child.code.name not in ('WARN', 'ERROR')
        and not child.show_when_quiet -%}
    {%- if dense and foldable %}{% set ns.quiet_boxes = ns.quiet_boxes + 1 %}{% endif -%}
    <div class="status-node s-{{ child.code | status_slug }}{% if node_dim %} dim{% endif %}{% if dense and foldable and ns.quiet_boxes > branch_cap %} is-extra{% endif %}">
        <div class="status-node__self" data-path="{{ child.path }}">
            {{ status_cue(child.code) }}<a class="status-node__name"
               href="{{ url_for('status', branch=child.path | url_branch) }}">{{ child.name }}</a>
            {#- The middle claims the slack between name and state with zero say in
                line-fitting (basis 0): the title ellipses inside it, and the
                `node.actions` chips sit absolutely at its right edge — **over the
                title** when the two would collide, because a chip is something to
                click and a title is a nicety. Chips therefore cost the head line
                no width at all: name and state alone decide whether a row fits. -#}
            <span class="status-head__middle">{% set shown = child | node_title %}{% if shown %}<span class="node-title">{{ shown | markdown_inline }}</span>{% endif %}
            {#- The `node.actions` slot, on a nested box as on a card head. A failing
                **leaf** almost always sits here rather than on a card — a card is the
                top of a subtree and usually a container with no reading of its own —
                so leaving boxes out put a deployment's node action nowhere the eye
                already is, and left the ticket-for-this-check gesture reachable only
                by drilling into the leaf's own page. The filler declines what it does
                not want, and the rail collapses when nobody fills it, so a deployment
                with no extension pays one empty span per box. A quiet leaf is a chip,
                not a box, and carries none — nothing quiet is worth acting on. -#}
            <span class="node-actions">{{ slot('node.actions', node=child, surface='grid') }}</span></span>
            {#- The box's state cluster, right-aligned like a card head's: staleness,
                the check time where the topmost-visible rule puts it here (ADR-0044;
                `box_time` also threads the suppression to the children below), and
                the status word — which a box used to lack, so its time dangled
                displaced after the title and its problem cue had to be aria-named.
                The word now speaks on every box, like on every card, so the box's
                one leading cue is decorative and a second cue in here would only
                duplicate the shape. -#}
            {%- set box_time = child.timestamp | localtime("%H:%M") if child.timestamp else "" -%}
            <span class="status-node__state">{% if child.stale %}<span class="status-stale">stale{% if not child.children %} · {{ child.age_seconds | elapsed }} ago{% endif %}</span> {% endif %}{{ card_time(child, shown_time) }}{{ child.code.name.lower() }}{{ reported_suffix(child) }}<button type="button" class="reason-chevron" tabindex="-1" aria-hidden="true"></button></span>
            {{ pin_stated(child, pinning) }}{{ reason_block(child, reason_cap) }}
        </div>
        {%- if has_kids -%}
        <div class="status-node__children node-children" data-branch="{{ child.path }}">{{ render_nodes(child.children, depth0 + 1, child.path, dense, max_depth, branch_cap, reason_cap, pinning, box_time or shown_time) }}</div>
        {%- endif -%}
    </div>
{%- endif -%}
{%- endfor -%}
{%- if dense and ns.quiet_boxes > branch_cap -%}
    {#- The in-place reveal for this level's folded quiet boxes; branches.js keeps the
        open state across the ~10s poll swap (the reasons.js pattern), and CSS swaps
        the label and shows the boxes. -#}
    <button type="button" class="branch-more" data-branch="{{ parent_path }}"
            aria-expanded="false"><span class="branch-more__show">+{{ ns.quiet_boxes - branch_cap }} more</span><span class="branch-more__hide">show less</span></button>
{%- endif -%}
{%- endmacro %}
{#- What every pin on this page shares (see `pin_stated`): the reader may write one
    as an admin, and not on the kiosk, where nothing is to be clicked; a write comes
    back to the page's own address, with its filters and its depth; and each editor
    counts itself. -#}
{%- set pinning = namespace(count=0, may=is_admin and layout != 'kiosk', back=here) %}
{%- if maintenance_rows or (heartbeat is defined and heartbeat) %}
{#- Status-strip band (ADR-0024): the self-monitor heartbeat pill and, to its
    left, the maintenance pill — a compact count that folds the always-visible
    index it replaced. Both live in the poll fragment, right-aligned beneath the
    controls, refreshing on the ~10s poll. -#}
<div class="strip-band">
{%- if maintenance_rows %}
{#- Maintenance pill: the always-visible index folded to a count. A click
    opens the shared popover (maintenance.js) over the whole set — the first
    ``maintenance_cap`` nodes, then a "+N more" to the /maintenance page, which is
    where every *pin* is listed one per row. Only shown when there are pins;
    maintenance-tinted, refreshed in the poll like the strip. -#}
<a class="maintenance-pill" href="{{ url_for('maintenance_overview') }}" aria-haspopup="true" aria-expanded="false" aria-label="{{ maintenance_rows | length }} nodes with maintenance"><svg class="maintenance-pill__glyph" viewBox="0 0 16 16" width="12" height="12" aria-hidden="true" focusable="false"><rect x="4" y="3.5" width="2.7" height="9" rx="0.7" fill="currentColor"/><rect x="9.3" y="3.5" width="2.7" height="9" rx="0.7" fill="currentColor"/></svg><span class="maintenance-pill__count">{{ maintenance_rows | length }}</span> in maintenance</a><template class="maintenance-pop-src" data-pop-for="__all__"><ul class="maintenance-pop__list">
{%- for row in maintenance_rows[:maintenance_cap] %}
{{ maintenance_row(row) }}
{%- endfor %}
{%- if maintenance_rows | length > maintenance_cap %}
<li class="maintenance-pop__more"><a href="{{ url_for('maintenance_overview') }}">+{{ maintenance_rows | length - maintenance_cap }} more…</a></li>
{%- endif %}
</ul></template>
{%- endif %}
{%- if heartbeat is defined and heartbeat %}
{#- Status strip (ADR-0024): the engine self-heartbeat (ADR-0005) lifted out of the card
    grid into a compact caption pill. It refreshes with the ~10s poll and dims with the
    grid under a sustained-outage banner. A stale heartbeat (the scheduler stalled) shows
    vivid, not pale — the self-monitor's own alarm. The path is reserved (the loader
    keeps custom checks off its line), and a heartbeat that grew children is not lifted
    at all — see _split_heartbeat. -#}
<div class="ls-strip s-{{ heartbeat.code | status_slug }}"
     data-path="{{ heartbeat.path }}">
    {#- Self-monitor identity: a watching-eye glyph marks this as the
        monitor observing itself, apart from the node pills. Decorative — the
        name carries the identity for screen readers. -#}
    <svg class="ls-strip__eye" viewBox="0 0 24 24" width="13" height="13"
         aria-hidden="true" focusable="false">
        <path d="M1 12s4-7 11-7 11 7 11 7-4 7-11 7S1 12 1 12z"
              fill="none" stroke="currentColor" stroke-width="2"/>
        <circle cx="12" cy="12" r="3.2" fill="currentColor"/>
    </svg>
    <a class="ls-strip__name"
       href="{{ url_for('status', branch=heartbeat.path | url_branch) }}">{{ heartbeat.name }}</a>
    {#- The title at its own width or not at all: its frame is one line high and
        wraps, so a title with no room beside the name and the state goes to a
        second line nobody sees, where it would have been squeezed to a few
        letters. The node's page and its inspection card still say it. -#}
    {% set shown = heartbeat | node_title %}{% if shown %}<span class="ls-strip__title"><span class="node-title">{{ shown | markdown_inline }}</span></span>{% endif %}
    <span class="ls-strip__state">
        {% if heartbeat.stale %}<span class="status-stale">stale</span>{% endif %}
        {{ status_cue(heartbeat.code) }}{{ heartbeat.code.name.lower() }}
    </span>
</div>
{%- endif %}
</div>
{%- endif %}
{% if node is none and no_node %}
    {% include '_no_node.html' %}
{% elif node is none %}
    <div class="alert alert-warning">
        No such branch: <code>{{ branch }}</code>.
        <a href="{{ url_for('status') }}" class="alert-link">Back to status</a>.
    </div>
{#- The overview is nobody's node, so with nothing under it there is only the
    sentence to show. A node's page is different: hide ok and hide idle filter its
    **children**, and a filter that hides every one of them leaves the node itself —
    its head, its card at depth 0, its own facts below — exactly where it was, with
    the grid saying that nothing in it matches. They went with the children once,
    and a page of one sentence could not say what the node was. -#}
{#- Where the filters leave none of the nodes a page shows, it says what they hid
    (`_nothing_left`): with hide ok on, the wall is the list of problems and empty on
    a good day, which must read as all well rather than as nothing reporting. A
    renderer that filters nothing passes no sentence. -#}
{% elif not node.children and not branch %}
    <p class="text-muted">{{ nothing_left | default("") or "No checks reporting yet." }}</p>
{% else %}
    {#- The head is drawn where the node has something of its own to say — which a
        written sole-check container does — or the reader may pin it, and the head
        carries the control (see `viewed_head`). Decided once, because what the head
        displays is what the cards below suppress (ADR-0044): the viewed head is the
        topmost visible node. -#}
    {%- set head_drawn = branch and max_depth >= 1
        and (pinning.may or node.maintenance_entry or pins_above or node.reason
             or node.stale or node.own_code.name != 'UNDEFINED') -%}
    {%- if head_drawn %}{{ viewed_head(node, reason_cap, pinning, branch) }}{% endif %}
    {%- set head_shown = node.timestamp | localtime("%H:%M")
        if (head_drawn and node.timestamp) else "" -%}
    {#- Stable flow spans (ADR-0056): the server derives useful width steps
        from rendered topology, depth and the configured reason-line budget — never
        current status or reason content — and prices each span at the width it
        actually has, publishing `(tenths, tracks, plan)` breakpoints — the grid
        width in tenths of a pixel, the model's own unit, against which
        dashboard-layout.js compares its measurement scaled by ten. That script
        measures only the grid's resolved width, sets the band's named track count
        and selects the latest applicable band;
        without that script, and under `dashboard_columns: plain`, this remains the
        ordinary auto-fill grid. Each card carries its one-track stable height and
        minimum-width useful steps for readable harness diagnostics. -#}
    {%- set grid_layout = dashboard_layout(node.children, max_depth, reason_cap)
        if max_depth >= 1 and dashboard_columns == 'flow' and node.children
        else none -%}
    {%- if max_depth >= 1 and not node.children %}
    <p class="text-muted">{{ nothing_left | default("") or "No checks reporting yet." }}</p>
    {%- else %}
    <div class="status-grid"{% if grid_layout %} data-layout-breakpoints='{{ grid_layout.breakpoints | tojson }}'{% endif %}>
        {% if max_depth < 1 %}
            {# depth 0 — a single card for the viewed node: its rolled-up "overall" light #}
            <div class="status-card s-{{ node.code | status_slug }}{% if node.code.name == 'OK' %} dim{% endif %}">
                <div class="status-card__head" data-path="{{ node.path }}">
                    <span class="status-card__name">{{ node.name }}</span>
                    <span class="status-head__middle">{% set shown = node | node_title %}{% if shown %}<span class="node-title">{{ shown | markdown_inline }}</span>{% endif %}
                    {#- The same `node.actions` slot the depth-1 cards carry. At
                        depth 0 this card *is* the viewed node, so an action whose
                        subject is the node belongs here more plainly than
                        anywhere — and the panel below already renders the
                        per-reason slot, so leaving this one out made a
                        deployment's node action vanish at one depth setting while
                        its reason action stayed. -#}
                    <span class="node-actions">{{ slot('node.actions', node=node, surface='grid') }}</span></span>
                    {#- At depth 0 this card is where the viewed node's pin stands, so
                        it is set here too — on a node's page. The overview's card is
                        every node there is, and silencing all of them from a form is
                        a foot-gun: that pin is not set from the wall. One that stands
                        is stated like any other, with *Edit* and *Clear*, as the
                        Maintenance page states it. -#}
                    {%- set settable = branch and pinning.may and not node.maintenance_entry %}
                    <span class="status-card__state{% if settable %} status-card__state--seat{% endif %}">
                        {% if node.stale %}<span class="status-stale">stale</span>{% endif %}
                        {% if node.path in maintenance_ancestors %}{{ maintenance_pip(node.path, maintenance_rows) }}{% endif %}{{ card_time(node) }}{{ status_cue(node.code) }}{{ node.code.name.lower() }}{{ reported_suffix(node) }}<button type="button" class="reason-chevron" tabindex="-1" aria-hidden="true"></button>
                    </span>
                    {%- if settable %}{{ pin_setter(node, pinning, containers) }}{% endif %}
                </div>
                {#- The panel also carries the pin's block, so a pinned node that
                    reports nothing at all still says who silenced it and why — and
                    the blocks of the pins above it, which silence it as much. -#}
                {% if node.reason or node.maintenance_entry or pins_above %}
                    {#- On a node's own page the card is its own card, and lists its
                        lines as the head does at every other depth; the overview's
                        is every node there is, and keeps the wall's clamp. -#}
                    <div class="status-panel">{{ pins_above_stated(pins_above, 'card-above-maintenance-', bare=true) }}{{ pin_stated(node, pinning) }}{% if branch %}{{ own_lines(node, branch, pinning.may, focus, focus_orphan, beneath=node.path in containers, back=pinning.back, surface='grid', prefix='card-line-maintenance-', muted=false, covered=pins_above | length) }}{% else %}{{ reason_block(node, reason_cap) }}{% endif %}</div>
                {% endif %}
            </div>
        {% else %}
        {% for system in node.children %}
            {# a card's children render only from depth 2 on (depth 1 is cards only) #}
            {% set card_has_kids = system.children and max_depth > 1 %}
            {% set card_dim = system.code.name == 'OK' or (system.derived and card_has_kids) %}
            <div class="status-card s-{{ system.code | status_slug }}{% if card_dim %} dim{% endif %}"
                 {%- if grid_layout %}
                 data-layout-weight="{{ grid_layout.weights[loop.index0] }}"
                 data-layout-steps="{{ grid_layout.profiles[loop.index0] | map(attribute='span') | join(',') }}"
                 {%- endif %}>
                <div class="status-card__head" data-path="{{ system.path }}">
                    <a class="status-card__name"
                       href="{{ url_for('status', branch=system.path | url_branch) }}">{{ system.name }}</a>
                    <span class="status-head__middle">{% set shown = system | node_title %}{% if shown %}<span class="node-title">{{ shown | markdown_inline }}</span>{% endif %}
                    {#- The `node.actions` slot (ADR-0034, second slot): an action
                        whose subject is the **whole node**, not one of its reason
                        lines — which is where it belongs when a node's reasons are
                        prose (ADR-0036). Offered on every card and declined by the
                        filler, like every slot; it collapses to nothing when
                        nobody fills it. Cards only, like the pause mark: a deep
                        box's own page carries it one drill-down away. -#}
                    <span class="node-actions">{{ slot('node.actions', node=system, surface='grid') }}</span></span>
                    {#- The pause mark follows the state cluster, on a seat the
                        cluster keeps for it, and opens its editor beneath the head
                        line (`pin_setter`). -#}
                    {%- set settable = pinning.may and not system.maintenance_entry %}
                    <span class="status-card__state{% if settable %} status-card__state--seat{% endif %}">
                        {% if system.stale %}<span class="status-stale">stale</span>{% endif %}
                        {% if system.path in maintenance_ancestors %}{{ maintenance_pip(system.path, maintenance_rows) }}{% endif %}{{ card_time(system, shown=head_shown) }}{{ status_cue(system.code) }}{{ system.code.name.lower() }}{{ reported_suffix(system) }}<button type="button" class="reason-chevron" tabindex="-1" aria-hidden="true"></button>
                    </span>
                    {%- if settable %}{{ pin_setter(system, pinning, containers) }}{% endif %}
                </div>
                <div class="status-panel">
                    {{ pin_stated(system, pinning) }}{{ reason_block(system, reason_cap) }}
                    {% if card_has_kids %}
                    <div class="node-children" data-branch="{{ system.path }}">{{ render_nodes(system.children, 0, system.path, dense, max_depth, branch_cap, reason_cap, pinning, (system.timestamp | localtime("%H:%M") if system.timestamp else head_shown)) }}</div>
                    {% endif %}
                </div>
            </div>
        {% endfor %}
        {% endif %}
    </div>
    {%- endif %}
    {#- The viewed node's own facts, **below** its children (ADR-0044 decision 8):
        the head line says what this node is, the grid says what is under it, and
        the details come last — a forty-line report above the grid would push the
        dashboard the reader came for off the screen.

        Inside `#status-grid` deliberately: `report` is an **output of the run** and
        changes with every tick, so a frozen roster beside a live grid would be the
        one part of the page quietly going wrong.

        Rendered only when the node has something of its own to say: an observation,
        a configuration, a report — or a period, which the route hands over as
        ``since`` (ADR-0115 decision 6). A container two checks share has none of
        the first three by construction — the snapshot withholds its text and its
        run facts (decision 1) — and its Time card could only say "not yet observed"
        about a node neither check writes. Pinned, a node nothing has written has
        shown *maintenance* since its pin, and the card says so: the pin's block
        above the children says who and until when, and since when was on no part
        of the page. Unpinned it declares nothing, has no period, and the block
        stays away. -#}
    {%- if branch and layout != 'kiosk'
           and (node.timestamp or node.config or node.report or since) %}
    <div class="mt-3" style="max-width: 820px">
        {#- The block's cards are h3s, and this page's only other heading is the
            band's h1 — so without this the outline jumps a level and a screen
            reader meets three headings belonging to nothing. Named, not
            decorative: it says *whose* time and report these are, which the
            sighted reader gets from the breadcrumb overhead. -#}
        <h2 class="visually-hidden">{{ node.name }}</h2>
        {% include '_node_facts.html' %}
    </div>
    {%- endif %}
{% endif %}