docs: the summary line, before and after, verbatim

The CHANGELOG entry quotes both forms of the line — the zero case and the
mixed corpus — so a reader sees exactly which bytes changed rather than a
description of them, plus `show`'s and `watch`'s status lines on both sides.

DESIGN.md is the spec, so it moves with the code: the coverage-line paragraph
now names the in-flight clause, says why it is stated at zero (the same
argument that already makes the skipped count unconditional), records that
`show` and `watch` carry the same wording, and points the count at
runstatus.InFlightCount over statuses those surfaces already derived — Derive
stays the one place the ADR 0015 rule lives.

Signed-off-by: jitokim <pigberger70@gmail.com>
Co-Authored-By: oh-my-graph <graphs@oh-my-graph.dev>

Author: jitokim

CHANGELOG.md

@@ -12,6 +12,68 @@ oh-my-graph is **alpha software**. The graph YAML schema, the CLI, and the
 
 ### Changed
 
+- **`runs list`, `show` and `watch` now state how many runs are IN FLIGHT,
+  including when the answer is zero.** Asked how many graphs were running, an
+  operator could only run `oh-my-graph runs list | grep -c RUNNING` and read
+  `0` — an inference from ABSENCE, indistinguishable from a table that failed
+  to render, a mis-filter, or broken status logic. The summary line counted
+  what was HIDDEN and never counted what was ALIVE.
+
+  Before, on a run home with one settled run and nothing running:
+
+  ```
+  1 of 1 run(s) shown; 0 skipped.
+  ```
+
+  After, the same corpus:
+
+  ```
+  1 of 1 run(s) shown; 0 in flight; 0 skipped.
+  ```
+
+  With two live runs, one abandoned one and one directory this build cannot
+  read, before:
+
+  ```
+  3 of 4 run(s) shown; 1 skipped (1 written by an incompatible snapshot schema) — pass --show-skipped to name them.
+  ```
+
+  After:
+
+  ```
+  3 of 4 run(s) shown; 2 in flight, 1 abandoned; 1 skipped (1 written by an incompatible snapshot schema) — pass --show-skipped to name them.
+  ```
+
+  It is the SAME line, not a second one: one line is one read, while a second
+  line can be scrolled past, cropped by a pager, or emitted only
+  conditionally — the exact failure mode this change exists to kill. An
+  abandoned run is named in the same sentence when there is one, and is never
+  added into the in-flight number: a reader asking "is anything running" is
+  answered wrongly by a count that folds in dead runs, and badly served by
+  silence about a run whose process died holding a lock.
+
+  The two single-run surfaces say the same sentence, so an operator learns one
+  wording rather than three. `show`, before and after:
+
+  ```
+  Run run-done — PASS, 1 node(s)
+  Run run-done — PASS, 1 node(s); 0 in flight.
+  ```
+
+  `watch`, before and after:
+
+  ```
+  run run-done is PASS
+  run run-done is PASS; 0 in flight.
+  ```
+
+  The count is `runstatus.InFlightCount` over statuses the surfaces already
+  derived, so nothing re-decides what in-flight means (ADR 0015 §4's open leg
+  AND held lock stays the one rule, in `runstatus.Derive`). The machine-readable
+  surfaces are unchanged: `/api/cards`, `/api/graph` and `events.jsonl` keep
+  their shapes and gain no prose — a consumer counts live runs itself from the
+  state token, as the dashboard's own page already does.
+
 - **An unresolvable `{{ inputs.x }}` or `{{ artifacts.id }}` now says that a
   merely-quoted placeholder is resolved too, and how to quote one.** The two
   reasons were written as if the graph had meant the token — the artifact one

DESIGN.md

@@ -1792,11 +1792,21 @@ oh-my-graph resume <run-id> (--approve <gate-id> | --reject <gate-id> | --retry-
   `VERDICT`, which would have kept the very conflation the enumeration
   removes) and, under its total, one line saying how much of the run home the
   table covers: how many runs are shown out of how many directories were found,
-  how many were skipped and under which reason. It is printed whether or not
+  **how many of them are in flight**, and how many were skipped and under which
+  reason (`3 of 4 run(s) shown; 2 in flight, 1 abandoned; 1 skipped (…)`). It is
+  printed whether or not
   anything was skipped, because a reader must be able to tell "nothing was
   hidden from me" apart from "64 of 325 runs are shown" — a summary that
   appeared only when there was something to report renders those two cases
-  identically. `--show-skipped` names each skipped directory and quotes the
+  identically. The in-flight clause is there for the same reason and is stated
+  AT ZERO: "no run is running" and "the status column is broken" are what an
+  empty `RUNNING` column renders identically, and only the first is the
+  conclusion an operator draws from it. `show` and `watch` append the same
+  clause to their own status lines (`run run-x is PASS; 0 in flight.`) so one
+  wording answers the question on every surface. The count is
+  `runstatus.InFlightCount` over statuses those surfaces already derived —
+  `Derive` remains the only place the open-leg-AND-held-lock rule lives, and no
+  surface re-decides it. `--show-skipped` names each skipped directory and quotes the
   reader's own reason, one line each on stderr; that per-run detail used to be
   unconditional and was four fifths of the command's output on a long-lived run
   home. That per-run sentence is `runstatus.Unreadable` and is the ONE wording