{#- The node's own facts — time, what the run found, what it ran with — as the **one** block both pages render (ADR-0044 decision 8, questions §4.8 answered: the container gets the detail page it never had, built by reuse rather than as a second surface). The leaf detail page owned all of this and the container owned none of it: `/status/` is a dashboard *of the children*, so a container's `config` was stored by two checks in the tree and rendered by nothing, and its run facts had nowhere to land. Same partial on both pages, so the two can no longer drift. Three cards, in the order a reader wants them: **when** it ran, **what it found** (`report` — the run's outputs), **what it ran with** (`config` — its inputs). Report before config on purpose: the outputs are why you opened the page, the inputs are the reference beside them. Both are Markdown through the hardened renderer (ADR-0018) — checks author them with `config_markdown()`, and rendering that bullet list as literal text was a leftover from before the renderer landed. Context: ``node`` (a StatusSnapshot), ``branch`` (its path, for the history link) and ``since`` (the start of the current own-status period, or None). Never included by the kiosk, which keeps none of this. -#}

Time

{#- Observation time (ADR-0027). No timestamp means no check has ever written this node — say so, rather than inventing an instant. With a timestamp but no recorded transition of its own (``since`` is None) there is no period to bound either, so report the single observation instead of a from/until of one moment. The period is bounded by the **own**-status event log, so it names the own status: on a container the rolled-up code is a statement about the children, and the children are on the same page saying it themselves. -#} {% if node.timestamp is none %}

Not yet observed.

{% elif since %}

Status {{ node.own_code.name.lower() }} from {{ since | localtime }} until {{ node.timestamp | localtime }}

{% else %}

Observed {{ node.timestamp | localtime }}.

{% endif %} {#- The run facts (ADR-0044 decisions 2 and 4), present exactly where this node carries them — the sole owning check's mount and the unwritten ancestors above it. This is where **wall time** surfaces: stored since the run-object slice, rendered nowhere until this header. The next update stays **absolute** here, as on the grid. §10.5 of the working note reserved the relative "in 4m" for this header, on the grounds that the reader is looking deliberately and the stale banner is directly above — but that argument needs a *live* page, and this partial is on one page that polls and one that does not. A relative form on the leaf page would go on claiming "in 4m" for as long as the tab is open, which is the same freeze the absolute form was chosen to survive. One partial, one form, and the safe one wins. -#} {% if node.run and node.run.next_run_at %}

Next update {{ node.run.next_run_at | localtime }}

{% endif %} {% if node.run and node.run.wall_seconds is not none %}

Last run took {{ node.run.wall_seconds | elapsed }}

{% endif %} {#- The period where there is one, and the **tolerance** where there is not (ADR-0081). "Checked every" is a claim that a subject was read on that interval, and it is only true of a check: the instance's own nodes are recorded state re-asserted on the scheduler tick and readiness measured its trust store once, at startup, so the line used to say "Checked every 1s" about something nothing checks. Such a node carries no period at all now — nor does a paced unit, which has none to carry — and what both do carry is the freshness they promise, which is the fact a reader of either wants and the one the server actually applied. One rule, both kinds, no discriminator: a node with a period shows it, a node without shows what it promises instead. -#} {% if node.frequency_seconds %}

Checked every {{ node.frequency_seconds | duration }}

{% elif node.stale_after_seconds %}

Goes stale after {{ node.stale_after_seconds | tolerance }}

{% endif %} {#- How often this node changed its mind lately. It sits next to the History button because it is the same question asked in one number, and it is **not** on a card: a card says what a node is now, and churn is history. A subject that flaps is the case the escalation counter deliberately does not catch — every recovery clears that counter — so without this there is no number anywhere that says *this thing is flapping*, only a list of events to count by eye. Suppressed transitions are in it: a check flapping underneath a pin is exactly what is worth seeing, which is the opposite of what the History list wants. -#} {% if node.changes %}

{{ node.changes }} status {{ "change" if node.changes == 1 else "changes" }} in the last hour

{% endif %} {#- The dependency graph, from whichever end this node stands at. Both sentences are about **reachability**, which is why they sit here with the freshness facts rather than on a status card: neither is a claim about how the subject is doing. Being shielded is the more urgent of the two — the node is not reaching the level above, and an operator who does not know that will read a quiet parent as good news — so it is said in the node's own words and links to the thing to go and look at. The other direction is the risk the feature carries: one dependency can quiet dozens, and a number that says how many is the only thing standing between that and a silence nobody can account for. -#} {%- if node.shielded_by %}

Reached through {{ node.shielded_by }}, which is failing — nothing from here reaches the level above until it answers.

{%- endif %} {%- if dependents %} {%- set reached = dependents | length %}

{{ reached }} {{ "check is" if reached == 1 else "checks are" }} reached through this{% if node.code.name == 'ERROR' %}, and not reaching the level above while it is failing{% endif %}.

{%- endif %} {# Secondary, like the maintenance buttons below it, rather than the off-palette `btn-info` cyan it used to wear — the one color on this page that belonged to no theme and followed none of them. #} History
{% if node.record %} {#- **What this run measured** (ADR-0085): the reading the node's code, lines and children are derived from, and the object it was taken on. Untyped rendering, the same `record_fields` the entry records use — nothing here reads what a name means, so one place decides what a field is. A card above says what the node *is now*; this says what was *read*. It is data and never a claim: anything that should alarm is a reason. -#}

Measured

{%- if node.subject %}

On {{ node.subject }}

{%- endif %}
{%- for name, value in node.record | record_fields %}
{{ name }}
{{ value }}
{%- endfor %}
{% endif %} {% if node.report %} {#- What the run **found** (ADR-0044 decision 6) — the roster, the scope, the enumeration — and never a status claim: anything that should alarm is a reason, and this field must not become a second, quieter reason channel. Never on a card either: volume is exactly what `reason_cap` exists to keep off the grid. -#}

Report

{{ node.report | markdown }}
{% endif %} {% if node.config %}

Configuration

{{ node.config | markdown }}
{% endif %}