diff --git a/.agents/docs/2026-09-29-build-progress-display-design.md b/.agents/docs/2026-09-29-build-progress-display-design.md
new file mode 100644
index 000000000..1877215a0
--- /dev/null
+++ b/.agents/docs/2026-09-29-build-progress-display-design.md
@@ -0,0 +1,728 @@
+---
+subject: design
+status: landed
+---
+
+# Build progress: each step's line states its outcome, and one status line states the build
+
+- Status: landed (revision 2). Implemented in #742, released as 2026.9.29.5
+- Date: 2026-09-29
+- Origin: the cross-verification of #742 on the validation project (run
+  36562019799). `mcpp build --workspace` printed its last `Compiling` line at
+  11:34:50 and `Finished` at 12:14:58; nothing was printed in between. The
+  discussion that followed settled the requirements in section 2.
+
+Revision 2 replaces the criterion "every step of the build is planned", which
+a measurement refuted (section 3.1), with a completion rule that holds in
+every build. It drops the per-package fraction and the `stopped` state, which
+depended on that criterion, and states how a step is attributed to its
+package (section 6.3) and how lines that bypass the renderer are handled
+(section 5.3).
+
+## 0. Scope
+
+This document covers the human output of the commands that build (`build`,
+`run`, `test`, `pack`, and the planning part of `emit build-database`), from
+the first line to `Finished`. It does not change machine output
+(`--message-format json`), the result lines of `mcpp test`, or the `Packed`
+report of `mcpp pack` (revised in 2026.9.29.5).
+
+## 1. The problem, measured
+
+1. **The ninja phase prints nothing.** ninja runs with `--quiet`, and mcpp
+   collects its output whole (`capture_exec`, `capture_exec_deadline`) and
+   examines it after ninja exits. In the run above the vcpkg binary cache was
+   cold, so the `prepare` actions of deps-vcpkg built ports from source for
+   most of the 40 minutes 8 seconds, and the log gives no indication of it.
+2. **A failure is reported late.** A failed step is printed after ninja exits,
+   that is, after every step already running has finished. A compile error
+   beside a running 20-minute vcpkg install is shown 20 minutes after it
+   occurred.
+3. **`Compiling <package>` states an intention, not an outcome.** The line is
+   printed for the root's direct dependencies before ninja starts, whether or
+   not they have anything to compile. Transitive dependencies are not named at
+   all, and nothing later states what happened to any of them.
+4. **A build program takes two lines and states no time**:
+   `build.mcpp compiling X` and `build.mcpp running X`, or
+   `build.mcpp up to date X (cached)`.
+5. **`Finished … in X` counts only ninja.** The validation project's step took
+   1124 s while `Finished` said 1020.65 s (the acceptance report of
+   2026.9.29.4).
+6. **Terminal detection answers "not a terminal" on macOS and Windows.**
+   `mcpp.platform.terminal::is_tty` is compiled only under `__unix__`, which
+   Apple's compilers do not define and Windows does not have. The one live
+   display mcpp has, the download bar, is therefore drawn only on Linux, and
+   colours are off on the other two platforms.
+
+## 2. Requirements
+
+These were settled in the discussion.
+
+- **R1** Each step's line carries the step's state. On a terminal the line is
+  updated in place while the step runs. In a log it is written once, when the
+  outcome is known.
+- **R2** One status line summarises the build, for example
+  `Building 612/1203 · 14:32 · gpp.gui: vcpkg install 6:10`. It is always the
+  last line, separated from the step lines by one blank line, and not aligned
+  with them.
+- **R3** `Finished` is separated from the step lines by one blank line and
+  states the total time and how it was spent.
+- **R4** The default output names the packages the user asked to build. The
+  packages they depend on are folded into one line.
+- **R5** `-v` or `--verbose` shows everything: every package, every step as
+  ninja reports it (commands and their output), and how long each build
+  program took to compile and to run.
+- **R6** The states are named `done`, `ran`, `cached` and `waiting`, with
+  `failed` and `fresh` for the cases the discussion did not cover
+  (section 4.2).
+- **R7** No line states something mcpp does not know. This is the codebase's
+  standing rule: the word `Cached` was once printed for three months while
+  ninja recompiled every unit behind it.
+
+## 3. What mcpp can know, and when
+
+| Fact | Source | Known | Exact |
+|---|---|---|---|
+| a download, a provisioning entry, a build program: start, end, outcome | mcpp runs them | as they happen | yes |
+| steps finished, steps planned so far | ninja's status line (`NINJA_STATUS`: `%f`, `%t`, `%e`) | when each step finishes | yes |
+| which step finished, when it started and ended | `.ninja_log`, written and flushed right after the status line (ninja 1.12.1, `build_log.cc:170`) | a moment after each step finishes | yes |
+| a step's output, a failure | ninja's standard output, after the step's status line | when the step finishes | yes |
+| which step is running | not reported by ninja through a pipe | not known | no |
+| which steps ninja will run | not reported; `%t` counts them and changes during the build | not known | no |
+
+**ninja through a pipe reports a step only when it finishes.** ninja prints a
+status line when a step starts only on a smart terminal or for the console
+pool (`StatusPrinter::BuildEdgeStarted`); mcpp reads ninja through a pipe.
+Measured with ninja 1.12.1 and a two-second step: the step's line appeared
+two seconds after it started, together with its output. `check` and
+`prepare` actions are the exception: they run through the engine's wrapper
+(`mcpp __action`, `mcpp __action-stamp`) on every platform, so the wrapper can
+report their start (section 6.4). These are the roles SPEC-007 assigns to
+analysers and to external builds, the steps that run for minutes.
+
+### 3.1 Measured on a first build
+
+A probe (a root package, a path dependency with two module units, `import
+std`, clang 22, ninja 1.12.1) built from an empty directory:
+
+- `%t` read 12 on the first seven status lines and 13 from the eighth on:
+  loading a dyndep file added the step that compiles `std.pcm`;
+- the graph holds 14 steps, and the build ran 13: `std.compat.pcm` is never
+  built unless something imports it;
+- `std.o` and `std.compat.o` ended in the same millisecond; the log tells
+  them apart by their command hashes.
+
+A criterion of the form "`%t` equals the graph's number of steps, so every
+step runs" is therefore never met, and a package's planned number of steps
+is not knowable from `%t`.
+
+### 3.2 The rule that follows
+
+**A package is complete when every step the graph assigns to it has finished
+in this build.** The rule needs no knowledge of ninja's plan:
+
+- in a first build it is met as the package's last step finishes;
+- in an incremental build a package rarely re-runs every step, and its
+  outcome is then stated when ninja exits;
+- a step the graph assigns to a package and that is never built (the
+  standard library's `std.compat` module in the probe) keeps the package open
+  until ninja exits. The rule can only state completion late, never early.
+
+A package is never shown as `waiting`, because mcpp cannot tell a package
+whose first step is running from one whose steps have not started. `waiting`
+is stated only where mcpp itself decides the order: build programs, which
+mcpp runs one after another.
+
+## 4. The output
+
+### 4.1 Two layers
+
+The output has two layers:
+
+- **the log**: lines that do not change once they are written;
+- **the status line**: always the last line. On a terminal it is rewritten
+  in place. In a log it is repeated when the log has been silent (section 5).
+
+A step line belongs to the log once its outcome is known. On a terminal it is
+shown between the log and the status line while it runs.
+
+### 4.2 Step lines
+
+A step line has the shape
+
+    <verb, right-aligned in 12 columns> <subject>  <state>
+
+The state begins two columns after the longest subject of its block, and at
+column 56 at most; a longer subject is followed by two spaces. A block is the
+set of lines of one kind: the build programs, the packages.
+
+| Verb | Subject | Live states (terminal) | Final states |
+|---|---|---|---|
+| `Downloading` | the package | the existing bar | unchanged: `done, 211.9 MB in 5.0s` |
+| `build.mcpp` | the package | `waiting`, `compiling 0:02`, `running 0:05` | `ran 7.52s`, `cached`, `failed` |
+| `Compiling` | the package: `gpp.core (GalTranslPP)`, `fmt v11.0.2`, `x (path)`, `y (git tag v1)` | `61 steps` | `done 3m12s`, `cached 12 units`, `failed`, `12 steps`, `fresh` |
+| `Compiling` | `23 dependencies` | `412 steps` | `done 1m12s`, `done 1m12s · 5 cached` |
+
+The meaning of each state:
+
+- `done <span>`: every step of the package that ran succeeded, and the
+  package is complete (section 3.2) or the build has ended. The span runs
+  from the start of its first step to the end of its last, both read from
+  ninja's log.
+- `ran <time>`: a build program ran. Its compile time is included. Verbose
+  output states the two parts: `compiled 3.21s · ran 7.52s`.
+- `cached`: the result came from a cache: a build program's result, or a
+  dependency whose units were staged from the global BMI cache
+  (`cached 12 units`, the number the `Cached` line states today).
+- `waiting`: a build program that mcpp has scheduled and not started.
+- `failed`: a step of the package failed.
+- `12 steps`: the steps of the package that ran. On a terminal it counts up
+  while the package is open. After a failed build it is the final state of a
+  package that did not complete, because whether it had steps left is not
+  known (R7).
+- `fresh`: the package had nothing to do. Shown only with `--verbose`.
+
+The verb stays `Compiling` after the step is finished: the verb names the kind
+of step, and the state names its outcome. The download line keeps its
+wording: it is already one line with its outcome, and matching it to the
+state column would change a line that has no defect.
+
+### 4.3 Folding (R4)
+
+The **requested** packages are the root package of a single-package build, or
+the selected members of a workspace. Every other package is a
+**dependency**: index packages, path dependencies that are not selected, git
+dependencies, and the standard library module that `import std` compiles.
+
+- The default output lists each requested package that has work. The
+  dependencies with work are folded into one line, `Compiling 23 dependencies`,
+  which is final when every one of them is complete, or when ninja exits.
+- A dependency that fails is always listed by name.
+- A package with nothing to do is not listed. Before this change the root's
+  direct dependencies were announced as `Compiling` although nothing compiled.
+- Build programs follow the same rule: the programs of requested packages are
+  listed, and those of dependencies are folded into `build.mcpp 3 dependencies`.
+- `--verbose` lists every package, including those with nothing to do
+  (`fresh`), and the per-dependency `Cached … (N units)` facts.
+
+### 4.4 The status line (R2)
+
+    <phase>[ n/m] · <elapsed>[ · <current>]
+
+- The phases are `Resolving`, `Running build programs`, `Building f/t`,
+  `Stopping` (a step failed and ninja waits for the steps still running) and
+  `Checking` (the validations after ninja).
+- `<elapsed>` is the time since the command started, as `m:ss` or `h:mm:ss`.
+  It therefore ends equal to the total that `Finished` states.
+- `<current>` is the longest-running step that mcpp knows to be running, with
+  its own time: a build program, or a `check` or `prepare` action. It is
+  omitted when no such step runs.
+- The line starts at column 0, is not aligned with the step lines, and is
+  truncated to the width of the terminal.
+
+### 4.5 `Finished` (R3)
+
+    Finished fast-release [unoptimized + debuginfo] in 41m53s · plan 1m13s · programs 32s · build 40m08s · longest gpp.gui: vcpkg install 22m10s
+
+- The time is the whole command's. Until now it was ninja's alone.
+- `plan` (resolution, provisioning, planning), `programs` (build programs)
+  and `build` (ninja and the validations after it) are listed when the command
+  took at least ten seconds and more than one of them took time. Their sum is
+  the total. A shorter command has no wait to explain.
+- `longest` names the longest single step when the build phase took at least
+  ten seconds and that step took at least a quarter of it. Below that, time
+  is spread over many steps, and naming one would misdirect the reader.
+- `Finished` ends the report: the region is erased before it and is not drawn
+  again below it.
+- One format for every duration: `0.84s` and `12.34s` below a minute,
+  `3m12s` below an hour, `1h02m` above it. The status line uses a clock:
+  `14:32`, `1:02:10`.
+
+### 4.6 Examples
+
+The numbers below are those of run 36562019799 where the run's log states
+them. The per-package spans and the vcpkg time are illustrative.
+
+**A terminal, during the build** (a first build):
+
+```
+   Workspace building 5 members: gpp.cli, gpp.core, gpp.gui, gpp.updater, gpp.version
+    Resolved llvm@22.1.8 → @mcpp/registry/data/xpkgs/xim-x-llvm/22.1.8/bin/clang++.exe
+  build.mcpp gpp.core                     ran 16.00s
+  build.mcpp gpp.cli                      ran 4.60s
+  build.mcpp gpp.updater                  ran 4.60s
+  build.mcpp gpp.gui                      ran 6.70s
+   Compiling gpp.version (GPPVersion)     done 2.10s
+   Compiling gpp.core (GalTranslPP)       done 3m12s
+   Compiling gpp.cli (GPPCLI)             done 41.20s
+   Compiling gpp.gui (GPPGUI)             61 steps
+   Compiling 23 dependencies              412 steps
+
+Building 612/1203 · 14:32 · gpp.gui: vcpkg install 6:10
+```
+
+The first nine lines are in the log. The two `Compiling` lines without a
+final state and the status line are redrawn in place. gpp.updater has no
+finished step yet and is not shown.
+
+**A log (CI), the same build**:
+
+```
+   Workspace building 5 members: gpp.cli, gpp.core, gpp.gui, gpp.updater, gpp.version
+    Resolved llvm@22.1.8 → @mcpp/registry/data/xpkgs/xim-x-llvm/22.1.8/bin/clang++.exe
+  build.mcpp gpp.core                     ran 16.00s
+  build.mcpp gpp.cli                      ran 4.60s
+  build.mcpp gpp.updater                  ran 4.60s
+  build.mcpp gpp.gui                      ran 6.70s
+   Compiling gpp.version (GPPVersion)     done 2.10s
+Building 214/1203 · 2:32 · gpp.gui: vcpkg install 0:52
+Building 388/1203 · 3:32 · gpp.gui: vcpkg install 1:52
+   Compiling gpp.core (GalTranslPP)       done 3m12s
+   Compiling gpp.cli (GPPCLI)             done 41.20s
+Building 612/1203 · 5:02 · gpp.gui: vcpkg install 3:22
+…
+   Compiling gpp.updater (Updater)        done 12.40s
+   Compiling 23 dependencies              done 6m20s
+   Compiling gpp.gui (GPPGUI)             done 38m05s
+
+    Finished fast-release [unoptimized + debuginfo] in 41m53s · plan 1m13s · programs 32s · build 40m08s · longest gpp.gui: vcpkg install 22m10s
+```
+
+**An incremental build** (one source of gpp.gui edited):
+
+```
+   Compiling gpp.gui (GPPGUI)             done 4.12s
+
+    Finished fast-release [unoptimized + debuginfo] in 4.31s
+```
+
+**A failure**:
+
+```
+   Compiling bad v0.1.0 (.)               failed
+error: build failed
+src/main.cpp:1:2: error: #error MARKER
+```
+
+The three lines are printed when the step fails, not when ninja exits. While
+ninja waits for the steps still running, the status line reads
+`Stopping · 0:03 · gpp.gui: vcpkg install 6:10`. The advice blocks that read
+the whole output (link failure, C library isolation) follow after ninja exits.
+
+**`--verbose`**: the lines above, every dependency on its own line, and above
+them each step as ninja reports it, `[f/t] <command>` followed by its output,
+printed when the step finishes rather than after ninja exits.
+
+## 5. The two media
+
+### 5.1 A terminal
+
+The region is the part of the screen below the log: the live lines, one
+blank line, and the status line. The live lines are the download bars, the
+build programs not yet final, and the packages still open.
+
+- Every other line mcpp writes goes above the region: the region is erased,
+  the line is written, and the region is redrawn, in one write. This covers
+  warnings, errors, notes and the step lines that become final.
+- The region holds at most `min(10, rows − 3)` live lines. The rest are
+  summarised as `… 12 more`.
+- Every line of the region is truncated to the width minus one column, in
+  display columns (colour sequences count zero, an East Asian wide character
+  two), so that no line wraps and the cursor arithmetic holds after a resize.
+- The region is drawn at most ten times a second when events arrive, and once
+  a second otherwise, so that the clocks advance.
+- When the command ends, the region is erased, and the final step lines and
+  `Finished` are written to the log.
+
+Whether the terminal medium is used is decided when the region opens, from
+the descriptor the region writes to (section 8).
+
+### 5.2 A log
+
+Only final lines are written. The status line is written, without a blank
+line, when the log has been silent for 60 seconds, so that a long step shows
+what is happening at least once a minute. `Finished` is preceded by a blank
+line, as on a terminal. A command that wrote no line before `Finished`
+writes no blank line.
+
+### 5.3 Lines that do not come from the renderer
+
+The region is drawn relative to the cursor, so a line written to the terminal
+by anything else while the region is on screen lands inside it. Three
+measures keep that from happening:
+
+- every line mcpp writes on the build path goes through `mcpp.ui`: the
+  command handlers' `std::println(stderr, "error: …")`, the failure report's
+  `fputs`, and the lines of `mcpp.log`'s verbose channel, which `mcpp.ui`
+  receives through a sink it installs;
+- a child that is given the terminal (a `[hooks]` command, the program
+  `mcpp run` starts) runs with the region erased, and the region is redrawn
+  after it returns;
+- a command with a `[hooks] during_build` command that writes to the
+  terminal while the build runs uses the log medium.
+
+### 5.4 Verbosity
+
+`--verbose` writes ninja's lines as they arrive, above the region, in either
+medium. `--quiet` and `--message-format json` write nothing, and none of the
+readers of section 6 runs.
+
+## 6. Sources
+
+### 6.1 ninja's standard output
+
+- ninja is started with `NINJA_STATUS="\x1b[0m@@mcpp %f %t %e@@ "` and
+  `CLICOLOR_FORCE=0` in its own environment and without `--quiet`, and its
+  output is read line by line as it arrives. The marker begins with an escape
+  sequence because a step's command inherits ninja's environment: a ninja it
+  runs (a `prepare` action's CMake or vcpkg build) prints the same marker, and
+  the outer ninja, whose output is not a terminal, strips escape sequences
+  from a command's output before relaying it while printing its own status
+  line as it is. Only the outer ninja's lines keep the escape sequence. The bounded launcher already delivers lines to a callback
+  (`dispatch_bounded`, used by `run_streaming_bounded`). Its contract gains
+  one case: with a callback and no bound, the child runs unbounded.
+- A line is one of: a status line (it starts with the marker), `FAILED: `
+  followed by the step's outputs, a line of ninja's own (`ninja: …`), or
+  output of the step whose status line came last.
+- The default output discards the output of a successful step, as it does
+  today, and filters a failed step's block with `filter_ninja_output` and
+  prints it at once. `--verbose` prints every line, with the marker replaced
+  by `[f/t] `.
+- The staged-cache pass (`_mcpp_staged_cache`), which copies what the global
+  cache supplies before the main pass, runs as before and is not read: a
+  dependency the cache supplied whole is stated as `cached` from the plan
+  (`BuildPlan::packages`), not from its copies.
+
+### 6.2 ninja's log
+
+ninja appends one entry per output of each successful step: start, end,
+modification time, output path and command hash. The entries of one step
+share start, end and hash, and the entries of a run follow the order of its
+status lines.
+
+- The log alone states which step finished, when it started and when it
+  ended. The status lines give the counts and pace the reading.
+- The entries of this run are those after the offset the file had when ninja
+  started. ninja rewrites the file when it recompacts it, which it does while
+  loading, before the first step; the reader then sees a different file, or a
+  shorter one, and finds this run's entries by their end times, which equal
+  the `%e` of the status lines (`Builder::FinishCommand` hands one value to
+  both).
+- The log is read after each status line and on each tick, from the last
+  position read. A read can land between two entries of one step (ninja
+  flushes each), so a step is counted by its identity in the step record,
+  once, however many reads its entries take.
+- A log that cannot be read or matched gives no durations and no attribution.
+  The counts still come from the status lines. The display loses detail; it
+  does not state anything false.
+
+### 6.3 The step record
+
+The function that writes `build.ninja` writes one more file beside it,
+`steps.tsv`:
+
+- per package: its qualified name, whether it is requested or a dependency,
+  its subject as its line shows it, the number of units it takes from the
+  global cache, and the number of steps the graph assigns to it;
+- per output of every step: the package the step belongs to, and the step
+  itself (the outputs of one step share its number);
+- per `check` or `prepare` action: its label (the action's description, or
+  its id).
+
+**Attribution.** The emitter knows, at each build statement it writes, which
+package's unit, link, action or staged file the statement is for. It records
+that package with the statement's outputs as it appends the statement: the
+compile unit's package, the link unit's (`LinkUnit::package`: the member's,
+the root's, or the dependency's whose library or program it is), the resource
+script's (`ResourceUnit::package`), the action's declaring package, `std` for
+the standard library's module, and none for the steps that belong to the build
+as a whole (the macOS `ios_base` shim, the files placed beside the programs,
+and `std.compat`, which is built only when something imports it and would
+otherwise keep `std` open).
+
+**Naming.** The plan names each package (`BuildPlan::packages`) as the edge
+from the root, or from its first requester, spells it: the dependency key,
+then `vX.Y.Z`, `(path)`, `(git <kind> <ref>)`, or a member's directory. The
+root is `name vX.Y.Z (.)`. Transitive dependencies are named too; before this
+change they were not announced at all.
+
+The full path and the fast path read the same file; the fast path reads it
+lazily, when ninja reports its first step. The record changes nothing in
+`build.ninja`.
+
+### 6.4 The start of a `check` or `prepare` action
+
+ninja is started with `MCPP_ACTION_STARTS=<build directory>/.mcpp-action-starts`,
+truncated before each run. When the variable is set, `mcpp __action` and
+`mcpp __action-stamp` append one line, `<first stamp>\t<start time>`, before
+running the command. The first stamp is the step's first output, so the step
+record gives the action's package and label.
+
+- The start is not passed on the command line, because an action's command
+  line is ninja's key for re-running it: the positional `__action-stamp` form
+  exists to keep that key unchanged, byte for byte. The environment is not
+  part of the key, so an upgrade re-runs no action.
+- Every mcpp that runs ninja sets the variable for that ninja, or empties it
+  when it reads no progress (the staged-cache pass, `--quiet`, machine
+  output). The wrapper empties it, and resets `NINJA_STATUS` to ninja's
+  default, for the command it runs, unless the action declares either. A
+  nested build therefore reports to its own file or to none.
+- One line is one write, in append mode (`O_APPEND`, `FILE_APPEND_DATA`), so
+  the lines of actions running at the same time do not interleave.
+- An action is running from its start line until its step appears in the log
+  or fails.
+
+### 6.5 mcpp's own steps
+
+Downloads, build programs and the phase boundaries are reported by the code
+that performs them.
+
+## 7. Architecture
+
+```
+  mcpp's own steps ──────────────┐
+  ninja stdout ─► stream reader ─┤
+  .ninja_log   ─► log reader ────┼─► mcpp.build.progress (model) ─► mcpp.ui region ─► terminal / log
+  action starts ► start reader ──┤        ▲
+  steps.tsv    ──────────────────┘        └─ clock (injected; steady_clock in use)
+```
+
+- **`mcpp.platform.terminal`**: whether a descriptor is a terminal that can
+  move the cursor, its width and height, enabling virtual terminal
+  processing on Windows, and writing UTF-8 text to a Windows console.
+- **`mcpp.ui`** (existing): every human line. It gains the region, and
+  `ProgressBar` becomes a live line of it. That realises the rule its header
+  already states, one renderer with two output modes, for every live element
+  rather than for one bar.
+- **`mcpp.build.progress`** (new): the model (phases, packages, steps,
+  running actions, counts, spans), the formatting of every line from it, and
+  the three readers of section 6, each of which turns one file format into
+  model events. It performs no terminal I/O, and its clock is injected, so
+  every rule of section 4 is testable without a terminal.
+- **The backend** writes `steps.tsv` from every plan, and, given a handle to
+  the model's record of its build through `BuildOptions`, runs ninja through
+  the readers.
+- **`mcpp.log` and the terminal.** `mcpp.log` stays a leaf that depends on
+  `std` alone: it states records (a tag, a message, a time), writes the log
+  file, and spells a verbose record once (`verbose_line`). The terminal
+  belongs to `mcpp.ui`, which installs a sink for verbose records at start-up
+  and writes them through the same writer as every other line, so a verbose
+  line lands above the region. Without the sink (a unit test, a tool that
+  does not use `mcpp.ui`) the record goes to stderr as before. The model
+  writes its events to the log file (`progress` records at `info`): the
+  build programs, each build's step counts and outcome, so the file holds a
+  trace of what the report showed.
+- **Threads.** The model is guarded by one mutex. The configuration groups of
+  a workspace build on their own threads (workspace design §6) and feed the
+  same model, so their counts are summed in one status line. One ticker
+  thread draws the region, or writes the heartbeat in a log. The ticker
+  takes the model's frame without holding the renderer's lock, and events
+  signal the ticker without taking it, so the two locks are never held
+  together.
+- **Lifetime.** The region belongs to the command. Closing it erases the
+  region before `mcpp run` starts the program and before the command returns.
+
+## 8. Platforms
+
+| Platform | Terminal | Cursor and colour | Text | Width |
+|---|---|---|---|---|
+| Linux | `isatty` (unchanged) | ANSI | UTF-8 | `TIOCGWINSZ`, `COLUMNS`, 80 |
+| macOS | `isatty` (today: always false) | ANSI | UTF-8 | `TIOCGWINSZ` |
+| Windows console | `GetConsoleMode` | `ENABLE_VIRTUAL_TERMINAL_PROCESSING`; if refused, the log medium without colour | UTF-16 through `WriteConsoleW` | `GetConsoleScreenBufferInfo` |
+| Windows, mintty or a pipe | not a console | the log medium | bytes, as today | none |
+
+- `TERM=dumb`, or a terminal narrower than 20 columns or lower than 5 rows,
+  uses the log medium.
+- On Windows the lines of `mcpp.ui` are written as UTF-16 when the
+  descriptor is a console, so `·`, `→`, `…` and non-ASCII paths appear as
+  written whatever the console's code page. Today the console decodes mcpp's
+  UTF-8 bytes in its own code page. The standard output buffer is flushed
+  before each such write.
+- ninja reports steps only when they finish, through a pipe, on all three
+  platforms (the same `StatusPrinter` code), and flushes its log after each
+  entry on all three.
+- An interrupted command leaves its last frame on the screen; the next line
+  the shell prints starts after it.
+
+## 9. Cases
+
+| Case | Behaviour |
+|---|---|
+| first build | packages final as they complete (section 3.2) |
+| incremental build | step counts; packages final when ninja exits; packages with nothing to do not listed |
+| nothing to do (fast path) | no step line, no blank line, `Finished` |
+| a failed step | its package `failed`, `error: build failed`, its diagnostics, at once; `Stopping` until ninja exits; then the other packages (`done`, or `N steps`) and the advice |
+| several failed steps (`-k 0`, or failures at the same time) | each failed step's diagnostics once; `error: build failed` once |
+| the build timeout | the existing message |
+| Ctrl-C | the last frame stays on the screen |
+| several configurations | one status line; each package line carries the configuration's directory name when there is more than one, as SPEC-005 v1.6 names the database's sets; one `Finished` |
+| the staged-cache pass | runs before the main pass, unread; cached dependencies are stated from the plan |
+| `mcpp run` | the region is closed before `Running`; the program owns the terminal |
+| `mcpp test` | the report covers planning, build programs and the package's own build (Phase A); it is closed before the tests' own builds and runs, whose lines are unchanged |
+| `mcpp pack` | the status line during its build; `Packing` and `Packed` unchanged |
+| `emit build-database` | the region opens inside the standard-output redirection and is decided on that descriptor, so the document on standard output stays clean |
+| `--message-format json`, `--quiet` | nothing written; no reader runs |
+| `--verbose`, `MCPP_VERBOSE=1` | section 5.4 |
+| a `[hooks]` command | runs with the region erased (section 5.3) |
+| a nested mcpp (in a build program or an action) | it reports to its own start file (section 6.4) |
+| an older ninja from `PATH` | status lines as above; if its log is not flushed per entry, attribution waits until ninja exits; log formats v5 and v6 are read, and any other gives no durations |
+| the sandbox (`xlings subos … --sandbox`) | a log medium; nothing depends on the host |
+| a terminal resized during the build | width and height are read at each frame |
+
+## 10. Compatibility and upgrade
+
+- **No command line changes.** The commands in `build.ninja` are unchanged,
+  so upgrading re-runs no step. The step record is a new file beside
+  `build.ninja`, and the descriptions in `build.ninja` are unchanged.
+- **The human output changes.** It is not an interface; the machine output
+  is (docs/50), and it is unchanged. The changes are:
+  - `build.mcpp compiling/running/up to date X (cached)` becomes one line,
+    `build.mcpp X  ran …` or `cached`;
+  - a package with nothing to do is no longer announced;
+  - dependencies are folded unless `--verbose` is given, including the
+    `Cached X (N units)` lines;
+  - `Finished` states the whole command's time and its distribution.
+- **mcpp's own tests.** The e2e tests that match these lines change with
+  them:
+  - `build.mcpp running` or `build.mcpp compiling` (110, 143, 144, 186, 189,
+    194, 325, 839);
+  - `up to date … (cached)` (139, 186, 651, 779, 826);
+  - a dependency's `Compiling` or `Cached` line (19, 40, 49, 53, 82, 135, 163,
+    172, 196, 212, 713, 839 B5), which add `--verbose`. Test 713 asserts the
+    absence of a line, and would pass vacuously once dependencies are folded,
+    so it changes in the same commit;
+  - the tests that read any `Compiling` line as "the full path ran" (218, 322,
+    324, 612, 638, 781, 821). Under this change the line means "a step of the
+    package ran", on either path. 322, 612 and 638 meant that, and are
+    unchanged; 218, 324, 781 and 821 meant "the build planned", and now ask
+    whether `build.ninja` is newer than a marker written before the build:
+    the full path writes it or moves its time, and the fast path does not;
+  - test 48 keeps its ordering: the package line comes before
+    `error: build failed`, and the diagnostic appears once.
+- **The ecosystem.**
+  - mcpp-plugins' CI asserts `! grep -q 'build.mcpp running'` in
+    `check-deps-and-qt.sh` (the qt import-only case). After this change that
+    assertion passes whether or not a program ran. It changes in the same
+    pull request that moves the plugins' CI to this release, to a check that
+    does not depend on wording.
+  - mcpp-index's `tests/openkal/compat.py` reads `Running bin/`, which does
+    not change.
+  - The validation project reads no build line.
+- **Upgrade without notice.** A build directory written by an earlier version
+  has no step record. Its first build under this version writes one, because
+  a version change regenerates `build.ninja`. A fast path that finds no
+  record shows counts without attribution.
+
+## 11. Tests
+
+- **Unit tests of the model and the formatting**, with an injected clock:
+  - each state of section 4.2, and the completion rule of section 3.2,
+    including a package with a step that never runs;
+  - folding, and the named failed dependency;
+  - the state column and truncation, with CJK subjects and colour sequences;
+  - the duration and clock formats;
+  - the heartbeat after 60 silent seconds, and none while lines are written;
+  - `longest`, at and below its thresholds.
+- **Unit tests of the readers**:
+  - status lines, `FAILED:` blocks, ninja's own lines and output, in both
+    modes;
+  - the log: entries of several outputs, two steps ending in one
+    millisecond, failed steps (no entry), a recompacted file, formats v5 and
+    v6, an unreadable file;
+  - the start file: interleaved lines, an unknown stamp.
+- **A unit test of attribution**: every step of an emitted plan has an owner
+  or is build-wide (section 6.3).
+- **Unit tests of the region**: the byte stream for a scripted sequence (a
+  line written above the region, the region growing and shrinking, closing).
+- **e2e, the log medium, every platform**:
+  - a workspace with a dependency: members listed, dependencies folded, the
+    blank line and `Finished` with its phases;
+  - `--verbose` lists every package and each step;
+  - a failure is reported before a concurrently running slow `prepare`
+    action ends;
+  - build program lines `ran` and `cached`;
+  - an incremental build lists only the package that did work.
+- **e2e, the terminal medium, Linux and macOS**: through a pseudo-terminal
+  (Python's `pty`), a `prepare` action that runs for three seconds is named in
+  the status line, and the final screen holds the log lines and `Finished`.
+- **Cross-verification**: the validation project's CI log shows the heartbeat
+  during the ninja phase and the package lines with their spans.
+
+## 12. Tasks and order
+
+All of them land in #742, with 2026.9.29.5.
+
+| Task | Content | Depends on |
+|---|---|---|
+| T1 | `mcpp.platform.terminal`: terminal detection on macOS and Windows, virtual terminal processing, width and height, console UTF-16 output | none |
+| T2 | the region in `mcpp.ui`; `ProgressBar` rebuilt on it; the sink for `mcpp.log`; the direct writes on the build path routed through `mcpp.ui` | T1 |
+| T3 | the launcher: unbounded runs with a line callback | none |
+| T4 | attribution in the emitter and `steps.tsv` | none |
+| T5 | `mcpp.build.progress`: model, formatting, readers; the start line in `__action` and `__action-stamp` | T3, T4 |
+| T6 | integration: phases, build programs, package lines, failure reporting, `Finished`, the fast paths, several configurations, `run`, `test`, `pack`, `emit` | T2, T5 |
+| T7 | tests (section 11), and the e2e tests that change with the wording | T6 |
+| T8 | docs/09 (the verbose flag and the output), docs/30 (build program lines), the pages whose examples show the output (docs/00, 21, 30, 40, in English and Chinese), CHANGELOG | T6 |
+| T9 | cross-verification with the validation project, together with #742's CI | T7 |
+| T10 | after the release, mcpp-plugins' CI check (section 10) with its pin bump | release |
+
+## 13. Alternatives not taken
+
+- **Running ninja under a pseudo-terminal**, so that it prints steps as they
+  start. On Windows this needs ConPTY, which rewrites the output stream, and
+  ninja's smart-terminal output overwrites and elides its own lines. The
+  start of a compile is not worth that.
+- **Wrapping every step in the engine** to report its start. That changes
+  every command line, and ninja re-runs every step whose command line
+  changed.
+- **`ninja -n` to learn the plan.** It cannot see what `restat` and `dyndep`
+  change during the build, and it loads the graph a second time.
+- **Comparing `%t` with the graph** to decide that every step runs. Refuted
+  by measurement (section 3.1).
+- **One completion step per package in the graph.** It would put a display
+  concern into the build graph, and a build with explicit goals (`mcpp test`,
+  `mcpp pack`) would not reach it.
+- **Reserving the bottom rows with a scrolling region (`DECSTBM`)**, which
+  makes the status line immune to writes from other processes. A process
+  that is killed leaves the terminal's scrolling region set, and the rows
+  must be re-reserved on every resize. Section 5.3 keeps writes out of the
+  region instead.
+- **An estimated time of completion** (ninja's `%W`). It is a prediction from
+  earlier runs, not a fact about this one (R7).
+- **Printing the warnings of successful steps by default.** This is a separate
+  decision; the default output discards them as before, and `--verbose`
+  prints them, now as they arrive.
+
+## 14. Self-review
+
+- **Architecture.** Four sources feed one model, and one renderer draws it.
+  Each source is a reader of one format. The model does no terminal I/O. The
+  renderer knows nothing about builds. The engine's graph and commands are
+  unchanged.
+- **Stability.** Every exact statement rests on a mechanism ninja documents
+  (`NINJA_STATUS`, the log format) or one the engine owns (the wrapper, the
+  step record). Completion is stated by a rule that can be late and cannot be
+  early. Where a source fails, the display loses detail and states nothing
+  false.
+- **Simplicity.** One rule for step lines (a line becomes final when its
+  outcome is known), one completion rule, one status line, one duration
+  format. No new option and no new environment variable for the user.
+- **User experience.** Something is visible every second on a terminal and
+  every minute in a log. A failure is reported when it occurs. The default
+  output shows what was asked for and what it cost; `--verbose` shows the
+  rest.
+- **Compatibility.** Machine output, commands and build directories are
+  unchanged. The changes to human output are listed, and so are the tests and
+  the one ecosystem check that read it.
+- **Platforms.** The live display reaches macOS and Windows for the first
+  time, and the Windows console shows non-ASCII text correctly for the first
+  time.
+- **Consistency.** Build programs and packages use the same line shape and
+  the same states. The status line has the same form in every phase.
+- **Upgrade.** Nothing is re-run and no directory is invalidated. A missing
+  step record degrades the fast path's display for one build.
+- **Coverage.** The rules are unit-tested with an injected clock, both media
+  are tested end to end, and the terminal medium is tested through a
+  pseudo-terminal on Linux and macOS.
+- **Known limit.** A single long compile is not named: ninja does not report
+  compiles when they start. It shows as a package whose count does not
+  advance, under a status line whose clock does.
diff --git a/.agents/docs/2026-09-29-workspace-build-graph-design.md b/.agents/docs/2026-09-29-workspace-build-graph-design.md
index 37b70ddfd..68157d042 100644
--- a/.agents/docs/2026-09-29-workspace-build-graph-design.md
+++ b/.agents/docs/2026-09-29-workspace-build-graph-design.md
@@ -563,6 +563,10 @@ read from the member, or made a value of the plan:
 | the runtime files of a program shipped through `artifacts` (2026.9.29.3) | its link waited for the plan's deploy set, which a workspace plan does not place; its own runtime files were not in the member's directory | the link waits for no plan-level file; a member's runtime set includes the closures its `artifacts` edges reach | e2e 833 G9 |
 | the link line of a program shipped through `artifacts` (2026.9.29.4) | the plan's line, which pools the dependencies' flags and not a member's, so a library its package's build program states was missing | a link group of its own closure that places nothing (`LinkGroup::linkOnly`) | e2e 838 |
 | `${mcpp.bin_dir}` in a member's action (2026.9.29.4) | the plan's `bin/` | the declaring member's product directory | e2e 838 A4 |
+| a member program's graph document (2026.9.29.5) | listed every requester in the plan, the virtual root included, so the program's re-run key followed the selection | the requests made inside the program's closure | e2e 839 B3, B4 |
+| the order of the members' programs (2026.9.29.5) | discovery order | dependencies first (a cycle skips its closing edge) | e2e 839 B2 |
+| `emit build-database`, `--configure-only` (2026.9.29.5) | one plan per member | one plan per configuration, each member's tests included; a failed configuration planned member by member | e2e 840 |
+| the root compile database of several configurations (2026.9.29.5) | the last written configuration's, a race under concurrent groups | the union, published once by the command | e2e 840 B |
 
 Each criterion fails on 2026.9.29.1 and passes on 2026.9.29.2. The resource
 case also showed a defect of every build: a quoted `#include` in a script was
diff --git a/.agents/docs/README.md b/.agents/docs/README.md
index 90f738909..fc89d3b28 100644
--- a/.agents/docs/README.md
+++ b/.agents/docs/README.md
@@ -18,7 +18,7 @@ superseded_by: 2026-09-07-....md  # when status is superseded
 ---
 ```
 
-317 records.
+318 records.
 
 ## By subject
 
@@ -31,6 +31,7 @@ Records that declare one. Everything else is listed by date below.
 ### design
 
 - [The workspace as the unit of build: one graph per configuration, one scheduler, product directories, and a reusable graph module](2026-09-29-workspace-build-graph-design.md) — landed
+- [Build progress: each step's line states its outcome, and one status line states the build](2026-09-29-build-progress-display-design.md) — landed
 - [An ecosystem design for mcpp and xlings: one authority per fact, and the work that follows from it](2026-09-28-ecosystem-design-and-optimisation-plan.md) — landed
 - [Build cost, foreign toolsets, the build-plugin architecture and the library surface: engine, plugin and index design (#734)](2026-09-28-build-cost-foreign-toolsets-and-library-surface-design.md) — landed
 - [The compile database, `emit build-database`, and #701/#702: triage against the specifications, and one design](2026-09-26-compile-database-and-issue-699-design.md) — landed
@@ -109,6 +110,7 @@ Records that declare one. Everything else is listed by date below.
 ### 2026-09
 
 - [The workspace as the unit of build: one graph per configuration, one scheduler, product directories, and a reusable graph module](2026-09-29-workspace-build-graph-design.md) — landed
+- [Build progress: each step's line states its outcome, and one status line states the build](2026-09-29-build-progress-display-design.md) — landed
 - [Two days of mcpp and xlings: a review of what merged, what is known, and what is open](2026-09-28-ecosystem-review-of-two-days-of-mcpp-and-xlings.md) — active
 - [An ecosystem design for mcpp and xlings: one authority per fact, and the work that follows from it](2026-09-28-ecosystem-design-and-optimisation-plan.md) — landed
 - [Build cost, foreign toolsets, the build-plugin architecture and the library surface: engine, plugin and index design (#734)](2026-09-28-build-cost-foreign-toolsets-and-library-surface-design.md) — landed
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fd0f0abf2..f67d46e98 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,91 @@
 > Each `## [<version>]` section is that release's notes. Entries are written in English
 > from 2026.9.28.3 on; earlier entries remain as written.
 
+## [2026.9.29.5] - 2026-09-29
+
+This release completes the workspace build graph in the commands around the
+build, from the validation project's post-release run of 2026.9.29.4: build
+programs are reused across selections and run dependencies first, the build
+database and `--configure-only` plan by configuration, and the output names
+what it reports. A build now reports each step when its outcome is known, and
+shows what runs while it runs (`.agents/docs/2026-09-29-build-progress-display-design.md`).
+
+### Added
+
+- **A build reports each step once, with its outcome.** A package's line is
+  written when every step the graph assigns to it has run (`done` with the
+  span of its steps, read from ninja's log), when the global cache supplied it
+  (`cached N units`), when a step of it failed (`failed`), or when the build
+  ends. A package with nothing to do has no line. The packages the command was
+  asked to build are listed; their dependencies are folded into one line, and
+  a dependency that fails is named. `--verbose` lists every package and prints
+  each step as ninja reports it (e2e 842).
+- **A status line states the build.** On a terminal the steps still running
+  and one status line, `Building 612/1203 · 14:32 · gpp.gui: vcpkg install
+  6:10`, are drawn below the output and updated in place; the status line
+  names the longest-running `check` or `prepare` action, which the engine's
+  action wrapper reports when it starts. In a log (CI, a pipe) only final lines
+  are written, and the status line is written when the log has been silent for
+  a minute (e2e 842, 843).
+- **`Finished` states the whole command's time**, and for a command of ten
+  seconds or more how it was spent (`plan`, `programs`, `build`) and the step
+  that took at least a quarter of the build.
+
+### Fixed
+
+- **A failed step is reported when it fails.** Its diagnostics were printed
+  after ninja exited, that is, after every step still running had finished:
+  a compile error beside a twenty-minute vcpkg install appeared twenty minutes
+  late (e2e 842).
+- **macOS and Windows terminals are terminals.** Terminal detection was
+  compiled only under `__unix__`, which Apple's compilers do not define, so
+  the download bar and colours were drawn on Linux alone. A Windows console
+  now receives mcpp's lines as UTF-16, so `·`, `→` and non-ASCII paths appear
+  as written whatever its code page.
+
+- **A member's build program is reused whichever members a command selects.**
+  Its graph document listed every requester in the plan, the virtual root
+  included, so the program's re-run key followed the selection: `-p`, `mcpp
+  pack` and `mcpp emit build-database` reran the programs a `--workspace`
+  build had run (7 to 15 s each in the validation project). A program's
+  document now lists the requests made inside its own closure (e2e 839).
+- **A member's build program runs after those of the members it depends on.**
+  They ran in discovery order, so a member's program could run before its
+  dependency's had applied its directives (e2e 839).
+- **`mcpp emit build-database` and `mcpp build --configure-only` plan a
+  workspace by configuration, as the build does.** They planned each member
+  separately, so a package two members use was described once per member,
+  each time with other arguments (the validation project's core library three
+  times). A member that is a program is described as one, and its tests as
+  tests. A configuration whose plan fails is planned member by member, so a
+  member's failure still affects that member only (e2e 840; SPEC-005 v1.6).
+- **A command that plans several configurations writes the root
+  `compile_commands.json` once**, as the union of their databases. Each
+  configuration replaced it, and under `mcpp build --workspace`, whose
+  configurations build at the same time, the file was the last one's (e2e 840).
+
+### Behaviour changes
+
+- **A build program has one line, which names its package and states its
+  outcome**: `build.mcpp <package>  ran <time>`, `cached` or `failed`, in
+  place of `build.mcpp compiling <package>` and `running <package>`, and of
+  `up to date <package> (cached)` (e2e 839, 842). The programs of the
+  requested packages are listed, and those of their dependencies are folded
+  into one line.
+- **`Compiling <package>` is written when the package's steps have run**, with
+  their outcome, rather than for every direct dependency before ninja starts;
+  the per-dependency `Cached <package> (N units)` line is `--verbose` output,
+  as `cached N units` (e2e 842).
+- **A selected member is announced by its directory** in a `--workspace`
+  build, also where another member depends on it (e2e 839).
+- **`mcpp pack` summarises many outputs.** A format that reports more than
+  eight outputs is reported by the entry each lies in below their common
+  directory, with a count; `--verbose` names every output, and
+  `--message-format json` lists every one as before (e2e 841).
+- **Build database set names (SPEC-005 v1.6).** A set is named by its package;
+  a document of several configurations prefixes each name with the
+  configuration's build directory name, instead of `<member>/`.
+
 ## [2026.9.29.4] - 2026-09-29
 
 This release links a program that a workspace member ships through
diff --git a/docs/00-what-mcpp-is.md b/docs/00-what-mcpp-is.md
index 8d0228ba1..92aa729bf 100644
--- a/docs/00-what-mcpp-is.md
+++ b/docs/00-what-mcpp-is.md
@@ -144,7 +144,8 @@ int main() {
 ```console
 $ mcpp run
     Inferred target hello (bin from src/main.cpp)
-   Compiling hello v0.1.0 (.)
+   Compiling hello v0.1.0 (.)  done 0.61s
+
     Finished dev [unoptimized + debuginfo] in 0.64s
      Running `target/x86_64-linux-gnu/0946988e9e4b52ba/bin/hello`
 
diff --git a/docs/07-workspace.md b/docs/07-workspace.md
index 1e851845a..28fe06a28 100644
--- a/docs/07-workspace.md
+++ b/docs/07-workspace.md
@@ -441,6 +441,14 @@ member that several members use is compiled once.
 - **Resources.** A member's `[resources]` and `windows_code_page` are
   compiled against the member's directory and include directories and embedded
   into that member's programs and shared libraries only (2026.9.29.2+).
+- **Build programs.** The members' build programs run dependencies first, and
+  a program's result is reused by every command whose inputs to it are
+  unchanged, whichever members the command selects (2026.9.29.5+).
+- **Compile database.** `mcpp build --configure-only` and `mcpp emit
+  build-database` plan as the build does, one plan per configuration with each
+  member's tests, so a package the members share is described once per
+  configuration. A command that planned several configurations writes the root
+  `compile_commands.json` once, as the union of their databases (2026.9.29.5+).
 - **No-op builds.** A command repeated with nothing changed is answered by one
   check per configuration, without planning.
 - **Module names.** Members built in one graph share one module namespace:
diff --git a/docs/09-commands-by-scenario.md b/docs/09-commands-by-scenario.md
index 21261d0bd..5a8928acf 100644
--- a/docs/09-commands-by-scenario.md
+++ b/docs/09-commands-by-scenario.md
@@ -227,6 +227,56 @@ An index refresh is reported step by step when the xlings that mcpp drives
 emits progress events for it (xlings 2026.9.28.1+). With an older xlings it
 shows its status line and finishes silently, as before.
 
+## What a build prints
+
+A build reports each step once, when its outcome is known (2026.9.29.5+):
+
+```console
+$ mcpp build --workspace
+  build.mcpp gpp.core                     ran 16.00s
+  build.mcpp gpp.gui                      ran 6.70s
+   Compiling gpp.core (GalTranslPP)       done 3m12s
+   Compiling 23 dependencies              done 6m20s
+   Compiling gpp.gui (GPPGUI)             done 38m05s
+
+    Finished fast-release [unoptimized + debuginfo] in 41m53s · plan 1m13s · programs 32s · build 40m08s · longest gpp.gui: vcpkg install 22m10s
+```
+
+- A package's line names the package and states its outcome: `done` with the
+  span of its steps, `cached` when the global cache supplied it, `failed`, or
+  the number of its steps that ran when a failed build stopped before the
+  package completed. A package with nothing to do has no line.
+- The packages the command was asked to build (the root package, or the
+  selected members) are listed. The packages they depend on are folded into
+  one line, and a dependency that fails is named.
+- A build program's line states `ran` with its time, `cached`, or `failed`.
+- A failed step is reported when it fails, with its diagnostics, while ninja
+  waits for the steps still running.
+- `Finished` states the whole command's time. A command of ten seconds or
+  more also states how the time was spent, and names the step that took at
+  least a quarter of the build when there is one.
+
+On a terminal, the steps still running and one status line are drawn below
+the output and updated in place:
+
+```
+   Compiling gpp.gui (GPPGUI)             61 steps
+
+Building 612/1203 · 14:32 · gpp.gui: vcpkg install 6:10
+```
+
+The status line counts the build's steps, shows the time since the command
+started, and names the longest-running `check` or `prepare` action; ninja
+reports every other step only when it finishes. When the output is not a
+terminal (a CI log, a pipe), only final lines are written, and the status line
+is written when the output has been silent for a minute. `TERM=dumb` selects
+that form on a terminal too.
+
+`--verbose` lists every package, including those with nothing to do (`fresh`),
+states each build program's compile and run times, and prints every step as
+ninja reports it (`[f/t] <command>` and its output). `--quiet` prints none of
+it. Machine output (`--message-format json`) is unchanged.
+
 ## Validating a descriptor before publishing
 
 `mcpp xpkg parse` reads a descriptor with the resolver's own grammar, so what
diff --git a/docs/10-pack-and-release.md b/docs/10-pack-and-release.md
index 313217532..56b76134c 100644
--- a/docs/10-pack-and-release.md
+++ b/docs/10-pack-and-release.md
@@ -265,6 +265,12 @@ the last is the distributable and only it is printed as `Packed`. A format
 whose chain ends in two files is refused by `mcpp run --format`, naming both,
 because a runner takes one operand.
 
+A format may report many outputs, one per file of a distribution tree. Up to
+eight are printed one per line; more are printed by the entry each lies in
+below their common directory, with a count (`Packed Release/app (1309
+files)`), and `--verbose` prints every one (2026.9.29.5+).
+`--message-format json` lists every output in either case.
+
 An unknown `<name>` is refused naming the format set the resolved graph
 provides, the same set `mcpp pack --format bogus` reports. `--format` together
 with `--no-runner` is refused — an `.apk` or an installed `.app` cannot be
diff --git a/docs/30-build-mcpp.md b/docs/30-build-mcpp.md
index 1fab5940a..58a0ab429 100644
--- a/docs/30-build-mcpp.md
+++ b/docs/30-build-mcpp.md
@@ -1045,6 +1045,11 @@ one. `mcpp::graph_file()` names a JSON document that states the resolved graph:
   `""`.** The root decides the graph, and when its program runs every input of
   that decision is final, which is the reason `dep_linkage` is offered to it
   alone.
+- **In a workspace plan each selected member's program receives the document
+  of its own closure**, in which it is `root`, and `requested_by` lists the
+  requests made inside that closure (2026.9.29.5+). The document, and so the
+  program's re-run key, is therefore the same whichever members a command
+  selects. The members' programs run dependencies first.
 - **`[package.metadata.<tool>]` is the package's statement about itself.** The
   engine does not interpret the table. A path in it is resolved by the reader
   against the entry's `manifest_dir`, because only the reader knows which values
@@ -1513,8 +1518,13 @@ variable, emit `mcpp:rerun-if-changed=config.h` / `mcpp:rerun-if-env-changed=USE
 This replaces the old "process exited 0, so assume it's fine" guesswork with an
 explicit input/output contract — incremental builds stay correct.
 
-When nothing changed the output is `build.mcpp up to date (cached)`; otherwise
-`build.mcpp compiling` / `running`.
+Each program has one line, written when it finishes (2026.9.29.5+):
+`build.mcpp <package>  cached` when nothing changed, `build.mcpp <package>  ran
+<time>` when it was compiled or run (with `--verbose`, `compiled <time> · ran
+<time>`), and `failed` when it failed. On a terminal the line shows `waiting`,
+`compiling` or `running` with a clock while the program is pending or running.
+The programs of the packages the command was asked to build are listed; those of
+their dependencies are folded into one line, `build.mcpp N dependencies`.
 
 ## Host tools from a dependency (mcpp 2026.8.5.1+)
 
diff --git a/docs/40-baremetal.md b/docs/40-baremetal.md
index aa2c38c6c..d2c1840e7 100644
--- a/docs/40-baremetal.md
+++ b/docs/40-baremetal.md
@@ -200,18 +200,18 @@ cd blinky
 mcpp run
 ```
 
-Measured output:
+Output (2026.9.29.5; the times vary by machine):
 
 ```
    Resolving toolchain
     Resolved llvm@22.1.8 → riscv64-none-elf → @mcpp/registry/data/xpkgs/xim-x-llvm/22.1.8/bin/clang++
     Resolved host toolchain for build.mcpp: clang 22.1.8 (x86_64-unknown-linux-gnu)
-  build.mcpp compiling
-  build.mcpp running
+  build.mcpp blinky  ran 0.41s
     Inferred sources [src/**/*.{cppm,cpp,cc,c,S,s,asm}]
     Inferred target blinky (bin from src/main.cpp)
-   Compiling blinky v0.1.0 (.)
-      Cached riscv-virt-rt v0.3.0 (1 unit)
+   Compiling blinky v0.1.0 (.)  done 0.04s
+   Compiling 1 dependency       cached
+
     Finished dev [unoptimized + debuginfo] in 0.05s
         Size blinky  text 8572  data 80  bss 5668  total 14320
      Running `…/xim-x-qemu-riscv/9.2.4-1/bin/qemu-system-riscv64 … target/riscv64-none-elf/…/bin/blinky`
diff --git a/docs/specs/README.md b/docs/specs/README.md
index f74dd422c..0647d87e4 100644
--- a/docs/specs/README.md
+++ b/docs/specs/README.md
@@ -34,7 +34,7 @@
 | [SPEC-002](target-side.md) | 目标侧模型与能力声明(`mcpp:` 保留命名空间、五层、三条规则) | 评审中 v1.0 | 2026-08-24 | mcpp >= 2026.8.24.2 |
 | [SPEC-003](exit-codes.md) | 退出码契约(分类、语义、稳定性承诺) | 评审中 v1.0 | 2026-09-01 | mcpp >= 2026.9.1.1 |
 | [SPEC-004](manifest-semantics.md) | `mcpp.toml` 的平面划分、条件化形状、解析轴与命名规约 | 草案 v1.10 | 2026-09-28 | 条件化形状 mcpp >= 2026.8.29.1;目标轴 mcpp >= 2026.9.6.4;`linkage` 默认值 mcpp >= 2026.9.15.2;链接 flag 的词读法 mcpp >= 2026.9.26.2;条件化的 `dialect_cxxflags` 与 `-p` 的包身份 mcpp >= 2026.9.28.1;条件表按具体程度生效 mcpp >= 2026.9.28.2 |
-| [SPEC-005](build-database.md) | 构建数据库:`mcpp emit build-database` 的内容、取值规则与不写工程目录的保证 | 评审中 v1.5 | 2026-09-28 | mcpp >= 2026.9.15.1;v1.3 条款 mcpp >= 2026.9.26.2;v1.4 条款 mcpp >= 2026.9.27.1;v1.5 条款 mcpp >= 2026.9.28.1 |
+| [SPEC-005](build-database.md) | 构建数据库:`mcpp emit build-database` 的内容、取值规则与不写工程目录的保证 | 评审中 v1.6 | 2026-09-29 | mcpp >= 2026.9.15.1;v1.3 条款 mcpp >= 2026.9.26.2;v1.4 条款 mcpp >= 2026.9.27.1;v1.5 条款 mcpp >= 2026.9.28.1;v1.6 条款 mcpp >= 2026.9.29.5 |
 | [SPEC-006](toolchain-management.md) | 工具链管理:身份、来源、选择与载荷契约 | 草案 v0.4 | 2026-09-28 | 逐条标注;已实现条款 mcpp >= 2026.9.24.1;§3.7 mcpp >= 2026.9.28.1;§3.7.1 mcpp >= 2026.9.28.2 |
 | [SPEC-007](build-plugins.md) | 构建插件:配置、施工与校验的分工,运行时与规划期的义务 | 草案 v0.6 | 2026-09-28 | 逐条标注;mcpp >= 2026.9.26.2;v0.3 条款 mcpp >= 2026.9.27.1;v0.4 条款 mcpp >= 2026.9.28.1;v0.5 条款 mcpp >= 2026.9.28.2;v0.6(§9)mcpp >= 2026.9.28.3 |
 | [SPEC-008](library-interface.md) | 库的接口:公开模块、发布闭包与两种形态的一致 | 草案 v0.1 | 2026-09-28 | 第一阶段(只警告)mcpp >= 2026.9.28.3 |
diff --git a/docs/specs/build-database.md b/docs/specs/build-database.md
index 3988e7b5c..d6234f24a 100644
--- a/docs/specs/build-database.md
+++ b/docs/specs/build-database.md
@@ -4,10 +4,10 @@
 |---|---|
 | 规范编号 | SPEC-005 |
 | 标题 | mcpp 输出的构建数据库:内容、取值规则与不写工程目录的保证 |
-| 状态 | 评审中 v1.5 |
-| 版本 | 1.5 |
-| 最后修改 | 2026-09-28 |
-| 对应实现 | mcpp >= 2026.9.15.1;v1.3 修改的 R2.5、R3.7、R3.8、R4.1、R5.2 为 mcpp >= 2026.9.26.2;v1.4 修改的 R2.5 为 mcpp >= 2026.9.27.1;v1.5 修改的 R3.7、R3.12、R5.1、R5.2 为 mcpp >= 2026.9.28.1 |
+| 状态 | 评审中 v1.6 |
+| 版本 | 1.6 |
+| 最后修改 | 2026-09-29 |
+| 对应实现 | mcpp >= 2026.9.15.1;v1.3 修改的 R2.5、R3.7、R3.8、R4.1、R5.2 为 mcpp >= 2026.9.26.2;v1.4 修改的 R2.5 为 mcpp >= 2026.9.27.1;v1.5 修改的 R3.7、R3.12、R5.1、R5.2 为 mcpp >= 2026.9.28.1;v1.6 修改的 R2.1、R3.3、R3.4、R3.5、R4.1、R5.2 为 mcpp >= 2026.9.29.5 |
 | 相关设计文档 | `.agents/docs/2026-09-14-636-build-database-and-the-latest-xlings.md`<br>`.agents/docs/2026-09-26-compile-database-and-issue-699-design.md` |
 | 相关 issue | #636, #648, #655, #699, #702, #707 |
 | 依据的外部规范 | S1「C++ Build Database: IDE Profile」profile 0.3.0(§7.2 的 `generated`,Sunrisepeak/mcpp-language-server#28;此前为 0.2.0)与 S2 0.2.0 §3.4,取自 https://github.com/Sunrisepeak/lsp-mcpp-private 提交 `b82859d`(schema 自提交 `28ecd6e` 起未变);S2 0.3.0 §3.4 的部分回答(S2-3.4-12、S2-3.4-13,Sunrisepeak/mcpp-language-server#25);JSON Compilation Database |
@@ -42,7 +42,7 @@ Database 定义,本规范不重复它们的字段定义,只规定 mcpp 作为生
 ## 2. 不写工程目录
 
 - **R2.1** 命令**禁止**写入工程目录,即根包、工作区成员与 path 依赖的源码树。规划
-  写入 `$MCPP_HOME/cache/build-database/<key>`,`<key>` 由工程根与成员决定。该目录
+  写入 `$MCPP_HOME/cache/build-database/<key>`,`<key>` 由工程根与一次规划的成员决定。该目录
   是缓存,可以随时删除。**已实现**
 - **R2.2** 命令不编译:标准库模块被描述而不被编译,也不生成只供链接使用的输入(GCC 的
   `mcpp-clean-link.specs`)。工具链照常被查询(版本、目标三元组、sysroot 等),与
@@ -84,14 +84,18 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
 
 ### 3.2 集合
 
-- **R3.3** 每个包一个集合,名为包的限定名(`<namespace>.<name>` 或 `<name>`)。根包
-  测试目标的源文件归入集合 `<包>:test`,标准库模块的单元归入集合 `mcpp:std`。工作区
-  文档中,每个集合名带前缀 `<成员>/`。**已实现**
-- **R3.4** `visible-sets` 列出同一成员的其余所有集合。引擎在一次调用的一张模块图上
+- **R3.3** 每个包一个集合,名为包的限定名(`<namespace>.<name>` 或 `<name>`)。根包与
+  工作区被选成员的测试目标的源文件归入集合 `<包>:test`,标准库模块的单元归入集合
+  `mcpp:std`。工作区按配置规划,与 `mcpp build` 相同:每个配置一次规划,成员共用的包
+  在一个配置中只有一个集合。文档描述多个配置时,每个集合名带前缀 `<配置>/`,`<配置>`
+  为该配置构建目录的名字;只有一个配置时不带前缀。两次规划描述同一配置的同一集合时
+  (见 R5.2 的逐成员规划),该集合只出现一次。**已实现**
+- **R3.4** `visible-sets` 列出同一次规划的其余所有集合。引擎在一次调用的一张模块图上
   解析 import,更窄的闭包会描述一条构建并不执行的规则。**已实现**
 - **R3.5** `family-name` 为包名,`mcpp:std` 集合的为 `mcpp:std`;`ide.configuration`
-  为 profile 名;`ide.kind` 在测试集合为 `test`,在根包集合按其目标为 `library`、
-  `executable` 或 `other`,在依赖包集合与 `mcpp:std` 为 `library`。**已实现**
+  为 profile 名;`ide.kind` 在测试集合为 `test`,在根包与工作区被选成员的集合按其
+  目标为 `library`、`executable` 或 `other`,在依赖包集合与 `mcpp:std` 为 `library`。
+  **已实现**
 - **R3.6** 单元的 `arguments` 依次是驱动、集合的 `baseline-arguments`、单元的
   `local-arguments`,以及单元自己结尾的 `-c <source> -o <object>`(若有;两个操作数
   相对 `work-directory` 指向 `source` 与 `object`)。`baseline-arguments` 是集合中每个
@@ -170,7 +174,8 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
 ## 4. `--spec compile-commands`
 
 - **R4.1** 文档为 `mcpp build --configure-only` 在同一组选择器下写入
-  `compile_commands.json` 的条目,差别只在输出路径位于 §2 的工作目录之下。标准库
+  `compile_commands.json` 的条目,差别只在输出路径位于 §2 的工作目录之下;同一文件与
+  同一输出只有一条条目,文档描述多个配置时,一个文件在每个编译它的配置中各有一条。标准库
   模块的单元也在其中,遵循 S1-12-1 的导出规则:S1 文档里 `mcpp:std` 集合的每个
   单元同样导出为一条 `compile_commands.json` 条目。**已实现**
 
@@ -179,8 +184,9 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
 - **R5.1** `kind` 为 `mcpp.build-database`,`kindVersion` 为 1。`data` 含 `spec`
   (`{"name": "s1", "version": "0.3.0"}` 或 `{"name": "compile-commands"}`)、
   `database`、`watch` 与 `inputs-fingerprint`。**已实现**
-- **R5.2** 命令独立规划每一个被选中的成员:一个成员规划失败只影响它自己,不影响
-  其余成员的集合(#699 第 1 项)。规划失败的成员不贡献任何集合,只贡献一条 `error`
+- **R5.2** 一个成员规划失败只影响它自己,不影响其余成员的集合(#699 第 1 项)。命令
+  按配置规划被选中的成员;一个配置的规划失败时,该配置的成员逐个规划,因此失败仍归于
+  各自的成员。规划失败的成员不贡献任何集合,只贡献一条 `error`
   诊断,`path` 为该成员的 `mcpp.toml`,相对工作区根目录;诊断码为:不在工程中时
   `MCPP_BUILD_DATABASE_NO_PROJECT`;该成员的规划因离线而需要下载时
   `MCPP_OFFLINE_DOWNLOAD_REQUIRED`,消息指出需要下载的第一项;其他规划失败为
@@ -226,3 +232,4 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
 | 1.3 | 2026-09-26 | R2.5:`emit` 下构建失败的宿主工具是警告。R3.7:`work-directory` 是输出目录,模块接口单元的 `arguments` 带语言 flag。R3.8:标准库单元的 `provides` 指向 std 缓存中的 BMI,工具链带 `build-id`。R4.1:compile-commands 文档包含标准库单元(S1-12-1)。R5.2:成员各自规划,构建程序失败的包不带其指令地被描述(#699,#702)。 |
 | 1.4 | 2026-09-26 | R2.5:命令不构建宿主工具;工具库中没有的工具被推迟,输出说明 `MCPP_BUILD_DATABASE_HOST_TOOL_DEFERRED`,取代 1.3 的警告 `MCPP_BUILD_DATABASE_HOST_TOOL_UNBUILT`(#707)。 |
 | 1.5 | 2026-09-28 | R3.7:规则声明的设备源不是编译单元,不进入 S1 与 `compile_commands.json`(#724)。新增 R3.12:集合的 `ide.generated` 列出规则生成的文件与目录,给出构建写入的路径与生成它的步骤,S1 0.3.0(#724,Sunrisepeak/mcpp-language-server#28)。R5.1:S1 版本为 0.3.0。R5.2:以构建程序的指令为前提的检查不对其构建程序已失败的包运行,失败路径保留已记录的说明(#724)。 |
+| 1.6 | 2026-09-29 | 工作区按配置规划,与 `mcpp build` 相同(R2.1、R3.3、R3.4、R5.2):成员共用的包在一个配置中只描述一次;集合名的前缀由 `<成员>/` 改为只在文档描述多个配置时出现的 `<配置>/`;一个配置的规划失败时逐成员规划。R3.5:被选成员的集合按其目标给出 `ide.kind`。R4.1:同一文件与输出一条条目。 |
diff --git a/docs/zh/00-what-mcpp-is.md b/docs/zh/00-what-mcpp-is.md
index e6618a506..5fbb3f11e 100644
--- a/docs/zh/00-what-mcpp-is.md
+++ b/docs/zh/00-what-mcpp-is.md
@@ -125,7 +125,8 @@ int main() {
 ```console
 $ mcpp run
     Inferred target hello (bin from src/main.cpp)
-   Compiling hello v0.1.0 (.)
+   Compiling hello v0.1.0 (.)  done 0.61s
+
     Finished dev [unoptimized + debuginfo] in 0.64s
      Running `target/x86_64-linux-gnu/0946988e9e4b52ba/bin/hello`
 
diff --git a/docs/zh/07-workspace.md b/docs/zh/07-workspace.md
index ad7a6b34d..df23764dc 100644
--- a/docs/zh/07-workspace.md
+++ b/docs/zh/07-workspace.md
@@ -407,6 +407,12 @@ mcpp test --workspace --workspace-timeout 1800   # whole fan-out (default 0 = no
 - **Hooks。** 每个被选成员的 `[hooks]` 按成员顺序在构建前后运行。
 - **资源。** 成员的 `[resources]` 与 `windows_code_page` 按该成员的目录与 include 目录编译，
   只嵌入该成员自己的程序与共享库（2026.9.29.2+）。
+- **构建程序。** 成员的构建程序按依赖在前的顺序运行；只要程序的输入不变，无论命令选中哪些
+  成员，程序的结果都被复用（2026.9.29.5+）。
+- **编译数据库。** `mcpp build --configure-only` 与 `mcpp emit build-database` 按构建的方式
+  规划，每个配置一次规划并包含各成员的测试，因此成员共用的包在每个配置中只描述一次。规划了
+  多个配置的命令只写一次根目录的 `compile_commands.json`，内容为各配置数据库的并集
+  （2026.9.29.5+）。
 - **无事可做的构建。** 在没有任何改动时重复执行的命令，每个配置只做一次检查，不重新规划。
 - **模块名。** 在同一张图中构建的成员共享一个模块命名空间：两个成员各自提供同名模块时，不能在
   同一条 `--workspace` 命令中构建；分别用 `-p` 构建。
diff --git a/docs/zh/09-commands-by-scenario.md b/docs/zh/09-commands-by-scenario.md
index 8861bd934..8b12398f1 100644
--- a/docs/zh/09-commands-by-scenario.md
+++ b/docs/zh/09-commands-by-scenario.md
@@ -209,6 +209,48 @@ commit 记进 `mcpp.toml`;`mcpp index unpin` 移除它。
 当 mcpp 驱动的 xlings 为索引刷新发出进度事件时（xlings 2026.9.28.1+），索引刷新
 逐步报告。较旧的 xlings 下，它显示其状态行，然后安静地结束，与以前相同。
 
+## 构建输出
+
+构建在每一步的结果已知时报告一次（2026.9.29.5+）：
+
+```console
+$ mcpp build --workspace
+  build.mcpp gpp.core                     ran 16.00s
+  build.mcpp gpp.gui                      ran 6.70s
+   Compiling gpp.core (GalTranslPP)       done 3m12s
+   Compiling 23 dependencies              done 6m20s
+   Compiling gpp.gui (GPPGUI)             done 38m05s
+
+    Finished fast-release [unoptimized + debuginfo] in 41m53s · plan 1m13s · programs 32s · build 40m08s · longest gpp.gui: vcpkg install 22m10s
+```
+
+- 包的行写出包名与结果：`done` 后接其各步骤的跨度，`cached` 表示由全局缓存提供，
+  `failed`，或者在失败的构建于该包完成前停止时，写出它已运行的步骤数。没有工作
+  的包不写行。
+- 命令被要求构建的包（根包或被选中的成员）逐个列出；它们依赖的包折叠为一行，
+  失败的依赖单独写出名字。
+- 构建程序的行写出 `ran` 及其耗时、`cached` 或 `failed`。
+- 一个步骤失败时立即报告，连同其诊断；ninja 此时仍在等待正在运行的步骤。
+- `Finished` 写出整条命令的耗时。十秒及以上的命令还写出时间的分布，并在某一步
+  占构建阶段四分之一以上时写出这一步。
+
+在终端上，仍在运行的步骤与一行状态行绘制在输出下方，并原地更新：
+
+```
+   Compiling gpp.gui (GPPGUI)             61 steps
+
+Building 612/1203 · 14:32 · gpp.gui: vcpkg install 6:10
+```
+
+状态行给出构建的步骤计数、自命令开始以来的时间，以及运行最久的 `check` 或
+`prepare` 动作；其他步骤 ninja 只在完成时报告。输出不是终端时（CI 日志、管道），
+只写最终的行，并在输出静默一分钟时写一次状态行。`TERM=dumb` 在终端上也选择
+这种形式。
+
+`--verbose` 列出每个包（包括没有工作的包，记为 `fresh`），写出每个构建程序的编译
+与运行耗时，并按 ninja 的报告打印每一步（`[f/t] <命令>` 及其输出）。`--quiet`
+不打印这些。机器输出（`--message-format json`）不变。
+
 ## 发布前校验描述符
 
 `mcpp xpkg parse` 用解析器自己的文法读一个描述符，所以它报告的就是解析时
diff --git a/docs/zh/10-pack-and-release.md b/docs/zh/10-pack-and-release.md
index 15bc883e8..b5714a3fa 100644
--- a/docs/zh/10-pack-and-release.md
+++ b/docs/zh/10-pack-and-release.md
@@ -240,6 +240,10 @@ mcpp run --target aarch64-ios-sim      --format app
 最后一个是发布物，也只有它以 `Packed` 报出。链的末端产出两个文件的格式会被
 `mcpp run --format` 拒绝并点名两者，因为一个 runner 只接受一个操作数。
 
+一个格式可能报出很多输出，发布目录中的每个文件各一个。不超过八个时逐行打印；更多时按它们
+在共同目录之下所处的条目打印，并附数量（`Packed Release/app (1309 files)`），`--verbose`
+打印全部（2026.9.29.5+）。`--message-format json` 在两种情况下都列出全部输出。
+
 未知的 `<name>` 会被拒绝，点名已解析图提供的格式集合，与
 `mcpp pack --format bogus` 报出的是同一个集合。`--format` 与 `--no-runner`
 同时出现会被拒绝 —— 一个 `.apk` 或一个已安装的 `.app` 无法被直接执行。在
diff --git a/docs/zh/30-build-mcpp.md b/docs/zh/30-build-mcpp.md
index 01480c411..81bf6615d 100644
--- a/docs/zh/30-build-mcpp.md
+++ b/docs/zh/30-build-mcpp.md
@@ -885,6 +885,9 @@ mcpp 会写出 `<暂存树>.stage-manifest` —— 一个兄弟文件，永不
 
 - **根包的程序拿到它；依赖包的程序读到 `""`。** 根包决定这张图，而它的程序运行时这个决定的
   每个输入都已确定 —— 这正是 `dep_linkage` 只提供给根包的原因。
+- **在工作区计划中，每个被选成员的程序拿到它自己闭包的文档**，其中它是 `root`，
+  `requested_by` 只列出闭包内部发出的请求（2026.9.29.5+）。因此无论命令选中哪些成员，
+  这份文档以及程序的重跑键都相同。成员的程序按依赖在前的顺序运行。
 - **`[package.metadata.<tool>]` 是包对自身的陈述。** 引擎不解释这张表。其中的路径由读取方
   相对于该条目的 `manifest_dir` 解析，因为只有读取方知道哪些值是路径。旧引擎忽略这张表，
   所以已发布的包可以在其使用方升级之前就写上它。
@@ -1273,8 +1276,11 @@ mcpp **不会**每次构建都重跑 `build.mcpp`。它会缓存程序产出的
 `mcpp:rerun-if-changed=config.h` / `mcpp:rerun-if-env-changed=USE_FAST`。这用一份明确的
 输入/输出契约取代了过去「进程退出码为 0 就当成功」的猜测——让增量构建保持正确。
 
-无变化时输出 `build.mcpp up to date (cached)`；否则是 `build.mcpp compiling` /
-`running`。
+每个程序一行，在程序结束时写出（2026.9.29.5+）：无变化时是 `build.mcpp <包名>  cached`，
+编译或运行过时是 `build.mcpp <包名>  ran <耗时>`（`--verbose` 下为 `compiled <耗时> · ran
+<耗时>`），失败时是 `failed`。在终端上，程序等待或运行期间该行显示 `waiting`、`compiling`
+或 `running` 及计时。命令被要求构建的包的程序逐个列出；其依赖的程序折叠为一行
+`build.mcpp N dependencies`。
 
 ## 依赖产出的 host 工具（mcpp 2026.8.5.1+）
 
diff --git a/docs/zh/40-baremetal.md b/docs/zh/40-baremetal.md
index fdf204c5b..4e4f22e0e 100644
--- a/docs/zh/40-baremetal.md
+++ b/docs/zh/40-baremetal.md
@@ -170,18 +170,18 @@ cd blinky
 mcpp run
 ```
 
-实测输出：
+输出（2026.9.29.5；耗时因机器而异）：
 
 ```
    Resolving toolchain
     Resolved llvm@22.1.8 → riscv64-none-elf → @mcpp/registry/data/xpkgs/xim-x-llvm/22.1.8/bin/clang++
     Resolved host toolchain for build.mcpp: clang 22.1.8 (x86_64-unknown-linux-gnu)
-  build.mcpp compiling
-  build.mcpp running
+  build.mcpp blinky  ran 0.41s
     Inferred sources [src/**/*.{cppm,cpp,cc,c,S,s,asm}]
     Inferred target blinky (bin from src/main.cpp)
-   Compiling blinky v0.1.0 (.)
-      Cached riscv-virt-rt v0.3.0 (1 unit)
+   Compiling blinky v0.1.0 (.)  done 0.04s
+   Compiling 1 dependency       cached
+
     Finished dev [unoptimized + debuginfo] in 0.05s
         Size blinky  text 8572  data 80  bss 5668  total 14320
      Running `…/xim-x-qemu-riscv/9.2.4-1/bin/qemu-system-riscv64 … target/riscv64-none-elf/…/bin/blinky`
diff --git a/mcpp.toml b/mcpp.toml
index 87c738f51..6fad06c2d 100644
--- a/mcpp.toml
+++ b/mcpp.toml
@@ -1,6 +1,6 @@
 [package]
 name        = "mcpp"
-version = "2026.9.29.4"
+version = "2026.9.29.5"
 description = "Modern C++ build & package management tool"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]
diff --git a/modules/log/src/log.cppm b/modules/log/src/log.cppm
index 7ee207145..cd0ece100 100644
--- a/modules/log/src/log.cppm
+++ b/modules/log/src/log.cppm
@@ -43,6 +43,28 @@ void set_verbose(bool v);
 bool is_verbose();
 void verbose(std::string_view tag, std::string_view message);
 
+// A record, as a sink receives it: what `verbose` was asked to say.
+struct Record {
+    std::string_view timestamp;   // local wall-clock time, as the file has it
+    std::string_view tag;
+    std::string_view message;
+};
+
+// The one spelling of a verbose record on a terminal: dim, with its time, so
+// that a long step is attributable from the live `--verbose` stream (the log
+// file already has the time). Grep-friendly: "[VERBOSE <ts>]".
+std::string verbose_line(const Record& r, bool colour);
+
+// Where a verbose record is shown. The terminal belongs to mcpp.ui, which
+// installs a sink at start-up and writes the record through the one writer
+// every other line goes through, so that a verbose line is written above a
+// build's live region rather than into it (build progress design 2026-09-29,
+// §5.3). Without a sink the record goes to stderr as `verbose_line` spells it.
+// This module stays a leaf: it states what to say, and the terminal's owner
+// decides how.
+using TerminalSink = void (*)(const Record& record);
+void set_terminal_sink(TerminalSink sink);
+
 // Scoped verbose timer for diagnosing slow steps (e.g. first-run init / bootstrap
 // hangs). Logs "<label>: start" on construction and "<label>: done (Δ=<ms>ms)" on
 // destruction, via verbose() — always to the timestamped log file
@@ -151,15 +173,17 @@ void write_log(Level level, std::string_view tag, std::string_view message) {
         << tag << ": " << message << '\n';
 }
 
+std::atomic<TerminalSink> g_terminalSink{nullptr};
+
 void write_stderr(std::string_view tag, std::string_view message) {
     // Dim gray for verbose output so it doesn't compete with ui::status.
     // Carry the wall-clock timestamp so a long first-run hang is attributable
     // to a specific step from the live --verbose stream (the log file already
     // has it). Grep-friendly: "[VERBOSE <ts>]".
-    std::fprintf(stderr, "\033[2m[VERBOSE %s] %.*s: %.*s\033[0m\n",
-        timestamp().c_str(),
-        static_cast<int>(tag.size()), tag.data(),
-        static_cast<int>(message.size()), message.data());
+    const auto ts = timestamp();
+    const Record record{ts, tag, message};
+    if (auto sink = g_terminalSink.load()) { sink(record); return; }
+    std::fputs(verbose_line(record, true).c_str(), stderr);
 }
 
 } // namespace
@@ -193,6 +217,14 @@ void init(const Config& cfg) {
     }
 }
 
+std::string verbose_line(const Record& r, bool colour) {
+    return colour
+        ? std::format("\033[2m[VERBOSE {}] {}: {}\033[0m\n", r.timestamp, r.tag, r.message)
+        : std::format("[VERBOSE {}] {}: {}\n", r.timestamp, r.tag, r.message);
+}
+
+void set_terminal_sink(TerminalSink sink) { g_terminalSink.store(sink); }
+
 void set_verbose(bool v) {
     g_verbose = v;
     // If verbose enabled but file logging off, auto-enable info level
diff --git a/modules/platform/src/fs.cppm b/modules/platform/src/fs.cppm
index d34ae4078..75d7c2339 100644
--- a/modules/platform/src/fs.cppm
+++ b/modules/platform/src/fs.cppm
@@ -81,6 +81,12 @@ bool replace_file(const std::filesystem::path& source,
                   const std::filesystem::path& destination,
                   std::error_code& ec);
 
+// Appends `bytes` to the file, creating it, in one write that another process
+// appending to the same file cannot split: `O_APPEND` on POSIX, an open for
+// FILE_APPEND_DATA alone on Windows, where the C runtime's append mode seeks
+// and then writes, and two writers can overwrite each other.
+bool append_atomically(const std::filesystem::path& file, std::string_view bytes);
+
 // ── FileLock ──────────────────────────────────────────────────────────────
 //
 // RAII exclusive non-blocking file lock.
@@ -259,6 +265,26 @@ bool replace_file(const std::filesystem::path& source,
 #endif
 }
 
+bool append_atomically(const std::filesystem::path& file, std::string_view bytes) {
+#if defined(_WIN32)
+    HANDLE h = CreateFileW(file.wstring().c_str(), FILE_APPEND_DATA,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                           nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (h == INVALID_HANDLE_VALUE) return false;
+    DWORD written = 0;
+    const bool ok = WriteFile(h, bytes.data(), static_cast<DWORD>(bytes.size()),
+                              &written, nullptr) && written == bytes.size();
+    CloseHandle(h);
+    return ok;
+#else
+    const int fd = ::open(file.c_str(), O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC, 0644);
+    if (fd < 0) return false;
+    const auto n = ::write(fd, bytes.data(), bytes.size());
+    ::close(fd);
+    return n == static_cast<decltype(n)>(bytes.size());
+#endif
+}
+
 // ── FileLock ──────────────────────────────────────────────────────────────
 
 #if defined(_WIN32)
diff --git a/modules/platform/src/process.cppm b/modules/platform/src/process.cppm
index 3dd90aca0..d559cded3 100644
--- a/modules/platform/src/process.cppm
+++ b/modules/platform/src/process.cppm
@@ -233,6 +233,19 @@ RunResult capture_exec_deadline(
     std::string_view cwd = {},
     int* spawn_error = nullptr);
 
+// Run `argv` with its stdout and stderr on one pipe and hand each line to
+// `on_line` as it arrives, without the line end. `deadline` bounds the run as
+// capture_exec_deadline's does; zero means no bound. A line the child did not
+// end is delivered after it exits. Returns the exit code; 127 with
+// *spawn_error set when the child could not be started. On a build with no
+// bounded launcher the output is delivered after the child exits.
+int stream_exec(const std::vector<std::string>& argv,
+                const std::vector<std::pair<std::string, std::string>>& extraEnv,
+                std::chrono::milliseconds deadline,
+                const std::function<void(std::string_view line)>& on_line,
+                bool* timed_out,
+                int* spawn_error = nullptr);
+
 // Run `command` silently (discard stdout/stderr).
 // On POSIX, stdin is automatically redirected from /dev/null.
 int run_silent(std::string_view command);
@@ -1178,6 +1191,43 @@ void clear_background_guard(const BackgroundCommand& child) {
         mcpp::platform::unixproc::unguard_group(child.group);
 }
 
+int stream_exec(const std::vector<std::string>& argv,
+                const std::vector<std::pair<std::string, std::string>>& extraEnv,
+                std::chrono::milliseconds deadline,
+                const std::function<void(std::string_view line)>& on_line,
+                bool* timed_out,
+                int* spawn_error)
+{
+    if (timed_out) *timed_out = false;
+    if (spawn_error) *spawn_error = 0;
+    if (argv.empty()) return 127;
+    // Its own process group, registered with the signal guard, as
+    // capture_exec's child is: a build's ninja must not outlive the mcpp that
+    // started it when that mcpp alone is signalled (e2e 340).
+    auto r = dispatch_bounded(argv, extraEnv, {}, deadline, /*capture=*/true, {},
+                              std::chrono::milliseconds{0}, /*ownGroup=*/true, &on_line);
+    if (!r.supported) {
+        if (r.spawn_error != 0) {
+            if (spawn_error) *spawn_error = r.spawn_error;
+            else on_line(spawn_failure(argv.front(), r.spawn_error));
+            return 127;
+        }
+        auto whole = capture_exec(argv, extraEnv, {}, spawn_error);
+        std::string_view rest = whole.output;
+        while (!rest.empty()) {
+            const auto nl = rest.find('\n');
+            auto l = rest.substr(0, nl);
+            while (!l.empty() && l.back() == '\r') l.remove_suffix(1);
+            on_line(l);
+            if (nl == std::string_view::npos) break;
+            rest.remove_prefix(nl + 1);
+        }
+        return whole.exit_code;
+    }
+    if (timed_out) *timed_out = r.timed_out;
+    return r.exit_code;
+}
+
 RunResult capture_exec_deadline(
     const std::vector<std::string>& argv,
     const std::vector<std::pair<std::string, std::string>>& extraEnv,
diff --git a/modules/platform/src/terminal.cppm b/modules/platform/src/terminal.cppm
index b8a7fe249..69ce29568 100644
--- a/modules/platform/src/terminal.cppm
+++ b/modules/platform/src/terminal.cppm
@@ -1,25 +1,31 @@
-// mcpp.platform.terminal — terminal capability detection.
+// mcpp.platform.terminal — terminal capability detection and output.
 //
 // Provides:
-//   is_tty()         — whether stdout is a terminal
-//   terminal_cols()  — terminal width in columns
+//   is_tty()          — whether stdout is a terminal
+//   is_terminal(s)    — whether a standard stream is a terminal
+//   can_move_cursor(s)— whether a live display may be drawn on it
+//   cols(), rows()    — the terminal's size
+//   write(s, text)    — UTF-8 text to a standard stream
 
 module;
 #include <cstdio>
 #include <cstdlib>
-#ifdef __unix__
+#if defined(__unix__) || defined(__APPLE__)
 #include <unistd.h>
 #include <sys/ioctl.h>
 #endif
 #if defined(_WIN32)
-#include <io.h>        // _dup, _dup2, _close, _get_osfhandle
+#include <io.h>        // _dup, _dup2, _close, _get_osfhandle, _fileno
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
-#include <windows.h>   // SetHandleInformation, HANDLE_FLAG_INHERIT
+#include <windows.h>   // SetHandleInformation, GetConsoleMode, WriteConsoleW
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING   // older SDK and MinGW headers
+#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif
 #else
 #include <unistd.h>    // dup2, close
 #include <fcntl.h>     // fcntl, F_DUPFD_CLOEXEC
@@ -31,13 +37,39 @@ import std;
 
 export namespace mcpp::platform::terminal {
 
+// The two standard streams a human reads.
+enum class Stream { Out, Err };
+
 // Returns true if stdout is connected to a terminal (TTY).
 bool is_tty();
 
-// Returns the terminal width in columns. Tries TIOCGWINSZ on Unix,
-// falls back to $COLUMNS, then defaults to 80.
+// Whether the stream is a terminal: `isatty` on POSIX, macOS included, and a
+// console on Windows. Until 2026.9.29.5 this was compiled only under
+// `__unix__`, which Apple's compilers do not define, so macOS and Windows were
+// never terminals and drew neither colour nor a live line. A Windows program
+// under mintty writes to a pipe, not a console, and is not a terminal here.
+bool is_terminal(Stream s);
+
+// Whether a display that moves the cursor may be drawn on the stream: a
+// terminal, not `TERM=dumb`, and on Windows a console that accepted virtual
+// terminal processing. The first call on Windows enables that processing, so
+// that the escape sequences mcpp writes are interpreted rather than printed.
+bool can_move_cursor(Stream s);
+
+// Returns the terminal width in columns. Tries the terminal first (TIOCGWINSZ,
+// or the console's window on Windows), falls back to $COLUMNS, then to 80.
 std::size_t cols();
 
+// The terminal's height in rows, by the same order, with $LINES and 24.
+std::size_t rows();
+
+// Writes UTF-8 text to the stream. A Windows console receives it as UTF-16
+// through WriteConsoleW, so that text outside ASCII (`·`, `→`, a path in
+// Chinese) appears as written whatever the console's code page is; the stdio
+// buffer is flushed first, so the two paths keep their order. Everything else
+// receives the bytes through stdio, unflushed.
+void write(Stream s, std::string_view text);
+
 // EVERYTHING WRITTEN TO STANDARD OUTPUT GOES TO STANDARD ERROR UNTIL THIS IS
 // DESTROYED.
 //
@@ -70,24 +102,109 @@ private:
 
 namespace mcpp::platform::terminal {
 
-bool is_tty() {
-#ifdef __unix__
-    return ::isatty(::fileno(stdout)) != 0;
+namespace {
+
+std::FILE* file_of(Stream s) { return s == Stream::Out ? stdout : stderr; }
+
+#if defined(_WIN32)
+HANDLE handle_of(Stream s) {
+    const auto h = reinterpret_cast<HANDLE>(::_get_osfhandle(::_fileno(file_of(s))));
+    return h == nullptr ? INVALID_HANDLE_VALUE : h;
+}
+
+bool console_of(Stream s, HANDLE* out = nullptr) {
+    const auto h = handle_of(s);
+    DWORD mode = 0;
+    if (h == INVALID_HANDLE_VALUE || !::GetConsoleMode(h, &mode)) return false;
+    if (out) *out = h;
+    return true;
+}
+#endif
+
+} // namespace
+
+bool is_terminal(Stream s) {
+#if defined(_WIN32)
+    return console_of(s);
+#elif defined(__unix__) || defined(__APPLE__)
+    return ::isatty(::fileno(file_of(s))) != 0;
 #else
+    (void)s;
     return false;
 #endif
 }
 
+bool is_tty() { return is_terminal(Stream::Out); }
+
+bool can_move_cursor(Stream s) {
+    if (!is_terminal(s)) return false;
+    if (const char* term = std::getenv("TERM"); term && std::string_view(term) == "dumb")
+        return false;
+#if defined(_WIN32)
+    HANDLE h;
+    if (!console_of(s, &h)) return false;
+    DWORD mode = 0;
+    if (!::GetConsoleMode(h, &mode)) return false;
+    if (mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) return true;
+    return ::SetConsoleMode(h, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0;
+#else
+    return true;
+#endif
+}
+
+namespace {
+std::size_t from_env(const char* name, std::size_t fallback) {
+    if (auto* e = std::getenv(name); e && *e) {
+        try { auto n = std::stoul(e); if (n > 0) return n; } catch (...) {}
+    }
+    return fallback;
+}
+} // namespace
+
 std::size_t cols() {
-#ifdef __unix__
+#if defined(_WIN32)
+    CONSOLE_SCREEN_BUFFER_INFO info{};
+    if (HANDLE h; console_of(Stream::Out, &h) && ::GetConsoleScreenBufferInfo(h, &info))
+        return static_cast<std::size_t>(info.srWindow.Right - info.srWindow.Left + 1);
+#elif defined(__unix__) || defined(__APPLE__)
     struct winsize w{};
     if (::ioctl(::fileno(stdout), TIOCGWINSZ, &w) == 0 && w.ws_col > 0)
         return w.ws_col;
 #endif
-    if (auto* e = std::getenv("COLUMNS"); e && *e) {
-        try { auto n = std::stoul(e); if (n > 0) return n; } catch (...) {}
+    return from_env("COLUMNS", 80);
+}
+
+std::size_t rows() {
+#if defined(_WIN32)
+    CONSOLE_SCREEN_BUFFER_INFO info{};
+    if (HANDLE h; console_of(Stream::Out, &h) && ::GetConsoleScreenBufferInfo(h, &info))
+        return static_cast<std::size_t>(info.srWindow.Bottom - info.srWindow.Top + 1);
+#elif defined(__unix__) || defined(__APPLE__)
+    struct winsize w{};
+    if (::ioctl(::fileno(stdout), TIOCGWINSZ, &w) == 0 && w.ws_row > 0)
+        return w.ws_row;
+#endif
+    return from_env("LINES", 24);
+}
+
+void write(Stream s, std::string_view text) {
+    if (text.empty()) return;
+#if defined(_WIN32)
+    if (HANDLE h; console_of(s, &h)) {
+        std::fflush(file_of(s));
+        const int n = ::MultiByteToWideChar(CP_UTF8, 0, text.data(),
+                                            static_cast<int>(text.size()), nullptr, 0);
+        if (n > 0) {
+            std::wstring wide(static_cast<std::size_t>(n), L'\0');
+            ::MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()),
+                                  wide.data(), n);
+            DWORD written = 0;
+            if (::WriteConsoleW(h, wide.data(), static_cast<DWORD>(wide.size()), &written, nullptr))
+                return;
+        }
     }
-    return 80;
+#endif
+    std::fwrite(text.data(), 1, text.size(), file_of(s));
 }
 
 StdoutToStderr::StdoutToStderr() {
diff --git a/modules/platform/src/unix/bounded_process.cppm b/modules/platform/src/unix/bounded_process.cppm
index ab9edf14b..7179299ef 100644
--- a/modules/platform/src/unix/bounded_process.cppm
+++ b/modules/platform/src/unix/bounded_process.cppm
@@ -92,7 +92,8 @@ using OutputSink = void (*)(void* ctx, const char* data, unsigned long len);
 // written nothing for that long. It is meaningful only with a sink, and it is
 // what lets a long, progressing child (a download that prints progress) run to
 // completion while a wedged one does not (#648). With `idleMs` positive a
-// non-positive `deadlineMs` means "no total bound".
+// non-positive `deadlineMs` means "no total bound", and so it does with a sink
+// and neither bound: a build's ninja, read line by line for its progress.
 //
 // `ownGroup` non-zero places the child in a process group of its own, kills
 // the GROUP at a bound, and registers the group with the signal guard for the
@@ -210,7 +211,11 @@ DeadlineRun capture_with_deadline(const char* const* argvEntries,
 {
     DeadlineRun out;
     const bool idleBound = idleMs > 0 && sink != nullptr;
-    if ((deadlineMs <= 0 && !idleBound) || argvCount == 0 || !argvEntries) return out;
+    // A child with no bound at all is accepted only with a sink: that caller
+    // reads the output as it arrives (a build's progress) and has no untimed
+    // path that could deliver it.
+    if ((deadlineMs <= 0 && !idleBound && sink == nullptr) || argvCount == 0 || !argvEntries)
+        return out;
 
     // The child's environment: ours, minus anything overridden, plus the
     // overrides. Names are case-SENSITIVE here (unlike the Windows peer).
diff --git a/modules/platform/src/windows/bounded_process.cppm b/modules/platform/src/windows/bounded_process.cppm
index 0b2c403f2..3fdb7444a 100644
--- a/modules/platform/src/windows/bounded_process.cppm
+++ b/modules/platform/src/windows/bounded_process.cppm
@@ -94,12 +94,14 @@ using OutputSink = void (*)(void* ctx, const char* data, unsigned long len);
 // `commandLine` is already quoted for CreateProcess (callers pass the output
 // of windows_command_from_argv). `envEntries` is `envCount` NUL-terminated
 // "KEY=VALUE" strings applied on top of the current environment. `cwd` may be
-// null. A non-positive `deadlineMs` is rejected with supported=false — "no
-// bound" belongs on the caller's untimed path, which needs none of this.
+// null. A non-positive `deadlineMs` without a sink is rejected with
+// supported=false — "no bound" belongs on the caller's untimed path, which
+// needs none of this.
 //
 // `idleMs`, when positive, kills the child once it has written nothing for that
 // long; the POSIX peer states the reason (#648). With `idleMs` positive a
-// non-positive `deadlineMs` means "no total bound". There is no `ownGroup`
+// non-positive `deadlineMs` means "no total bound", and so it does with a sink
+// and neither bound. There is no `ownGroup`
 // parameter: every child here runs in a job object with
 // JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE already, which is what the POSIX flag
 // buys there.
@@ -261,7 +263,9 @@ DeadlineRun capture_with_deadline(const char*        commandLine,
 {
     DeadlineRun out;
     const bool idleBound = idleMs > 0 && sink != nullptr;
-    if ((deadlineMs <= 0 && !idleBound) || !commandLine || !*commandLine) return out;
+    // A child with no bound at all is accepted only with a sink, as on POSIX.
+    if ((deadlineMs <= 0 && !idleBound && sink == nullptr) || !commandLine || !*commandLine)
+        return out;
 
     const bool capture = (sink != nullptr);
 
diff --git a/modules/versioning/src/version.cppm b/modules/versioning/src/version.cppm
index 42a160128..588e692da 100644
--- a/modules/versioning/src/version.cppm
+++ b/modules/versioning/src/version.cppm
@@ -31,6 +31,6 @@ import std;
 
 export namespace mcpp {
 
-inline constexpr std::string_view MCPP_VERSION = "2026.9.29.4";
+inline constexpr std::string_view MCPP_VERSION = "2026.9.29.5";
 
 } // namespace mcpp
diff --git a/src/build/backend.cppm b/src/build/backend.cppm
index 6d243f3ff..ad56358a9 100644
--- a/src/build/backend.cppm
+++ b/src/build/backend.cppm
@@ -4,6 +4,7 @@ export module mcpp.build.backend;
 
 import std;
 import mcpp.build.plan;
+import mcpp.build.progress;
 
 export namespace mcpp::build {
 
@@ -31,6 +32,12 @@ struct BuildOptions {
     // failure. POSIX only: the deadline runner has no kill-by-handle path on
     // Windows (see mcpp.platform.process), where the value is ignored.
     unsigned                    buildTimeoutSecs = 0;
+    // The report of this build directory (build progress design 2026-09-29).
+    // Set, ninja runs without `--quiet` and is read as it runs: the step
+    // record is written, the status lines and ninja's log feed the report,
+    // and a failed step's diagnostics are written when it fails. Null (under
+    // --quiet or machine output), ninja's output is examined after it exits.
+    mcpp::build::progress::Build* progress = nullptr;
 };
 
 struct BuildResult {
@@ -54,6 +61,10 @@ struct BuildError {
     // compile differently from a broken one, and matching on prose is how that
     // distinction silently rots.
     bool                                    timedOut = false;
+    // `message` and the failed steps' diagnostics were written as the steps
+    // failed; `diagnosticOutput` holds only what follows them (the advice
+    // that reads the whole output).
+    bool                                    reported = false;
 };
 
 struct Backend {
diff --git a/src/build/build_database.cppm b/src/build/build_database.cppm
index ffdad9b56..4ebf4d6b0 100644
--- a/src/build/build_database.cppm
+++ b/src/build/build_database.cppm
@@ -12,7 +12,7 @@
 //   - `arguments` come from the record the compile database renders
 //     (mcpp.build.compile_commands::unit_invocations), so the two databases
 //     cannot list different command lines for one unit.
-//   - `visible-sets` is every other set of the planned member. The engine
+//   - `visible-sets` is every other set of the same plan. The engine
 //     resolves imports over one graph per invocation; a narrower closure would
 //     describe a rule the build does not enforce.
 //   - The standard library modules are translation units of their own set,
@@ -54,10 +54,10 @@ struct Member {
     // Where the planning pass wrote (BuildOverrides::work_dir): the build
     // programs' caches, and so their declared inputs, are under it.
     std::filesystem::path workDir;
-    // Test discovery (`[test] discover`, relative to `testRoot`): a new file
+    // Test discovery (`[test] discover`, relative to its root), one entry
+    // per package the plan tests (each member of a group plan): a new file
     // matching it is a new test target, and so a new unit in the document.
-    std::filesystem::path    testRoot;
-    std::vector<std::string> testDiscover;
+    std::vector<std::pair<std::filesystem::path, std::vector<std::string>>> tests;
 };
 
 struct Rendered {
@@ -312,6 +312,11 @@ Rendered render(std::span<const Member> members,
     Rendered r;
     nlohmann::json toolchains = nlohmann::json::object();
     nlohmann::json sets = nlohmann::json::array();
+    // Two plans of one configuration (the members of a group whose plan
+    // failed, planned one by one) describe the packages they share alike: a
+    // set is described once, and so is a compile command, keyed by its file
+    // and its output. A file two configurations compile has a command of each.
+    std::set<std::string> describedSets, describedCommands;
 
     std::set<std::string> watch;
     std::set<std::filesystem::path> inputFiles;
@@ -349,12 +354,23 @@ Rendered render(std::span<const Member> members,
         const auto tcId = toolchain_id(ctx.tc, compilerTriple);
 
         const auto rootName = qualified_name(ctx.manifest);
+        // The packages whose own targets this plan builds: the root, or in a
+        // workspace plan each selected member (§15 of the 2026-09-29 workspace
+        // design), with the directory their target entries are written in.
+        std::vector<std::pair<const mcpp::manifest::Manifest*, std::filesystem::path>> subjects;
+        if (ctx.workspaceMembers.empty())
+            subjects.emplace_back(&ctx.manifest, ctx.projectRoot);
+        for (auto const& wm : ctx.workspaceMembers) subjects.emplace_back(&wm.manifest, wm.root);
+        std::map<std::string, const mcpp::manifest::Manifest*> subjectByName;
         std::set<std::filesystem::path> testSources;
-        for (auto const& t : ctx.manifest.targets) {
-            if (t.kind != mcpp::manifest::Target::TestBinary || t.main.empty()) continue;
-            std::filesystem::path main{t.main};
-            testSources.insert((main.is_absolute() ? main : ctx.projectRoot / main)
-                                   .lexically_normal());
+        for (auto const& [sm, sroot] : subjects) {
+            subjectByName[qualified_name(*sm)] = sm;
+            for (auto const& t : sm->targets) {
+                if (t.kind != mcpp::manifest::Target::TestBinary || t.main.empty()) continue;
+                std::filesystem::path main{t.main};
+                testSources.insert((main.is_absolute() ? main : sroot / main)
+                                       .lexically_normal());
+            }
         }
 
         std::vector<std::string> order;
@@ -394,8 +410,9 @@ Rendered render(std::span<const Member> members,
             const auto& cu = *inv.unit;
             const bool isTest = testSources.contains(cu.source.lexically_normal());
             const std::string package = cu.packageName.empty() ? rootName : cu.packageName;
+            const auto subject = subjectByName.find(package);
             const std::string kind = isTest ? "test"
-                                   : package == rootName ? target_kind(ctx.manifest)
+                                   : subject != subjectByName.end() ? target_kind(*subject->second)
                                    : "library";
             auto& set = set_for(member.setPrefix + package + (isTest ? ":test" : ""),
                                 package, kind);
@@ -407,7 +424,8 @@ Rendered render(std::span<const Member> members,
             if (!cu.providesModule.empty()) provides[cu.providesModule] = "";
             nlohmann::json requires_ = nlohmann::json::array();
             for (auto const& name : cu.imports) requires_.push_back(name);
-            r.compileCommands.push_back(nlohmann::json{
+            if (describedCommands.insert(inv.file + '\x1f' + inv.output).second)
+                r.compileCommands.push_back(nlohmann::json{
                 {"directory", inv.directory},
                 {"file",      inv.file},
                 {"arguments", inv.arguments},
@@ -439,7 +457,8 @@ Rendered render(std::span<const Member> members,
                 const auto sourceStr = native_string(unit.source);
                 const auto objectStr = native_string(unit.object);
                 const auto workDirStr = native_string(unit.workDirectory);
-                r.compileCommands.push_back(nlohmann::json{
+                if (describedCommands.insert(sourceStr + '\x1f' + objectStr).second)
+                    r.compileCommands.push_back(nlohmann::json{
                     {"directory", workDirStr},
                     {"file",      sourceStr},
                     {"arguments", unit.arguments},
@@ -516,6 +535,7 @@ Rendered render(std::span<const Member> members,
         }
 
         for (auto const& name : order) {
+            if (!describedSets.insert(name).second) continue;
             auto& set = groups.at(name);
             nlohmann::json visible = nlohmann::json::array();
             for (auto const& other : order)
@@ -545,7 +565,8 @@ Rendered render(std::span<const Member> members,
                 watch_file(sp.root / "build.mcpp");
             for (auto const& g : sp.sources) watch_glob(sp.root, g);
         }
-        for (auto const& g : member.testDiscover) watch_glob(member.testRoot, g);
+        for (auto const& [testRoot, globs] : member.tests)
+            for (auto const& g : globs) watch_glob(testRoot, g);
         // Only an editable package's build program inputs can change: a store
         // package's are fixed by the version its manifest and lock name.
         std::set<std::filesystem::path> editableRoots;
diff --git a/src/build/build_program.cppm b/src/build/build_program.cppm
index e333934da..53ee91d21 100644
--- a/src/build/build_program.cppm
+++ b/src/build/build_program.cppm
@@ -22,6 +22,7 @@ import mcpp.toolchain.cppfly;        // std_flag (dialect- and c++fly-aware -std
 import mcpp.toolchain.dialect;       // CommandDialect — gnu vs cl.exe spellings
 import mcpp.toolchain.fingerprint;   // hash_file / hash_string (FNV-1a, 16 hex)
 import mcpp.build.directives;        // the directive definition table (own module: see its header)
+import mcpp.build.progress;          // the program's line (build progress design 2026-09-29)
 import mcpp.build.refusal;           // the machine-readable identity of a refusal
 import mcpp.build.hostprogram;       // bundled `mcpp` module compile (own module: see its header)
 import mcpp.build.resources;         // compile_utf8_manifest — the build program speaks UTF-8 (#693)
@@ -74,6 +75,11 @@ inline constexpr std::string_view kBuildInformationKeys[] = {
 };
 
 struct BuildProgramEnv {
+    // The program belongs to a package the command was asked to build (the
+    // root, or a selected member): its line is listed, and the programs of
+    // every other package are folded into one (build progress design
+    // 2026-09-29, §4.3).
+    bool requested = false;
     std::string targetTriple;               // resolved canonical triple; "" = host
     // The resolved toolchain's payload root and the target's own C library
     // root. Both exist so a package can ASK instead of DECLARE — see
@@ -1238,6 +1244,11 @@ std::expected<void, std::string> run_build_program(
         }
     }
 
+    // The package the status lines name: several programs run in one
+    // workspace plan, and a line without its package cannot be attributed.
+    const std::string who = m.package.namespace_.empty()
+        ? m.package.name : m.package.namespace_ + "." + m.package.name;
+
     // Fast path: declared inputs + contract unchanged → reapply cached
     // directives, no run.
     CacheRecord cache = read_cache(bdir);
@@ -1261,10 +1272,39 @@ std::expected<void, std::string> run_build_program(
         for (auto const& a : dirs::advisories(m.package.name, cache.directives))
             mcpp::ui::warning(a);
         report_stated_diagnostics(m.package.name, cache.directives);
-        mcpp::ui::info("build.mcpp", "up to date (cached)");
+        mcpp::build::progress::program_finished(
+            who, env.requested, mcpp::build::progress::ProgramOutcome::Cached, {}, {});
         return {};
     }
 
+    // From here on the program is compiled or run, and every return reports
+    // its outcome: `ran` when the directives were applied, `failed` otherwise.
+    using ProgressClock = std::chrono::steady_clock;
+    struct ProgramReport {
+        const std::string& who;
+        bool requested;
+        ProgressClock::time_point compileStart{}, runStart{};
+        bool ran = false;
+        bool reported = false;
+        ~ProgramReport() { report(); }
+        void report() {
+            if (reported) return;
+            reported = true;
+            using namespace std::chrono;
+            const auto now = ProgressClock::now();
+            const auto zero = ProgressClock::time_point{};
+            const auto compile = compileStart == zero ? milliseconds{0}
+                : duration_cast<milliseconds>((runStart == zero ? now : runStart) - compileStart);
+            const auto run = runStart == zero ? milliseconds{0}
+                : duration_cast<milliseconds>(now - runStart);
+            mcpp::build::progress::program_finished(
+                who, requested,
+                ran ? mcpp::build::progress::ProgramOutcome::Ran
+                    : mcpp::build::progress::ProgramOutcome::Failed,
+                compile, run);
+        }
+    } programReport{who, env.requested};
+
     fs::create_directories(outDir, ec);   // creates bdir too
     // #230: on Windows the capture_exec shell is cmd.exe, which can only launch
     // a PE by an executable extension — a bare `.bin` is not in PATHEXT and
@@ -1622,7 +1662,8 @@ std::expected<void, std::string> run_build_program(
             "       arrived. Please report it with the toolchain name and this "
             "line.", *orphan));
     }
-    mcpp::ui::info("build.mcpp", "compiling");
+    mcpp::build::progress::program_compiling(who, env.requested);
+    programReport.compileStart = ProgressClock::now();
     // GCC resolves imported BMIs via gcm.cache/ relative to the compile cwd, so
     // any compile that imports a module — `mcpp`, `std`, a build rule's host
     // module, or any mix — has to run from bdir, where they were staged or
@@ -1663,7 +1704,8 @@ std::expected<void, std::string> run_build_program(
     // produces a baffling failure; a build PROGRAM that runs long is usually
     // stuck — waiting on a network read or spinning — and without a bound the
     // whole build hangs with no diagnostic at all.
-    mcpp::ui::info("build.mcpp", "running");
+    mcpp::build::progress::program_running(who, env.requested);
+    programReport.runStart = ProgressClock::now();
     bool timedOut = false;
     // The bound comes from THIS package's manifest — a dependency's generator
     // is bounded by the dependency's own declaration, because its author is
@@ -1760,6 +1802,9 @@ std::expected<void, std::string> run_build_program(
     }
 
     dirs::apply(m, d);
+    // The program's line comes before what it has to say.
+    programReport.ran = true;
+    programReport.report();
     // The second of the two sites. See the note on the cache-hit path above.
     for (auto const& a : dirs::advisories(m.package.name, d))
         mcpp::ui::warning(a);
diff --git a/src/build/compile_commands.cppm b/src/build/compile_commands.cppm
index 24214e2d5..39f9ba24c 100644
--- a/src/build/compile_commands.cppm
+++ b/src/build/compile_commands.cppm
@@ -168,6 +168,22 @@ publish_root_compile_commands(
     const std::filesystem::path& mcppHome,
     ReplaceFile replaceFile = mcpp::platform::fs::replace_file);
 
+// The same for a command that planned several configurations (a workspace
+// whose members form more than one configuration group, workspace design
+// 2026-09-29 §15): the root file is the union of their databases, sorted by
+// file as every database is, an entry of an earlier database kept where two
+// have the same file and output. A file two configurations compile has an
+// entry of each (the format allows several; clangd reads the first). The
+// command publishes the file once, after all its plans, so it does not depend
+// on which concurrent build finished last.
+std::expected<CompileCommandsWriteResult, CompileCommandsWriteError>
+publish_root_compile_commands(
+    std::span<const std::filesystem::path> configDbPaths,
+    const std::filesystem::path& rootPath,
+    const std::filesystem::path& targetRoot,
+    const std::filesystem::path& mcppHome,
+    ReplaceFile replaceFile = mcpp::platform::fs::replace_file);
+
 // Writes the configuration's database for `plan`, then publishes the root
 // copy from it. `commandCount` is the configuration database's entry count;
 // `foreignEntries` is the root publish's (see publish_root_compile_commands).
@@ -625,27 +641,56 @@ publish_root_compile_commands(
     const std::filesystem::path& targetRoot,
     const std::filesystem::path& mcppHome,
     ReplaceFile replaceFile) {
+    return publish_root_compile_commands(std::span(&configDbPath, 1), rootPath,
+                                         targetRoot, mcppHome, std::move(replaceFile));
+}
+
+std::expected<CompileCommandsWriteResult, CompileCommandsWriteError>
+publish_root_compile_commands(
+    std::span<const std::filesystem::path> configDbPaths,
+    const std::filesystem::path& rootPath,
+    const std::filesystem::path& targetRoot,
+    const std::filesystem::path& mcppHome,
+    ReplaceFile replaceFile) {
+    // One database is copied byte for byte; several are joined.
     std::string content;
-    {
-        std::ifstream input(configDbPath, std::ios::binary);
-        if (!input) {
-            return std::unexpected(write_error(std::format(
-                "cannot read configuration compile database '{}'", configDbPath.string())));
+    nlohmann::json configJson = nlohmann::json::array();
+    std::set<std::string> described;
+    for (auto const& configDbPath : configDbPaths) {
+        std::string text;
+        {
+            std::ifstream input(configDbPath, std::ios::binary);
+            if (!input) {
+                return std::unexpected(write_error(std::format(
+                    "cannot read configuration compile database '{}'", configDbPath.string())));
+            }
+            std::stringstream ss;
+            ss << input.rdbuf();
+            if (input.bad()) {
+                return std::unexpected(write_error(std::format(
+                    "cannot read configuration compile database '{}'", configDbPath.string())));
+            }
+            text = ss.str();
         }
-        std::stringstream ss;
-        ss << input.rdbuf();
-        if (input.bad()) {
+        auto json = nlohmann::json::parse(text, nullptr, /*allow_exceptions=*/false);
+        if (json.is_discarded() || !json.is_array()) {
             return std::unexpected(write_error(std::format(
-                "cannot read configuration compile database '{}'", configDbPath.string())));
+                "configuration compile database '{}' is not a JSON array",
+                configDbPath.string())));
+        }
+        if (configDbPaths.size() == 1) { content = std::move(text); configJson = std::move(json); break; }
+        for (auto& e : json) {
+            if (!e.is_object() || !e.contains("file") || !e.at("file").is_string()) continue;
+            auto key = dedup_key(resolve_against_directory(e, "file"));
+            if (e.contains("output") && e.at("output").is_string())
+                key += '\x1f' + dedup_key(resolve_against_directory(e, "output"));
+            if (described.insert(std::move(key)).second)
+                configJson.push_back(std::move(e));
         }
-        content = ss.str();
     }
-
-    auto configJson = nlohmann::json::parse(content, nullptr, /*allow_exceptions=*/false);
-    if (configJson.is_discarded() || !configJson.is_array()) {
-        return std::unexpected(write_error(std::format(
-            "configuration compile database '{}' is not a JSON array",
-            configDbPath.string())));
+    if (configDbPaths.size() != 1) {
+        sort_entries_by_file(configJson);
+        content = configJson.dump(2) + "\n";
     }
 
     auto doc = read_existing_document(rootPath);
@@ -701,6 +746,7 @@ write_compile_commands(const BuildPlan& plan, const CompileFlags& flags) {
     auto configPath = plan.outputDir / "compile_commands.json";
     auto configResult = publish_compile_commands(configPath, fresh, fileExists);
     if (!configResult) return configResult;
+    if (!plan.publishRootCompileDb) return configResult;
 
     // §3.2 items 2-3: the root is a copy of it, replaced whole. `emit`
     // (`mcpp emit build-database`) never reaches this function (SPEC-005
diff --git a/src/build/configure.cppm b/src/build/configure.cppm
index 87b95cb75..6b9960200 100644
--- a/src/build/configure.cppm
+++ b/src/build/configure.cppm
@@ -106,8 +106,7 @@ int run_configure_plan(BuildContext& ctx, bool verbose) {
     auto result = backend->build(ctx.plan, options);
     if (!result) {
         mcpp::ui::error(result.error().message);
-        if (!result.error().diagnosticOutput.empty())
-            std::fputs(result.error().diagnosticOutput.c_str(), stderr);
+        mcpp::ui::block(result.error().diagnosticOutput);
         return 1;
     }
     if (!mcpp::diag::flush(ctx.strict)) return 1;
diff --git a/src/build/execute.cppm b/src/build/execute.cppm
index 6923c2c2c..2f4358611 100644
--- a/src/build/execute.cppm
+++ b/src/build/execute.cppm
@@ -49,6 +49,7 @@ import mcpp.build.schedule.policy;   // resolve_jobs — one answer to "how many
 import mcpp.fetcher.progress;
 import mcpp.project;
 import mcpp.ui;
+import mcpp.build.progress;
 
 namespace mcpp::build {
 
@@ -925,83 +926,16 @@ export int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache,
         for (auto& note : ctx.workspaceMembers.front().manifest.inferredNotes)
             mcpp::ui::status("Inferred", note);
 
-    // Announce the package being built (and any deps). A dep served from the
-    // global cache says "Cached" and HOW MANY translation units that saved. The
-    // count is the point: the bare word "Cached" was printed for three months
-    // while ninja recompiled every one of those units behind it, and no output
-    // contradicted it. A number that has to match the edges ninja actually skips
-    // cannot be quietly wrong in the same way.
-    std::map<std::string, std::size_t> cachedUnits;
-    for (auto& dep : ctx.cachedDeps) cachedUnits[dep.name] = dep.units;
-    std::set<std::string> announced;
-    announced.insert(ctx.manifest.package.name);
-    // A workspace plan's virtual root compiles nothing; its members are
-    // announced as its dependencies, by their directories (§15).
-    if (!ctx.manifest.package.virtualRoot)
-        mcpp::ui::status("Compiling",
-            std::format("{} v{} (.)",
-                        ctx.manifest.package.name, ctx.manifest.package.version));
-    // The packages announced: the root's dependencies, and in a workspace
-    // plan each member followed by the member's own dependencies (§15), as
-    // the member's own build announced them.
-    std::vector<std::pair<std::string, mcpp::manifest::DependencySpec>> announcedDeps;
-    for (auto const& [name, spec] : ctx.manifest.dependencies) {
-        announcedDeps.emplace_back(name, spec);
-        if (!spec.workspaceMember) continue;
-        for (auto const& m : ctx.workspaceMembers) {
-            std::error_code e1, e2;
-            if (std::filesystem::weakly_canonical(spec.path, e1)
-                != std::filesystem::weakly_canonical(m.root, e2))
-                continue;
-            for (auto const& [dn, ds] : m.manifest.dependencies) announcedDeps.emplace_back(dn, ds);
-        }
-    }
-    for (auto& [name, spec] : announcedDeps) {
-        if (announced.contains(name)) continue;
-        announced.insert(name);
-        // Two keys that resolved to one identity (#634, A2) are one package
-        // and one compile, so they are announced once.
-        if (!spec.shortName.empty()
-            && !announced.insert(std::format("identity:{}.{}", spec.namespace_,
-                                             spec.shortName)).second)
-            continue;
-        // `spec.version` is the constraint the manifest WROTE. Announcing it
-        // printed "Compiling compat.imgui v^1.92.8" — a banner naming a version
-        // that does not exist (mcpp#363). prepare_build hands the resolution
-        // result over in ctx.resolvedVersions; fall back to the spec only for
-        // deps that never went through resolution (git, or an exact pin).
-        auto rit = ctx.resolvedVersions.find(name);
-        // A git dependency has no version to announce: `spec.version` is empty
-        // for it, and the banner used to read "Compiling spike.fw v" (#649 E7).
-        // It names the reference the manifest wrote instead, shortening a
-        // commit to the length `git` itself abbreviates to.
-        auto gitReference = [&] {
-            std::string ref = spec.gitRev;
-            if (spec.gitRefKind == "rev" && ref.size() > 12) ref.resize(12);
-            return std::format("(git {} {})",
-                               spec.gitRefKind.empty() ? "rev" : spec.gitRefKind, ref);
-        };
-        auto memberDir = [&] {
-            auto rel = std::filesystem::path(spec.path).lexically_normal()
-                           .lexically_relative(ctx.projectRoot.lexically_normal()).generic_string();
-            return std::format("({})", rel.empty() ? std::string(".") : rel);
-        };
-        std::string ver = spec.workspaceMember
-            ? memberDir()
-            : spec.isPath()
-            ? "(path)"
-            : spec.isGit()
-            ? gitReference()
-            : std::string("v") + (rit != ctx.resolvedVersions.end() ? rit->second
-                                                                    : spec.version);
-        auto it = cachedUnits.find(name);
-        if (it == cachedUnits.end()) {
-            mcpp::ui::status("Compiling", std::format("{} {}", name, ver));
-        } else {
-            mcpp::ui::status("Cached", std::format("{} {} ({} unit{})",
-                name, ver, it->second, it->second == 1 ? "" : "s"));
-        }
-    }
+    // The packages are no longer announced before ninja runs: each package's
+    // line is written when its outcome is known, with that outcome (build
+    // progress design 2026-09-29, §4.2). The plan names them
+    // (`BuildPlan::packages`), and a dependency served from the global cache
+    // states how many units that saved, as the `Cached` line did: a number
+    // that has to match the edges ninja actually skips cannot be quietly
+    // wrong, where the bare word was printed for three months over full
+    // recompiles.
+    mcpp::build::progress::programs_done();
+    mcpp::build::progress::Build report(ctx.outputDir);
 
     // RECLAIM THE STALE CONCURRENCY TOKENS, HERE AND NOT IN prepare.
     //
@@ -1030,15 +964,13 @@ export int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache,
     mcpp::build::BuildOptions opts;
     opts.verbose = verbose;
     opts.parallelJobs = static_cast<std::size_t>(ctx.plan.scheduleNinjaJobs);
+    if (!mcpp::ui::is_quiet()) opts.progress = &report;
     auto r = be->build(ctx.plan, opts);
     if (!r) {
-        std::fflush(stdout);
-        mcpp::ui::error(r.error().message);
-        if (!r.error().diagnosticOutput.empty()) {
-            std::fputs(r.error().diagnosticOutput.c_str(), stderr);
-            if (r.error().diagnosticOutput.back() != '\n')
-                std::fputc('\n', stderr);
-        }
+        // A failed step was reported when it failed; what follows is the
+        // advice that reads the whole output.
+        if (!r.error().reported) mcpp::ui::error(r.error().message);
+        mcpp::ui::block(r.error().diagnosticOutput);
         return 1;
     }
 
@@ -1142,7 +1074,7 @@ export int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache,
             mcpp::build::realises_optimization(bc) ? "optimized" : "unoptimized";
         if (bc.debug) descriptor += " + debuginfo";
         if (bc.lto)   descriptor += " + lto";
-        mcpp::ui::finished(ctx.profile, r->elapsed, descriptor);
+        mcpp::build::progress::finished(ctx.profile, descriptor);
     }
     report_freestanding_size(ctx);
     return 0;
@@ -1311,8 +1243,11 @@ std::optional<int> run_ninja_fast(const std::string& ninjaProgram,
                                   const std::string& runtimeEnvKey,
                                   const std::string& runtimeEnvValue,
                                   std::chrono::milliseconds* elapsedOut = nullptr) {
+    // Read as it runs, into this directory's report, unless nothing is to be
+    // shown (build progress design 2026-09-29, §6.1).
+    const bool reporting = !mcpp::ui::is_quiet();
     std::vector<std::string> argv{ninjaProgram};
-    if (!verbose) argv.push_back("--quiet");
+    if (!verbose && !reporting) argv.push_back("--quiet");
     argv.push_back("-C");
     argv.push_back(outputDir.string());
     if (verbose) argv.push_back("-v");
@@ -1355,42 +1290,58 @@ std::optional<int> run_ninja_fast(const std::string& ninjaProgram,
     auto t0 = std::chrono::steady_clock::now();
     // capture_exec merges stderr into the captured output (replacing `2>&1`),
     // so is_stale_ninja_failure / filter_ninja_output still see ninja errors.
-    auto r = mcpp::platform::process::capture_exec(argv, childEnv);
-    std::string out = r.output;
-    int status = r.exit_code;
+    std::string out;
+    int status = 0;
+    bool reported = false;
+    const auto prefixes = read_ninja_command_prefixes(ninjaPath);
+    if (reporting) {
+        mcpp::build::progress::Build report(outputDir);
+        auto run = mcpp::build::run_ninja_reporting(argv, childEnv, std::chrono::milliseconds{0},
+                                                    report, verbose, prefixes);
+        out = std::move(run.output);
+        status = run.exitCode;
+        reported = run.reported;
+        // A stale graph is not this build's outcome: the full path plans
+        // again and builds, and reports the packages then.
+        if (status == 0 || reported || !is_stale_ninja_failure(out))
+            report.finish(status == 0);
+    } else {
+        // Nobody reads this ninja's progress: it reports no action start
+        // (build progress design 2026-09-29, §6.4).
+        childEnv.emplace_back(std::string(mcpp::build::progress::kStartsEnv), "");
+        auto r = mcpp::platform::process::capture_exec(argv, childEnv);
+        out = std::move(r.output);
+        status = r.exit_code;
+    }
     if (status != 0) {
-        if (is_stale_ninja_failure(out))
+        if (!reported && is_stale_ninja_failure(out))
             return std::nullopt;
-        std::fflush(stdout);
-        mcpp::ui::error("build failed");
-        auto prefixes = read_ninja_command_prefixes(ninjaPath);
-        auto diagnostics = verbose ? out : mcpp::build::filter_ninja_output(out, prefixes);
-        if (!diagnostics.empty()) {
-            std::fputs(diagnostics.c_str(), stderr);
-            if (diagnostics.back() != '\n')
-                std::fputc('\n', stderr);
-        }
+        // A failed step was reported when it failed (and every line, under
+        // --verbose); what remains is the advice below.
+        if (!reported) mcpp::ui::error("build failed");
+        if (!reported && !(reporting && verbose))
+            mcpp::ui::block(verbose ? out : mcpp::build::filter_ninja_output(out, prefixes));
         // Read from the RAW output, not from `diagnostics`: the filter drops
         // command lines, and a future filter change must not be able to
         // silently remove the advice along with them.
         if (auto advice = mcpp::build::link_failure_advice(out); !advice.empty())
-            std::fputs(advice.c_str(), stderr);
+            mcpp::ui::block(advice);
         // mcpp#662, the fast-path form: no `BuildPlan` here to name the C
         // library from (the whole point of this path is skipping `prepare`),
         // so both name arguments are empty — the note still fires (it reads
         // the isolation token in `out` itself) but names no package.
         if (auto advice = mcpp::build::graph_c_library_isolation_advice(out);
             !advice.empty())
-            std::fputs(advice.c_str(), stderr);
+            mcpp::ui::block(advice);
         // #696, the fast-path form of the same unnamed shape.
         if (auto advice = mcpp::build::graph_link_library_advice(out); !advice.empty())
-            std::fputs(advice.c_str(), stderr);
+            mcpp::ui::block(advice);
         // #690: the consumer-include note, from the list the plan wrote beside
         // build.ninja (`write_consumer_include_sidecar`).
         if (auto advice = mcpp::build::consumer_include_scope_advice(
                 out, mcpp::build::read_consumer_include_sidecar(ninjaPath.parent_path()));
             !advice.empty())
-            std::fputs(advice.c_str(), stderr);
+            mcpp::ui::block(advice);
         // THE SAME ADVICE THE PLAN PATH GIVES, FROM THE LIST THE PLAN WROTE
         // DOWN. This path has no `BuildPlan` by construction, so the C
         // library's `[c-abi-absent]` table reaches it through a file beside
@@ -1402,11 +1353,11 @@ std::optional<int> run_ninja_fast(const std::string& ninjaProgram,
                 ninjaPath.parent_path());
             if (auto advice = mcpp::build::c_abi_absent_facility_advice(
                     out, cAbiName, absent); !advice.empty())
-                std::fputs(advice.c_str(), stderr);
+                mcpp::ui::block(advice);
         }
         return 1;
     }
-    if (verbose && !out.empty())
+    if (verbose && !reporting && !out.empty())
         std::fputs(out.c_str(), stdout);
     // What the edges that ran had to say on success: the same reader the full
     // path calls (mcpp.build.advice), because this path skips `prepare` and a
@@ -1561,6 +1512,31 @@ void restore_root_compile_commands(const std::filesystem::path& projectRoot,
     }
 }
 
+// The root compile database of a command that planned configuration groups of
+// a workspace (workspace design 2026-09-29 §15): the union of the groups'
+// databases (one entry per file and output), published once after every
+// group, so the file does not depend on which group's build finished last.
+export void publish_workspace_compile_commands(
+        const std::filesystem::path& wsRoot,
+        const std::vector<std::filesystem::path>& outputDirs) {
+    std::vector<std::filesystem::path> databases;
+    for (auto const& dir : outputDirs) {
+        std::error_code ec;
+        auto db = dir / "compile_commands.json";
+        if (std::filesystem::exists(db, ec) && !ec) databases.push_back(std::move(db));
+    }
+    if (databases.empty()) return;
+    auto result = mcpp::build::publish_root_compile_commands(
+        databases, wsRoot / "compile_commands.json",
+        outputDirs.front().parent_path().parent_path(), mcpp::home::root());
+    if (!result) {
+        mcpp::ui::warning(std::format(
+            "compile_commands.json was not updated: {}", result.error().message));
+    } else if (result->foreignEntries > 0) {
+        mcpp::ui::warning(mcpp::build::foreign_entries_warning(result->foreignEntries));
+    }
+}
+
 // Every xlings payload the entry's build read is still installed (#716). A
 // cache written before the field was recorded declines once.
 bool xlings_payloads_present(const BuildCacheEntry& e) {
@@ -1713,7 +1689,7 @@ export std::optional<int> try_fast_build(const std::filesystem::path& projectRoo
             *validatedBefore))
         return fast_path_declined("build", "ninja relinked an artifact, whose closure the full path validates"); // relinked: full path reconstructs + validates closure
 
-    mcpp::ui::finished(want->profile, elapsed);
+    mcpp::build::progress::finished(want->profile, "");
     return 0;
 }
 
@@ -1806,9 +1782,15 @@ export std::optional<int> try_fast_workspace_build(
         profile = want->profile;
     }
 
-    std::chrono::milliseconds total{};
+    if (ready.size() > 1) {
+        std::vector<std::filesystem::path> dirs;
+        for (auto const& r : ready) dirs.push_back(r.outputDir);
+        publish_workspace_compile_commands(wsRoot, dirs);
+    }
+    // With more than one configuration, a package's line names its own.
+    mcpp::build::progress::configurations(ready.size());
     for (auto& r : ready) {
-        restore_root_compile_commands(wsRoot, r.outputDir);
+        if (ready.size() == 1) restore_root_compile_commands(wsRoot, r.outputDir);
         std::chrono::milliseconds elapsed{};
         auto rc = run_ninja_fast(r.ninjaProgram, r.outputDir, r.outputDir / "build.ninja",
                                  verbose, r.runtimeEnvKey, r.runtimeEnvValue, &elapsed);
@@ -1816,9 +1798,8 @@ export std::optional<int> try_fast_workspace_build(
         if (*rc != 0) return rc;
         if (!mcpp::build::runtime_validation::artifact_snapshot_unchanged(r.validated))
             return fast_path_declined("workspace", "ninja relinked an artifact, whose closure the full path validates");
-        total += elapsed;
     }
-    mcpp::ui::finished(profile, total);
+    mcpp::build::progress::finished(profile, "");
     return 0;
 }
 
@@ -1975,6 +1956,7 @@ std::optional<int> try_fast_run(const std::filesystem::path& projectRoot,
 
     auto exe = outputDir / chosen->second;
     auto pathCtx = mcpp::fetcher::make_path_ctx(/*cfg=*/nullptr, projectRoot);
+    mcpp::build::progress::close();   // the program owns the terminal
     mcpp::ui::status("Running",
         std::format("`{}`", mcpp::ui::shorten_path(exe, pathCtx)));
     std::println("");
@@ -2165,11 +2147,13 @@ int run_artifact_via_runner(mcpp::build::BuildContext& ctx,
                                                              : slotName;
         if (!isRunSlot && !runner_from_format && !verb.empty())
             verb[0] = static_cast<char>(std::toupper(verb[0]));
+        mcpp::build::progress::close();   // the program owns the terminal
         mcpp::ui::status(verb, std::format("`{} … {}`", choice.tmpl.front(),
                                            mcpp::ui::shorten_path(exe, pathCtx)));
     } else {
         argv.push_back(exe.string());
         for (auto& a : passthrough) argv.push_back(a);
+        mcpp::build::progress::close();   // the program owns the terminal
         mcpp::ui::status("Running",
             std::format("`{}`", mcpp::ui::shorten_path(exe, pathCtx)));
     }
@@ -2356,7 +2340,7 @@ export int build_run_target(const std::optional<std::string>& targetName,
         ov2.will_run       = true;
         auto ctx2 = prepare_build(/*print_fp=*/false, /*includeDevDeps=*/false,
                                   /*extraTargets=*/{}, ov2);
-        if (!ctx2) { std::println(stderr, "error: {}", ctx2.error()); return 2; }
+        if (!ctx2) { mcpp::ui::error(std::format("{}", ctx2.error())); return 2; }
         if (auto rc = run_build_plan(*ctx2, /*verbose=*/false, no_cache, target_triple);
             rc != 0)
             return rc;
@@ -2411,7 +2395,7 @@ export int build_run_target(const std::optional<std::string>& targetName,
     ov.will_run       = true;
     auto ctx = prepare_build(/*print_fp=*/false, /*includeDevDeps=*/false,
                              /*extraTargets=*/{}, ov);
-    if (!ctx) { std::println(stderr, "error: {}", ctx.error()); return 2; }
+    if (!ctx) { mcpp::ui::error(std::format("{}", ctx.error())); return 2; }
     // `target_triple` IS PASSED, AND OMITTING IT WROTE A CROSS BUILD INTO
     // THE HOST'S CACHE SLOT.
     //
@@ -2602,6 +2586,9 @@ export int run_tests(std::span<const std::string> passthrough,
     // JSON mode: stdout carries NDJSON only. All ui::status/info lines print
     // to stdout, so silence them wholesale; errors already go to stderr.
     if (json) mcpp::ui::set_quiet(true);
+    // The report covers the planning and the package's own build (Phase A);
+    // it is closed before the tests' own lines.
+    mcpp::build::progress::open(mcpp::log::is_verbose());
 
     auto root = mcpp::project::find_manifest_root(std::filesystem::current_path());
     if (!root) {
@@ -2795,10 +2782,19 @@ export int run_tests(std::span<const std::string> passthrough,
     for (auto& lu : ctx->plan.linkUnits)
         if (lu.kind != mcpp::build::LinkUnit::TestBinary)
             pkgTargets.push_back(lu.output.generic_string());
+    mcpp::build::progress::programs_done();
     if (!pkgTargets.empty()) {
         mcpp::build::BuildOptions aOpts;
         aOpts.ninjaTargets = pkgTargets;
         aOpts.buildTimeoutSecs = static_cast<unsigned>(testOpts.buildTimeoutSecs);
+        // Phase A is the package's own build, and is reported as `mcpp build`
+        // reports one (build progress design 2026-09-29); the tests' own
+        // builds and runs below keep their per-test lines.
+        std::optional<mcpp::build::progress::Build> phaseReport;
+        if (!json && !mcpp::ui::is_quiet()) {
+            phaseReport.emplace(ctx->outputDir);
+            aOpts.progress = &*phaseReport;
+        }
         auto tPhaseA = std::chrono::steady_clock::now();
         auto a = backend->build(ctx->plan, aOpts);
         summary.buildMs += std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -2810,15 +2806,12 @@ export int run_tests(std::span<const std::string> passthrough,
             if (json)
                 std::println("{{\"error\":\"package\",\"compile_output\":\"{}\"}}",
                              test_json_escape(a.error().diagnosticOutput));
-            mcpp::ui::error(a.error().message);
             // Surface the compiler/linker stderr (parity with run_build_plan) —
             // otherwise `mcpp test` failures show only "build failed" with no
-            // diagnostic, which is undebuggable (notably on CI).
-            if (!a.error().diagnosticOutput.empty()) {
-                std::fputs(a.error().diagnosticOutput.c_str(), stderr);
-                if (a.error().diagnosticOutput.back() != '\n')
-                    std::fputc('\n', stderr);
-            }
+            // diagnostic, which is undebuggable (notably on CI). A failed step
+            // was reported when it failed.
+            if (!a.error().reported) mcpp::ui::error(a.error().message);
+            mcpp::ui::block(a.error().diagnosticOutput);
             return 1;
         }
 
@@ -2837,6 +2830,8 @@ export int run_tests(std::span<const std::string> passthrough,
         // prerequisites. Printing a success banner right before per-test
         // failures read as a contradiction; the final summary carries timing.
     }
+    // The tests' own lines follow, as they always have.
+    mcpp::build::progress::close();
 
     // 6. Phase B. First a single keep-going bulk build over every selected
     //    test goal — ninja parallelizes across tests and a failing test does
diff --git a/src/build/ninja_backend.cppm b/src/build/ninja_backend.cppm
index 5f9bf9149..18a594189 100644
--- a/src/build/ninja_backend.cppm
+++ b/src/build/ninja_backend.cppm
@@ -46,6 +46,7 @@ import mcpp.xlings;
 import mcpp.platform;
 import mcpp.ui;
 import mcpp.log;
+import mcpp.build.progress;
 
 export namespace mcpp::build {
 
@@ -72,10 +73,35 @@ std::string emit_ninja_string(const BuildPlan& plan);
 // The same, and when the plan places two or more files beside its programs,
 // the placement list the one `stage_list` edge reads (#734 E4), for the caller
 // to write as `<outputDir>/placements.list`. Empty when there is no such edge.
-std::string emit_ninja_string(const BuildPlan& plan, std::string* placements);
+std::string emit_ninja_string(const BuildPlan& plan, std::string* placements,
+                              mcpp::build::progress::Attribution* attribution = nullptr);
 std::string filter_ninja_output(std::string_view output,
                                 std::span<const std::string> commandPrefixes);
 
+// One ninja run read line by line into its build's report (build progress
+// design 2026-09-29, §6.1). `argv` must not carry `--quiet`: the status lines
+// are the report's clock. A failed step is reported when ninja prints it: its
+// package's line, `error: build failed` once per command, and the step's
+// diagnostics filtered as `filter_ninja_output` filters them (every line
+// under `verbose`, which also prints each step as `[f/t] <command>`).
+struct NinjaRun {
+    int         exitCode   = 0;
+    bool        timedOut   = false;
+    std::string output;             // every line ninja wrote
+    bool        reported   = false; // a failed step was reported as it failed
+};
+NinjaRun run_ninja_reporting(const std::vector<std::string>& argv,
+                             std::vector<std::pair<std::string, std::string>> env,
+                             std::chrono::milliseconds deadline,
+                             mcpp::build::progress::Build& progress,
+                             bool verbose,
+                             std::span<const std::string> commandPrefixes);
+
+// The step record of a plan (design §6.3): how the plan names its packages,
+// and which package each statement of `attribution` is for.
+mcpp::build::progress::Record step_record(const BuildPlan& plan,
+                                          const mcpp::build::progress::Attribution& attribution);
+
 // The link flags one executable's `windows_subsystem` / `windows_entry` render
 // to (#618). Empty on every object format other than PE, and for the pair of
 // defaults. `sep` is `LinkStyle::SeparateLinker`, as for `pe_link_flag`.
@@ -1113,6 +1139,9 @@ std::string filter_ninja_output(std::string_view output,
         if (trimmed.starts_with("ninja: Entering directory")
             || trimmed.starts_with("ninja: build stopped")
             || is_ninja_progress_line(trimmed)
+            // The report's status marker (build progress design 2026-09-29),
+            // and a nested ninja's copy of it, its escape sequence stripped.
+            || trimmed.starts_with("\x1b[0m@@mcpp ") || trimmed.starts_with("@@mcpp ")
             || is_command_line(trimmed, commandPrefixes)) {
             continue;
         }
@@ -1141,6 +1170,64 @@ std::string filter_ninja_output(std::string_view output,
     return filtered;
 }
 
+NinjaRun run_ninja_reporting(const std::vector<std::string>& argv,
+                             std::vector<std::pair<std::string, std::string>> env,
+                             std::chrono::milliseconds deadline,
+                             mcpp::build::progress::Build& progress,
+                             bool verbose,
+                             std::span<const std::string> commandPrefixes) {
+    NinjaRun run;
+    for (auto& kv : progress.environment()) env.push_back(std::move(kv));
+    progress.pass_begin();
+    // The lines after `FAILED:` up to the next status line are the failed
+    // step's command and output; the lines after a status line alone are a
+    // successful step's output, which only --verbose shows (as before).
+    bool inFailure = false;
+    auto on_line = [&](std::string_view line) {
+        // A status line is the report's, not ninja's output: the advice and
+        // the failure report read `output`, and must not see the markers.
+        if (auto st = mcpp::build::progress::parse_status(line)) {
+            inFailure = false;
+            progress.status(*st);
+            if (verbose)
+                mcpp::ui::line(std::format("[{}/{}] {}", st->finished, st->total, st->text));
+            return;
+        }
+        run.output.append(line).push_back('\n');
+        auto trimmed = line;
+        while (!trimmed.empty() && (trimmed.front() == ' ' || trimmed.front() == '\t'))
+            trimmed.remove_prefix(1);
+        if (trimmed.starts_with("FAILED:")) {
+            inFailure = true;
+            if (progress.failed(trimmed.substr(std::string_view("FAILED:").size())))
+                mcpp::ui::error("build failed");
+            run.reported = true;
+        }
+        if (inFailure) {
+            if (verbose) mcpp::ui::block(line);
+            else if (auto f = filter_ninja_output(line, commandPrefixes); !f.empty())
+                mcpp::ui::block(f);
+            return;
+        }
+        if (verbose) mcpp::ui::line(line);
+    };
+    // A ninja that cannot be started is reported through `on_line`, into the
+    // output the failure report reads.
+    run.exitCode = mcpp::platform::process::stream_exec(argv, env, deadline, on_line,
+                                                        &run.timedOut);
+    progress.pass_end();
+    return run;
+}
+
+mcpp::build::progress::Record step_record(const BuildPlan& plan,
+                                          const mcpp::build::progress::Attribution& attribution) {
+    std::vector<mcpp::build::progress::PackageInfo> declared;
+    declared.reserve(plan.packages.size());
+    for (auto const& p : plan.packages)
+        declared.push_back({p.name, p.requested, p.subject, p.cachedUnits, 0});
+    return attribution.record(declared);
+}
+
 // The aggregate target for everything staged out of the global cache. Named
 // with a leading underscore so it cannot collide with a module or target name
 // (both of which are identifiers or paths).
@@ -1150,7 +1237,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     return emit_ninja_string(plan, nullptr);
 }
 
-std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
+std::string emit_ninja_string(const BuildPlan& plan, std::string* placements,
+                              mcpp::build::progress::Attribution* attribution) {
     // dyndep requires P1689 scanning capability:
     //   GCC: built-in -fdeps-format=p1689r5
     //   Clang: external clang-scan-deps tool (same P1689 output format)
@@ -1181,7 +1269,13 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
                        && !traits.bmiOnlyFlags.empty();
     const auto& dial = mcpp::toolchain::dialect_for(plan.toolchain);
     std::string out;
-    auto append = [&](std::string s) { out += std::move(s); };
+    auto append = [&](std::string s) {
+        if (attribution) attribution->statement(s);
+        out += std::move(s);
+    };
+    auto attribute = [&](std::string_view package) {
+        if (attribution) attribution->owner(package);
+    };
 
     append("# Auto-generated by mcpp v0.0.1. Do not edit by hand.\n");
     // #407: the graph declares which mode produced it, because three modes
@@ -2106,6 +2200,9 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     auto ios_init_src = std::filesystem::path("obj") / "mcpp_ios_init.c";
     auto ios_init_obj = std::filesystem::path("obj")
                       / std::format("mcpp_ios_init{}", dial.objExt);
+    // Each statement is recorded with the package it is for (build progress
+    // design 2026-09-29, §6.3); the shim is the build's own.
+    attribute("");
     if (need_ios_init_shim) {
         append(std::format("build {} : ios_init_object {}\n",
                            escape_ninja_path(ios_init_obj),
@@ -2180,6 +2277,8 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     auto unit_needs_cxx_runtime = [&](const LinkUnit& lu) {
         return mcpp::build::link_unit_holds_cxx(plan, lu);
     };
+    // The standard library module is a dependency of the build: `std`.
+    attribute("std");
     if (has_std_artifacts) {
         append(std::format("build {} : stage_file {}\n", escape_ninja_path(std_bmi_dst),
                            escape_ninja_path(plan.stdBmiPath)));
@@ -2195,6 +2294,9 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
                         / std::format("std.compat{}", traits.bmiExt);
     auto compat_o_dst = std::filesystem::path("obj")
                       / std::format("std.compat{}", dial.objExt);
+    // `std.compat` is built only when something imports it, so it belongs to
+    // no package: a step that never runs would keep its package open (§3.2).
+    attribute("");
     if (has_std_compat) {
         // std.compat.pcm depends on std.pcm — ensure std.pcm is staged first
         // so clang can resolve the transitive dependency when loading std.compat.pcm.
@@ -2308,6 +2410,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     {
         std::vector<std::string> staged;
         for (auto& cu : plan.compileUnits) {
+            attribute(cu.packageName);
             if (!cu.servedFromCache) continue;
             if (cu.cachedObject.empty()) continue;
             auto obj = escape_ninja_path(cu.object);
@@ -2424,12 +2527,15 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
         // -fmodules which is exactly what C support is here to avoid.
         std::vector<std::string> ddi_paths;
         ddi_paths.reserve(plan.compileUnits.size());
+        std::unordered_map<std::string, std::string> ddiOwner;
         for (auto& cu : plan.compileUnits) {
+            attribute(cu.packageName);
             if (cu.servedFromCache) continue;   // staged, never scanned
             if (is_scan_exempt(cu))
                 continue;
             auto ddi = (cu.object.parent_path() / cu.source.filename()).string() + ".ddi";
             ddi_paths.push_back(ddi);
+            ddiOwner[ddi] = cu.packageName;
             append(std::format("build {} : cxx_scan {}{}\n", escape_ninja_path(ddi),
                                escape_ninja_path(cu.source), order_only_for(cu)));
             // `-o` and `-fdeps-target` are DIFFERENT under the split shape and
@@ -2527,6 +2633,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
             }
         }
         for (auto& ddi : ddi_paths) {
+            attribute(ddiOwner[ddi]);
             auto dd = ddi + ".dd";   // e.g. obj/cli.cppm.ddi.dd
             ddi_to_dd[ddi] = dd;
             append(std::format("build {} : cxx_dyndep {}\n", dd, ddi));
@@ -2541,6 +2648,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
         // Each compile edge references its OWN .dd file instead of a global one.
         // P2: module compile edges get a $bmi_out variable for BMI preservation.
         for (auto& cu : plan.compileUnits) {
+            attribute(cu.packageName);
             if (cu.servedFromCache) continue;   // a stage_file edge owns these outputs
             std::string rule = pick_rule(cu);
 
@@ -2683,6 +2791,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     } else {
         // ── Static-deps mode (M3.2 and earlier). ────────────────────────
         for (auto& cu : plan.compileUnits) {
+            attribute(cu.packageName);
             if (cu.servedFromCache) continue;   // a stage_file edge owns these outputs
             std::string rule = pick_rule(cu);
 
@@ -2745,6 +2854,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     // path smuggled through ldflags that this replaces, editing the icon or the
     // script now actually reaches the linker.
     for (auto const& ru : plan.resourceUnits) {
+        attribute(ru.package);
         std::string implicit;
         for (auto const& in : ru.implicitInputs)
             implicit += " " + escape_ninja_path(in);
@@ -2776,6 +2886,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
 
     // Link units
     for (auto& lu : plan.linkUnits) {
+        attribute(lu.package);
         // A member's unit reads its link group's flags (§15); every other
         // unit reads the plan's.
         const auto& uflags = lu.linkGroup >= 0
@@ -3092,6 +3203,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     // exactly one source (every project before this feature, and most
     // packages after it) emits the exact same line as always: the loop below
     // reduces to the one-word case with no change in spelling.
+    attribute("");
     if (placedFiles.size() >= 2) {
         // #734 E4: one edge for the whole list. One entry keeps the per-file
         // edge below, byte for byte.
@@ -3147,6 +3259,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
     // incrementality.
     std::string actionDefaults;
     for (std::size_t i = 0; i < plan.actions.size(); ++i) {
+        attribute(plan.actions[i].packageName);
         auto const& a = plan.actions[i];
         std::string cmd;
         for (auto const& tok : a.command) {
@@ -3280,6 +3393,11 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
         for (auto const& o : a.outputs) outs += " " + escape_ninja_path(o);
         for (auto const& in : a.inputs) ins += " " + escape_ninja_path(in);
         append(std::format("build{} : mcpp_action_{}{}\n", outs, i, ins));
+        // A check or prepare action reports its start through the wrapper,
+        // by its first output (design §6.4); the record gives it its label.
+        if (attribution && stamped)
+            attribution->action(std::filesystem::path(a.outputs.front()).generic_string(),
+                                a.description.empty() ? a.id : a.description);
         append("\n");
         // A Source action's outputs are reachable through the phony its
         // package's compile edges name, and an Object action's through the
@@ -3769,8 +3887,16 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
                                  : std::vector<mcpp::targetside::CAbiAbsentEntry>{});
     write_consumer_include_sidecar(plan.outputDir, root_include_dirs_of(plan));
     std::string placements;
-    auto manifest = emit_ninja_string(plan, &placements);
+    mcpp::build::progress::Attribution attribution;
+    auto manifest = emit_ninja_string(plan, &placements, &attribution);
     stage("emit-ninja");
+    // The step record, beside build.ninja like the other files the fast path
+    // reads (build progress design 2026-09-29, §6.3).
+    {
+        auto record = step_record(plan, attribution);
+        mcpp::build::progress::write_record(plan.outputDir, record);
+        if (opts.progress) opts.progress->set_record(std::move(record));
+    }
     if (!placements.empty()) {
         // Written only when it changes: it is an input of the placement edge.
         const auto listPath = plan.outputDir / "placements.list";
@@ -4026,7 +4152,9 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
     // the runtime env to the child ONLY — so a bundled-glibc LD_LIBRARY_PATH
     // can never poison the host shell (the newer-glibc `sh:` crash class).
     std::vector<std::string> nargv{ninjaProgram};
-    if (!opts.verbose)
+    // With a report, ninja's status lines are read as it runs (build progress
+    // design 2026-09-29, §6.1), so they are not suppressed.
+    if (!opts.verbose && !opts.progress)
         nargv.push_back("--quiet");
     nargv.push_back("-C");
     nargv.push_back(plan.outputDir.string());
@@ -4086,20 +4214,45 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
     if (manifest.find("\nbuild " + std::string(kStagedCacheGoal) + " : phony") != std::string::npos) {
         std::vector<std::string> pre{ninjaProgram, "--quiet", "-C", plan.outputDir.string(),
                                      std::string(kStagedCacheGoal)};
-        (void)mcpp::platform::process::capture_exec_deadline(pre, nenv,
+        // A ninja whose progress nobody reads reports no action start, not
+        // even into the file of a build that runs this one (design §6.4).
+        auto preEnv = nenv;
+        preEnv.emplace_back(std::string(mcpp::build::progress::kStartsEnv), "");
+        (void)mcpp::platform::process::capture_exec_deadline(pre, preEnv,
             std::chrono::milliseconds(static_cast<long long>(opts.buildTimeoutSecs) * 1000),
             nullptr);
         stage("ninja-staged-cache");
     }
 
     bool buildTimedOut = false;
-    auto cap = mcpp::platform::process::capture_exec_deadline(
-        nargv, nenv,
-        std::chrono::milliseconds(static_cast<long long>(opts.buildTimeoutSecs) * 1000),
-        &buildTimedOut);
+    bool reported = false;
+    std::string out;
+    int ninjaExit = 0;
+    const auto deadline =
+        std::chrono::milliseconds(static_cast<long long>(opts.buildTimeoutSecs) * 1000);
+    if (opts.progress) {
+        auto run = run_ninja_reporting(nargv, nenv, deadline, *opts.progress, opts.verbose,
+                                       command_prefixes(flags, plan));
+        out = std::move(run.output);
+        ninjaExit = run.exitCode;
+        buildTimedOut = run.timedOut;
+        reported = run.reported;
+    } else {
+        auto quietEnv = nenv;
+        quietEnv.emplace_back(std::string(mcpp::build::progress::kStartsEnv), "");
+        auto cap = mcpp::platform::process::capture_exec_deadline(
+            nargv, quietEnv, deadline, &buildTimedOut);
+        out = std::move(cap.output);
+        ninjaExit = cap.exit_code;
+    }
     stage("ninja");
-    std::string out = cap.output;
-    bool ok = (cap.exit_code == 0) && !buildTimedOut;
+    bool ok = (ninjaExit == 0) && !buildTimedOut;
+    // Every package gets its final line before what the build has to say
+    // after ninja: validations, advice, `Finished`.
+    if (opts.progress) {
+        opts.progress->finish(ok);
+        if (ok) mcpp::build::progress::checking();
+    }
 
     if (buildTimedOut) {
         // Report as a build failure with the partial ninja output attached —
@@ -4108,9 +4261,14 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
         r.exitCode = 1;
         r.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::steady_clock::now() - t0);
+        // Under a report the failed steps were written as they failed, and
+        // under --verbose every line was: only what is left is attached.
+        std::string partial = !opts.progress ? out
+            : reported || opts.verbose ? std::string{}
+            : filter_ninja_output(out, command_prefixes(flags, plan));
         return std::unexpected(BuildError{
             std::format("build timed out after {}s", opts.buildTimeoutSecs),
-            plan.outputDir / "build.ninja", out, /*timedOut=*/true});
+            plan.outputDir / "build.ninja", std::move(partial), /*timedOut=*/true});
     }
 
     r.exitCode = ok ? 0 : 1;
@@ -4232,7 +4390,8 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
                 "see docs/05 `[build] dependency_linkage`");
         }
         stage("symbol-provision");
-        if (opts.verbose && !out.empty())
+        // Under a report the lines were printed as ninja wrote them.
+        if (opts.verbose && !opts.progress && !out.empty())
             std::fputs(out.c_str(), stdout);
         std::set<std::string> want(opts.ninjaTargets.begin(), opts.ninjaTargets.end());
         for (auto& lu : plan.linkUnits) {
@@ -4244,7 +4403,10 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
         }
     } else {
         auto prefixes = command_prefixes(flags, plan);
-        auto diagnostics = opts.verbose ? out : filter_ninja_output(out, prefixes);
+        // What was reported as it happened is not repeated: a failed step's
+        // diagnostics (default output), or every line (--verbose).
+        auto diagnostics = reported || (opts.progress && opts.verbose) ? std::string{}
+                         : opts.verbose ? out : filter_ninja_output(out, prefixes);
         // Appended here as well as on the fast path (execute.cppm): the two
         // paths report failure through different channels, and advice attached
         // to only one of them would appear or not depending on whether
@@ -4267,8 +4429,10 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
                 plan.targetSide.cAbiDecl->absent);
         // (the fast path reads the same list from the sidecar this build
         // wrote beside build.ninja — see `write_c_abi_absent_sidecar`)
-        return std::unexpected(BuildError{"build failed", plan.outputDir / "build.ninja",
-                                          std::move(diagnostics)});
+        BuildError failure{"build failed", plan.outputDir / "build.ninja",
+                           std::move(diagnostics)};
+        failure.reported = reported;
+        return std::unexpected(std::move(failure));
     }
     return r;
 }
diff --git a/src/build/plan.cppm b/src/build/plan.cppm
index dba12722b..4a22362aa 100644
--- a/src/build/plan.cppm
+++ b/src/build/plan.cppm
@@ -88,6 +88,11 @@ struct CompileUnit {
 
 struct LinkUnit {
     std::string                     targetName;
+    // The package the unit belongs to (qualified name): the root's, a
+    // member's, or the dependency's whose library or program it is. The build
+    // report attributes the link step to it (build progress design
+    // 2026-09-29, §6.3).
+    std::string                     package;
     enum Kind { Binary, StaticLibrary, SharedLibrary, TestBinary } kind = Binary;
     // Does this image belong to a DEPENDENCY rather than to the package being
     // built? A `kind = "shared"` dependency contributes a link unit to the
@@ -169,6 +174,8 @@ struct LinkUnit {
 // string in the link command, so a `.res` named there is invisible to ninja and
 // changing it produced "no work to do".
 struct ResourceUnit {
+    // The package whose `[resources]` declared the script (qualified name).
+    std::string                        package;
     std::filesystem::path              source;    // absolute; synthesised ones live under outputDir
     std::filesystem::path              output;    // relative to plan.outputDir
     // The `.rc`'s own inputs: quoted #includes and the data files named by its
@@ -286,8 +293,22 @@ std::optional<RecoveredInvocation> recover_invocation(
     const std::filesystem::path& defaultDirectory,
     bool windows);
 
+// How the build's report names a package of the plan (build progress design
+// 2026-09-29, §4.2, §6.3): the qualified name the plan's units carry, whether
+// the command asked for it (the root, or a selected member), the subject of
+// its line, and the units the global cache supplied.
+struct PlanPackage {
+    std::string name;
+    bool        requested   = false;
+    std::string subject;
+    std::size_t cachedUnits = 0;
+};
+
 struct BuildPlan {
     mcpp::manifest::Manifest        manifest;
+    // Every package of the graph, as the report names it; the backend writes
+    // the step record from it and from the statements it emits.
+    std::vector<PlanPackage>        packages;
     // Packages whose declared `[build] c_standard` the compiler does not apply,
     // spelt `<package> (<standard>)`, in the order their first C unit appears.
     // Filled only for cl.exe (W3b of the #693-#696 record) and reported once by
@@ -375,6 +396,11 @@ struct BuildPlan {
     // (possibly read-only) registry directory, and deriving the path would put
     // an IDE database there. Empty → projectRoot, the historical default.
     std::filesystem::path           compileDbPath;
+    // Whether writing this plan's compile database also publishes the root
+    // copy. False for each plan of a command that planned several
+    // configurations, which publishes the root file itself, once, from all of
+    // them (`publish_root_compile_commands` over a list).
+    bool                            publishRootCompileDb = true;
     // See StdModuleUnit above. Empty when the build does not import `std`.
     std::vector<StdModuleUnit>      stdModuleUnits;
     // GCC only: a specs file that replaces the pristine `*link:`, so the
@@ -2379,6 +2405,7 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
     for (auto const& dep : sharedDepTargets) {
         LinkUnit lu;
         lu.targetName = dep.target.name;
+        lu.package    = dep.packageName;
         lu.kind       = LinkUnit::SharedLibrary;
         lu.dependencyOwned = true;
         lu.output     = dep.output;
@@ -2505,6 +2532,7 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
         if (inTestMode && t.kind != mcpp::manifest::Target::TestBinary) continue;
         LinkUnit lu;
         lu.targetName = t.name;
+        lu.package    = qualified_package_name(manifest);
         if (t.kind == mcpp::manifest::Target::Library) {
             lu.kind   = LinkUnit::StaticLibrary;
             lu.output = target_output(t, naming);
@@ -2709,6 +2737,7 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
         const auto owner = qualified_package_name(pkg.manifest);
         LinkUnit lu;
         lu.targetName      = r.target.name;
+        lu.package         = owner;
         lu.kind            = LinkUnit::Binary;
         lu.dependencyOwned = true;
         lu.artifactOf      = owner;
@@ -2926,6 +2955,7 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
             }
             LinkUnit lu;
             lu.targetName = t.name;
+            lu.package    = owner;
             lu.memberOf   = owner;
             lu.linkGroup  = groupIndex;
             if (t.kind == mcpp::manifest::Target::Library) {
diff --git a/src/build/prepare.cppm b/src/build/prepare.cppm
index 2b30c8aa5..0e33e6cd7 100644
--- a/src/build/prepare.cppm
+++ b/src/build/prepare.cppm
@@ -641,6 +641,10 @@ export struct BuildOverrides {
     // Every member the COMMAND selected, across its configuration groups: the
     // request a fast-path record names. Empty: `workspace_members`.
     std::vector<std::string> workspace_request;
+    // The test targets each member of `workspace_members` receives, by member
+    // path: what `extraTargets` is for a plan of one member, for a plan of
+    // several (`--configure-only`, `mcpp emit build-database`).
+    std::map<std::string, std::vector<mcpp::manifest::Target>> member_targets;
     // --profile <name>. Empty = fall through to `[build] default-profile`, then
     // to `profile_fallback` below, whose own default is "dev". The comment here
     // said "release" for as long as `mcpp build --help` did, and neither had
diff --git a/src/build/prepare/features.cpp b/src/build/prepare/features.cpp
index d2b0f68b5..fefc5a4d6 100644
--- a/src/build/prepare/features.cpp
+++ b/src/build/prepare/features.cpp
@@ -1887,6 +1887,7 @@ static std::expected<void, std::string> step6_dependency_build_programs(PrepareS
             bpEnv.packStageDir = state.overrides.pack_stage_dir;
             bpEnv.packStrip           = state.overrides.pack_strip;
             bpEnv.packDebugSymbolsDir = state.overrides.pack_debug_symbols_dir;
+            bpEnv.requested       = pkg.selectedMember;
             bpEnv.languageModules = pkg.manifest.language.modules;
             bpEnv.ruleModules  = pkg.manifest.buildConfig.ruleModules;
             if (auto dit = state.deviceSourcesByPackage.find(pkg.root.string()); dit != state.deviceSourcesByPackage.end())
diff --git a/src/build/prepare/graph.cpp b/src/build/prepare/graph.cpp
index 9364e07c1..39bcb6983 100644
--- a/src/build/prepare/graph.cpp
+++ b/src/build/prepare/graph.cpp
@@ -1763,9 +1763,13 @@ step4b_finalize_dependency(PrepareState& state, WorklistItemCtx& ctx) {
                                  && spec.artifacts.empty() && !selectedMember;
         // A root receives the profile's own compile flags; in a workspace plan
         // each selected member does, as it did when it was the root. The
-        // tests `mcpp test` discovered are the selected member's targets.
+        // tests `mcpp test` discovered are the selected member's targets; a
+        // plan of several members receives each member's own.
         if (selectedMember && state.selectedMembers.size() == 1)
             for (auto const& t : state.extraTargets) ctx.dep_manifest->targets.push_back(t);
+        if (selectedMember)
+            if (auto t = state.memberTargets.find(*selectedMember); t != state.memberTargets.end())
+                for (auto const& target : t->second) ctx.dep_manifest->targets.push_back(target);
         if (selectedMember) {
             auto& mbc = ctx.dep_manifest->buildConfig;
             mbc.cflags.insert(mbc.cflags.end(), state.profileCflags.begin(),
diff --git a/src/build/prepare/manifest.cpp b/src/build/prepare/manifest.cpp
index 5be45e054..4b22bbba9 100644
--- a/src/build/prepare/manifest.cpp
+++ b/src/build/prepare/manifest.cpp
@@ -184,6 +184,8 @@ select_workspace_members(PrepareState& state, const std::filesystem::path& wsRoo
         auto canonical = std::filesystem::weakly_canonical(dir, canonEc);
         if (canonEc) canonical = dir;
         state.selectedMembers[canonical] = mcpp::project::product_directory_name(all, mp);
+        if (auto t = state.overrides.member_targets.find(mp); t != state.overrides.member_targets.end())
+            state.memberTargets[canonical] = t->second;
         auto member = mcpp::project::load_member_manifest(*state.wsManifest, wsRoot, mp);
         if (!member) return std::unexpected(member.error());
         if (auto r = refuse_unknown_capability(*member, dir / "mcpp.toml"); !r)
diff --git a/src/build/prepare/plan.cpp b/src/build/prepare/plan.cpp
index 7c2257544..20edaca1b 100644
--- a/src/build/prepare/plan.cpp
+++ b/src/build/prepare/plan.cpp
@@ -89,6 +89,8 @@ namespace mcpp::build {
 // names are this file's own, not part of mcpp.build.prepare's surface;
 // the two records steps live in records.cpp and are declared in `:state`.
 
+static void step13_report_packages(PrepareState& state, BuildContext& ctx);
+
 static std::expected<void, std::string> step13_source_packages(PrepareState& state, BuildContext& ctx) {
     {
         std::error_code ec;
@@ -812,7 +814,8 @@ static void step13_graph_and_schedule(PrepareState& state, BuildContext& ctx) {
     // own target, and the output directory is shared with plain builds because
     // the fingerprint covers neither input. Stamping it on the plan is what
     // lets the graph say so about itself.
-    ctx.plan.graphShape = (state.includeDevDeps || !state.extraTargets.empty())
+    ctx.plan.graphShape = (state.includeDevDeps || !state.extraTargets.empty()
+                           || !state.memberTargets.empty())
         ? mcpp::build::GraphShape::WithTests
         : mcpp::build::GraphShape::Normal;
     // The device variant an override chose is stamped for the same reason: the
@@ -1603,6 +1606,7 @@ static std::expected<void, std::string> step13_windows_resources(PrepareState& s
                             "[resources] two resource scripts are named '{}.rc'; "
                             "they would produce the same artifact. Rename one.", stem));
                     mcpp::build::ResourceUnit ru;
+                    ru.package = mcpp::build::qualified_package_name(M);
                     ru.source = src;
                     ru.output = resRel / (std::string(stem) + std::string(outExt));
                     ru.includeDirs = rcIncludes;
@@ -2281,11 +2285,66 @@ std::expected<BuildContext, std::string> phase13_finish(PrepareState& state) {
     if (auto r = step13_abi_enforcement(state, ctx); !r) return std::unexpected(r.error());
     step13_resolution_json(state, ctx);
     if (auto r = step13_empty_link_check(state, ctx); !r) return std::unexpected(r.error());
+    step13_report_packages(state, ctx);
 
     ctx.planNotes = std::move(state.planNotes);
     return ctx;
 }
 
+// How the report names each package of the plan (build progress design
+// 2026-09-29, §4.2): as the requester wrote its key, with where it comes from.
+// A package is named after the edge from the root (or the virtual root) when
+// there is one, and after its first requester otherwise.
+static void step13_report_packages(PrepareState& state, BuildContext& ctx) {
+    std::vector<mcpp::build::PlanPackage> out;
+    out.reserve(state.packages.size());
+    const auto base = ctx.projectRoot.lexically_normal();
+    for (std::size_t i = 0; i < state.packages.size(); ++i) {
+        const auto& pkg = state.packages[i];
+        const auto& m = pkg.manifest;
+        mcpp::build::PlanPackage p;
+        p.name = mcpp::build::qualified_package_name(m);
+        if (i == 0) {
+            if (m.package.virtualRoot) continue;
+            p.requested = true;
+            p.subject = std::format("{} v{} (.)", m.package.name, m.package.version);
+            out.push_back(std::move(p));
+            continue;
+        }
+        p.requested = pkg.selectedMember;
+        const GraphRequest* edge = nullptr;
+        for (auto const& r : state.graphRequests) {
+            if (r.dependencyPackageIndex != i || r.consumerPackageIndex == i) continue;
+            if (!edge || r.consumerPackageIndex == 0) edge = &r;
+            if (r.consumerPackageIndex == 0) break;
+        }
+        const std::string key = edge ? edge->key : p.name;
+        const mcpp::manifest::DependencySpec* spec = nullptr;
+        if (edge) {
+            const auto& deps = state.packages[edge->consumerPackageIndex].manifest.dependencies;
+            if (auto it = deps.find(key); it != deps.end()) spec = &it->second;
+        }
+        std::string origin;
+        if (pkg.selectedMember || (spec && spec->workspaceMember)) {
+            auto rel = pkg.root.lexically_normal().lexically_relative(base).generic_string();
+            origin = std::format("({})", rel.empty() ? std::string(".") : rel);
+        } else if (spec && spec->isPath()) {
+            origin = "(path)";
+        } else if (spec && spec->isGit()) {
+            std::string ref = spec->gitRev;
+            if (spec->gitRefKind == "rev" && ref.size() > 12) ref.resize(12);
+            origin = std::format("(git {} {})", spec->gitRefKind.empty() ? "rev" : spec->gitRefKind, ref);
+        } else if (!m.package.version.empty()) {
+            origin = "v" + m.package.version;
+        }
+        p.subject = origin.empty() ? key : std::format("{} {}", key, origin);
+        for (auto const& c : ctx.cachedDeps)
+            if (c.name == p.name) p.cachedUnits = c.units;
+        out.push_back(std::move(p));
+    }
+    ctx.plan.packages = std::move(out);
+}
+
 void focus_on_member(BuildContext& ctx) {
     if (ctx.workspaceMembers.size() != 1) return;
     auto& m = ctx.workspaceMembers.front();
diff --git a/src/build/prepare/records.cpp b/src/build/prepare/records.cpp
index 4484d9237..e3a41e15c 100644
--- a/src/build/prepare/records.cpp
+++ b/src/build/prepare/records.cpp
@@ -431,7 +431,7 @@ void step13_resolution_json(PrepareState& state, BuildContext& ctx) {
         {
             nlohmann::json graphPackages = nlohmann::json::array();
             for (std::size_t i = 0; i < state.packages.size(); ++i)
-                graphPackages.push_back(state.graph_package_entry(i, /*forBuildProgram=*/false));
+                graphPackages.push_back(state.graph_package_entry(i, /*forBuildProgram=*/false, nullptr));
             j["graph"] = { {"packages", std::move(graphPackages)} };
         }
 
diff --git a/src/build/prepare/state.cppm b/src/build/prepare/state.cppm
index 7706704dc..a7d026011 100644
--- a/src/build/prepare/state.cppm
+++ b/src/build/prepare/state.cppm
@@ -300,6 +300,9 @@ struct PrepareState {
     // declares the dependency key: the forwards its edges receive.
     std::map<std::filesystem::path, std::vector<std::pair<std::string, std::string>>>
         memberCliForwards;
+    // The test targets a selected member receives (`BuildOverrides::
+    // member_targets`), by the same key.
+    std::map<std::filesystem::path, std::vector<mcpp::manifest::Target>> memberTargets;
     // The profile's own compile flags (`[profile.<name>] cflags`/`cxxflags`),
     // which a root receives; in a workspace plan every selected member does.
     std::vector<std::string> profileCflags, profileCxxflags;
@@ -523,7 +526,9 @@ struct PrepareState {
     std::filesystem::path stdCompatObjectPath;
     std::optional<mcpp::toolchain::StdModuleDescription> describedStdModule;
     std::string stdFlagAndDialect;
-    std::function<nlohmann::json(std::size_t, bool)> graph_package_entry;
+    // The entry of package `i`; with `requesters`, only the requests made by
+    // the packages it marks (a build program's closure).
+    std::function<nlohmann::json(std::size_t, bool, const std::vector<bool>*)> graph_package_entry;
     mcpp::modgraph::ScanResult scan;
     mcpp::modgraph::ValidateReport report;
 };
diff --git a/src/build/prepare/target_side.cpp b/src/build/prepare/target_side.cpp
index dd5348f73..bc8e2adf0 100644
--- a/src/build/prepare/target_side.cpp
+++ b/src/build/prepare/target_side.cpp
@@ -18,6 +18,8 @@ import mcpp.log;
 import mcpp.manifest;
 import mcpp.source_kind;
 import mcpp.modgraph.glob;
+import mcpp.graph;
+import mcpp.build.progress;   // the members' programs wait in order (design 2026-09-29 §4.2)
 import mcpp.modgraph.graph;
 import mcpp.modgraph.scanner;
 import mcpp.modgraph.validate;
@@ -1436,7 +1438,8 @@ static void step9_define_graph_package_entry_closure(PrepareState& state) {
     //
     // The link form is read from `dependencyLinkForms`, which is computed once,
     // before this point, for exactly this program (#642 E2).
-    state.graph_package_entry = [&](std::size_t i, bool forBuildProgram) {
+    state.graph_package_entry = [&](std::size_t i, bool forBuildProgram,
+                                    const std::vector<bool>* requesters) {
         auto const& pm = state.packages[i].manifest;
         const auto id = mcpp::manifest::package_id(pm.package);
         nlohmann::json entry = {
@@ -1452,6 +1455,8 @@ static void step9_define_graph_package_entry_closure(PrepareState& state) {
         nlohmann::json requests = nlohmann::json::array();
         for (auto const& r : state.graphRequests) {
             if (r.dependencyPackageIndex != i) continue;
+            if (requesters && (r.consumerPackageIndex >= requesters->size()
+                               || !(*requesters)[r.consumerPackageIndex])) continue;
             requests.push_back({
                 {"requester", mcpp::manifest::package_id(
                     state.packages[r.consumerPackageIndex].manifest.package).canonical()},
@@ -1630,7 +1635,7 @@ static std::expected<void, std::string> step9_root_build_program(PrepareState& s
             doc["kind"] = "mcpp.graph";
             doc["version"] = 1;
             nlohmann::json list = nlohmann::json::array();
-            for (auto i : order) list.push_back(state.graph_package_entry(i, true));
+            for (auto i : order) list.push_back(state.graph_package_entry(i, true, nullptr));
             doc["packages"] = std::move(list);
             const auto text = doc.dump(2) + "\n";
             const auto graphPath = bpEnv.artifactsDir / "graph.json";
@@ -1669,6 +1674,8 @@ static std::expected<void, std::string> step9_root_build_program(PrepareState& s
         // measured: `run-A.sh run-B.sh <artifact>`).
         const auto runnerBeforeRoot = bcRoot.runner;
         const auto namedBeforeRoot  = bcRoot.namedRunners;
+        // The root's program is the requested package's.
+        bpEnv.requested = !state.m->package.virtualRoot;
         auto bp = mcpp::build::run_build_program(
             *state.m, *state.root, host->first, host->second,
             state.m->cppStandard, bpEnv);
@@ -1854,9 +1861,14 @@ write_graph_document(PrepareState& state, std::size_t subject,
     nlohmann::json doc;
     doc["kind"] = "mcpp.graph";
     doc["version"] = 1;
+    // The requests a document lists are those made by its own packages. A
+    // request from outside the program's closure (another workspace member, a
+    // workspace plan's virtual root) is a fact about the plan, not about the
+    // package, and would make the document, and with it the program's cache
+    // key, depend on which members the command selected.
     nlohmann::json list = nlohmann::json::array();
     for (auto i : order) {
-        auto entry = state.graph_package_entry(i, true);
+        auto entry = state.graph_package_entry(i, true, &reached);
         entry["root"] = i == subject;
         list.push_back(std::move(entry));
     }
@@ -1888,13 +1900,40 @@ write_graph_document(PrepareState& state, std::size_t subject,
 // environment in every selection.
 static std::expected<void, std::string> step9_member_build_programs(PrepareState& state) {
     if (!state.m->package.virtualRoot) return {};
-    for (std::size_t i = 1; i < state.packages.size(); ++i) {
-        if (!state.isWorkspaceMemberPackage(i)) continue;
-        if (!state.compilesHere(i)) continue;
-        auto& pkg = state.packages[i];
+    // Dependencies first: a member's program runs after the programs of the
+    // members it depends on, whose directives are then in place in the graph
+    // it reads. Discovery order, which the packages are numbered in, puts a
+    // member before its dependency when its key sorts first.
+    mcpp::graph::AdjacencyList deps(state.packages.size());
+    for (auto const& r : state.graphRequests)
+        if (r.consumerPackageIndex < deps.size() && r.dependencyPackageIndex < deps.size()
+            && r.consumerPackageIndex != r.dependencyPackageIndex)
+            deps[r.consumerPackageIndex].push_back(r.dependencyPackageIndex);
+    // Mutual dev-dependencies between members are legal, so a cycle skips its
+    // closing edge and every other dependency still comes first.
+    std::vector<std::size_t> roots(state.packages.size());
+    std::iota(roots.begin(), roots.end(), std::size_t{0});
+    const auto order = *mcpp::graph::depth_first_order(deps, roots, mcpp::graph::Cycles::Skip);
+    auto hasProgram = [&](std::size_t i) {
+        if (i == 0 || !state.isWorkspaceMemberPackage(i) || !state.compilesHere(i)) return false;
         std::error_code bpEc;
-        if (!std::filesystem::exists(pkg.root / "build.mcpp", bpEc)
-            && pkg.manifest.buildConfig.ruleModules.empty()) continue;
+        return std::filesystem::exists(state.packages[i].root / "build.mcpp", bpEc)
+            || !state.packages[i].manifest.buildConfig.ruleModules.empty();
+    };
+    // mcpp runs them one after another, in this order, so every program not
+    // yet started is truly waiting; its line says so (build progress design
+    // 2026-09-29, §3.2), named as the program names itself.
+    for (auto const i : order) {
+        if (!hasProgram(i)) continue;
+        const auto& m = state.packages[i].manifest;
+        mcpp::build::progress::program_scheduled(
+            m.package.namespace_.empty() ? m.package.name
+                                         : m.package.namespace_ + "." + m.package.name,
+            state.packages[i].selectedMember);
+    }
+    for (auto const i : order) {
+        if (!hasProgram(i)) continue;
+        auto& pkg = state.packages[i];
         auto host = state.host_tc_for_build_program();
         if (!host) return std::unexpected(host.error());
         mcpp::build::BuildProgramEnv bpEnv;
@@ -1909,6 +1948,7 @@ static std::expected<void, std::string> step9_member_build_programs(PrepareState
         bpEnv.packStageDir = state.overrides.pack_stage_dir;
         bpEnv.packStrip           = state.overrides.pack_strip;
         bpEnv.packDebugSymbolsDir = state.overrides.pack_debug_symbols_dir;
+        bpEnv.requested       = pkg.selectedMember;
         bpEnv.languageModules = pkg.manifest.language.modules;
         bpEnv.ruleModules  = pkg.manifest.buildConfig.ruleModules;
         if (auto dit = state.deviceSourcesByPackage.find(pkg.root.string());
diff --git a/src/build/progress.cppm b/src/build/progress.cppm
new file mode 100644
index 000000000..e9e2e3ff6
--- /dev/null
+++ b/src/build/progress.cppm
@@ -0,0 +1,1364 @@
+// mcpp.build.progress — what a build reports while it runs, and how
+// (.agents/docs/2026-09-29-build-progress-display-design.md).
+//
+// Four sources feed one model, and mcpp.ui draws it:
+//
+//   - mcpp's own steps (build programs, the phases), reported by the code that
+//     performs them;
+//   - ninja's status lines, one per finished step (`NINJA_STATUS`), which give
+//     the counts and pace the reading;
+//   - ninja's log, which states which step finished, when it started and when
+//     it ended;
+//   - the start file, where the engine's action wrapper writes the start of a
+//     `check` or `prepare` action, the only steps whose start is observable.
+//
+// The step record, written beside build.ninja, names the package each step
+// belongs to. A package is complete when every step the record assigns to it
+// has finished in this build (§3.2): the rule can state completion late,
+// never early.
+//
+// LOCKS. The model has one mutex. mcpp.ui asks the model for its frame while
+// holding its own lock, so the model never calls mcpp.ui while holding the
+// model's: every line the model writes is collected under the lock and written
+// after it is released.
+
+module;
+#include <cstdio>
+
+export module mcpp.build.progress;
+
+import std;
+import mcpp.ui;
+import mcpp.log;
+import mcpp.platform;
+
+export namespace mcpp::build::progress {
+
+// ─── The step record (design §6.3) ───────────────────────────────────────
+
+struct PackageInfo {
+    std::string name;              // qualified name: what the emitter records
+    bool        requested   = false;
+    std::string subject;           // as the package's line shows it
+    std::size_t cachedUnits = 0;   // units staged from the global cache
+    std::size_t steps       = 0;   // steps the graph assigns to it
+};
+
+struct Record {
+    std::vector<PackageInfo> packages;
+    // An output path, normalised, to its step's package in `packages`.
+    std::unordered_map<std::string, std::size_t> owner;
+    // An output path, normalised, to its step: the outputs of one step share
+    // it, so a step whose log entries are read in two pieces counts once.
+    std::unordered_map<std::string, std::size_t> step;
+    // The first output of a check or prepare action, normalised, to its label.
+    std::unordered_map<std::string, std::string> actions;
+    std::size_t steps = 0;         // every step of the graph
+};
+
+inline constexpr std::string_view kRecordFile = "steps.tsv";
+
+// A path as the record and the readers compare it: forward slashes, no `.`
+// segments. ninja's log writes paths as build.ninja spelled them; a stamp the
+// action wrapper reports was spelled by the same plan.
+std::string normalise(std::string_view path);
+
+std::string format_record(const Record& record);
+Record parse_record(std::string_view text);
+void write_record(const std::filesystem::path& buildDir, const Record& record);
+std::optional<Record> read_record(const std::filesystem::path& buildDir);
+
+// What the emitter states about each step as it writes it: the package whose
+// unit, link, action or staged file the statement is for. `owner("")` marks
+// the statements that follow as the build's own.
+class Attribution {
+public:
+    struct Step {
+        std::vector<std::string> outputs;   // normalised
+        std::string              rule;
+        std::string              owner;
+    };
+    void owner(std::string_view package);
+    // Text appended to build.ninja: each `build` statement in it is recorded
+    // with the current owner. Phony statements are not steps.
+    void statement(std::string_view text);
+    // A check or prepare action's first output and label.
+    void action(std::string_view firstOutput, std::string_view label);
+    const std::vector<Step>& steps() const { return steps_; }
+    // The record: `declared` states how the packages are shown; an owner that
+    // no entry declares is shown by its qualified name, as a dependency.
+    Record record(const std::vector<PackageInfo>& declared) const;
+
+private:
+    std::string owner_;
+    std::vector<Step> steps_;
+    std::vector<std::pair<std::string, std::string>> actions_;
+};
+
+// ─── The readers (design §6) ─────────────────────────────────────────────
+
+// Set as NINJA_STATUS: ninja prints it before the description of each step
+// it finishes, with the steps finished, the steps planned and the step's end
+// time in seconds since ninja started.
+//
+// IT BEGINS WITH AN ESCAPE SEQUENCE ON PURPOSE. A step's command inherits
+// ninja's environment, so a ninja it runs (a `prepare` action's CMake or
+// vcpkg build) prints the same marker, and the outer ninja relays that output
+// after the step. ninja prints its own status line as it is, and strips
+// escape sequences from a command's output when its standard output is not a
+// terminal, as it is not here: only the outer ninja's lines keep the leading
+// `ESC [ 0 m`. The outer ninja runs with CLICOLOR_FORCE=0, which keeps that
+// stripping on.
+inline constexpr std::string_view kStatusFormat = "\x1b[0m@@mcpp %f %t %e@@ ";
+
+struct StatusLine {
+    std::size_t      finished = 0;
+    std::size_t      total    = 0;
+    long long        endMs    = 0;
+    std::string_view text;     // the description, or the command under -v
+};
+std::optional<StatusLine> parse_status(std::string_view line);
+
+// One step of ninja's log: its entries share start, end and command hash.
+struct LogStep {
+    long long                start = 0;   // ms since that ninja started
+    long long                end   = 0;
+    std::vector<std::string> outputs;     // normalised
+};
+// The complete entries of `text`, which starts at the beginning of a line,
+// grouped by step. `consumed` is the length of the complete lines read.
+// Header and comment lines are skipped; `*version` receives the format a
+// header states.
+std::vector<LogStep> parse_log(std::string_view text, std::size_t* consumed,
+                               int* version = nullptr,
+                               std::vector<std::size_t>* offsets = nullptr);
+// The index of the first step of this run in `steps`: the suffix whose end
+// times are among `ends`, the end times of the status lines seen (§6.2).
+std::size_t run_boundary(const std::vector<LogStep>& steps, std::vector<long long> ends);
+
+// The start file of `mcpp __action` (design §6.4).
+inline constexpr std::string_view kStartsEnv  = "MCPP_ACTION_STARTS";
+inline constexpr std::string_view kStartsFile = ".mcpp-action-starts";
+struct ActionStart {
+    std::string stamp;      // normalised
+    long long   unixMs = 0;
+};
+std::vector<ActionStart> parse_starts(std::string_view text, std::size_t* consumed);
+// Called by the wrapper before it runs the command: appends the start of the
+// action whose first stamp is `stamp` to the file MCPP_ACTION_STARTS names,
+// in one write. Nothing when the variable is unset.
+void record_action_start(std::string_view stamp);
+
+// ─── The model (design §4) ───────────────────────────────────────────────
+
+enum class ProgramOutcome { Ran, Cached, Failed };
+
+// Opens the report of this command: the region, its frame and its poll.
+// `verbose` lists every package (design §4.3). Idempotent.
+void open(bool verbose);
+// Closes it: the region is erased. Idempotent.
+void close();
+// The number of configurations the command builds: with more than one, a
+// package line names its configuration.
+void configurations(std::size_t n);
+
+// Build programs (design §4.2). `requested` programs are listed, the others
+// folded into one line when `programs_done` is called.
+void program_scheduled(std::string_view package, bool requested);
+void program_compiling(std::string_view package, bool requested);
+void program_running(std::string_view package, bool requested);
+void program_finished(std::string_view package, bool requested, ProgramOutcome outcome,
+                      std::chrono::milliseconds compile, std::chrono::milliseconds run);
+void programs_done();
+
+// The validations after ninja.
+void checking();
+
+// `Finished` (design §4.5): the whole command's time, and how it was spent.
+void finished(std::string_view profile, std::string_view descriptor);
+// A command that builds several configurations writes one `Finished`, after
+// all of them: `finished` then only records what it was given, and
+// `finish_deferred` writes it.
+void defer_finished();
+void finish_deferred();
+
+// One build directory's ninja runs within this command.
+class Build {
+public:
+    // Opaque: its definition is this module's own.
+    struct Impl;
+
+    explicit Build(const std::filesystem::path& dir);
+    ~Build();
+    Build(const Build&) = delete;
+    Build& operator=(const Build&) = delete;
+
+    // How the plan names its packages (the full path; the fast path reads
+    // the record instead).
+    void declare(std::vector<PackageInfo> packages);
+    const std::vector<PackageInfo>& declared() const;
+    void set_record(Record record);
+    bool has_record() const;
+
+    // The environment ninja runs with: NINJA_STATUS and the start file.
+    std::vector<std::pair<std::string, std::string>> environment() const;
+    // One ninja invocation.
+    void pass_begin();
+    void status(const StatusLine& line);
+    // A `FAILED: <outputs>` line: the step's package is failed. Returns true
+    // for the command's first failure, after which the caller writes
+    // `error: build failed` and the step's diagnostics.
+    bool failed(std::string_view outputs);
+    void pass_end();
+    // The build ended: every package still open gets its final line.
+    void finish(bool success);
+
+private:
+    std::shared_ptr<Impl> impl_;
+};
+
+} // namespace mcpp::build::progress
+
+namespace mcpp::build::progress {
+
+using Clock = std::chrono::steady_clock;
+using ms    = std::chrono::milliseconds;
+
+// ─── The step record ─────────────────────────────────────────────────────
+
+std::string normalise(std::string_view path) {
+    std::string s(path);
+    std::ranges::replace(s, '\\', '/');
+    return std::filesystem::path(s).lexically_normal().generic_string();
+}
+
+namespace {
+
+// Tabs and line ends cannot appear in a field.
+std::string field(std::string_view s) {
+    std::string out(s);
+    std::ranges::replace(out, '\t', ' ');
+    std::ranges::replace(out, '\n', ' ');
+    std::ranges::replace(out, '\r', ' ');
+    return out;
+}
+
+std::vector<std::string_view> split_tabs(std::string_view line) {
+    std::vector<std::string_view> out;
+    while (true) {
+        auto t = line.find('\t');
+        out.push_back(line.substr(0, t));
+        if (t == std::string_view::npos) break;
+        line.remove_prefix(t + 1);
+    }
+    return out;
+}
+
+std::size_t to_size(std::string_view s) {
+    std::size_t v = 0;
+    std::from_chars(s.data(), s.data() + s.size(), v);
+    return v;
+}
+
+long long to_ll(std::string_view s) {
+    long long v = 0;
+    std::from_chars(s.data(), s.data() + s.size(), v);
+    return v;
+}
+
+} // namespace
+
+// Format: a header, then `P` lines (packages, in order), `A` lines (actions)
+// and `O` lines (an output and its package's index).
+std::string format_record(const Record& r) {
+    std::string out = std::format("# mcpp steps v1\t{}\n", r.steps);
+    for (auto const& p : r.packages)
+        out += std::format("P\t{}\t{}\t{}\t{}\t{}\n", field(p.name), p.requested ? 1 : 0,
+                           p.cachedUnits, p.steps, field(p.subject));
+    std::vector<std::pair<std::string, std::string>> actions(r.actions.begin(), r.actions.end());
+    std::ranges::sort(actions);
+    for (auto const& [out1, label] : actions)
+        out += std::format("A\t{}\t{}\n", field(out1), field(label));
+    std::vector<std::pair<std::string, std::size_t>> owners(r.owner.begin(), r.owner.end());
+    std::ranges::sort(owners);
+    for (auto const& [path, index] : owners) {
+        auto st = r.step.find(path);
+        out += std::format("O\t{}\t{}\t{}\n", index,
+                           st == r.step.end() ? std::size_t{0} : st->second, field(path));
+    }
+    return out;
+}
+
+Record parse_record(std::string_view text) {
+    Record r;
+    while (!text.empty()) {
+        auto nl = text.find('\n');
+        auto line = text.substr(0, nl);
+        text.remove_prefix(nl == std::string_view::npos ? text.size() : nl + 1);
+        if (!line.empty() && line.back() == '\r') line.remove_suffix(1);
+        if (line.empty()) continue;
+        auto f = split_tabs(line);
+        if (f[0] == "# mcpp steps v1" && f.size() >= 2) { r.steps = to_size(f[1]); continue; }
+        if (f[0] == "P" && f.size() >= 6) {
+            r.packages.push_back({std::string(f[1]), f[2] == "1", std::string(f[5]),
+                                  to_size(f[3]), to_size(f[4])});
+        } else if (f[0] == "A" && f.size() >= 3) {
+            r.actions.emplace(std::string(f[1]), std::string(f[2]));
+        } else if (f[0] == "O" && f.size() >= 4) {
+            const auto index = to_size(f[1]);
+            if (index < r.packages.size()) {
+                r.owner.emplace(std::string(f[3]), index);
+                r.step.emplace(std::string(f[3]), to_size(f[2]));
+            }
+        }
+    }
+    return r;
+}
+
+void write_record(const std::filesystem::path& buildDir, const Record& record) {
+    std::ofstream f(buildDir / kRecordFile, std::ios::binary | std::ios::trunc);
+    f << format_record(record);
+}
+
+std::optional<Record> read_record(const std::filesystem::path& buildDir) {
+    std::ifstream f(buildDir / kRecordFile, std::ios::binary);
+    if (!f) return std::nullopt;
+    std::string text{std::istreambuf_iterator<char>(f), {}};
+    return parse_record(text);
+}
+
+// ─── Attribution ─────────────────────────────────────────────────────────
+
+void Attribution::owner(std::string_view package) { owner_ = std::string(package); }
+
+namespace {
+
+// The outputs and the rule of a `build` line: tokens up to the first colon
+// ninja does not read as escaped, `|` dropped, `$ ` `$:` `$$` unescaped.
+std::optional<std::pair<std::vector<std::string>, std::string>>
+parse_build_line(std::string_view line) {
+    if (!line.starts_with("build ")) return std::nullopt;
+    line.remove_prefix(6);
+    std::vector<std::string> outputs;
+    std::string cur;
+    std::size_t i = 0;
+    bool done = false;
+    auto flush = [&] {
+        if (!cur.empty() && cur != "|") outputs.push_back(normalise(cur));
+        cur.clear();
+    };
+    for (; i < line.size() && !done; ++i) {
+        const char c = line[i];
+        if (c == '$' && i + 1 < line.size()) {
+            const char n = line[i + 1];
+            if (n == ' ' || n == ':' || n == '$') { cur += n; ++i; continue; }
+            cur += c;
+            continue;
+        }
+        if (c == ':') { flush(); done = true; break; }
+        if (c == ' ') { flush(); continue; }
+        cur += c;
+    }
+    if (!done) return std::nullopt;
+    std::string_view rest = line.substr(i + 1);
+    while (!rest.empty() && rest.front() == ' ') rest.remove_prefix(1);
+    auto rule = rest.substr(0, rest.find_first_of(" \n"));
+    return std::pair{std::move(outputs), std::string(rule)};
+}
+
+} // namespace
+
+void Attribution::statement(std::string_view text) {
+    while (!text.empty()) {
+        auto nl = text.find('\n');
+        auto line = text.substr(0, nl);
+        text.remove_prefix(nl == std::string_view::npos ? text.size() : nl + 1);
+        auto parsed = parse_build_line(line);
+        if (!parsed || parsed->second == "phony" || parsed->first.empty()) continue;
+        steps_.push_back({std::move(parsed->first), std::move(parsed->second), owner_});
+    }
+}
+
+void Attribution::action(std::string_view firstOutput, std::string_view label) {
+    actions_.emplace_back(normalise(firstOutput), std::string(label));
+}
+
+Record Attribution::record(const std::vector<PackageInfo>& declared) const {
+    Record r;
+    std::unordered_map<std::string, std::size_t> index;
+    for (auto const& d : declared) {
+        if (index.contains(d.name)) continue;
+        index.emplace(d.name, r.packages.size());
+        auto p = d;
+        p.steps = 0;
+        r.packages.push_back(std::move(p));
+    }
+    for (auto const& s : steps_) {
+        const auto id = r.steps++;
+        if (s.owner.empty()) continue;
+        auto it = index.find(s.owner);
+        if (it == index.end()) {
+            it = index.emplace(s.owner, r.packages.size()).first;
+            r.packages.push_back({s.owner, false, s.owner, 0, 0});
+        }
+        ++r.packages[it->second].steps;
+        for (auto const& o : s.outputs) {
+            r.owner.emplace(o, it->second);
+            r.step.emplace(o, id);
+        }
+    }
+    for (auto const& [out1, label] : actions_) r.actions.emplace(out1, label);
+    return r;
+}
+
+// ─── The readers ─────────────────────────────────────────────────────────
+
+std::optional<StatusLine> parse_status(std::string_view line) {
+    constexpr std::string_view head = "\x1b[0m@@mcpp ";
+    if (!line.starts_with(head)) return std::nullopt;
+    line.remove_prefix(head.size());
+    const auto close = line.find("@@ ");
+    const auto closeEnd = close == std::string_view::npos ? line.find("@@") : close;
+    if (closeEnd == std::string_view::npos) return std::nullopt;
+    auto nums = line.substr(0, closeEnd);
+    StatusLine s;
+    s.text = close == std::string_view::npos ? std::string_view{} : line.substr(close + 3);
+    std::array<std::string_view, 3> part;
+    for (std::size_t i = 0; i < 3; ++i) {
+        auto sp = nums.find(' ');
+        part[i] = nums.substr(0, sp);
+        if (sp == std::string_view::npos) { if (i < 2) return std::nullopt; break; }
+        nums.remove_prefix(sp + 1);
+    }
+    s.finished = to_size(part[0]);
+    s.total    = to_size(part[1]);
+    // `%e` is seconds with three decimals: the step's end in milliseconds.
+    auto e = part[2];
+    auto dot = e.find('.');
+    long long secs = to_ll(e.substr(0, dot));
+    long long frac = 0;
+    if (dot != std::string_view::npos) {
+        auto f = e.substr(dot + 1);
+        std::string three(f.substr(0, 3));
+        while (three.size() < 3) three += '0';
+        frac = to_ll(three);
+    }
+    s.endMs = secs * 1000 + frac;
+    return s;
+}
+
+std::vector<LogStep> parse_log(std::string_view text, std::size_t* consumed, int* version,
+                               std::vector<std::size_t>* offsets) {
+    std::vector<LogStep> steps;
+    std::size_t pos = 0;
+    std::string lastHash;
+    while (pos < text.size()) {
+        auto nl = text.find('\n', pos);
+        if (nl == std::string_view::npos) break;   // an entry still being written
+        auto line = text.substr(pos, nl - pos);
+        const auto lineStart = pos;
+        pos = nl + 1;
+        if (!line.empty() && line.back() == '\r') line.remove_suffix(1);
+        if (line.empty()) continue;
+        if (line.front() == '#') {
+            if (version) {
+                constexpr std::string_view v = "# ninja log v";
+                if (line.starts_with(v)) *version = static_cast<int>(to_ll(line.substr(v.size())));
+            }
+            continue;
+        }
+        auto f = split_tabs(line);
+        if (f.size() < 5) continue;
+        const long long start = to_ll(f[0]), end = to_ll(f[1]);
+        const std::string hash(f[4]);
+        if (!steps.empty() && steps.back().start == start && steps.back().end == end
+            && hash == lastHash) {
+            steps.back().outputs.push_back(normalise(f[3]));
+        } else {
+            steps.push_back({start, end, {normalise(f[3])}});
+            if (offsets) offsets->push_back(lineStart);
+            lastHash = hash;
+        }
+    }
+    if (consumed) *consumed = pos;
+    return steps;
+}
+
+std::size_t run_boundary(const std::vector<LogStep>& steps, std::vector<long long> ends) {
+    std::size_t i = steps.size();
+    while (i > 0) {
+        auto it = std::ranges::find(ends, steps[i - 1].end);
+        if (it == ends.end()) break;
+        ends.erase(it);
+        --i;
+    }
+    return i;
+}
+
+std::vector<ActionStart> parse_starts(std::string_view text, std::size_t* consumed) {
+    std::vector<ActionStart> out;
+    std::size_t pos = 0;
+    while (pos < text.size()) {
+        auto nl = text.find('\n', pos);
+        if (nl == std::string_view::npos) break;
+        auto line = text.substr(pos, nl - pos);
+        pos = nl + 1;
+        if (!line.empty() && line.back() == '\r') line.remove_suffix(1);
+        auto f = split_tabs(line);
+        if (f.size() < 2 || f[0].empty()) continue;
+        out.push_back({normalise(f[0]), to_ll(f[1])});
+    }
+    if (consumed) *consumed = pos;
+    return out;
+}
+
+void record_action_start(std::string_view stamp) {
+    const char* file = std::getenv(std::string(kStartsEnv).c_str());
+    if (!file || !*file || stamp.empty()) return;
+    const auto now = std::chrono::duration_cast<ms>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+    // One line, one write, in append mode: the lines of actions that start at
+    // the same time do not interleave.
+    (void)mcpp::platform::fs::append_atomically(
+        std::filesystem::path(file), std::format("{}\t{}\n", field(stamp), now));
+}
+
+// ─── The model ───────────────────────────────────────────────────────────
+
+// Not exported, and not TU-local either: `Build::Impl` holds them.
+enum class Phase { Resolving, Programs, Building, Stopping, Checking };
+
+struct Program {
+    std::string name;
+    bool requested = false;
+    enum State { Waiting, Compiling, Running, Done } state = Waiting;
+    ProgramOutcome outcome = ProgramOutcome::Ran;
+    Clock::time_point since{};
+    ms compile{0}, run{0};
+};
+
+struct PackageState {
+    std::size_t finished = 0;
+    long long   first    = std::numeric_limits<long long>::max();   // ms since command start
+    long long   last     = 0;
+    bool        failed    = false;
+    bool        committed = false;
+};
+
+struct Running {
+    std::size_t package = 0;
+    std::string label;
+    std::string stamp;
+    long long   since = 0;   // ms since command start
+};
+
+struct Build::Impl {
+    std::filesystem::path dir;
+    std::vector<PackageInfo> declared;
+    std::optional<Record> record;
+    bool recordTried = false;
+    bool closed = false;                       // the build's Build object is gone
+    std::unordered_set<std::size_t> counted;   // steps already counted
+    std::vector<PackageState> packages;
+    bool depsCommitted = false;
+    // Passes of ninja.
+    long long   passStart = 0;       // ms since command start
+    std::size_t doneBefore = 0, totalBefore = 0;   // earlier passes
+    std::size_t finished = 0, total = 0;          // this pass
+    bool        inPass = false;
+    // The log of this pass.
+    std::filesystem::path logPath;
+    std::string logTail;             // the file's last bytes when the pass began
+    std::uintmax_t logStart = 0;     // its size then
+    std::optional<std::uintmax_t> logOffset;   // where this pass's entries are read from
+    std::vector<long long> ends;     // end times of the status lines of this pass
+    // The start file.
+    std::uintmax_t startsOffset = 0;
+    std::vector<Running> running;
+    // The longest step, for `Finished`.
+    long long   longest = 0;
+    std::string longestLabel;
+    bool        anyStep = false;
+};
+
+namespace {
+
+// The fast path has no plan: it reads the record the plan wrote, when ninja
+// reports its first step, so a build with nothing to do reads nothing.
+void ensure_record(Build::Impl& b) {
+    if (b.record || b.recordTried) return;
+    b.recordTried = true;
+    if (auto rec = read_record(b.dir)) {
+        b.packages.assign(rec->packages.size(), PackageState{});
+        b.record = std::move(*rec);
+    }
+}
+
+struct Report {
+    std::mutex m;
+    bool open = false;
+    bool verbose = false;
+    Phase phase = Phase::Resolving;
+    std::size_t configurations = 1;
+    std::vector<Program> programs;
+    bool programsCommitted = false;
+    ms   programTime{0};
+    std::vector<std::shared_ptr<Build::Impl>> builds;
+    std::optional<long long> buildStart;   // ms since command start
+    bool failureReported = false;
+    bool deferred = false;
+    std::optional<std::pair<std::string, std::string>> deferredFinish;
+};
+
+Report& report() {
+    static Report r;
+    return r;
+}
+
+long long now_ms() {
+    return std::chrono::duration_cast<ms>(Clock::now() - mcpp::ui::command_start()).count();
+}
+
+constexpr std::size_t kColumnMax = 43;   // the state at column 56 at most
+
+std::string plural(std::size_t n, std::string_view one, std::string_view many) {
+    return std::format("{} {}", n, n == 1 ? one : many);
+}
+
+// ── Programs ──
+
+std::size_t program_column(const Report& r) {
+    std::size_t w = 0;
+    for (auto const& p : r.programs)
+        if (p.requested || r.verbose) w = std::max(w, mcpp::ui::display_width(p.name));
+    w = std::max<std::size_t>(w, 16);   // "N dependencies"
+    return std::min(w + 2, kColumnMax);
+}
+
+std::string program_state(const Program& p, bool verbose) {
+    switch (p.state) {
+    case Program::Waiting:   return "waiting";
+    case Program::Compiling:
+        return std::format("compiling {}", mcpp::ui::format_clock(
+            std::chrono::duration_cast<ms>(Clock::now() - p.since)));
+    case Program::Running:
+        return std::format("running {}", mcpp::ui::format_clock(
+            std::chrono::duration_cast<ms>(Clock::now() - p.since)));
+    case Program::Done: break;
+    }
+    if (p.outcome == ProgramOutcome::Cached) return "cached";
+    if (p.outcome == ProgramOutcome::Failed) return "failed";
+    if (verbose && p.compile.count() > 0)
+        return std::format("compiled {} · ran {}", mcpp::ui::format_duration(p.compile),
+                           mcpp::ui::format_duration(p.run));
+    return std::format("ran {}", mcpp::ui::format_duration(p.compile + p.run));
+}
+
+mcpp::ui::Tone program_tone(const Program& p) {
+    if (p.state != Program::Done) return mcpp::ui::Tone::Plain;
+    if (p.outcome == ProgramOutcome::Failed) return mcpp::ui::Tone::Bad;
+    if (p.outcome == ProgramOutcome::Cached) return mcpp::ui::Tone::Muted;
+    return mcpp::ui::Tone::Good;
+}
+
+std::string program_line(const Report& r, const Program& p) {
+    return mcpp::ui::step_line("build.mcpp", p.name, program_column(r), program_state(p, r.verbose),
+                               program_tone(p), /*infoVerb=*/true);
+}
+
+// The folded line of the dependencies' programs.
+std::optional<std::string> folded_programs_line(const Report& r) {
+    std::size_t n = 0, ran = 0, cached = 0, failed = 0;
+    ms time{0};
+    for (auto const& p : r.programs) {
+        if (p.requested || r.verbose || p.state != Program::Done) continue;
+        ++n;
+        if (p.outcome == ProgramOutcome::Cached) ++cached;
+        else if (p.outcome == ProgramOutcome::Failed) ++failed;
+        else { ++ran; time += p.compile + p.run; }
+    }
+    if (n == 0) return std::nullopt;
+    std::string state;
+    if (ran) state = std::format("ran {}", mcpp::ui::format_duration(time));
+    if (cached) state += std::format("{}{}", state.empty() ? "" : " · ",
+                                     ran ? std::format("{} cached", cached) : std::string("cached"));
+    if (failed) state += std::format("{}{} failed", state.empty() ? "" : " · ", failed);
+    return mcpp::ui::step_line("build.mcpp", plural(n, "dependency", "dependencies"),
+                               program_column(r), state,
+                               failed ? mcpp::ui::Tone::Bad
+                                      : ran ? mcpp::ui::Tone::Good : mcpp::ui::Tone::Muted,
+                               /*infoVerb=*/true);
+}
+
+Program& program(Report& r, std::string_view name, bool requested) {
+    for (auto& p : r.programs)
+        if (p.name == name && p.state != Program::Done) return p;
+    r.programs.push_back({std::string(name), requested});
+    return r.programs.back();
+}
+
+// ── Packages ──
+
+bool listed(const Report& r, const PackageInfo& p) { return p.requested || r.verbose; }
+
+std::string subject_of(const Report& r, const Build::Impl& b, const PackageInfo& p) {
+    if (r.configurations <= 1) return p.subject;
+    return std::format("{} [{}]", p.subject, b.dir.filename().string());
+}
+
+std::size_t package_column(const Report& r, const Build::Impl& b) {
+    std::size_t w = 16;   // "NN dependencies"
+    if (b.record)
+        for (auto const& p : b.record->packages)
+            if (listed(r, p)) w = std::max(w, mcpp::ui::display_width(subject_of(r, b, p)));
+    return std::min(w + 2, kColumnMax);
+}
+
+bool complete(const PackageInfo& p, const PackageState& s) {
+    return p.steps > 0 && s.finished >= p.steps;
+}
+
+std::string span_of(const PackageState& s) {
+    if (s.first > s.last) return {};
+    return mcpp::ui::format_duration(ms(s.last - s.first));
+}
+
+std::string package_line(const Report& r, const Build::Impl& b, std::size_t i, bool final,
+                         bool success) {
+    const auto& p = b.record->packages[i];
+    const auto& s = b.packages[i];
+    std::string state;
+    auto tone = mcpp::ui::Tone::Plain;
+    if (s.failed) { state = "failed"; tone = mcpp::ui::Tone::Bad; }
+    else if (s.finished == 0 && final) {
+        state = p.cachedUnits > 0 ? std::format("cached {}", plural(p.cachedUnits, "unit", "units"))
+                                  : "fresh";
+        tone = mcpp::ui::Tone::Muted;
+    } else if (p.cachedUnits > 0 && (complete(p, s) || (final && success))) {
+        state = std::format("cached {}", plural(p.cachedUnits, "unit", "units"));
+        tone = mcpp::ui::Tone::Muted;
+    } else if (complete(p, s) || (final && success)) {
+        state = std::format("done {}", span_of(s));
+        tone = mcpp::ui::Tone::Good;
+    } else {
+        state = plural(s.finished, "step", "steps");
+    }
+    return mcpp::ui::step_line("Compiling", subject_of(r, b, p), package_column(r, b), state, tone);
+}
+
+// The folded line of the dependencies (design §4.3): those with steps in
+// this build, and at the end also those the global cache supplied whole.
+std::optional<std::string> dependencies_line(const Report& r, const Build::Impl& b, bool final,
+                                             bool success) {
+    std::size_t active = 0, cached = 0, cachedOnly = 0, steps = 0;
+    long long first = std::numeric_limits<long long>::max(), last = 0;
+    for (std::size_t i = 0; i < b.record->packages.size(); ++i) {
+        const auto& p = b.record->packages[i];
+        const auto& s = b.packages[i];
+        if (listed(r, p) || s.committed) continue;
+        if (p.cachedUnits > 0 && final) {
+            ++cached;
+            if (s.finished == 0) ++cachedOnly;
+        }
+        if (s.finished == 0) continue;
+        ++active;
+        steps += s.finished;
+        first = std::min(first, s.first);
+        last  = std::max(last, s.last);
+    }
+    const std::size_t n = active + cachedOnly;
+    if (active == 0 && (!final || cached == 0)) return std::nullopt;
+    std::string state;
+    auto tone = mcpp::ui::Tone::Plain;
+    if (final && success) {
+        if (active > 0) {
+            state = first <= last
+                ? std::format("done {}", mcpp::ui::format_duration(ms(last - first)))
+                : std::string("done");
+            if (cached) state += std::format(" · {} cached", cached);
+            tone = mcpp::ui::Tone::Good;
+        } else {
+            state = "cached";
+            tone = mcpp::ui::Tone::Muted;
+        }
+    } else {
+        state = plural(steps, "step", "steps");
+    }
+    return mcpp::ui::step_line("Compiling", plural(n, "dependency", "dependencies"),
+                               package_column(r, b), state, tone);
+}
+
+bool dependencies_complete(const Report& r, const Build::Impl& b) {
+    for (std::size_t i = 0; i < b.record->packages.size(); ++i) {
+        const auto& p = b.record->packages[i];
+        if (listed(r, p) || b.packages[i].committed) continue;
+        if (p.steps > 0 && !complete(p, b.packages[i])) return false;
+    }
+    return true;
+}
+
+// Commits what became final; lines to write are appended to `out`.
+void settle(Report& r, Build::Impl& b, std::vector<std::string>& out) {
+    if (!b.record) return;
+    for (std::size_t i = 0; i < b.record->packages.size(); ++i) {
+        auto& s = b.packages[i];
+        const auto& p = b.record->packages[i];
+        if (s.committed || !listed(r, p) || !complete(p, s)) continue;
+        s.committed = true;
+        out.push_back(package_line(r, b, i, /*final=*/true, /*success=*/true));
+    }
+    if (!b.depsCommitted && dependencies_complete(r, b)) {
+        if (auto l = dependencies_line(r, b, /*final=*/true, /*success=*/true)) {
+            out.push_back(*l);
+            b.depsCommitted = true;
+            for (std::size_t i = 0; i < b.record->packages.size(); ++i)
+                if (!listed(r, b.record->packages[i]) && b.packages[i].finished > 0)
+                    b.packages[i].committed = true;
+        }
+    }
+}
+
+void write_lines(const std::vector<std::string>& lines) {
+    for (auto const& l : lines) mcpp::ui::line(l);
+    if (!lines.empty()) mcpp::ui::touch_region();
+}
+
+// Reads the log of an open pass; model lock held.
+void read_log(Build::Impl& b) {
+    if (!b.inPass || !b.record) return;
+    std::error_code ec;
+    const auto size = std::filesystem::file_size(b.logPath, ec);
+    if (ec) return;
+    std::ifstream f(b.logPath, std::ios::binary);
+    if (!f) return;
+    if (!b.logOffset) {
+        // Is the file the one the pass began with? A recompaction rewrote it.
+        bool same = size >= b.logStart;
+        if (same && !b.logTail.empty()) {
+            std::string tail(b.logTail.size(), '\0');
+            f.seekg(static_cast<std::streamoff>(b.logStart - b.logTail.size()));
+            f.read(tail.data(), static_cast<std::streamsize>(tail.size()));
+            same = f && tail == b.logTail;
+            f.clear();
+        }
+        if (same) b.logOffset = b.logStart;
+        else {
+            // This pass's entries are the suffix whose end times are those of
+            // the status lines seen (design §6.2).
+            f.seekg(0);
+            std::string all{std::istreambuf_iterator<char>(f), {}};
+            std::size_t consumed = 0;
+            std::vector<std::size_t> offsets;
+            auto steps = parse_log(all, &consumed, nullptr, &offsets);
+            const auto first = run_boundary(steps, b.ends);
+            b.logOffset = first < offsets.size() ? offsets[first] : consumed;
+            f.clear();
+        }
+    }
+    if (size <= *b.logOffset) return;
+    f.seekg(static_cast<std::streamoff>(*b.logOffset));
+    std::string text(static_cast<std::size_t>(size - *b.logOffset), '\0');
+    f.read(text.data(), static_cast<std::streamsize>(text.size()));
+    text.resize(static_cast<std::size_t>(f.gcount()));
+    std::size_t consumed = 0;
+    auto steps = parse_log(text, &consumed);
+    *b.logOffset += consumed;
+    for (auto const& st : steps) {
+        const long long start = b.passStart + st.start, end = b.passStart + st.end;
+        std::optional<std::size_t> owner;
+        bool seen = false;
+        for (auto const& o : st.outputs) {
+            if (auto it = b.record->owner.find(o); it != b.record->owner.end()) {
+                owner = it->second;
+                if (auto sid = b.record->step.find(o); sid != b.record->step.end())
+                    seen = !b.counted.insert(sid->second).second;
+                break;
+            }
+        }
+        // The rest of a step whose first entries an earlier read counted.
+        if (seen) continue;
+        std::string label = st.outputs.front();
+        if (auto it = b.record->actions.find(st.outputs.front()); it != b.record->actions.end())
+            label = it->second;
+        if (owner) {
+            auto& s = b.packages[*owner];
+            ++s.finished;
+            s.first = std::min(s.first, start);
+            s.last  = std::max(s.last, end);
+            label = std::format("{}: {}", b.record->packages[*owner].name, label);
+        }
+        if (st.end - st.start > b.longest || !b.anyStep) {
+            b.longest = st.end - st.start;
+            b.longestLabel = label;
+            b.anyStep = true;
+        }
+        std::erase_if(b.running, [&](const Running& a) {
+            return std::ranges::find(st.outputs, a.stamp) != st.outputs.end();
+        });
+    }
+}
+
+// Reads the start file of an open pass; model lock held.
+void read_starts(Build::Impl& b) {
+    if (!b.inPass || !b.record) return;
+    std::error_code ec;
+    const auto path = b.dir / kStartsFile;
+    const auto size = std::filesystem::file_size(path, ec);
+    if (ec || size <= b.startsOffset) return;
+    std::ifstream f(path, std::ios::binary);
+    f.seekg(static_cast<std::streamoff>(b.startsOffset));
+    std::string text(static_cast<std::size_t>(size - b.startsOffset), '\0');
+    f.read(text.data(), static_cast<std::streamsize>(text.size()));
+    text.resize(static_cast<std::size_t>(f.gcount()));
+    std::size_t consumed = 0;
+    auto starts = parse_starts(text, &consumed);
+    b.startsOffset += consumed;
+    const auto nowUnix = std::chrono::duration_cast<ms>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+    for (auto const& a : starts) {
+        auto owner = b.record->owner.find(a.stamp);
+        if (owner == b.record->owner.end()) continue;
+        auto label = b.record->actions.find(a.stamp);
+        b.running.push_back({owner->second,
+                             label != b.record->actions.end() ? label->second : a.stamp,
+                             a.stamp, now_ms() - std::max<long long>(0, nowUnix - a.unixMs)});
+    }
+}
+
+// The builds whose Build object is alive: the frame, the poll and the status
+// line read these. `Finished` reads every build of the command.
+std::vector<std::shared_ptr<Build::Impl>> live_builds(Report& r) {
+    std::vector<std::shared_ptr<Build::Impl>> out;
+    for (auto const& b : r.builds)
+        if (!b->closed) out.push_back(b);
+    return out;
+}
+
+std::string phase_status(Report& r) {
+    const auto clock = mcpp::ui::format_clock(ms(now_ms()));
+    std::string current;
+    long long oldest = std::numeric_limits<long long>::max();
+    std::size_t done = 0, total = 0;
+    for (auto const& b : live_builds(r)) {
+        done  += b->doneBefore + b->finished;
+        total += b->totalBefore + b->total;
+        for (auto const& a : b->running)
+            if (a.since < oldest) {
+                oldest  = a.since;
+                current = std::format("{}: {} {}", b->record->packages[a.package].name, a.label,
+                                      mcpp::ui::format_clock(ms(now_ms() - a.since)));
+            }
+    }
+    switch (r.phase) {
+    case Phase::Resolving:
+        return mcpp::ui::status_line("Resolving", std::format("· {}", clock));
+    case Phase::Programs: {
+        for (auto const& p : r.programs)
+            if (p.state == Program::Compiling || p.state == Program::Running)
+                current = std::format("{} {}", p.name, mcpp::ui::format_clock(
+                    std::chrono::duration_cast<ms>(Clock::now() - p.since)));
+        return mcpp::ui::status_line("Running build programs",
+            std::format("· {}{}", clock, current.empty() ? "" : " · " + current));
+    }
+    case Phase::Building:
+    case Phase::Stopping:
+        return mcpp::ui::status_line(r.phase == Phase::Building ? "Building" : "Stopping",
+            std::format("{}· {}{}", r.phase == Phase::Building && total > 0
+                                        ? std::format("{}/{} ", done, total) : "",
+                        clock, current.empty() ? "" : " · " + current));
+    case Phase::Checking:
+        return mcpp::ui::status_line("Checking", std::format("· {}", clock));
+    }
+    return {};
+}
+
+mcpp::ui::Frame frame() {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    mcpp::ui::Frame f;
+    for (auto const& p : r.programs)
+        if (p.state != Program::Done && (p.requested || r.verbose)) f.lines.push_back(program_line(r, p));
+    for (auto const& b : live_builds(r)) {
+        if (!b->record) continue;
+        for (std::size_t i = 0; i < b->record->packages.size(); ++i) {
+            const auto& p = b->record->packages[i];
+            const auto& s = b->packages[i];
+            if (s.committed || s.finished == 0 || !listed(r, p)) continue;
+            f.lines.push_back(package_line(r, *b, i, /*final=*/false, false));
+        }
+        if (!b->depsCommitted)
+            if (auto l = dependencies_line(r, *b, /*final=*/false, false)) f.lines.push_back(*l);
+    }
+    f.status = phase_status(r);
+    return f;
+}
+
+void poll() {
+    auto& r = report();
+    std::vector<std::string> out;
+    {
+        std::lock_guard lock(r.m);
+        for (auto const& b : live_builds(r)) {
+            read_starts(*b);
+            read_log(*b);
+            settle(r, *b, out);
+        }
+    }
+    write_lines(out);
+}
+
+} // namespace
+
+void open(bool verbose) {
+    auto& r = report();
+    {
+        std::lock_guard lock(r.m);
+        if (r.open) return;
+        r.open = true;
+        r.verbose = verbose;
+    }
+    mcpp::ui::open_region(&frame, &poll);
+}
+
+void close() {
+    mcpp::ui::close_region();
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    r.open = false;
+}
+
+void configurations(std::size_t n) {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    r.configurations = std::max<std::size_t>(1, n);
+}
+
+void program_scheduled(std::string_view package, bool requested) {
+    auto& r = report();
+    {
+        std::lock_guard lock(r.m);
+        program(r, package, requested);
+    }
+    mcpp::ui::touch_region();
+}
+
+void program_compiling(std::string_view package, bool requested) {
+    auto& r = report();
+    {
+        std::lock_guard lock(r.m);
+        r.phase = Phase::Programs;
+        auto& p = program(r, package, requested);
+        p.state = Program::Compiling;
+        p.since = Clock::now();
+    }
+    mcpp::ui::touch_region();
+}
+
+void program_running(std::string_view package, bool requested) {
+    auto& r = report();
+    {
+        std::lock_guard lock(r.m);
+        r.phase = Phase::Programs;
+        auto& p = program(r, package, requested);
+        p.state = Program::Running;
+        p.since = Clock::now();
+    }
+    mcpp::ui::touch_region();
+}
+
+void program_finished(std::string_view package, bool requested, ProgramOutcome outcome,
+                      std::chrono::milliseconds compile, std::chrono::milliseconds run) {
+    auto& r = report();
+    std::vector<std::string> out;
+    {
+        std::lock_guard lock(r.m);
+        auto& p = program(r, package, requested);
+        p.state   = Program::Done;
+        p.outcome = outcome;
+        p.compile = compile;
+        p.run     = run;
+        r.programTime += compile + run;
+        if (p.requested || r.verbose || outcome == ProgramOutcome::Failed)
+            out.push_back(program_line(r, p));
+        if (outcome == ProgramOutcome::Failed) p.requested = true;   // not folded again
+    }
+    write_lines(out);
+    mcpp::log::info("progress", std::format("build.mcpp {} {}", package,
+        outcome == ProgramOutcome::Cached ? "cached"
+        : outcome == ProgramOutcome::Failed ? "failed"
+        : std::format("compiled {}ms ran {}ms", compile.count(), run.count())));
+}
+
+void programs_done() {
+    auto& r = report();
+    std::vector<std::string> out;
+    {
+        std::lock_guard lock(r.m);
+        if (r.programsCommitted) return;
+        r.programsCommitted = true;
+        if (auto l = folded_programs_line(r)) out.push_back(*l);
+    }
+    write_lines(out);
+}
+
+void checking() {
+    auto& r = report();
+    {
+        std::lock_guard lock(r.m);
+        r.phase = Phase::Checking;
+    }
+    mcpp::ui::touch_region();
+}
+
+void defer_finished() {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    r.deferred = true;
+}
+
+void finish_deferred() {
+    auto& r = report();
+    std::optional<std::pair<std::string, std::string>> f;
+    {
+        std::lock_guard lock(r.m);
+        r.deferred = false;
+        f = std::exchange(r.deferredFinish, std::nullopt);
+    }
+    if (f) finished(f->first, f->second);
+}
+
+void finished(std::string_view profile, std::string_view descriptor) {
+    auto& r = report();
+    std::string detail;
+    const auto total = now_ms();
+    {
+        std::lock_guard lock(r.m);
+        if (r.deferred) {
+            r.deferredFinish.emplace(std::string(profile), std::string(descriptor));
+            return;
+        }
+        // The breakdown and the longest step explain a wait; a command shorter
+        // than ten seconds has none to explain (design §4.5).
+        if (total >= 10'000) {
+            const long long build = r.buildStart ? total - *r.buildStart : 0;
+            const long long programs = r.programTime.count();
+            const long long plan = std::max<long long>(0, total - build - programs);
+            std::vector<std::string> parts;
+            if (plan > 0)     parts.push_back("plan " + mcpp::ui::format_duration(ms(plan)));
+            if (programs > 0) parts.push_back("programs " + mcpp::ui::format_duration(ms(programs)));
+            if (build > 0)    parts.push_back("build " + mcpp::ui::format_duration(ms(build)));
+            if (parts.size() > 1)
+                for (std::size_t i = 0; i < parts.size(); ++i)
+                    detail += (i ? " · " : "") + parts[i];
+            long long longest = 0;
+            std::string label;
+            for (auto const& b : r.builds)
+                if (b->anyStep && b->longest > longest) {
+                    longest = b->longest;
+                    label   = b->longestLabel;
+                }
+            if (build >= 10'000 && longest * 4 >= build && !label.empty())
+                detail += std::format("{}longest {} {}", detail.empty() ? "" : " · ", label,
+                                      mcpp::ui::format_duration(ms(longest)));
+        }
+    }
+    // `Finished` ends the report: the region is erased before it, and not
+    // drawn again below it.
+    close();
+    mcpp::ui::finished(profile, ms(total), descriptor, detail);
+}
+
+// ─── Build ───────────────────────────────────────────────────────────────
+
+Build::Build(const std::filesystem::path& dir) : impl_(std::make_shared<Impl>()) {
+    impl_->dir = dir;
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    r.builds.push_back(impl_);
+}
+
+// A build that ended without `finish` (the fast path's stale graph, which the
+// full path then plans and builds) shows nothing from here on.
+Build::~Build() {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    impl_->closed = true;
+}
+
+void Build::declare(std::vector<PackageInfo> packages) {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    impl_->declared = std::move(packages);
+}
+
+const std::vector<PackageInfo>& Build::declared() const { return impl_->declared; }
+
+void Build::set_record(Record record) {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    impl_->packages.assign(record.packages.size(), PackageState{});
+    impl_->record = std::move(record);
+    impl_->recordTried = true;
+}
+
+bool Build::has_record() const {
+    auto& r = report();
+    std::lock_guard lock(r.m);
+    return impl_->record.has_value();
+}
+
+std::vector<std::pair<std::string, std::string>> Build::environment() const {
+    // CLICOLOR_FORCE=0 keeps ninja stripping escape sequences from the
+    // commands' output, which is what tells its own status lines from a
+    // nested ninja's (see kStatusFormat).
+    return {{"NINJA_STATUS", std::string(kStatusFormat)},
+            {"CLICOLOR_FORCE", "0"},
+            {std::string(kStartsEnv), (impl_->dir / kStartsFile).string()}};
+}
+
+void Build::pass_begin() {
+    auto& r = report();
+    {
+        std::lock_guard lock(r.m);
+        auto& b = *impl_;
+        b.doneBefore  += b.finished;
+        b.totalBefore += b.total;
+        b.finished = b.total = 0;
+        b.passStart = now_ms();
+        if (!r.buildStart) r.buildStart = b.passStart;
+        r.phase = Phase::Building;
+        b.inPass = true;
+        b.ends.clear();
+        b.logPath = b.dir / ".ninja_log";
+        b.logOffset.reset();
+        std::error_code ec;
+        b.logStart = std::filesystem::exists(b.logPath, ec)
+                         ? std::filesystem::file_size(b.logPath, ec) : 0;
+        if (ec) b.logStart = 0;
+        b.logTail.clear();
+        if (b.logStart > 0) {
+            std::ifstream f(b.logPath, std::ios::binary);
+            const auto n = std::min<std::uintmax_t>(b.logStart, 256);
+            f.seekg(static_cast<std::streamoff>(b.logStart - n));
+            b.logTail.resize(static_cast<std::size_t>(n));
+            f.read(b.logTail.data(), static_cast<std::streamsize>(n));
+            if (!f) b.logTail.clear();
+        }
+        b.running.clear();
+        std::ofstream(b.dir / kStartsFile, std::ios::binary | std::ios::trunc);
+        b.startsOffset = 0;
+    }
+    mcpp::ui::touch_region();
+}
+
+void Build::status(const StatusLine& line) {
+    auto& r = report();
+    std::vector<std::string> out;
+    {
+        std::lock_guard lock(r.m);
+        auto& b = *impl_;
+        ensure_record(b);
+        b.finished = line.finished;
+        b.total    = line.total;
+        b.ends.push_back(line.endMs);
+        read_starts(b);
+        read_log(b);
+        settle(r, b, out);
+    }
+    write_lines(out);
+    mcpp::ui::touch_region();
+}
+
+bool Build::failed(std::string_view outputs) {
+    auto& r = report();
+    std::vector<std::string> out;
+    bool first = false;
+    {
+        std::lock_guard lock(r.m);
+        auto& b = *impl_;
+        ensure_record(b);
+        // `FAILED: [code=N] out1 out2 `: the step's outputs, space-separated.
+        auto rest = outputs;
+        if (rest.starts_with("[code=")) {
+            auto close = rest.find(']');
+            rest = close == std::string_view::npos ? std::string_view{} : rest.substr(close + 1);
+        }
+        while (!rest.empty() && rest.front() == ' ') rest.remove_prefix(1);
+        std::optional<std::size_t> owner;
+        while (!rest.empty() && !owner) {
+            auto sp = rest.find(' ');
+            auto o = normalise(rest.substr(0, sp));
+            if (b.record)
+                if (auto it = b.record->owner.find(o); it != b.record->owner.end()) owner = it->second;
+            rest.remove_prefix(sp == std::string_view::npos ? rest.size() : sp + 1);
+        }
+        if (owner && !b.packages[*owner].committed) {
+            b.packages[*owner].failed = true;
+            b.packages[*owner].committed = true;
+            out.push_back(package_line(r, b, *owner, /*final=*/true, /*success=*/false));
+        }
+        r.phase = Phase::Stopping;
+        first = !r.failureReported;
+        r.failureReported = true;
+    }
+    write_lines(out);
+    return first;
+}
+
+void Build::pass_end() {
+    auto& r = report();
+    std::vector<std::string> out;
+    {
+        std::lock_guard lock(r.m);
+        auto& b = *impl_;
+        read_log(b);
+        settle(r, b, out);
+        b.inPass = false;
+        b.running.clear();
+    }
+    write_lines(out);
+}
+
+void Build::finish(bool success) {
+    auto& r = report();
+    std::vector<std::string> out;
+    {
+        std::lock_guard lock(r.m);
+        auto& b = *impl_;
+        if (b.record) {
+            // In the order the packages completed; those with nothing to do
+            // last, in the plan's order.
+            std::vector<std::pair<long long, std::string>> lines;
+            constexpr auto never = std::numeric_limits<long long>::max();
+            for (std::size_t i = 0; i < b.record->packages.size(); ++i) {
+                auto& s = b.packages[i];
+                const auto& p = b.record->packages[i];
+                if (s.committed || !listed(r, p)) continue;
+                // A package with nothing to do is listed only with --verbose.
+                if (s.finished == 0 && !(r.verbose && success)) continue;
+                s.committed = true;
+                lines.emplace_back(s.finished ? s.last : never,
+                                   package_line(r, b, i, /*final=*/true, success));
+            }
+            if (!b.depsCommitted) {
+                long long last = 0;
+                for (std::size_t i = 0; i < b.record->packages.size(); ++i)
+                    if (!listed(r, b.record->packages[i]) && b.packages[i].finished)
+                        last = std::max(last, b.packages[i].last);
+                if (auto l = dependencies_line(r, b, /*final=*/true, success))
+                    lines.emplace_back(last ? last : never, *l);
+                b.depsCommitted = true;
+            }
+            std::ranges::stable_sort(lines, {}, &std::pair<long long, std::string>::first);
+            for (auto& l : lines) out.push_back(std::move(l.second));
+        }
+        std::size_t done = 0;
+        for (auto const& s : b.packages) done += s.finished;
+        mcpp::log::info("progress", std::format("build {}: {} steps, {} attributed, {}",
+            b.dir.filename().string(), b.doneBefore + b.finished, done,
+            success ? "succeeded" : "failed"));
+    }
+    write_lines(out);
+}
+
+} // namespace mcpp::build::progress
diff --git a/src/cli.cppm b/src/cli.cppm
index 4508092b5..9d52436ac 100644
--- a/src/cli.cppm
+++ b/src/cli.cppm
@@ -35,6 +35,7 @@ import mcpp.platform;                // is_windows — the PATH separator of `__
 import mcpp.platform.env;            // --offline → MCPP_OFFLINE
 import mcpp.platform.process;        // __action-stamp runs the checked command
 import mcpp.platform.fs;             // __action-stamp writes its stamps
+import mcpp.build.progress;          // __action reports its start
 import mcpp.platform.runtime_search; // linker-wrapper path-injection opt-out
 import mcpp.ui;
 import mcpp.log;
@@ -1167,6 +1168,23 @@ int run(int argc, char** argv) {
             if (declared != env.end()) declared->second = std::move(joined);
             else env.emplace_back("PATH", std::move(joined));
         }
+        // The build's report learns that this action started (build progress
+        // design 2026-09-29, §6.4), by its first stamp as build.ninja spells
+        // it: the step's first output. Nothing is written when the build that
+        // runs it reads no progress.
+        if (!stamps.empty()) mcpp::build::progress::record_action_start(stamps.front());
+        // The command's own ninja, if it runs one (a CMake or vcpkg build),
+        // prints ninja's usual status and reports into no file of this
+        // build. An action that declares either variable keeps its value.
+        auto declares = [&](std::string_view name) {
+            return std::ranges::any_of(env, [&](auto const& kv) { return kv.first == name; });
+        };
+        if (const char* ns = std::getenv("NINJA_STATUS");
+            ns && std::string_view(ns).find("@@mcpp") != std::string_view::npos
+            && !declares("NINJA_STATUS"))
+            env.emplace_back("NINJA_STATUS", "[%f/%t] ");
+        if (!declares(mcpp::build::progress::kStartsEnv))
+            env.emplace_back(std::string(mcpp::build::progress::kStartsEnv), "");
         // Stamps and the required directory are named relative to the build
         // directory, where ninja started this process. Anchored before the
         // command's own directory is entered, so `cwd` moves the command and
diff --git a/src/cli/cmd_build.cppm b/src/cli/cmd_build.cppm
index 76e794b57..3c2375233 100644
--- a/src/cli/cmd_build.cppm
+++ b/src/cli/cmd_build.cppm
@@ -21,6 +21,7 @@ import mcpp.build.schedule.detach_codegen;
 import mcpp.build.test_targets;
 import mcpp.build.build_database;
 import mcpp.build.build_program;
+import mcpp.build.progress;         // the report every building command opens
 import mcpp.build.refusal;          // offline-download-required (#648 A1)
 import mcpp.diag;                   // a member's own diagnostics, in the envelope (WS3)
 import mcpp.dyndep;
@@ -137,6 +138,25 @@ workspace_groups(const std::filesystem::path& wsRoot, const std::vector<std::str
     return groups;
 }
 
+// The tests of each member of a configuration group, for a plan of the group
+// that includes them (`--configure-only`, `mcpp emit build-database`): the
+// targets by member path, and the root and globs each member's discovery read.
+struct GroupTests {
+    std::map<std::string, std::vector<mcpp::manifest::Target>>              targets;
+    std::vector<std::pair<std::filesystem::path, std::vector<std::string>>> discovery;
+};
+std::expected<GroupTests, std::string>
+group_tests(const std::filesystem::path& wsRoot, const std::vector<std::string>& group) {
+    GroupTests out;
+    for (auto const& mp : group) {
+        auto d = mcpp::build::discover_test_targets(wsRoot, mp);
+        if (!d) return std::unexpected(std::format("{}: {}", mp, d.error()));
+        if (!d->targets.empty()) out.targets[mp] = std::move(d->targets);
+        out.discovery.emplace_back(d->packageRoot, std::move(d->discover));
+    }
+    return out;
+}
+
 // run_build_plan, wrapped in the project's `[hooks]` lifecycle (#496).
 //
 // The hooks are those of the package being built: the root's, or in a
@@ -168,8 +188,20 @@ int run_build_with_hooks(mcpp::build::BuildContext& ctx, bool verbose,
         if (!spans.back()->ok()) return 1;
     }
 
+    // A hook command writes to the terminal itself, so the build's live
+    // region is erased while one runs (build progress design 2026-09-29,
+    // §5.3); a `during_build` command that writes while the build runs keeps
+    // it erased for the whole build.
+    std::optional<mcpp::ui::SuspendRegion> sharedTerminal;
+    if (std::ranges::any_of(spans, [](auto const& s) { return s->writes_to_terminal(); }))
+        sharedTerminal.emplace();
+    auto invoke = [](auto const& hooks, mcpp::hooks::Event event, auto const& root) {
+        mcpp::ui::SuspendRegion hookOwnsTheTerminal;
+        return mcpp::hooks::invoke(hooks, event, root);
+    };
+
     for (auto const& sub : subjects)
-        if (!mcpp::hooks::invoke(*sub.hooks, mcpp::hooks::Event::BuildStart, sub.root))
+        if (!invoke(*sub.hooks, mcpp::hooks::Event::BuildStart, sub.root))
             return 1;
 
     int rc = mcpp::build::run_build_plan(ctx, verbose, no_cache, targetOverride);
@@ -186,8 +218,9 @@ int run_build_with_hooks(mcpp::build::BuildContext& ctx, bool verbose,
     // "the notifier failed" for a compile error would answer a question nobody
     // asked. A hook failure only decides the exit code of a build that worked.
     bool hookOk = true;
+    sharedTerminal.reset();
     for (auto const& sub : subjects)
-        hookOk = mcpp::hooks::invoke(*sub.hooks, terminalEvent, sub.root) && hookOk;
+        hookOk = invoke(*sub.hooks, terminalEvent, sub.root) && hookOk;
     return rc != 0 ? rc : ((spanOk && hookOk) ? 0 : 1);
 }
 
@@ -229,6 +262,9 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
     bool print_fp = parsed.is_flag_set("print-fingerprint");
     bool no_cache = parsed.is_flag_set("no-cache");
     bool configure_only = parsed.is_flag_set("configure-only");
+    // The build's report: its steps, its status line, `Finished` (build
+    // progress design 2026-09-29).
+    mcpp::build::progress::open(verbose);
 
     mcpp::build::BuildOverrides ov = overrides_from_selectors(parsed);
     // --cache global|local|off. --no-cache is the deprecated alias for off; the
@@ -239,11 +275,15 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
 
     // Fan-out prefixes every diagnostic with the member it came from; the
     // single-package path has nothing to disambiguate and passes "".
+    // `configured`, when given, receives the plan's output directory and the
+    // plan leaves the root compile database to the caller, which publishes
+    // it once for every configuration it planned.
     auto configure_member = [&](mcpp::build::BuildOverrides memberOv,
-                                std::string_view label) -> int {
+                                std::string_view label,
+                                std::vector<std::filesystem::path>* configured = nullptr) -> int {
         auto where = [&](std::string_view msg) {
-            if (label.empty()) std::println(stderr, "error: {}", msg);
-            else               std::println(stderr, "error: {}: {}", label, msg);
+            if (label.empty()) mcpp::ui::error(std::format("{}", msg));
+            else               mcpp::ui::error(std::format("{}: {}", label, msg));
         };
         auto root = mcpp::project::find_manifest_root(std::filesystem::current_path());
         if (!root) {
@@ -268,6 +308,10 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
             where(ctx.error());
             return 2;
         }
+        if (configured) {
+            ctx->plan.publishRootCompileDb = false;
+            configured->push_back(ctx->outputDir);
+        }
         return mcpp::build::run_configure_plan(*ctx, verbose);
     };
 
@@ -278,24 +322,58 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
     // each), and a failed group does not stop the others; the first non-zero
     // exit wins.
     auto selection = workspace_selection(parsed.is_flag_set("workspace"), ov.package_filter);
-    if (!selection) { std::println(stderr, "error: {}", selection.error()); return 2; }
+    if (!selection) { mcpp::ui::error(std::format("{}", selection.error())); return 2; }
     if (*selection) {
         auto const& members = (*selection)->members;
+        if (configure_only && members.size() == 1) {
+            mcpp::build::BuildOverrides mo = ov;
+            mo.package_filter = members.front();
+            return configure_member(std::move(mo), "");
+        }
+        auto groups = workspace_groups((*selection)->root, members);
+        if (!groups) { mcpp::ui::error(std::format("{}", groups.error())); return 2; }
+        std::vector<std::string> request;
+        for (auto const& g : *groups)
+            for (auto const& mp : g) request.push_back(mp);
+        // Configured as built: one plan per configuration group, with each
+        // member's tests and dev-dependencies (the surface an editor needs,
+        // as for one member), so the compile database of a group describes
+        // each of its packages once.
         if (configure_only) {
             int rc = 0;
-            for (auto const& mp : members) {
+            std::vector<std::filesystem::path> configured;
+            for (auto const& g : *groups) {
+                auto configure_one_by_one = [&] {
+                    // Planned member by member, so a member's failure affects
+                    // that member only, as a plan of one member always did.
+                    for (auto const& mp : g) {
+                        mcpp::build::BuildOverrides one = ov;
+                        one.package_filter = mp;
+                        if (int r = configure_member(std::move(one), mp, &configured); r != 0) rc = r;
+                    }
+                };
+                auto tests = group_tests((*selection)->root, g);
+                if (!tests && g.size() > 1) { configure_one_by_one(); continue; }
+                if (!tests) { mcpp::ui::error(std::format("{}", tests.error())); rc = 2; continue; }
                 mcpp::build::BuildOverrides mo = ov;
-                mo.package_filter = mp;
-                int r = configure_member(std::move(mo), members.size() > 1 ? mp : "");
-                if (r != 0) rc = r;
+                mo.package_filter.clear();
+                mo.project_root = (*selection)->root;
+                mo.workspace_members = g;
+                mo.workspace_request = request;
+                const bool includeDevDeps = !tests->targets.empty();
+                mo.member_targets = std::move(tests->targets);
+                auto ctx = mcpp::build::prepare_build(print_fp, includeDevDeps,
+                                                      /*extraTargets=*/{}, mo);
+                if (!ctx && g.size() > 1) { configure_one_by_one(); continue; }
+                if (!ctx) { mcpp::ui::error(std::format("{}: {}", g.front(), ctx.error())); rc = 2; continue; }
+                ctx->plan.publishRootCompileDb = false;
+                if (int r = mcpp::build::run_configure_plan(*ctx, verbose); r != 0) rc = r;
+                configured.push_back(ctx->outputDir);
             }
+            if (!configured.empty())
+                mcpp::build::publish_workspace_compile_commands((*selection)->root, configured);
             return rc;
         }
-        auto groups = workspace_groups((*selection)->root, members);
-        if (!groups) { std::println(stderr, "error: {}", groups.error()); return 2; }
-        std::vector<std::string> request;
-        for (auto const& g : *groups)
-            for (auto const& mp : g) request.push_back(mp);
         const bool plain = !print_fp && ov.target_triple.empty() && !ov.force_static
             && ov.profile.empty() && ov.features.empty() && !ov.strict
             && ov.capabilities.empty() && ov.cache_mode.empty() && ov.accel.empty();
@@ -319,7 +397,7 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
             mo.workspace_request = request;
             auto ctx = mcpp::build::prepare_build(print_fp, /*includeDevDeps=*/false,
                                                   /*extraTargets=*/{}, mo);
-            if (!ctx) { std::println(stderr, "error: {}", ctx.error()); rc = 2; continue; }
+            if (!ctx) { mcpp::ui::error(std::format("{}", ctx.error())); rc = 2; continue; }
             contexts.push_back(std::move(*ctx));
         }
         if (contexts.size() == 1) {
@@ -327,9 +405,16 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
                                                ov.target_triple);
             return r != 0 ? r : rc;
         }
+        // One report for every configuration: each package line names its
+        // configuration, and one `Finished` follows them all (design §9).
+        mcpp::build::progress::configurations(contexts.size());
+        mcpp::build::progress::defer_finished();
         const std::size_t hw = std::max(1u, std::thread::hardware_concurrency());
         std::set<std::filesystem::path> directories;
         for (auto const& c : contexts) directories.insert(c.outputDir.lexically_normal());
+        // The root compile database is the command's, published once below
+        // from every group's (execute.cppm), not by each concurrent build.
+        for (auto& c : contexts) c.plan.publishRootCompileDb = false;
         for (auto& c : contexts) {
             const std::size_t want = c.plan.scheduleNinjaJobs > 0
                 ? static_cast<std::size_t>(c.plan.scheduleNinjaJobs) : hw + 2;
@@ -354,6 +439,10 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
         }
         for (int r : results)
             if (r != 0 && rc == 0) rc = r;
+        std::vector<std::filesystem::path> dirs;
+        for (auto const& c : contexts) dirs.push_back(c.outputDir);
+        mcpp::build::publish_workspace_compile_commands((*selection)->root, dirs);
+        if (rc == 0) mcpp::build::progress::finish_deferred();
         return rc;
     }
 
@@ -387,7 +476,7 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
 
     auto ctx = mcpp::build::prepare_build(print_fp, /*includeDevDeps=*/false,
                                           /*extraTargets=*/{}, ov);
-    if (!ctx) { std::println(stderr, "error: {}", ctx.error()); return 2; }
+    if (!ctx) { mcpp::ui::error(std::format("{}", ctx.error())); return 2; }
 
     return run_build_with_hooks(*ctx, verbose, no_cache, ov.target_triple);
 }
@@ -504,16 +593,47 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
         return failed("MCPP_BUILD_DATABASE_NO_PROJECT",
                       "no mcpp.toml found in current directory or any parent");
 
-    std::vector<std::pair<std::string, mcpp::build::BuildOverrides>> requests;
-    if (auto members = workspace_fanout_members(parsed.is_flag_set("workspace"),
-                                                ov.package_filter)) {
-        for (auto const& mp : *members) {
-            auto mo = ov;
-            mo.package_filter = mp;
-            requests.emplace_back(mp, std::move(mo));
+    // One plan per configuration group, as `mcpp build` plans a workspace
+    // (workspace design 2026-09-29 §15): a package the members share is one
+    // set of the document, described once. A selection of one member is one
+    // plan of that member, as before.
+    struct PlanRequest {
+        std::string                 member;   // one member's path; empty for a group or a package
+        std::vector<std::string>    group;    // the members of a group plan
+        mcpp::build::BuildOverrides mo;
+    };
+    std::vector<PlanRequest> requests;
+    auto plan_alone = [&](const std::string& mp) {
+        auto one = ov;
+        one.package_filter = mp;
+        requests.push_back({mp, {}, std::move(one)});
+    };
+    std::filesystem::path wsRoot = *root;
+    auto selection = workspace_selection(parsed.is_flag_set("workspace"), ov.package_filter);
+    if (!selection)
+        return failed("MCPP_BUILD_DATABASE_PLAN_FAILED", selection.error());
+    if (*selection && (*selection)->members.size() > 1) {
+        wsRoot = (*selection)->root;
+        // A member whose manifest cannot be read has no configuration; the
+        // members are then planned one by one, and it fails alone (R5.2).
+        auto groups = workspace_groups(wsRoot, (*selection)->members);
+        if (!groups) {
+            for (auto const& mp : (*selection)->members) plan_alone(mp);
+        } else {
+            for (auto const& g : *groups) {
+                auto mo = ov;
+                mo.package_filter.clear();
+                mo.project_root = wsRoot;
+                mo.workspace_members = g;
+                mo.workspace_request = (*selection)->members;
+                requests.push_back({g.size() == 1 ? g.front() : std::string{}, g, std::move(mo)});
+            }
         }
+    } else if (auto members = workspace_fanout_members(parsed.is_flag_set("workspace"),
+                                                       ov.package_filter)) {
+        plan_alone(members->front());
     } else {
-        requests.emplace_back(std::string{}, ov);
+        requests.push_back({std::string{}, {}, ov});
     }
 
     // An offline plan that needs a download is not a defect of the project, and
@@ -533,8 +653,7 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
 
     std::vector<mcpp::build::BuildContext> contexts;
     std::vector<std::filesystem::path>     workDirs;
-    std::vector<std::string>               prefixes;
-    std::vector<std::pair<std::filesystem::path, std::vector<std::string>>> testDiscovery;
+    std::vector<std::vector<std::pair<std::filesystem::path, std::vector<std::string>>>> testDiscovery;
     // The root of every member whose planning failed: `mcpp.toml` and
     // `build.mcpp` (when it exists) join `watch` exactly as a planned
     // member's do (render(), below), so an edit that might fix the failure is
@@ -560,30 +679,72 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
         // Planning narrates on stdout and may start programs that inherit it;
         // the document is printed after this scope, alone.
         mcpp::platform::terminal::StdoutToStderr narration;
-        for (auto& [member, mo] : requests) {
-            const auto memberRoot = member.empty() ? *root : *root / member;
-            const auto memberPath = member.empty() ? std::string("mcpp.toml")
-                                                   : member + "/mcpp.toml";
-            auto discovered = mcpp::build::discover_test_targets(*root, mo.package_filter);
-            if (!discovered) {
+        // A group whose plan fails is planned member by member (appended to
+        // `requests` and reached by this same loop), so a member's failure
+        // still affects that member only (SPEC-005 R5.2).
+        for (std::size_t ri = 0; ri < requests.size(); ++ri) {
+            auto req = requests[ri];
+            auto& mo = req.mo;
+            const auto memberRoot = req.member.empty() ? wsRoot : wsRoot / req.member;
+            const auto memberPath = req.member.empty() ? std::string("mcpp.toml")
+                                                       : req.member + "/mcpp.toml";
+            // The roots whose `mcpp.toml` and `build.mcpp` join `watch` when
+            // this plan fails: the member's, or every member's of a group.
+            std::vector<std::filesystem::path> planRoots;
+            if (req.group.empty()) planRoots.push_back(memberRoot);
+            for (auto const& mp : req.group) planRoots.push_back(wsRoot / mp);
+            auto fail_plan = [&](std::string message) {
                 diagnostics.push_back({plan_failure_code(), Severity::Error,
-                    member.empty() ? discovered.error()
-                                   : std::format("{}: {}", member, discovered.error()),
-                    memberPath});
-                failedMemberRoots.push_back(memberRoot);
-                continue;
-            }
+                                       std::move(message), memberPath});
+                for (auto const& r : planRoots) failedMemberRoots.push_back(r);
+            };
             // As `--configure-only`: tests and dev-dependencies are part of the
-            // surface an editor needs.
-            const bool includeDevDeps = !discovered->targets.empty();
-            auto discovery = std::pair{discovered->packageRoot, discovered->discover};
+            // surface an editor needs, each member's own in a group plan.
+            std::vector<mcpp::manifest::Target> extraTargets;
+            std::vector<std::pair<std::filesystem::path, std::vector<std::string>>> discovery;
+            bool includeDevDeps = false;
+            if (req.group.empty()) {
+                auto discovered = mcpp::build::discover_test_targets(*root, mo.package_filter);
+                if (!discovered) {
+                    fail_plan(req.member.empty() ? discovered.error()
+                              : std::format("{}: {}", req.member, discovered.error()));
+                    continue;
+                }
+                includeDevDeps = !discovered->targets.empty();
+                discovery.emplace_back(discovered->packageRoot, discovered->discover);
+                extraTargets = std::move(discovered->targets);
+            } else {
+                auto tests = group_tests(wsRoot, req.group);
+                if (!tests && req.group.size() == 1) { fail_plan(tests.error()); continue; }
+                if (!tests) {
+                    for (auto const& mp : req.group) plan_alone(mp);
+                    continue;
+                }
+                includeDevDeps = !tests->targets.empty();
+                discovery = std::move(tests->discovery);
+                mo.member_targets = std::move(tests->targets);
+            }
             mo.plan_only = true;
-            mo.work_dir  = build_database_work_dir(*root, mo.package_filter);
+            std::string workKey = mo.package_filter;
+            for (auto const& mp : req.group) workKey += (workKey.empty() ? "" : ",") + mp;
+            mo.work_dir = build_database_work_dir(req.group.empty() ? *root : wsRoot, workKey);
             std::error_code ec;
             std::filesystem::remove(mo.work_dir / "mcpp.lock", ec);
+            const auto diagnosticsBefore = diagnostics.size();
             auto ctx = mcpp::build::prepare_build(/*print_fingerprint=*/false,
                                                   includeDevDeps,
-                                                  std::move(discovered->targets), mo);
+                                                  std::move(extraTargets), mo);
+            if (!ctx && req.group.size() > 1) {
+                // What the group's attempt recorded is recorded again, per
+                // member, by the plans below.
+                (void)mcpp::diag::take();
+                (void)mcpp::build::take_notes_on_failure();
+                (void)mcpp::build::refusal::take();
+                diagnostics.erase(diagnostics.begin() + static_cast<std::ptrdiff_t>(diagnosticsBefore),
+                                  diagnostics.end());
+                for (auto const& mp : req.group) plan_alone(mp);
+                continue;
+            }
             take_member_diagnostics(memberPath);
             if (!ctx) {
                 // A wholly-failed member contributes exactly one `error`
@@ -598,8 +759,8 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
                 // recorded, then discarded the moment `prepare_build` returned
                 // — never reached the reader (design 2026-09-27 §4.2, mcpp#724
                 // side finding A, fix item 2).
-                std::string message = member.empty() ? ctx.error()
-                                                     : std::format("{}: {}", member, ctx.error());
+                std::string message = req.member.empty() ? ctx.error()
+                                                         : std::format("{}: {}", req.member, ctx.error());
                 for (auto const& note : mcpp::build::take_notes_on_failure())
                     message += note.path.empty()
                         ? std::format("\n       earlier in this pass, {}: {}",
@@ -608,12 +769,11 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
                                       note.code, note.path, note.message);
                 diagnostics.push_back({plan_failure_code(), Severity::Error,
                                        std::move(message), memberPath});
-                failedMemberRoots.push_back(memberRoot);
+                for (auto const& r : planRoots) failedMemberRoots.push_back(r);
                 continue;
             }
             contexts.push_back(std::move(*ctx));
             workDirs.push_back(mo.work_dir);
-            prefixes.push_back(member.empty() ? std::string{} : member + "/");
             testDiscovery.push_back(std::move(discovery));
         }
     }
@@ -642,11 +802,20 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
                             "would update it", projectLock.string())});
     }
 
+    // A set is named by its package; a document of several configurations
+    // prefixes each name with its configuration's name, the name of the build
+    // directory the configuration is built in (SPEC-005 R3.3), so a package
+    // two configurations compile is a set of each.
+    std::set<std::string> configurations;
+    for (auto const& c : contexts) configurations.insert(c.outputDir.filename().string());
+    auto configurationPrefix = [&](const mcpp::build::BuildContext& c) {
+        return configurations.size() > 1 ? c.outputDir.filename().string() + "/" : std::string{};
+    };
     std::vector<mcpp::build::database::Member> members;
     bool ranBuildPrograms = false;
     for (std::size_t i = 0; i < contexts.size(); ++i) {
-        members.push_back({&contexts[i], prefixes[i], workDirs[i],
-                           testDiscovery[i].first, testDiscovery[i].second});
+        members.push_back({&contexts[i], configurationPrefix(contexts[i]), workDirs[i],
+                           testDiscovery[i]});
         if (!mcpp::build::declared_program_inputs(workDirs[i]).empty())
             ranBuildPrograms = true;
         for (auto const& sp : contexts[i].sourcePackages) {
@@ -663,7 +832,7 @@ export int cmd_emit_build_database(const mcpplibs::cmdline::ParsedArgs& parsed)
         ov.profile, ov.features, ov.capabilities, ov.accel, ov.force_static,
         ov.package_filter, parsed.is_flag_set("workspace"));
     auto rendered = mcpp::build::database::render(members, failedMemberRoots,
-                                                  *root, selector);
+                                                  wsRoot, selector);
     // A note's severity is its own (E3's program-failure note is an error;
     // every other note today is a warning) and its `path`, when set, already
     // names the file relative to the workspace root — render() rewrote it.
@@ -754,6 +923,8 @@ export int cmd_run(const mcpplibs::cmdline::ParsedArgs& parsed,
     if (parsed.is_flag_set("list-runners"))
         return mcpp::build::list_runners(package_filter, cache_mode, no_cache,
                                          target_triple, features, profile, accel);
+    // Closed before the program starts: the program owns the terminal.
+    mcpp::build::progress::open(mcpp::log::is_verbose());
     return mcpp::build::build_run_target(targetName, passthrough, package_filter,
                                          cache_mode, no_cache, target_triple,
                                          no_runner, runner_name, features,
diff --git a/src/cli/cmd_publish.cppm b/src/cli/cmd_publish.cppm
index bbc8d4576..aac28a609 100644
--- a/src/cli/cmd_publish.cppm
+++ b/src/cli/cmd_publish.cppm
@@ -11,6 +11,8 @@ import std;
 import mcpp.build.advice;
 import mcpplibs.cmdline;
 import mcpp.build.prepare;   // profile_override_from_flags
+import mcpp.build.progress;  // the build's report (build progress design 2026-09-29)
+import mcpp.log;
 import mcpp.libs.json;
 import mcpp.pack;
 import mcpp.pack.library_pipeline;
@@ -197,8 +199,12 @@ export int cmd_pack(const mcpplibs::cmdline::ParsedArgs& parsed) {
                                     messageFormat));
         return 2;
     }
-    if (messageFormat == "human")
+    if (messageFormat == "human") {
+        // The build is reported as `mcpp build` reports it; `Finished` closes
+        // the report before the pack's own lines.
+        mcpp::build::progress::open(mcpp::log::is_verbose());
         return cmd_pack_body(parsed, nullptr, nullptr, nullptr);
+    }
 
     mcpp::pack::PackOutcome outcome;
     mcpp::pack::LibraryPackReport library;
diff --git a/src/hooks.cppm b/src/hooks.cppm
index 2f01c82cf..2e529e22a 100644
--- a/src/hooks.cppm
+++ b/src/hooks.cppm
@@ -59,6 +59,10 @@ public:
     // that a failed `build_start` produces. Already reported.
     bool ok() const { return ok_; }
 
+    // Whether the command writes to the terminal while the build runs, beside
+    // the build's own lines (build progress design 2026-09-29, §5.3).
+    bool writes_to_terminal() const { return started_ && inheritOutput_; }
+
     // Close the interval and report what happened while it was open. Returns
     // whether the build may keep its result.
     //
diff --git a/src/main.cpp b/src/main.cpp
index 1c2b27ae4..a96c075d8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -24,6 +24,11 @@ int main(int argc, char* argv[]) {
     // ui::flush() covers the same ground for the ui layer on Windows, where
     // MSVCRT silently treats _IOLBF as _IOFBF.
     mcpp::ui::set_line_buffered();
+    // The status line's clock and `Finished` count from here (build progress
+    // design 2026-09-29, §4.4), and every line, mcpp.log's verbose records
+    // included, is written through mcpp.ui from the first one on.
+    mcpp::ui::mark_command_start();
+    mcpp::ui::init();
 
     int rc;
     try {
@@ -33,12 +38,16 @@ int main(int argc, char* argv[]) {
         // std::terminate — on Windows a silent 0xC0000409 that git-bash
         // reports as a bare exit 127 (mcpp#230 wore that mask). Name the
         // real error and exit with a recognizable internal-error code.
-        std::println(std::cerr, "error: internal: unhandled exception: {}", e.what());
+        mcpp::ui::error(std::format("internal: unhandled exception: {}", e.what()));
         rc = 70;   // EX_SOFTWARE
     } catch (...) {
-        std::println(std::cerr, "error: internal: unhandled non-standard exception");
+        mcpp::ui::error("internal: unhandled non-standard exception");
         rc = 70;
     }
+    // A command that returned early, on an error, may have left its live
+    // region on the screen; the shell's prompt must not follow it on the
+    // status line.
+    mcpp::ui::close_region();
 #ifdef __APPLE__
     // With statically linked libc++ (the macOS release linkage since
     // 0.0.50), static destruction can SIGABRT on exit — same issue xlings
diff --git a/src/pack/pipeline.cppm b/src/pack/pipeline.cppm
index 6753d3270..13321aba0 100644
--- a/src/pack/pipeline.cppm
+++ b/src/pack/pipeline.cppm
@@ -28,6 +28,7 @@ import mcpp.toolchain.model;
 import mcpp.toolchain.probe;
 import mcpp.toolchain.registry;
 import mcpp.toolchain.triple;
+import mcpp.log;
 import mcpp.ui;
 import mcpp.xlings;
 
@@ -207,6 +208,48 @@ build_extra_android_legs(const std::string& targetName,
     return out;
 }
 
+// The human report of what a dispatched format produced. A format may submit
+// one output per file of a distribution tree (1,309 for one program of the
+// validation project), and a line per file then buries the rest of the pass.
+// Up to `kListedOutputs` outputs are named one per line; more are named by the
+// entry each lies in below their common parent, with a count, and --verbose
+// names every one. `--message-format json` lists every output in either case.
+constexpr std::size_t kListedOutputs = 8;
+
+void report_packed(const std::vector<std::filesystem::path>& outputs,
+                   const mcpp::ui::PathContext& pathCtx) {
+    if (outputs.size() <= kListedOutputs || mcpp::log::is_verbose()) {
+        for (auto const& o : outputs)
+            mcpp::ui::status("Packed", mcpp::ui::shorten_path(o, pathCtx));
+        return;
+    }
+    auto parent = outputs.front().parent_path();
+    for (auto const& o : outputs) {
+        auto a = parent.begin(), b = o.begin();
+        std::filesystem::path common;
+        for (; a != parent.end() && b != o.end() && *a == *b; ++a, ++b) common /= *a;
+        parent = common;
+    }
+    // Each entry, in the order first reached, with the outputs below it and
+    // whether it is itself an output (then named alone).
+    struct Entry { std::filesystem::path path; std::size_t outputs = 0; bool isOutput = false; };
+    std::vector<Entry> entries;
+    for (auto const& o : outputs) {
+        // Outputs with no common parent (two drives) are named one by one.
+        const auto rel = parent.empty() ? std::filesystem::path{} : o.lexically_relative(parent);
+        const auto path = rel.empty() || rel == "." ? o : parent / *rel.begin();
+        auto it = std::ranges::find(entries, path, &Entry::path);
+        if (it == entries.end()) it = entries.insert(entries.end(), Entry{path});
+        ++it->outputs;
+        it->isOutput = it->isOutput || path == o;
+    }
+    for (auto const& e : entries)
+        mcpp::ui::status("Packed", e.outputs == 1 && e.isOutput
+            ? mcpp::ui::shorten_path(e.path, pathCtx)
+            : std::format("{} ({} {})", mcpp::ui::shorten_path(e.path, pathCtx), e.outputs,
+                          e.outputs == 1 ? "file" : "files"));
+}
+
 // Everything after CLI option parsing for `mcpp pack`.
 //
 // `wantTarget` is the target NAME the user asked for, empty when they did not.
@@ -821,9 +864,9 @@ export PackOutcome build_and_pack(Options opts, bool modeFromUser,
                 return PackOutcome{1};
             }
             if (consumed.contains(abs)) { intermediate.push_back(std::move(abs)); continue; }
-            mcpp::ui::status("Packed", mcpp::ui::shorten_path(abs, pathCtx));
             reported.push_back(std::move(abs));
         }
+        report_packed(reported, pathCtx);
         // Every output consumed by another: a cycle a provider should not
         // write, reported as all outputs rather than as nothing.
         if (reported.empty()) reported = std::move(intermediate);
diff --git a/src/ui.cppm b/src/ui.cppm
index 345aa67d4..a9545725b 100644
--- a/src/ui.cppm
+++ b/src/ui.cppm
@@ -2,6 +2,15 @@
 //
 // All user-visible status lines from CLI / fetcher / build go through
 // here. TTY auto-detect; MCPP_NO_COLOR / --no-color disables colors.
+//
+// ONE RENDERER, TWO MEDIA (build progress design 2026-09-29, §5). Every line
+// goes through `emit`. On a terminal that can move the cursor, the lines that
+// are still changing -- a download bar, a build program running, a package
+// still compiling, and the status line -- form a region below the log, and a
+// line written while the region is on screen is written above it: the region
+// is erased, the line is written, and the region is drawn again. Anywhere
+// else only final lines are written, and the status line is repeated when the
+// log has been silent for a minute.
 
 module;
 #include <cstdio>      // fileno, stdout
@@ -10,6 +19,7 @@ export module mcpp.ui;
 
 import std;
 import mcpp.platform;
+import mcpp.log;
 
 export namespace mcpp::ui {
 
@@ -30,12 +40,14 @@ void status(std::string_view verb, std::string_view message);
 // Cyan verb (Updating, Downloading, Cleaned).
 void info(std::string_view verb, std::string_view message);
 
-// Bold green Finished line.
+// Bold green Finished line, preceded by a blank line when the command wrote a
+// line before it (design §4.5).
 // `descriptor` annotates the profile's actual effect (e.g. "optimized",
 // "unoptimized + debuginfo"). Empty = print the profile name alone; callers
-// that never resolved the profile knobs must not invent one.
+// that never resolved the profile knobs must not invent one. `detail` follows
+// the time: how the time was spent, when the caller knows it.
 void finished(std::string_view profile, std::chrono::milliseconds elapsed,
-              std::string_view descriptor = {});
+              std::string_view descriptor = {}, std::string_view detail = {});
 
 // "warning:" / "error:" prefix lines (yellow / red).
 void warning(std::string_view message);
@@ -44,6 +56,10 @@ void error(std::string_view message);
 // changes nothing the build does and that a reader may want to act on.
 void note(std::string_view message);
 
+// Text written to stderr as it is, through the region: a block of compiler
+// diagnostics or advice that already carries its own line ends.
+void block(std::string_view text);
+
 // Closing notices: advisories that concern the run as a whole rather than the
 // step that noticed them, such as a refreshed package index that requires a
 // newer mcpp. They are printed once, after the command's own output, as `tip:`
@@ -106,13 +122,101 @@ void flush();
 // and not at all if the process is killed before its buffer fills.
 void set_line_buffered();
 
+// --- measures of text (design §4.2, §5.1) ---
+
+// The columns `text` occupies on a terminal: colour sequences count zero, an
+// East Asian wide or fullwidth character two, a combining mark zero, and every
+// other character one.
+std::size_t display_width(std::string_view text);
+// `text` cut to at most `width` columns, its last column `…` when it was cut.
+// Colour sequences are kept, and a reset follows a cut inside colour.
+std::string fit(std::string_view text, std::size_t width);
+// One format for every duration: `0.84s` and `12.34s` below a minute, `3m12s`
+// below an hour, `1h02m` above it.
+std::string format_duration(std::chrono::milliseconds d);
+// A clock for the status line: `4:05`, `1:02:10`.
+std::string format_clock(std::chrono::milliseconds d);
+
+// The tone of a step line's state.
+enum class Tone { Plain, Good, Muted, Bad };
+// A step line (design §4.2): the verb right-aligned in 12 columns, the
+// subject, and the state starting at `column` (the column after the verb's
+// space), or two spaces after a longer subject. `infoVerb` colours the verb
+// as `info` does, otherwise as `status` does.
+std::string step_line(std::string_view verb, std::string_view subject,
+                      std::size_t column, std::string_view state,
+                      Tone tone = Tone::Plain, bool infoVerb = false);
+// The status line (design §4.4): its first word in the verb colour.
+std::string status_line(std::string_view phase, std::string_view rest);
+
+// --- the command's clock ---
+
+// The moment the command started; main() marks it before anything else. The
+// status line's clock and `Finished` both count from it.
+void mark_command_start();
+std::chrono::steady_clock::time_point command_start();
+
+// --- the live region (design §5) ---
+
+// What the region shows: the lines still changing, and the status line.
+struct Frame {
+    std::vector<std::string> lines;
+    std::string              status;
+};
+using FrameSource = std::function<Frame()>;
+
+// Opens the region for the rest of the command. `source` is asked for the
+// frame on every redraw and heartbeat; it may be called while mcpp.ui holds
+// its own lock, so it must not call back into mcpp.ui, and nothing may call
+// mcpp.ui while holding a lock that `source` takes. On a terminal that can
+// move the cursor the frame is drawn below the log, at most ten times a
+// second on events and once a second otherwise; anywhere else the status line
+// is written when the log has been silent for `heartbeat`. Under --quiet the
+// region shows nothing. `poll`, when given, is called by the same thread
+// before each redraw and heartbeat, without mcpp.ui's lock: it is where the
+// frame's owner reads the files that feed it, and it may write lines.
+void open_region(FrameSource source, std::function<void()> poll = {});
+// Erases the region and stops drawing it. Idempotent.
+void close_region();
+// Something the frame shows changed: redraw within a tenth of a second.
+void touch_region();
+// Whether the region is drawn on a terminal.
+bool region_live();
+// The heartbeat interval of the log medium (tests shorten it).
+void set_heartbeat(std::chrono::milliseconds interval);
+
+// Erases the region for the lifetime of the object, and draws it again after:
+// for a child that writes to the terminal itself.
+class SuspendRegion {
+public:
+    SuspendRegion();
+    ~SuspendRegion();
+    SuspendRegion(const SuspendRegion&) = delete;
+    SuspendRegion& operator=(const SuspendRegion&) = delete;
+};
+
+// One final line to stdout, through the region; suppressed by --quiet.
+void line(std::string_view text);
+
+// The bytes that replace a region of `previousRows` rows with `rows` (each
+// already fitted to the width), and leave the cursor at the end of the last
+// row. Pure: the unit tests read it.
+std::string redraw_bytes(std::size_t previousRows, const std::vector<std::string>& rows);
+// The rows of a frame: the bars, then at most `maxLines` of the frame's lines
+// (the rest summarised as `… N more`), then a blank row and the status line
+// when there is a status. The blank row is left out when nothing precedes the
+// status line, on the screen or above it (`anythingAbove`).
+std::vector<std::string> region_rows(const std::vector<std::string>& bars,
+                                     const Frame& frame, std::size_t maxLines,
+                                     bool anythingAbove);
+
 // --- progress bar (single-line, \r-rewritten) ---
 //
-// ONE RENDERER, TWO OUTPUT MODES. On a terminal the bar is redrawn in place.
-// When stdout is not a terminal (a CI log, a pipe, a file) it prints one line
-// when the item starts, with its size when known, and one line when it
-// finishes, with its duration: no `\r`, no erase sequence, no repaint per
-// frame. The mode follows stdout; `set_live_progress` overrides it for tests.
+// ONE RENDERER, TWO OUTPUT MODES. On a terminal the bar is a line of the
+// region, redrawn in place. When stdout is not a terminal (a CI log, a pipe, a
+// file) it prints one line when the item finishes, with its duration: no `\r`,
+// no erase sequence, no repaint per frame. The mode follows stdout;
+// `set_live_progress` overrides it for tests.
 void set_live_progress(bool live);
 bool live_progress();
 
@@ -234,6 +338,8 @@ namespace mcpp::ui {
 
 namespace {
 
+namespace term = mcpp::platform::terminal;
+
 bool g_color  = false;
 bool g_quiet  = false;
 bool g_inited = false;
@@ -242,6 +348,7 @@ int  g_liveOverride = -1;
 
 constexpr std::string_view kReset      = "\033[0m";
 constexpr std::string_view kBold       = "\033[1m";
+constexpr std::string_view kDim        = "\033[2m";
 constexpr std::string_view kGreen      = "\033[32m";
 constexpr std::string_view kBrightGreen= "\033[92m";
 constexpr std::string_view kCyan       = "\033[36m";
@@ -253,7 +360,9 @@ constexpr std::string_view kBrightRed  = "\033[91m";
 bool detect_color() {
     if (auto* e = std::getenv("MCPP_NO_COLOR"); e && *e == '1') return false;
     if (auto* e = std::getenv("NO_COLOR");      e && *e)        return false;
-    return mcpp::platform::terminal::is_tty();
+    // On Windows this also turns the console's escape processing on, without
+    // which the colour sequences would be printed as text.
+    return term::can_move_cursor(term::Stream::Out);
 }
 
 std::string with_color(std::string_view code, std::string_view text) {
@@ -272,12 +381,182 @@ std::string verb_padded(std::string_view verb) {
     return s;
 }
 
+std::string verb_line(std::string_view colour, std::string_view verb,
+                      std::string_view message) {
+    auto v = verb_padded(verb);
+    if (g_color) return std::format("{}{}{}{} {}", kBold, colour, v, kReset, message);
+    return std::format("{} {}", v, message);
+}
+
+// The configuration groups of one workspace command build on threads
+// (workspace design 2026-09-29 §6), and each narrates its build: one line is
+// written as a whole. The region below is guarded by the same lock.
+std::mutex& line_mutex() {
+    static std::mutex m;
+    return m;
+}
+
+// ─── The region's state, guarded by line_mutex() ────────────────────────
+
+struct Region {
+    bool open      = false;   // open_region was called and close_region not yet
+    bool live      = false;   // drawn on a terminal (decided at open)
+    int  suspended = 0;       // SuspendRegion objects alive
+    FrameSource source;
+    std::function<void()> poll;
+    // The bars of the ProgressBars alive, in creation order.
+    std::vector<std::pair<const void*, std::string>> bars;
+    std::size_t drawnRows = 0;  // rows of the region on the screen now
+    bool anythingAbove = false; // this command wrote a line to stdout
+    std::chrono::steady_clock::time_point lastDraw{};
+    std::chrono::steady_clock::time_point lastLine{};
+    std::chrono::milliseconds heartbeat{60'000};
+};
+
+Region& region() {
+    static Region r;
+    return r;
+}
+
+// The ticker, and how events reach it without the line lock.
+struct Ticker {
+    std::jthread            thread;
+    std::mutex              m;
+    std::condition_variable_any cv;
+    std::atomic<bool>       dirty{false};
+};
+Ticker& ticker() {
+    static Ticker t;
+    return t;
+}
+
+std::chrono::steady_clock::time_point& start_point() {
+    static auto t = std::chrono::steady_clock::now();
+    return t;
+}
+
+// Whether the bars draw on a terminal: the region's decision while it is
+// open, stdout's otherwise.
+bool bars_live() {
+    auto& r = region();
+    if (r.open) return r.live;
+    if (g_liveOverride >= 0) return g_liveOverride == 1;
+    return term::can_move_cursor(term::Stream::Out);
+}
+
+std::string erase_bytes(std::size_t rows) {
+    if (rows == 0) return {};
+    std::string s = "\r";
+    if (rows > 1) s += std::format("\033[{}A", rows - 1);
+    s += "\033[J";
+    return s;
+}
+
+std::size_t max_live_lines() {
+    const auto rows = term::rows();
+    return std::min<std::size_t>(10, rows > 3 ? rows - 3 : 1);
+}
+
+// Draws the region as it is now; line_mutex() held.
+void redraw_locked() {
+    auto& r = region();
+    if (r.suspended > 0 || g_quiet) return;
+    const bool live = bars_live();
+    if (!live) return;
+    Frame frame;
+    if (r.open && r.source) frame = r.source();
+    std::vector<std::string> bars;
+    for (auto const& [who, text] : r.bars) bars.push_back(text);
+    auto rows = region_rows(bars, frame, max_live_lines(), r.anythingAbove);
+    const auto width = term::cols() > 1 ? term::cols() - 1 : 1;
+    for (auto& row : rows) row = fit(row, width);
+    term::write(term::Stream::Out, redraw_bytes(r.drawnRows, rows));
+    std::fflush(stdout);
+    r.drawnRows = rows.size();
+    r.lastDraw  = std::chrono::steady_clock::now();
+}
+
+void erase_locked() {
+    auto& r = region();
+    if (r.drawnRows == 0) return;
+    term::write(term::Stream::Out, erase_bytes(r.drawnRows));
+    std::fflush(stdout);
+    r.drawnRows = 0;
+}
+
+// Writes `text` (whole lines) to the stream above the region; line_mutex()
+// held.
+void emit_locked(term::Stream s, std::string_view text) {
+    auto& r = region();
+    erase_locked();
+    term::write(s, text);
+    std::fflush(s == term::Stream::Out ? stdout : stderr);
+    if (s == term::Stream::Out && !text.empty()) r.anythingAbove = true;
+    r.lastLine = std::chrono::steady_clock::now();
+    redraw_locked();
+}
+
+void emit(term::Stream s, std::string_view text);
+
+// The terminal side of mcpp.log's verbose records: through the one writer.
+void verbose_record(const mcpp::log::Record& record) {
+    emit(term::Stream::Err, mcpp::log::verbose_line(record, g_color));
+}
+
+void tick(std::stop_token stop) {
+    auto& t = ticker();
+    constexpr auto kMinInterval = std::chrono::milliseconds(100);
+    auto lastTick = std::chrono::steady_clock::now() - kMinInterval;
+    while (!stop.stop_requested()) {
+        {
+            std::unique_lock lk(t.m);
+            // At most ten frames a second (design §5.1): an event within a
+            // tenth of a second of the last tick waits for the rest of it,
+            // and its `dirty` flag is honoured then.
+            const auto next = lastTick + kMinInterval;
+            if (std::chrono::steady_clock::now() < next)
+                t.cv.wait_until(lk, stop, next, [] { return false; });
+            else
+                t.cv.wait_for(lk, stop, kMinInterval, [&] { return t.dirty.load(); });
+        }
+        if (stop.stop_requested()) break;
+        lastTick = std::chrono::steady_clock::now();
+        std::function<void()> poll;
+        {
+            std::lock_guard line(line_mutex());
+            poll = region().poll;
+        }
+        if (poll) poll();
+        const bool dirty = t.dirty.exchange(false);
+        std::lock_guard line(line_mutex());
+        auto& r = region();
+        if (!r.open) continue;
+        const auto now = std::chrono::steady_clock::now();
+        if (r.live) {
+            if (dirty || now - r.lastDraw >= std::chrono::seconds(1)) redraw_locked();
+            continue;
+        }
+        if (g_quiet || !r.source || now - r.lastLine < r.heartbeat) continue;
+        auto frame = r.source();
+        if (frame.status.empty()) { r.lastLine = now; continue; }
+        emit_locked(term::Stream::Out, frame.status + "\n");
+    }
+}
+
+} // namespace
+
+namespace {
+void emit(term::Stream s, std::string_view text) {
+    std::lock_guard line(line_mutex());
+    emit_locked(s, text);
+}
 } // namespace
 
 void init() {
     if (g_inited) return;
     g_color  = detect_color();
     g_inited = true;
+    mcpp::log::set_terminal_sink(&verbose_record);
 }
 
 void disable_color() { g_color = false; }
@@ -289,8 +568,7 @@ void set_live_progress(bool live) { g_liveOverride = live ? 1 : 0; }
 
 bool live_progress() {
     if (g_liveOverride >= 0) return g_liveOverride == 1;
-    static const bool tty = mcpp::platform::terminal::is_tty();
-    return tty;
+    return term::can_move_cursor(term::Stream::Out);
 }
 bool is_quiet()        { return g_quiet; }
 
@@ -315,94 +593,64 @@ void set_line_buffered() {
 #endif
 }
 
-// The configuration groups of one workspace command build on threads
-// (workspace design 2026-09-29 §6), and each narrates its build: one line is
-// written as a whole.
-std::mutex& line_mutex() {
-    static std::mutex m;
-    return m;
-}
-
 void status(std::string_view verb, std::string_view message) {
-    std::lock_guard line(line_mutex());
     if (g_quiet) return;
     init();
-    auto v = verb_padded(verb);
-    if (g_color) {
-        std::println("{}{}{}{} {}",
-                     kBold, kBrightGreen, v, kReset, message);
-    } else {
-        std::println("{} {}", v, message);
-    }
-    flush();
+    emit(term::Stream::Out, verb_line(kBrightGreen, verb, message) + "\n");
 }
 
 void info(std::string_view verb, std::string_view message) {
-    std::lock_guard line(line_mutex());
     if (g_quiet) return;
     init();
-    auto v = verb_padded(verb);
-    if (g_color) {
-        std::println("{}{}{}{} {}",
-                     kBold, kBrightCyan, v, kReset, message);
-    } else {
-        std::println("{} {}", v, message);
-    }
-    flush();
+    emit(term::Stream::Out, verb_line(kBrightCyan, verb, message) + "\n");
 }
 
 void finished(std::string_view profile, std::chrono::milliseconds elapsed,
-              std::string_view descriptor) {
-    std::lock_guard line(line_mutex());
+              std::string_view descriptor, std::string_view detail) {
     if (g_quiet) return;
     init();
-    auto v = verb_padded("Finished");
-    auto secs = static_cast<double>(elapsed.count()) / 1000.0;
     // `[optimized]` used to be hardcoded here alongside a hardcoded "release"
     // at the only call site, so every build — including `--dev` at -O0 -g —
     // announced "Finished release [optimized]". The descriptor is now supplied
     // by whoever actually resolved the profile knobs, and omitted by callers
     // (the fast path) that never resolved them: no caller has to guess.
     auto msg = descriptor.empty()
-        ? std::format("{} in {:.2f}s", profile, secs)
-        : std::format("{} [{}] in {:.2f}s", profile, descriptor, secs);
-    if (g_color) {
-        std::println("{}{}{}{} {}",
-                     kBold, kBrightGreen, v, kReset, msg);
-    } else {
-        std::println("{} {}", v, msg);
-    }
-    flush();
+        ? std::format("{} in {}", profile, format_duration(elapsed))
+        : std::format("{} [{}] in {}", profile, descriptor, format_duration(elapsed));
+    if (!detail.empty()) msg += std::format(" · {}", detail);
+    std::lock_guard line(line_mutex());
+    // The summary is separated from the steps above it by one blank line
+    // (design §4.5); a command that wrote nothing before it writes none.
+    const std::string head = region().anythingAbove ? "\n" : "";
+    emit_locked(term::Stream::Out, head + verb_line(kBrightGreen, "Finished", msg) + "\n");
 }
 
 void warning(std::string_view message) {
-    std::lock_guard line(line_mutex());
     init();
-    if (g_color) {
-        std::println(stderr, "{}{}warning:{} {}", kBold, kYellow, kReset, message);
-    } else {
-        std::println(stderr, "warning: {}", message);
-    }
+    emit(term::Stream::Err, g_color
+        ? std::format("{}{}warning:{} {}\n", kBold, kYellow, kReset, message)
+        : std::format("warning: {}\n", message));
 }
 
 void error(std::string_view message) {
-    std::lock_guard line(line_mutex());
     init();
-    if (g_color) {
-        std::println(stderr, "{}{}error:{} {}", kBold, kBrightRed, kReset, message);
-    } else {
-        std::println(stderr, "error: {}", message);
-    }
+    emit(term::Stream::Err, g_color
+        ? std::format("{}{}error:{} {}\n", kBold, kBrightRed, kReset, message)
+        : std::format("error: {}\n", message));
 }
 
 void note(std::string_view message) {
-    std::lock_guard line(line_mutex());
     init();
-    if (g_color) {
-        std::println(stderr, "{}{}note:{} {}", kBold, kCyan, kReset, message);
-    } else {
-        std::println(stderr, "note: {}", message);
-    }
+    emit(term::Stream::Err, g_color
+        ? std::format("{}{}note:{} {}\n", kBold, kCyan, kReset, message)
+        : std::format("note: {}\n", message));
+}
+
+void block(std::string_view text) {
+    if (text.empty()) return;
+    std::string s(text);
+    if (s.back() != '\n') s += '\n';
+    emit(term::Stream::Err, s);
 }
 
 namespace {
@@ -428,17 +676,20 @@ void print_closing_notices() {
     if (g_quiet) return;
     init();
     for (auto const& n : notices) {
-        if (g_color)
-            std::println(stderr, "{}{}tip:{} {}", kBold, kCyan, kReset, n.message);
-        else
-            std::println(stderr, "tip: {}", n.message);
+        emit(term::Stream::Err, g_color
+            ? std::format("{}{}tip:{} {}\n", kBold, kCyan, kReset, n.message)
+            : std::format("tip: {}\n", n.message));
     }
 }
 
 void plain(std::string_view message) {
     if (g_quiet) return;
-    std::println("{}", message);
-    flush();
+    emit(term::Stream::Out, std::string(message) + "\n");
+}
+
+void line(std::string_view text) {
+    if (g_quiet) return;
+    emit(term::Stream::Out, std::string(text) + "\n");
 }
 
 void diagnostic(const Diagnostic& d) {
@@ -451,45 +702,277 @@ void diagnostic(const Diagnostic& d) {
         return g_color ? std::format("{}{}{}{}", kBold, kBrightCyan, s, kReset)
                        : std::string(s);
     };
+    std::string out;
     std::string head = "error";
     if (!d.code.empty()) head += "[" + d.code + "]";
     head += ":";
-    std::println(stderr, "{} {}", bold_red(head), d.title);
+    out += std::format("{} {}\n", bold_red(head), d.title);
 
     if (!d.path.empty()) {
         if (d.line)
-            std::println(stderr, "  {} {}:{}{}",
+            out += std::format("  {} {}:{}{}\n",
                 blue("-->"), d.path.string(), d.line,
                 d.column ? std::format(":{}", d.column) : "");
         else
-            std::println(stderr, "  {} {}", blue("-->"), d.path.string());
+            out += std::format("  {} {}\n", blue("-->"), d.path.string());
     }
 
     if (!d.sourceLine.empty()) {
-        std::println(stderr, "   {}", blue("|"));
-        std::println(stderr, " {} {} {}",
+        out += std::format("   {}\n", blue("|"));
+        out += std::format(" {} {} {}\n",
             d.line ? std::format("{:>2}", d.line) : "  ", blue("|"), d.sourceLine);
         if (!d.spanMessage.empty()) {
             std::string caret(d.column ? d.column - 1 : 0, ' ');
             caret += "^";
-            std::println(stderr, "   {} {} {}", blue("|"), caret, d.spanMessage);
+            out += std::format("   {} {} {}\n", blue("|"), caret, d.spanMessage);
         }
     }
 
     if (!d.notes.empty() || !d.helps.empty()) {
-        std::println(stderr, "   {}", blue("|"));
+        out += std::format("   {}\n", blue("|"));
     }
     for (auto& n : d.notes) {
-        std::println(stderr, "   {} {}: {}", blue("="), blue("note"), n);
+        out += std::format("   {} {}: {}\n", blue("="), blue("note"), n);
     }
     for (auto& h : d.helps) {
-        std::println(stderr, "   {} {}: {}", blue("="), blue("help"), h);
+        out += std::format("   {} {}: {}\n", blue("="), blue("help"), h);
     }
     if (!d.code.empty()) {
-        std::println(stderr, "");
-        std::println(stderr, "For more information on this error: `mcpp --explain {}`",
-                     d.code);
+        out += "\n";
+        out += std::format("For more information on this error: `mcpp --explain {}`\n",
+                           d.code);
+    }
+    emit(term::Stream::Err, out);
+}
+
+// ─── Measures of text ────────────────────────────────────────────────────
+
+namespace {
+
+// One UTF-8 character at `i`: its code point and its length in bytes. A
+// malformed byte is one character of one byte.
+std::pair<char32_t, std::size_t> decode(std::string_view s, std::size_t i) {
+    const auto b = static_cast<unsigned char>(s[i]);
+    auto cont = [&](std::size_t k) {
+        return i + k < s.size() && (static_cast<unsigned char>(s[i + k]) & 0xC0) == 0x80;
+    };
+    auto bits = [&](std::size_t k) {
+        return static_cast<char32_t>(static_cast<unsigned char>(s[i + k]) & 0x3F);
+    };
+    if (b < 0x80) return {b, 1};
+    if ((b & 0xE0) == 0xC0 && cont(1))
+        return {(static_cast<char32_t>(b & 0x1F) << 6) | bits(1), 2};
+    if ((b & 0xF0) == 0xE0 && cont(1) && cont(2))
+        return {(static_cast<char32_t>(b & 0x0F) << 12) | (bits(1) << 6) | bits(2), 3};
+    if ((b & 0xF8) == 0xF0 && cont(1) && cont(2) && cont(3))
+        return {(static_cast<char32_t>(b & 0x07) << 18) | (bits(1) << 12)
+                    | (bits(2) << 6) | bits(3), 4};
+    return {b, 1};
+}
+
+std::size_t char_width(char32_t c) {
+    if (c < 0x20 || c == 0x7F) return 0;
+    // Combining marks.
+    if ((c >= 0x0300 && c <= 0x036F) || (c >= 0x1AB0 && c <= 0x1AFF)
+        || (c >= 0x1DC0 && c <= 0x1DFF) || (c >= 0x20D0 && c <= 0x20FF)
+        || (c >= 0xFE20 && c <= 0xFE2F) || c == 0x200B || c == 0x200D)
+        return 0;
+    // East Asian wide and fullwidth.
+    if ((c >= 0x1100 && c <= 0x115F) || (c >= 0x2E80 && c <= 0x303E)
+        || (c >= 0x3041 && c <= 0x33FF) || (c >= 0x3400 && c <= 0x4DBF)
+        || (c >= 0x4E00 && c <= 0x9FFF) || (c >= 0xA000 && c <= 0xA4CF)
+        || (c >= 0xAC00 && c <= 0xD7A3) || (c >= 0xF900 && c <= 0xFAFF)
+        || (c >= 0xFE30 && c <= 0xFE4F) || (c >= 0xFF00 && c <= 0xFF60)
+        || (c >= 0xFFE0 && c <= 0xFFE6) || (c >= 0x20000 && c <= 0x3FFFD))
+        return 2;
+    return 1;
+}
+
+// The length of the escape sequence starting at `i`, or 0.
+std::size_t escape_length(std::string_view s, std::size_t i) {
+    if (s[i] != '\033' || i + 1 >= s.size() || s[i + 1] != '[') return 0;
+    std::size_t k = i + 2;
+    while (k < s.size() && !(s[k] >= 0x40 && s[k] <= 0x7E)) ++k;
+    return k < s.size() ? k - i + 1 : s.size() - i;
+}
+
+} // namespace
+
+std::size_t display_width(std::string_view text) {
+    std::size_t w = 0;
+    for (std::size_t i = 0; i < text.size();) {
+        if (auto e = escape_length(text, i)) { i += e; continue; }
+        auto [c, n] = decode(text, i);
+        w += char_width(c);
+        i += n;
+    }
+    return w;
+}
+
+std::string fit(std::string_view text, std::size_t width) {
+    if (display_width(text) <= width) return std::string(text);
+    std::string out;
+    std::size_t w = 0;
+    bool coloured = false;
+    const std::size_t room = width > 0 ? width - 1 : 0;   // one column for `…`
+    for (std::size_t i = 0; i < text.size();) {
+        if (auto e = escape_length(text, i)) {
+            out.append(text.substr(i, e));
+            coloured = true;
+            i += e;
+            continue;
+        }
+        auto [c, n] = decode(text, i);
+        const auto cw = char_width(c);
+        if (w + cw > room) break;
+        out.append(text.substr(i, n));
+        w += cw;
+        i += n;
+    }
+    if (width > 0) out += "…";
+    if (coloured) out += kReset;
+    return out;
+}
+
+std::string format_duration(std::chrono::milliseconds d) {
+    const auto ms = d.count() < 0 ? 0 : d.count();
+    if (ms < 60'000) return std::format("{:.2f}s", static_cast<double>(ms) / 1000.0);
+    const auto s = ms / 1000;
+    if (s < 3600) return std::format("{}m{:02}s", s / 60, s % 60);
+    return std::format("{}h{:02}m", s / 3600, (s % 3600) / 60);
+}
+
+std::string format_clock(std::chrono::milliseconds d) {
+    const auto s = (d.count() < 0 ? 0 : d.count()) / 1000;
+    if (s < 3600) return std::format("{}:{:02}", s / 60, s % 60);
+    return std::format("{}:{:02}:{:02}", s / 3600, (s % 3600) / 60, s % 60);
+}
+
+std::string step_line(std::string_view verb, std::string_view subject,
+                      std::size_t column, std::string_view state,
+                      Tone tone, bool infoVerb) {
+    init();
+    std::string s = verb_line(infoVerb ? kBrightCyan : kBrightGreen, verb, subject);
+    if (state.empty()) return s;
+    const auto used = display_width(subject);
+    s.append(used + 2 <= column ? column - used : 2, ' ');
+    std::string_view colour = tone == Tone::Good  ? kGreen
+                            : tone == Tone::Muted ? kDim
+                            : tone == Tone::Bad   ? kRed
+                                                  : std::string_view{};
+    if (g_color && !colour.empty()) s += std::format("{}{}{}", colour, state, kReset);
+    else s += state;
+    return s;
+}
+
+std::string status_line(std::string_view phase, std::string_view rest) {
+    init();
+    std::string s = g_color ? std::format("{}{}{}{}", kBold, kBrightCyan, phase, kReset)
+                            : std::string(phase);
+    if (!rest.empty()) s += std::format(" {}", rest);
+    return s;
+}
+
+// ─── The command's clock ─────────────────────────────────────────────────
+
+void mark_command_start() { (void)start_point(); }
+std::chrono::steady_clock::time_point command_start() { return start_point(); }
+
+// ─── The live region ─────────────────────────────────────────────────────
+
+std::string redraw_bytes(std::size_t previousRows, const std::vector<std::string>& rows) {
+    std::string s = erase_bytes(previousRows);
+    for (std::size_t i = 0; i < rows.size(); ++i) {
+        if (i) s += '\n';
+        s += rows[i];
+    }
+    return s;
+}
+
+std::vector<std::string> region_rows(const std::vector<std::string>& bars,
+                                     const Frame& frame, std::size_t maxLines,
+                                     bool anythingAbove) {
+    std::vector<std::string> rows = bars;
+    const std::size_t room = maxLines > bars.size() ? maxLines - bars.size() : 0;
+    const std::size_t shown = frame.lines.size() <= room
+        ? frame.lines.size() : (room > 0 ? room - 1 : 0);
+    for (std::size_t i = 0; i < shown; ++i) rows.push_back(frame.lines[i]);
+    if (shown < frame.lines.size())
+        rows.push_back(std::format("{}… {} more", std::string(12, ' '),
+                                   frame.lines.size() - shown));
+    if (!frame.status.empty()) {
+        if (!rows.empty() || anythingAbove) rows.emplace_back();
+        rows.push_back(frame.status);
+    }
+    return rows;
+}
+
+void open_region(FrameSource source, std::function<void()> poll) {
+    {
+        std::lock_guard line(line_mutex());
+        auto& r = region();
+        if (r.open) { r.source = std::move(source); r.poll = std::move(poll); return; }
+        r.open   = true;
+        r.live   = !g_quiet && live_progress();
+        r.source = std::move(source);
+        r.poll   = std::move(poll);
+        r.lastLine = std::chrono::steady_clock::now();
+    }
+    ticker().thread = std::jthread(tick);
+}
+
+void close_region() {
+    auto& t = ticker();
+    if (t.thread.joinable()) {
+        t.thread.request_stop();
+        t.cv.notify_all();
+        t.thread.join();
     }
+    std::lock_guard line(line_mutex());
+    auto& r = region();
+    if (!r.open) return;
+    // Bars that outlive the region are drawn by themselves from here on.
+    const auto bars = std::move(r.bars);
+    r.bars.clear();
+    erase_locked();
+    r.open   = false;
+    r.source = nullptr;
+    r.poll   = nullptr;
+    r.bars   = bars;
+}
+
+void touch_region() {
+    auto& t = ticker();
+    t.dirty.store(true);
+    t.cv.notify_all();
+}
+
+bool region_live() {
+    std::lock_guard line(line_mutex());
+    return region().open && region().live;
+}
+
+void set_heartbeat(std::chrono::milliseconds interval) {
+    std::lock_guard line(line_mutex());
+    region().heartbeat = interval;
+}
+
+SuspendRegion::SuspendRegion() {
+    std::fflush(stdout);
+    std::lock_guard line(line_mutex());
+    erase_locked();
+    ++region().suspended;
+}
+
+SuspendRegion::~SuspendRegion() {
+    std::fflush(stdout);
+    std::fflush(stderr);
+    std::lock_guard line(line_mutex());
+    auto& r = region();
+    if (r.suspended > 0) --r.suspended;
+    // The child's lines are above the region now, and it ended its last line.
+    r.anythingAbove = true;
+    redraw_locked();
 }
 
 // --- ProgressBar ---
@@ -523,7 +1006,7 @@ std::string fmt_bytes(std::size_t b) {
 // rather collapse the bar than wrap into a second row that `\r\033[2K`
 // can't clean up later.
 std::size_t terminal_cols() {
-    return mcpp::platform::terminal::cols();
+    return term::cols();
 }
 
 // Truncate a "visible" string (no ANSI codes inside) to `max` chars, replacing
@@ -557,14 +1040,14 @@ std::string render_bar_swept(std::size_t frame, std::size_t width = 20) {
     return "[" + inner + "]";
 }
 
-// Shared terminal-width budgeting for a one-line status: draws
+// Shared terminal-width budgeting for a one-line status: composes
 //   <verb-padded-12> <label> <bar> <info>
 // shrinking the bar first, then truncating the label, so the result is always
 // ≤ cols-1 visible chars. `makeBar(innerWidth)` produces the bar string
 // (including its `[`/`]` brackets) for the negotiated inner width.
 template <class MakeBar>
-void draw_status_line(std::string_view verb, const std::string& label,
-                      MakeBar&& makeBar, const std::string& info_text)
+std::string status_bar_text(std::string_view verb, const std::string& label,
+                            MakeBar&& makeBar, const std::string& info_text)
 {
     constexpr std::size_t kVerbWidth = 12;
     constexpr std::size_t kBarMax    = 20;
@@ -581,15 +1064,7 @@ void draw_status_line(std::string_view verb, const std::string& label,
                          ? budget - kVerbWidth - 1 - info_text.size() - 1
                          : 0;
         auto lbl = trunc_visible(label, labelBudget);
-        if (g_color) {
-            std::print("\r\033[2K{}{}{}{} {} {}",
-                       kBold, kBrightCyan, verb_padded(verb), kReset,
-                       lbl, info_text);
-        } else {
-            std::print("\r\033[2K{} {} {}", verb_padded(verb), lbl, info_text);
-        }
-        std::fflush(stdout);
-        return;
+        return verb_line(kBrightCyan, verb, std::format("{} {}", lbl, info_text));
     }
     auto contentBudget = budget - fixed;   // barInner + visible-label-cols
 
@@ -602,16 +1077,24 @@ void draw_status_line(std::string_view verb, const std::string& label,
     }
     auto bar = makeBar(barW);
     auto lbl = trunc_visible(label, labelMax);
+    return verb_line(kBrightCyan, verb, std::format("{} {} {}", lbl, bar, info_text));
+}
 
-    if (g_color) {
-        std::print("\r\033[2K{}{}{}{} {} {} {}",
-                   kBold, kBrightCyan, verb_padded(verb), kReset,
-                   lbl, bar, info_text);
-    } else {
-        std::print("\r\033[2K{} {} {} {}",
-                   verb_padded(verb), lbl, bar, info_text);
-    }
-    std::fflush(stdout);
+// Sets this bar's row of the region and draws it.
+void show_bar(const void* who, std::string text) {
+    std::lock_guard line(line_mutex());
+    auto& bars = region().bars;
+    auto it = std::ranges::find_if(bars, [&](auto const& b) { return b.first == who; });
+    if (it == bars.end()) bars.emplace_back(who, std::move(text));
+    else it->second = std::move(text);
+    redraw_locked();
+}
+
+// Removes this bar's row; the region is drawn again by the next line.
+void drop_bar(const void* who) {
+    std::lock_guard line(line_mutex());
+    auto& bars = region().bars;
+    std::erase_if(bars, [&](auto const& b) { return b.first == who; });
 }
 
 } // namespace
@@ -644,26 +1127,19 @@ ProgressBar::~ProgressBar() {
     if (!finished_) finish();
 }
 
-// Render a single progress-bar frame. The verb is drawn separately (with
-// optional color) so we can keep ANSI escapes out of the truncation budget.
-// `cols` is the available terminal width; `info_text` is the trailing
-// "%" / "X MB / Y MB / Z MB/s" suffix; `pct` drives the bar fill.
+// Render a single progress-bar frame as this bar's row of the region. The
+// verb is coloured separately so the ANSI escapes stay out of the truncation
+// budget.
 //
-// Layout (visible chars only):
-//   <verb-padded-12> <label> <bar> <info>
-//
-// The bar shrinks first when we run out of room, then `label` is truncated
-// with an ellipsis. Result is always ≤ cols-1 chars so a `\r\033[2K{...}`
-// write never wraps into a second row.
 // Layout (visible chars only): <verb-padded-12> <label> <bar> <info>.
-// The width budgeting lives in draw_status_line(); this just supplies a
+// The width budgeting lives in status_bar_text(); this just supplies a
 // percentage-fill bar for the negotiated inner width.
 void ProgressBar::render_line(std::size_t pct, const std::string& info_text)
 {
     init();
-    draw_status_line(verb_, label_,
-                     [pct](std::size_t w) { return render_bar(pct, w); },
-                     info_text);
+    show_bar(this, status_bar_text(verb_, label_,
+                                   [pct](std::size_t w) { return render_bar(pct, w); },
+                                   info_text));
 }
 
 // Same layout, but an animated swept/indeterminate bar (used while the total
@@ -671,14 +1147,14 @@ void ProgressBar::render_line(std::size_t pct, const std::string& info_text)
 void ProgressBar::render_line_swept(std::size_t frame, const std::string& info_text)
 {
     init();
-    draw_status_line(verb_, label_,
-                     [frame](std::size_t w) { return render_bar_swept(frame, w); },
-                     info_text);
+    show_bar(this, status_bar_text(verb_, label_,
+                                   [frame](std::size_t w) { return render_bar_swept(frame, w); },
+                                   info_text));
 }
 
 void ProgressBar::update(std::size_t percent) {
     if (g_quiet || finished_) return;
-    if (!live_progress()) { announce(0); return; }
+    if (!bars_live()) { announce(0); return; }
     auto now = std::chrono::steady_clock::now();
     if (now - lastDraw_ < std::chrono::milliseconds(80) && percent < 100) return;
     lastDraw_ = now;
@@ -688,7 +1164,7 @@ void ProgressBar::update(std::size_t percent) {
 void ProgressBar::update_bytes(std::size_t current, std::size_t total,
                                double elapsed_sec) {
     if (g_quiet || finished_) return;
-    if (!live_progress()) { announce(total); if (current > lastBytes_) lastBytes_ = current; return; }
+    if (!bars_live()) { announce(total); if (current > lastBytes_) lastBytes_ = current; return; }
     if (current > lastBytes_) lastBytes_ = current;
     auto now = std::chrono::steady_clock::now();
     auto pct = total ? (current * 100 / total) : 0;
@@ -712,7 +1188,7 @@ void ProgressBar::update_bytes(std::size_t current, std::size_t total,
 void ProgressBar::update_indeterminate(std::size_t current_bytes,
                                        double elapsed_sec) {
     if (g_quiet || finished_) return;
-    if (!live_progress()) { announce(0); lastBytes_ = current_bytes; return; }
+    if (!bars_live()) { announce(0); lastBytes_ = current_bytes; return; }
     lastBytes_ = current_bytes;
     auto now = std::chrono::steady_clock::now();
     // Same ~80ms throttle as update_bytes(); there is no "100%" early-out here
@@ -735,36 +1211,28 @@ void ProgressBar::update_indeterminate(std::size_t current_bytes,
 void ProgressBar::finish() {
     if (finished_) return;
     finished_ = true;
+    drop_bar(this);
     if (g_quiet) return;
-    if (!live_progress()) {
-        announce(0);
-        finish_plain(label_);
-        return;
-    }
-    // Clear the line and re-emit it as the completion line.
-    std::print("\r\033[2K");
-    info(verb_, completion(label_));
+    if (!bars_live()) announce(0);
+    // The bar's row is replaced by the completion line in both modes.
+    finish_plain(label_);
 }
 
 void ProgressBar::finish_with(std::string_view final_message) {
     if (finished_) return;
     finished_ = true;
+    drop_bar(this);
     if (g_quiet) return;
-    if (!live_progress()) {
-        announce(0);
-        finish_plain(final_message);
-        return;
-    }
-    std::print("\r\033[2K");
-    info(verb_, completion(final_message));
+    if (!bars_live()) announce(0);
+    finish_plain(final_message);
 }
 
 void ProgressBar::finish_failed(std::string_view final_message) {
     if (finished_) return;
     finished_ = true;
+    drop_bar(this);
     if (g_quiet) return;
-    if (live_progress()) std::print("\r\033[2K");
-    else announce(0);
+    if (!bars_live()) announce(0);
     const auto secs = std::chrono::duration<double>(
         std::chrono::steady_clock::now() - start_).count();
     info(verb_, std::format("{} did not complete ({:.1f}s)", final_message, secs));
diff --git a/tests/e2e/110_build_mcpp_env_contract.sh b/tests/e2e/110_build_mcpp_env_contract.sh
index f735fc6fd..b31a60eae 100755
--- a/tests/e2e/110_build_mcpp_env_contract.sh
+++ b/tests/e2e/110_build_mcpp_env_contract.sh
@@ -89,13 +89,13 @@ tos="${BASH_REMATCH[1]}"; tarch="${BASH_REMATCH[2]}"
 # before build.mcpp, or the build.mcpp cache hits — both are fine; a "running"
 # line is not).
 "$MCPP" build > build2.log 2>&1
-grep -q "build.mcpp running" build2.log && {
+grep -qE "^ *build\.mcpp .* ran [0-9]" build2.log && {
     cat build2.log; echo "identical build re-ran build.mcpp"; exit 1; } || true
 
 # Feature change → contract hash changes → re-run, and the program observes
 # the feature.
 "$MCPP" build --features extra > build3.log 2>&1 || { cat build3.log; echo "build 3 failed"; exit 1; }
-grep -q "build.mcpp running" build3.log || {
+grep -qE "^ *build\.mcpp .* ran [0-9]" build3.log || {
     cat build3.log; echo "feature change did not re-run build.mcpp"; exit 1; }
 bin="$(ls -t $(find target -name 'envbp' -type f) | head -1)"
 out="$("./$bin" | tail -1)"
@@ -104,7 +104,7 @@ out="$("./$bin" | tail -1)"
 
 # Profile change also re-runs.
 "$MCPP" build --release > build4.log 2>&1 || { cat build4.log; echo "build 4 failed"; exit 1; }
-grep -q "build.mcpp running" build4.log || {
+grep -qE "^ *build\.mcpp .* ran [0-9]" build4.log || {
     cat build4.log; echo "profile change did not re-run build.mcpp"; exit 1; }
 bin="$(ls -t $(find target -name 'envbp' -type f) | head -1)"
 out="$("./$bin" | tail -1)"
diff --git a/tests/e2e/135_diagnostic_promise_resolves.sh b/tests/e2e/135_diagnostic_promise_resolves.sh
index 383d2d1b6..f0797cc76 100755
--- a/tests/e2e/135_diagnostic_promise_resolves.sh
+++ b/tests/e2e/135_diagnostic_promise_resolves.sh
@@ -91,7 +91,7 @@ EOF
 # and that failure is not what this test is about. What must not happen is a
 # RESOLUTION failure: that is what a stale name or a stale version produces, and
 # it is what both historical occurrences looked like.
-"$MCPP" build > paste.log 2>&1 || true
+"$MCPP" build -v > paste.log 2>&1 || true
 
 if grep -qE 'not found in the synced index|package not found|E_NOT_FOUND' paste.log; then
     cat paste.log
@@ -107,7 +107,7 @@ fi
 # ...and the package must actually have entered the graph, so that a build which
 # silently ignored the dependency cannot pass. One of the three verbs mcpp uses
 # for a dependency it resolved has to name it.
-grep -qE '(Downloading|Compiling|Cached).*std-freestanding' paste.log || {
+grep -qE '(Downloading|Compiling).*std-freestanding' paste.log || {
     cat paste.log
     echo "the pasted dependency never entered the build graph"
     exit 1; }
diff --git a/tests/e2e/139_build_program_advisory.sh b/tests/e2e/139_build_program_advisory.sh
index 247db6e69..d4d5e5387 100755
--- a/tests/e2e/139_build_program_advisory.sh
+++ b/tests/e2e/139_build_program_advisory.sh
@@ -91,7 +91,7 @@ touch src/main.cpp
 # First establish that this build really was a cache hit. Without this the next
 # assertion could pass for the wrong reason — a re-run would also print the
 # line, and the replay path would go untested.
-grep -q "up to date (cached)" second.log \
+grep -qE "^ *build\.mcpp .* cached" second.log \
   || { cat second.log; echo "FAIL: the second build re-ran the program; the replay path was not exercised"; exit 1; }
 
 grep -q "advisory: no emulator found" second.log \
diff --git a/tests/e2e/143_build_mcpp_source_directive.sh b/tests/e2e/143_build_mcpp_source_directive.sh
index 55e1b9741..3e916d6b3 100755
--- a/tests/e2e/143_build_mcpp_source_directive.sh
+++ b/tests/e2e/143_build_mcpp_source_directive.sh
@@ -70,7 +70,7 @@ int main() {
 }
 EOF
 "$MCPP" build > build2.log 2>&1 || { cat build2.log; echo "FAIL: rebuild failed"; exit 1; }
-grep -q "build.mcpp running" build2.log && {
+grep -qE "^ *build\.mcpp .* ran [0-9]" build2.log && {
     cat build2.log; echo "FAIL: unchanged build.mcpp re-ran"; exit 1; } || true
 out="$("$MCPP" run 2>&1 | grep '^SELECTED2=' | tail -1)"
 [[ "$out" == "SELECTED2=42" ]] || { echo "FAIL: cached source record lost: $out"; exit 1; }
diff --git a/tests/e2e/144_build_mcpp_include_dir.sh b/tests/e2e/144_build_mcpp_include_dir.sh
index f77b0556b..eedfde95f 100755
--- a/tests/e2e/144_build_mcpp_include_dir.sh
+++ b/tests/e2e/144_build_mcpp_include_dir.sh
@@ -83,7 +83,7 @@ int main() {
 }
 EOF
 "$MCPP" build > build2.log 2>&1 || { cat build2.log; echo "FAIL: rebuild failed"; exit 1; }
-grep -q "build.mcpp running" build2.log && {
+grep -qE "^ *build\.mcpp .* ran [0-9]" build2.log && {
     cat build2.log; echo "FAIL: unchanged build.mcpp re-ran"; exit 1; } || true
 out="$("$MCPP" run 2>&1 | grep '^ANSWER2=' | tail -1)"
 [[ "$out" == "ANSWER2=42" ]] || { echo "FAIL: cached include-dir record lost: $out"; exit 1; }
diff --git a/tests/e2e/163_identity_first_resolution.sh b/tests/e2e/163_identity_first_resolution.sh
index f91f8481c..4c8b4be6f 100755
--- a/tests/e2e/163_identity_first_resolution.sh
+++ b/tests/e2e/163_identity_first_resolution.sh
@@ -80,13 +80,13 @@ EOF
 # ── 1. short-name descriptor installs ───────────────────────────────
 mkidx idx1 a/acme.widget.lua acme widget
 mkapp app1 acme ../idx1 acme widget
-(cd app1 && "$MCPP" build > out.txt 2>&1) || { cat app1/out.txt; exit 1; }
+(cd app1 && "$MCPP" build -v > out.txt 2>&1) || { cat app1/out.txt; exit 1; }
 # Either verb: what this test is about is that the descriptor was found BY
 # IDENTITY and the package became part of the build. Whether its objects were
 # compiled here or served from the global build cache is a different subsystem's
 # business — and now that the cache actually works, a sibling app dir under the
 # same MCPP_HOME (or a restored CI sandbox) can legitimately supply them.
-grep -qE "(Compiling|Cached) acme\.widget" app1/out.txt || {
+grep -qE "Compiling acme\.widget" app1/out.txt || {
     cat app1/out.txt
     echo "FAIL: acme.widget was neither compiled nor served from cache"
     exit 1
diff --git a/tests/e2e/172_build_cache_cross_project.sh b/tests/e2e/172_build_cache_cross_project.sh
index 990b20cd5..0d6467d33 100644
--- a/tests/e2e/172_build_cache_cross_project.sh
+++ b/tests/e2e/172_build_cache_cross_project.sh
@@ -123,7 +123,7 @@ grep -q 'shared-lib' list1.log || {
 # ── project two: DIFFERENT name and version, same dependency ─────────────────
 make_project projtwo projtwo 9.9.9
 cd "$TMP/projtwo"
-"$MCPP" build > build.log 2>&1 || { cat build.log; exit 1; }
+"$MCPP" build -v > build.log 2>&1 || { cat build.log; exit 1; }
 
 N2="$(find_ninja "$TMP/projtwo")"
 [[ -n "$N2" ]] || { echo "FAIL: projtwo has no build.ninja"; exit 1; }
@@ -146,8 +146,8 @@ staged="$(dep_stage_edges "$N2")"
 # The status line must agree, and must carry the unit count. The bare word
 # "Cached" was printed for months while every unit was recompiled behind it; a
 # number that has to match the skipped edges cannot go quietly wrong that way.
-grep -qE 'Cached local-dev\.shared-lib v1\.0\.0 \([0-9]+ unit' build.log || {
-    echo "FAIL: no 'Cached ... (N units)' line for the reused dependency"
+grep -qE 'Compiling local-dev\.shared-lib v1\.0\.0 +cached [0-9]+ unit' build.log || {
+    echo "FAIL: no 'cached N units' line for the reused dependency"
     cat build.log
     exit 1
 }
diff --git a/tests/e2e/186_build_mcpp_protocol_and_bound.sh b/tests/e2e/186_build_mcpp_protocol_and_bound.sh
index c3371a99b..ed6147fc4 100755
--- a/tests/e2e/186_build_mcpp_protocol_and_bound.sh
+++ b/tests/e2e/186_build_mcpp_protocol_and_bound.sh
@@ -175,13 +175,13 @@ cp "$CACHE" "$TMP/good.cache"
 # the build.mcpp cache) actually runs.
 touch src/main.cpp
 "$MCPP" build > b6.log 2>&1 || { cat b6.log; echo "FAIL: build failed"; exit 1; }
-grep -q "up to date (cached)" b6.log || {
+grep -qE "^ *build\.mcpp .* cached" b6.log || {
     cat b6.log; echo "FAIL: an unchanged build.mcpp was re-run"; exit 1; }
 
 sed 's/^epoch .*/epoch 987654/' "$TMP/good.cache" > "$CACHE"
 touch src/main.cpp
 "$MCPP" build > b7.log 2>&1 || { cat b7.log; echo "FAIL: build failed"; exit 1; }
-grep -q "build.mcpp running" b7.log || {
+grep -qE "^ *build\.mcpp .* ran [0-9]" b7.log || {
     cat b7.log; echo "FAIL: a foreign cache epoch did not force a re-run"; exit 1; }
 
 # A `d` record this mcpp cannot interpret (a cache written by a NEWER mcpp)
@@ -191,7 +191,7 @@ cp "$TMP/good.cache" "$CACHE"
 echo "d some-future-tag /x" >> "$CACHE"
 touch src/main.cpp
 "$MCPP" build > b8.log 2>&1 || { cat b8.log; echo "FAIL: build failed"; exit 1; }
-grep -q "build.mcpp running" b8.log || {
+grep -qE "^ *build\.mcpp .* ran [0-9]" b8.log || {
     cat b8.log; echo "FAIL: an unknown cache record did not force a re-run"; exit 1; }
 
 echo "OK"
diff --git a/tests/e2e/189_host_module_rules.sh b/tests/e2e/189_host_module_rules.sh
index feea1476d..ebe943d7d 100755
--- a/tests/e2e/189_host_module_rules.sh
+++ b/tests/e2e/189_host_module_rules.sh
@@ -89,7 +89,7 @@ out="$("$MCPP" run 2>&1 | grep '^ANSWER=' | tail -1)"
 sed -i 's/define_answer(int n)/define_answer(int n_)/; s/RULE_ANSWER=%d\\n", n)/RULE_ANSWER=%d\\n", n_ + 1)/' ../rules/src/rules.cppm
 touch src/main.cpp
 "$MCPP" build > b2.log 2>&1 || { cat b2.log; echo "FAIL: rebuild after editing the rule failed"; exit 1; }
-grep -q "build.mcpp running" b2.log || {
+grep -qE "^ *build\.mcpp .* ran [0-9]" b2.log || {
     cat b2.log; echo "FAIL: editing the rule module did not re-run build.mcpp"; exit 1; }
 out="$("$MCPP" run 2>&1 | grep '^ANSWER=' | tail -1)"
 [[ "$out" == "ANSWER=43" ]] || {
diff --git a/tests/e2e/194_build_mcpp_glob_input.sh b/tests/e2e/194_build_mcpp_glob_input.sh
index 3fcf73e70..046433811 100755
--- a/tests/e2e/194_build_mcpp_glob_input.sh
+++ b/tests/e2e/194_build_mcpp_glob_input.sh
@@ -70,7 +70,7 @@ cd app
 LOGS="$TMP/logs"; mkdir -p "$LOGS"
 printf 'a\n' > inputs/a.in
 
-ran()    { grep -q "build.mcpp running" "$1"; }
+ran()    { grep -qE "^ *build\.mcpp .* ran [0-9]" "$1"; }
 cached() { grep -q "build.mcpp.*cached" "$1"; }
 
 "$MCPP" build > "$LOGS/b1.log" 2>&1 || { cat "$LOGS/b1.log"; echo "FAIL: first build failed"; exit 1; }
diff --git a/tests/e2e/196_version_identity_and_lock.sh b/tests/e2e/196_version_identity_and_lock.sh
index 591afb5e6..61b3bcfb2 100755
--- a/tests/e2e/196_version_identity_and_lock.sh
+++ b/tests/e2e/196_version_identity_and_lock.sh
@@ -156,7 +156,7 @@ grep -q '1\.0\.0+b' b6b.log || fail "the exact key must be addressed literally"
 
 # ── 6. mcpp.lock records the resolution, not the constraint ───────────────
 use_dep im '^1.92.8'
-"$MCPP" build > b7.log 2>&1 || fail "rebuild failed" b7.log
+"$MCPP" build -v > b7.log 2>&1 || fail "rebuild failed" b7.log
 grep -q 'version = "1.92.8"' mcpp.lock \
     || fail "the lock must record the resolved version" mcpp.lock
 grep -q '\^' mcpp.lock \
@@ -164,7 +164,7 @@ grep -q '\^' mcpp.lock \
 # The banner and the lock read the same data, so they cannot disagree. (The dep
 # announces itself as Compiling or Cached depending on the build cache; both go
 # through the same version string, which is the point.)
-grep -qE '(Compiling|Cached) +acme\.im v1\.92\.8' b7.log \
+grep -qE 'Compiling +acme\.im v1\.92\.8' b7.log \
     || fail "the dependency banner must announce the resolved version" b7.log
 grep -q 'acme\.im v\^' b7.log \
     && fail "the banner must never print a constraint as a version" b7.log
diff --git a/tests/e2e/19_bmi_cache_reuse.sh b/tests/e2e/19_bmi_cache_reuse.sh
index e83023d9e..0bf8709db 100755
--- a/tests/e2e/19_bmi_cache_reuse.sh
+++ b/tests/e2e/19_bmi_cache_reuse.sh
@@ -73,7 +73,7 @@ main = "src/main.cpp"
 path = "../mylibA"
 EOF
 
-"$MCPP" build > build.log 2>&1 || { cat build.log; exit 1; }
+"$MCPP" build -v > build.log 2>&1 || { cat build.log; exit 1; }
 
 # The cache root exists (env init creates it) but holds no package entry for a
 # path dep.
@@ -84,8 +84,9 @@ if find "$MCPP_HOME/build-cache/v1/pkg" -path "*mylibA*" 2>/dev/null | grep -q .
     exit 1
 fi
 
-# Build output must NOT show "Cached mylibA" (it's a path dep, not a registry dep).
-if grep -q 'Cached mylibA' build.log; then
+# Build output must NOT state that mylibA came from the cache (it's a path
+# dep, not a registry dep). `-v` lists the dependencies the default folds.
+if grep -qE 'Compiling mylibA .*cached [0-9]+ unit' build.log; then
     echo "FAIL: path dep wrongly labeled Cached"
     cat build.log; exit 1
 fi
diff --git a/tests/e2e/212_cached_dep_std_is_ordered.sh b/tests/e2e/212_cached_dep_std_is_ordered.sh
index 9736b7c48..894bee5d8 100755
--- a/tests/e2e/212_cached_dep_std_is_ordered.sh
+++ b/tests/e2e/212_cached_dep_std_is_ordered.sh
@@ -114,7 +114,7 @@ cd "$TMP/projmiss"
 # ── project two: cache HIT. This is the one that used to fail. ───────────────
 make_project projhit projhit
 cd "$TMP/projhit"
-if ! "$MCPP" build > build.log 2>&1; then
+if ! "$MCPP" build -v > build.log 2>&1; then
     echo "FAIL: second project (cache hit) did not build"
     if grep -q 'Bad import dependency\|std.gcm' build.log; then
         echo "      this is mcpp#405: the restored BMI's std edge is not in the graph"
@@ -127,7 +127,7 @@ N="$(find_ninja "$TMP/projhit")"
 [[ -n "$N" ]] || { echo "FAIL: projhit has no build.ninja"; exit 1; }
 
 # The hit actually happened — otherwise the assertion below proves nothing.
-grep -qE 'Cached local-dev\.stdlib-dep v1\.0\.0 \([0-9]+ unit' build.log || {
+grep -qE 'Compiling local-dev\.stdlib-dep v1\.0\.0 +cached [0-9]+ unit' build.log || {
     echo "FAIL: the second project did not hit the cache, so #405 was not exercised"
     cat build.log
     exit 1
diff --git a/tests/e2e/218_module_extensions_graph_shape.sh b/tests/e2e/218_module_extensions_graph_shape.sh
index 625807070..2be95cfbd 100755
--- a/tests/e2e/218_module_extensions_graph_shape.sh
+++ b/tests/e2e/218_module_extensions_graph_shape.sh
@@ -67,16 +67,23 @@ fingerprint() {
 FP_BEFORE="$(fingerprint)"
 [ -n "$FP_BEFORE" ] || { echo "FAIL: could not read the fingerprint"; exit 1; }
 
+# Whether the last build planned: the full path writes build.ninja (or moves
+# its time when the text is unchanged), and the fast path replays it untouched.
+# A `Compiling` line no longer tells the two apart: it states that a package's
+# steps ran, on either path (build progress design 2026-09-29).
+planned_since() { find target -name build.ninja -newer "$1" 2>/dev/null | grep -q .; }
+touch .before-b1; sleep 1
 "$MCPP" build > b1.log 2>&1 || { cat b1.log; echo "FAIL: no-change build"; exit 1; }
-grep -q "Compiling" b1.log && {
+planned_since .before-b1 && {
     cat b1.log; echo "FAIL: fast path did not engage — the rest proves nothing"; exit 1; }
 echo "  ok: fast path engages on a no-change build"
 
 # ── 1. A NEW import inside the .ixx must invalidate the graph ──────────────
+touch .before-b2; sleep 1
 printf 'export module gshape.face;\nimport std;\nimport gshape.helper;\nexport auto face() -> int { return helper() + 1; }\n' > src/face.ixx
 
 "$MCPP" build > b2.log 2>&1 || { cat b2.log; echo "FAIL: build after .ixx edit"; exit 1; }
-grep -q "Compiling" b2.log || {
+planned_since .before-b2 || {
     cat b2.log
     echo "FAIL: editing a .ixx did not invalidate the fast path"
     echo "      (the freshness sweep is not classifying it as a graph-shape input)"
diff --git a/tests/e2e/324_fast_path_sees_path_deps.sh b/tests/e2e/324_fast_path_sees_path_deps.sh
index 4c91a7ad9..9a6d8d743 100755
--- a/tests/e2e/324_fast_path_sees_path_deps.sh
+++ b/tests/e2e/324_fast_path_sees_path_deps.sh
@@ -35,9 +35,15 @@ cd app
 "$MCPP" build > b2.log 2>&1 || { cat b2.log; exit 1; }
 
 # The fast path must actually be in play, or the rest of this test is asserting
-# on a path it never took. A fast-path build prints no "Compiling" line.
+# Whether the last build planned: the full path writes build.ninja (or moves
+# its time when the text is unchanged), and the fast path replays it untouched.
+# A `Compiling` line no longer tells the two apart: it states that a package's
+# steps ran, on either path (build progress design 2026-09-29).
+planned_since() { find target -name build.ninja -newer "$1" 2>/dev/null | grep -q .; }
+# on a path it never took.
+touch .before-warm; sleep 1
 "$MCPP" build > warm.log 2>&1 || { cat warm.log; exit 1; }
-if grep -q "Compiling" warm.log; then
+if planned_since .before-warm; then
     echo "NOTE: the fast path was not taken on a warm build; the assertion below"
     echo "      still holds but tests less than it means to."
     cat warm.log
diff --git a/tests/e2e/325_system_toolchain_refused.sh b/tests/e2e/325_system_toolchain_refused.sh
index 9d60ec1de..912de19a2 100755
--- a/tests/e2e/325_system_toolchain_refused.sh
+++ b/tests/e2e/325_system_toolchain_refused.sh
@@ -87,7 +87,7 @@ expect_refusal bp.log "a project with a build.mcpp"
 grep -q "posix_spawnp" bp.log && {
     echo "FAIL: still spawning an empty compiler path instead of refusing"
     cat bp.log; exit 1; }
-grep -q "build.mcpp compiling" bp.log && {
+grep -qE "^ *build\.mcpp " bp.log && {
     echo "FAIL: the refusal arrived after the build program had started"
     cat bp.log; exit 1; }
 
diff --git a/tests/e2e/40_llvm_bmi_cache.sh b/tests/e2e/40_llvm_bmi_cache.sh
index 698eaa1e4..c17848934 100755
--- a/tests/e2e/40_llvm_bmi_cache.sh
+++ b/tests/e2e/40_llvm_bmi_cache.sh
@@ -64,7 +64,7 @@ EOF
 # an alias for `--cache=off`, which means neither read NOR write, so a build that
 # used it would leave nothing for the second build to reuse. MCPP_HOME is fresh
 # here, so this build is already cold.
-out1=$("$MCPP" build 2>&1)
+out1=$("$MCPP" build -v 2>&1)
 echo "$out1" | grep -q "Compiling.*mcpplibs.cmdline" || {
     echo "FAIL: mcpplibs.cmdline not compiled in the first (cold) build: $out1"
     exit 1
@@ -72,8 +72,8 @@ echo "$out1" | grep -q "Compiling.*mcpplibs.cmdline" || {
 
 # Second build, clean target dir, cache kept — the dependency must be reused.
 rm -rf target
-out2=$("$MCPP" build 2>&1)
-echo "$out2" | grep -q "Cached.*mcpplibs.cmdline" || {
+out2=$("$MCPP" build -v 2>&1)
+echo "$out2" | grep -qE "Compiling .*mcpplibs\.cmdline.* cached [0-9]+ unit" || {
     echo "FAIL: mcpplibs.cmdline not cached on second build: $out2"
     exit 1
 }
diff --git a/tests/e2e/49_bmi_cache_nested_custom_index.sh b/tests/e2e/49_bmi_cache_nested_custom_index.sh
index 8ff0531ee..d7fe91e84 100644
--- a/tests/e2e/49_bmi_cache_nested_custom_index.sh
+++ b/tests/e2e/49_bmi_cache_nested_custom_index.sh
@@ -120,9 +120,9 @@ for o in objs:
 PYEOF
 
 rm -rf target
-"$MCPP" build > build2.log 2>&1 || { cat build2.log; exit 1; }
+"$MCPP" build -v > build2.log 2>&1 || { cat build2.log; exit 1; }
 
-grep -q "Cached local-dev.collision-lib v1.0.0" build2.log || {
+grep -qE "Compiling local-dev\.collision-lib v1\.0\.0 +cached [0-9]+ unit" build2.log || {
     echo "FAIL: second cold build did not reuse the build cache"
     cat build2.log
     exit 1
diff --git a/tests/e2e/53_namespaced_cache_label.sh b/tests/e2e/53_namespaced_cache_label.sh
index 8fc9d54c7..1011bc5e7 100755
--- a/tests/e2e/53_namespaced_cache_label.sh
+++ b/tests/e2e/53_namespaced_cache_label.sh
@@ -98,12 +98,12 @@ fi
 }
 
 rm -rf target
-"$MCPP" build > build2.log 2>&1 || {
+"$MCPP" build -v > build2.log 2>&1 || {
     cat build2.log
     exit 1
 }
 
-grep -q "Cached compat.widget v1.0.0" build2.log || {
+grep -qE "Compiling compat\.widget v1\.0\.0 +cached [0-9]+ unit" build2.log || {
     echo "FAIL: cached namespaced dependency should be reported as compat.widget"
     cat build2.log
     exit 1
diff --git a/tests/e2e/651_a_build_program_deploys_what_it_generated.sh b/tests/e2e/651_a_build_program_deploys_what_it_generated.sh
index e6e75150d..8e55ec449 100755
--- a/tests/e2e/651_a_build_program_deploys_what_it_generated.sh
+++ b/tests/e2e/651_a_build_program_deploys_what_it_generated.sh
@@ -148,7 +148,7 @@ grep -qx "changed resource" "$DEPLOYED" \
 rm -rf "$BINDIR"
 touch src/main.cpp
 "$MCPP" build > b3.log 2>&1 || fail "third build failed" b3.log
-grep -q "up to date (cached)" b3.log \
+grep -qE "^ *build\.mcpp .* cached" b3.log \
   || fail "the third build re-ran build.mcpp; the replay path was not exercised" b3.log
 [ -f "$DEPLOYED" ] \
   || fail "the deployed file was not restored on a build.mcpp cache hit" b3.log
diff --git a/tests/e2e/713_a_git_dependency_selects_a_repository_member.sh b/tests/e2e/713_a_git_dependency_selects_a_repository_member.sh
index 695dbfe61..6863a8341 100755
--- a/tests/e2e/713_a_git_dependency_selects_a_repository_member.sh
+++ b/tests/e2e/713_a_git_dependency_selects_a_repository_member.sh
@@ -132,11 +132,11 @@ int fw_answer();
 int main() { return fw_answer() == 42 ? 0 : 1; }
 EOF
 cd "$TMP/both"
-"$MCPP" build > b2.log 2>&1 || fail "the root and a member by one revision did not build" b2.log
+"$MCPP" build -v > b2.log 2>&1 || fail "the root and a member by one revision did not build" b2.log
 grep -q "that identity is used" b2.log \
     && fail "the member's key adopted the root's identity" b2.log
 grep -q 'DEPBIN tool=\[[^]]' b2.log || fail "the member's tools request was lost" b2.log
-grep -q "Compiling spike.fw v$" b2.log && fail "the git banner printed an empty version" b2.log
+grep -qE "Compiling spike\.fw v( |$)" b2.log && fail "the git banner printed an empty version" b2.log
 grep -q "spike.fw (git rev ${REV:0:12})" b2.log \
     || fail "the git banner does not name the reference" b2.log
 "$MCPP" run > r2.log 2>&1 || fail "the application over the git root does not run" r2.log
diff --git a/tests/e2e/779_a_build_program_declares_a_runtime_search_dir.sh b/tests/e2e/779_a_build_program_declares_a_runtime_search_dir.sh
index 0de16ebaa..c876fe949 100755
--- a/tests/e2e/779_a_build_program_declares_a_runtime_search_dir.sh
+++ b/tests/e2e/779_a_build_program_declares_a_runtime_search_dir.sh
@@ -119,7 +119,7 @@ grep -F -- "-Wl,-rpath,$RTDIR" "$G" >/dev/null \
 touch src/main.cpp   # past the whole-project no-op fast path, without
                       # touching build.mcpp itself
 "$MCPP" build > b2.log 2>&1 || fail "second build failed" b2.log
-grep -q "up to date (cached)" b2.log \
+grep -qE "^ *build\.mcpp .* cached" b2.log \
   || fail "the second build re-ran build.mcpp; the replay path was not exercised" b2.log
 G2=$(find_graph)
 [ -n "$G2" ] || fail "no build.ninja after the second build" b2.log
diff --git a/tests/e2e/781_deleted_root_cdb_is_restored.sh b/tests/e2e/781_deleted_root_cdb_is_restored.sh
index a57cb6235..f5cc9536f 100755
--- a/tests/e2e/781_deleted_root_cdb_is_restored.sh
+++ b/tests/e2e/781_deleted_root_cdb_is_restored.sh
@@ -23,7 +23,13 @@ config_cdb=$(find target -name compile_commands.json | head -1)
 [[ -n "$config_cdb" ]] || { echo "FAIL: no configuration database under target/"; exit 1; }
 before=$(cat "$config_cdb")
 
+# Whether the last build planned: the full path writes build.ninja (or moves
+# its time when the text is unchanged), and the fast path replays it untouched.
+# A `Compiling` line no longer tells the two apart: it states that a package's
+# steps ran, on either path (build progress design 2026-09-29).
+planned_since() { find target -name build.ninja -newer "$1" 2>/dev/null | grep -q .; }
 rm compile_commands.json
+touch .before-build2; sleep 1
 
 "$MCPP" build > build2.log 2>&1 || {
     cat build2.log
@@ -39,11 +45,10 @@ rm compile_commands.json
 
 # "Without a plan": nothing in the tree changed since the first build, so a
 # real prepare pass has nothing to compile -- the restore must not trigger
-# one. A plan prints a "Compiling <pkg>" line; the fast path prints only
-# "Finished ... in <time>".
+# one. A plan writes build.ninja; the fast path replays it untouched.
 # The fast path replays ELF builds only (#400); on macOS and Windows the
 # second build plans again, and the full path's writer restores the file.
-if [[ "$(uname -s)" == Linux ]] && grep -q "Compiling" build2.log; then
+if [[ "$(uname -s)" == Linux ]] && planned_since .before-build2; then
     echo "FAIL: restoring the root database ran a full plan"
     cat build2.log
     exit 1
diff --git a/tests/e2e/787_emit_plans_every_member_on_its_own.sh b/tests/e2e/787_emit_plans_every_member_on_its_own.sh
index a7e338f3e..aa40eb299 100755
--- a/tests/e2e/787_emit_plans_every_member_on_its_own.sh
+++ b/tests/e2e/787_emit_plans_every_member_on_its_own.sh
@@ -16,7 +16,8 @@
 # narrower case (E3, #699 item 2 -- see e2e 789), where the member is still
 # described. Criteria:
 #   A. `emit --workspace --format json` over `good` and `bad`: exit 1, `data`
-#      present, its one set is `good/good`, `diagnostics` holds exactly one
+#      present, its one set is `good` (one configuration: no prefix, SPEC-005
+#      v1.6 R3.3), `diagnostics` holds exactly one
 #      `error` with `path` "bad/mcpp.toml" and a message naming `bad`, and
 #      `watch` lists `bad/mcpp.toml` alongside `good`'s own inputs.
 #   B. Without `--format`, the same run prints the document (not empty) and
@@ -66,7 +67,7 @@ import json, sys
 e = json.load(open(sys.argv[1]))
 d = e["data"]
 sets = [s["name"] for s in d["database"]["sets"]]
-assert sets == ["good/good"], sets
+assert sets == ["good"], sets
 diags = e["diagnostics"]
 assert len(diags) == 1, diags
 diag = diags[0]
@@ -86,7 +87,7 @@ rc=$?
 set -e
 [ "$rc" = 1 ] || fail "B: bare invocation exit status $rc, expected 1" b.out b.err
 [ -s b.out ] || fail "B: the bare document is empty" b.err
-"$PY" -c 'import json,sys; d=json.load(open(sys.argv[1])); assert d["sets"][0]["name"]=="good/good", d["sets"]' b.out \
+"$PY" -c 'import json,sys; d=json.load(open(sys.argv[1])); assert d["sets"][0]["name"]=="good", d["sets"]' b.out \
     || fail "B: the bare document's set" b.out
 grep -q "bad" b.err || fail "B: the failed member's reason is not on stderr" b.err
 echo "ok: B, the exit code is 1 without --format too, and the document still prints"
diff --git a/tests/e2e/807_a_lib_root_imports_its_own_package.sh b/tests/e2e/807_a_lib_root_imports_its_own_package.sh
index 103d933ce..60e59893f 100755
--- a/tests/e2e/807_a_lib_root_imports_its_own_package.sh
+++ b/tests/e2e/807_a_lib_root_imports_its_own_package.sh
@@ -76,7 +76,7 @@ for form in explicit convention; do
         echo "FAIL: $form lib root: a lib root that imports its own package's unit did not build"
         exit 1
     }
-    grep -q "build.mcpp running" "$form/app/build.log" || {
+    grep -qE "^ *build\.mcpp .* ran [0-9]" "$form/app/build.log" || {
         cat "$form/app/build.log"
         echo "FAIL: $form lib root: the build program did not run"
         exit 1
diff --git a/tests/e2e/821_an_edge_states_its_advice_on_both_paths.sh b/tests/e2e/821_an_edge_states_its_advice_on_both_paths.sh
index 7c303ca7f..e9250f65b 100755
--- a/tests/e2e/821_an_edge_states_its_advice_on_both_paths.sh
+++ b/tests/e2e/821_an_edge_states_its_advice_on_both_paths.sh
@@ -60,13 +60,19 @@ EOF
     || fail "A1: the full path did not report the edge's advice exactly once" b1.log
 echo "ok: A1 the full path reports the advice once"
 
+# Whether the last build planned: the full path writes build.ninja (or moves
+# its time when the text is unchanged), and the fast path replays it untouched.
+# A `Compiling` line no longer tells the two apart: it states that a package's
+# steps ran, on either path (build progress design 2026-09-29).
+planned_since() { find target -name build.ninja -newer "$1" 2>/dev/null | grep -q .; }
+touch .before-b2
 sleep 1   # a coarse file system clock must see the input as newer
 printf 'second\n' > data/probe.in
 "$MCPP" build > b2.log 2>&1 || fail "the second build failed" b2.log
 # The fast path serves only ELF products (#400): on Linux the second build
 # must take it, or A2 tests nothing new; elsewhere it declines, and A2 reads
 # the full path again.
-if grep -q "Compiling" b2.log; then
+if planned_since .before-b2; then
     case "$(uname -s)" in
         Linux) fail "A2: the second build planned again, so the fast path was not exercised" b2.log ;;
         *)     echo "READING 821: the fast path declines on $(uname -s) (#400); A2 reads the full path" ;;
diff --git a/tests/e2e/826_plugin_diagnostics_features_and_names.sh b/tests/e2e/826_plugin_diagnostics_features_and_names.sh
index ae0adbfda..8d0950dfd 100755
--- a/tests/e2e/826_plugin_diagnostics_features_and_names.sh
+++ b/tests/e2e/826_plugin_diagnostics_features_and_names.sh
@@ -70,7 +70,7 @@ grep -q "mcpp.acme.gen'.*mcpp\.\|claims an origin" d1.log && fail "R1: an own-na
 # fast path and reaches no build program, so it would measure neither path.
 touch src/main.cpp
 "$MCPP" build > d2.log 2>&1 || fail "D2: the second build failed" d2.log
-grep -q "up to date (cached)" d2.log || fail "D2: the second build ran the program; the replay is not measured" d2.log
+grep -qE "^ *build\.mcpp .* cached" d2.log || fail "D2: the second build ran the program; the replay is not measured" d2.log
 grep -q "impact: no bindings are generated" d2.log || fail "D2: the cached run did not report the diagnostic" d2.log
 
 # N1
diff --git a/tests/e2e/82_feature_optional_deps.sh b/tests/e2e/82_feature_optional_deps.sh
index 65603fcd1..3bb2812b3 100755
--- a/tests/e2e/82_feature_optional_deps.sh
+++ b/tests/e2e/82_feature_optional_deps.sh
@@ -51,17 +51,17 @@ cd app
 # `Cached` — so "Compiling" alone is too narrow for the positive AND too weak for
 # the negative: a wrongly-pulled dependency whose objects happened to be cached
 # would print `Cached widget` and slip past a `Compiling`-only check.
-pulled() { grep -qE '(Compiling|Cached) widget' "$1"; }
+pulled() { grep -qE 'Compiling widget ' "$1"; }
 
 # 1. Feature inactive → widget is NOT pulled (never resolved, never built).
-"$MCPP" build > b1.log 2>&1 || { cat b1.log; echo "FAIL: baseline build failed"; exit 1; }
+"$MCPP" build -v > b1.log 2>&1 || { cat b1.log; echo "FAIL: baseline build failed"; exit 1; }
 if pulled b1.log; then
     cat b1.log; echo "FAIL: widget must NOT be pulled when feature inactive"; exit 1
 fi
 
 # 2. Feature active → widget IS pulled and built like a normal dependency.
 rm -rf target
-"$MCPP" build --features extra > b2.log 2>&1 || { cat b2.log; echo "FAIL: feature build failed (widget not pulled?)"; exit 1; }
+"$MCPP" build -v --features extra > b2.log 2>&1 || { cat b2.log; echo "FAIL: feature build failed (widget not pulled?)"; exit 1; }
 pulled b2.log || { cat b2.log; echo "FAIL: widget was not pulled when feature active"; exit 1; }
 
 echo "OK"
diff --git a/tests/e2e/839_a_workspaces_build_programs_are_named_ordered_and_cached.sh b/tests/e2e/839_a_workspaces_build_programs_are_named_ordered_and_cached.sh
new file mode 100644
index 000000000..5e71b5b6e
--- /dev/null
+++ b/tests/e2e/839_a_workspaces_build_programs_are_named_ordered_and_cached.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# 839_a_workspaces_build_programs_are_named_ordered_and_cached.sh -- workspace
+# design 2026-09-29 §15 and §17.1.
+#
+# Every member of the workspace below has a build program; cli and gui depend
+# on core.
+#
+#   B1  each program's line names its package and states that it ran;
+#   B2  a member's program runs after the programs of the members it depends
+#       on (2026.9.29.4 ran them in discovery order: cli before core);
+#   B3  after `--workspace`, a selection of one member, a second
+#       `--workspace` and another selection reuse every program's result
+#       (2026.9.29.4 reran them: a program's graph document listed every
+#       requester of the plan, the virtual root included, so its cache key
+#       followed the selection);
+#   B4  `mcpp emit build-database` after the build reuses them too;
+#   B5  in a `--workspace` build a member another member depends on is
+#       named by its directory, and as a path dependency only where it is not
+#       selected (`-v` lists the dependencies the default output folds).
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+MCPP="${MCPP:-mcpp}"
+
+cat > mcpp.toml <<'EOF'
+[workspace]
+members = ["core", "cli", "gui"]
+EOF
+mkdir -p core/src cli/src gui/src
+cat > core/mcpp.toml <<'EOF'
+[package]
+name = "core"
+version = "0.1.0"
+
+[targets.core]
+kind = "lib"
+EOF
+printf 'export module bp_core;\nexport int core_v() { return 1; }\n' > core/src/core.cppm
+for m in cli gui; do
+    cat > $m/mcpp.toml <<EOF
+[package]
+name = "$m"
+version = "0.1.0"
+
+[dependencies]
+core = { path = "../core" }
+
+[targets.$m]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+    printf 'import bp_core;\nint main() { return core_v() == 1 ? 0 : 1; }\n' > $m/src/main.cpp
+done
+for p in core cli gui; do
+    printf 'import mcpp;\nint main() { mcpp::define("BP_%s=1"); return 0; }\n' $p > $p/build.mcpp
+done
+
+"$MCPP" build --workspace > b1.log 2>&1 || fail "the first build failed" b1.log
+
+# B1
+for p in core cli gui; do
+    grep -qE "^ *build\.mcpp $p .* ran [0-9]" b1.log || fail "B1: no line states that $p's program ran" b1.log
+done
+
+# B2
+first=$(grep -m1 -E "^ *build\.mcpp .* ran [0-9]" b1.log)
+case "$first" in *"build.mcpp core "*) ;; *) fail "B2: core's program did not run first" b1.log ;; esac
+
+# B3
+"$MCPP" build -p cli -v > b2.log 2>&1 || fail "-p cli failed" b2.log
+touch core/src/core.cppm
+"$MCPP" build --workspace > b3.log 2>&1 || fail "the second --workspace failed" b3.log
+touch core/src/core.cppm
+"$MCPP" build -p gui > b4.log 2>&1 || fail "-p gui failed" b4.log
+for f in b2.log b3.log b4.log; do
+    ! grep -qE "^ *build\.mcpp .* ran [0-9]" $f || fail "B3: a program reran in $f" $f
+    grep -qE "^ *build\.mcpp .* cached" $f || fail "B3: $f shows no program at all" $f
+done
+
+# B4
+"$MCPP" emit build-database --format json -o db.json > e.log 2>&1 || fail "emit failed" e.log
+! grep -qE "^ *build\.mcpp .* ran [0-9]" e.log || fail "B4: emit reran a program" e.log
+
+# B5
+grep -q "Compiling core (core)" b1.log || fail "B5: core is not announced by its directory" b1.log
+! grep -q "Compiling core (path)" b1.log || fail "B5: a selected member is announced as a path dependency" b1.log
+grep -q "Compiling core (path)" b2.log || fail "B5: under -p cli, core is cli's path dependency" b2.log
+
+echo "PASS: 839_a_workspaces_build_programs_are_named_ordered_and_cached"
diff --git a/tests/e2e/840_a_workspace_database_describes_each_package_once.sh b/tests/e2e/840_a_workspace_database_describes_each_package_once.sh
new file mode 100644
index 000000000..549328ba0
--- /dev/null
+++ b/tests/e2e/840_a_workspace_database_describes_each_package_once.sh
@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# requires: python3
+# 840_a_workspace_database_describes_each_package_once.sh -- workspace design
+# 2026-09-29 §15 and §17.1; SPEC-005 R3.3, R3.5, R5.2.
+#
+# `mcpp emit build-database` and `mcpp build --configure-only` plan a
+# workspace as `mcpp build` does: one plan per configuration group, with each
+# member's tests. 2026.9.29.4 planned each member separately, so a package two
+# members use was described once per member, each time with other arguments.
+#
+#   A  one configuration: each set is named by its package, with no prefix;
+#      each source is described once; a member that is a program is described
+#      as one and its tests as tests; `--configure-only` writes one compile
+#      command per source;
+#   B  two configurations that both compile core: each set name is prefixed
+#      with its configuration's name, core is described once per
+#      configuration, and the root `compile_commands.json` of `--configure-only`
+#      and of `build --workspace` describes both configurations (it was the
+#      database of whichever group was written last);
+#   C  a member whose planning fails, in a group with others: it fails alone,
+#      with its own `mcpp.toml` as the diagnostic's path, and the others are
+#      described (R5.2).
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+MCPP="${MCPP:-mcpp}"
+
+member() {   # $1 = name, $2 = standard ("" for the default)
+    mkdir -p $1/src
+    { printf '[package]\nname = "%s"\nversion = "0.1.0"\n' $1
+      [ -n "$2" ] && printf 'standard = "%s"\n' "$2"
+      printf '\n[dependencies]\ncore = { path = "../core" }\n\n[targets.%s]\nkind = "bin"\nmain = "src/main.cpp"\n' $1
+    } > $1/mcpp.toml
+    printf 'import db_core;\nint main() { return core_v() == 1 ? 0 : 1; }\n' > $1/src/main.cpp
+}
+core() {
+    mkdir -p core/src
+    printf '[package]\nname = "core"\nversion = "0.1.0"\n\n[targets.core]\nkind = "lib"\n' > core/mcpp.toml
+    printf 'export module db_core;\nexport int core_v() { return 1; }\n' > core/src/core.cppm
+}
+
+cat > check.py <<'PY'
+import json, sys, re, collections
+d = json.load(open(sys.argv[1])); part = sys.argv[2]
+sets = d["data"]["database"]["sets"]
+names = [s["name"] for s in sets]
+assert len(names) == len(set(names)), f"{part}: a set is described twice: {names}"
+prefix = lambda n: n.split("/")[0] if "/" in n else ""
+base = lambda n: n.split("/")[-1]
+units = collections.Counter((prefix(s["name"]), t["source"]) for s in sets for t in s["translation-units"])
+assert all(c == 1 for c in units.values()), f"{part}: a source is described twice in one configuration"
+kinds = {base(s["name"]): s["ide"]["kind"] for s in sets}
+if part == "A":
+    assert all("/" not in n for n in names), f"A: a set of one configuration is prefixed: {names}"
+    assert names.count("core") == 1, f"A: core: {names}"
+    assert kinds.get("cli") == "executable" and kinds.get("cli:test") == "test", f"A: kinds {kinds}"
+if part == "B":
+    assert all(re.fullmatch(r"[0-9a-f]{16}/.+", n) for n in names), f"B: names {names}"
+    cores = [n for n in names if base(n) == "core"]
+    assert len(cores) == 2 and len({prefix(n) for n in cores}) == 2, f"B: core per configuration: {names}"
+if part == "C":
+    errors = [x for x in d["diagnostics"] if x["severity"] == "error"]
+    assert len(errors) == 1 and errors[0].get("path", "").replace("\\", "/") == "broken/mcpp.toml", \
+        f"C: diagnostics {d['diagnostics']}"
+    assert {"core", "cli", "gui"} <= {base(n) for n in names}, f"C: the other members: {names}"
+    # Planned one by one, the members are still one configuration.
+    assert all("/" not in n for n in names), f"C: the fallback split the configuration: {names}"
+PY
+cat > root.py <<'PY'
+import json, pathlib, sys, collections
+# argv: <configurations that compile core> <file>...
+entries = json.loads(pathlib.Path("compile_commands.json").read_text())
+norm = lambda s: s.replace("\\", "/")
+pairs = collections.Counter((norm(e["file"]), norm(e.get("output", ""))) for e in entries)
+assert all(c == 1 for c in pairs.values()), "a file and output have two commands"
+files = [norm(e["file"]) for e in entries]
+cores = sum(1 for f in files if f.endswith("core/src/core.cppm"))
+assert cores == int(sys.argv[1]), f"core has {cores} commands, expected one per configuration ({sys.argv[1]})"
+for want in sys.argv[2:]:
+    assert any(f.endswith(want) for f in files), f"{want} is not described"
+PY
+
+# ── A ──────────────────────────────────────────────────────────────────────
+mkdir a && cd a
+printf '[workspace]\nmembers = ["core", "cli", "gui"]\n' > mcpp.toml
+core; member cli; member gui
+mkdir -p cli/tests
+printf 'import db_core;\nint main() { return core_v() == 1 ? 0 : 1; }\n' > cli/tests/check.cpp
+"$MCPP" emit build-database --format json -o db.json > e.log 2>&1 || fail "A: emit failed" e.log
+python3 ../check.py db.json A || fail "A" db.json
+"$MCPP" build --configure-only > c.log 2>&1 || fail "A: --configure-only failed" c.log
+python3 ../root.py 1 cli/src/main.cpp || fail "A: compile_commands.json" c.log
+cd ..
+
+# ── B ──────────────────────────────────────────────────────────────────────
+mkdir b && cd b
+printf '[workspace]\nmembers = ["core", "cli", "modern"]\n' > mcpp.toml
+core; member cli; member modern c++26
+"$MCPP" emit build-database --format json -o db.json > e.log 2>&1 || fail "B: emit failed" e.log
+python3 ../check.py db.json B || fail "B" db.json
+for cmd in "build --configure-only" "build --workspace"; do
+    rm -f compile_commands.json
+    "$MCPP" $cmd > d.log 2>&1 || fail "B: mcpp $cmd failed" d.log
+    python3 ../root.py 2 cli/src/main.cpp modern/src/main.cpp \
+        || fail "B: the root database of mcpp $cmd" d.log
+done
+cd ..
+
+# ── C ──────────────────────────────────────────────────────────────────────
+mkdir c && cd c
+printf '[workspace]\nmembers = ["core", "cli", "gui", "broken"]\n' > mcpp.toml
+core; member cli; member gui
+mkdir -p broken/src
+printf '[package]\nname = "broken"\nversion = "0.1.0"\n\n[dependencies]\nmissing = { path = "../missing" }\n' > broken/mcpp.toml
+printf 'int main() { return 0; }\n' > broken/src/main.cpp
+set +e
+"$MCPP" emit build-database --format json -o db.json > e.log 2>&1
+rc=$?
+set -e
+[ "$rc" = 1 ] || fail "C: emit exited $rc, expected 1" e.log
+python3 ../check.py db.json C || fail "C" db.json e.log
+
+echo "PASS: 840_a_workspace_database_describes_each_package_once"
diff --git a/tests/e2e/841_pack_summarizes_many_outputs.sh b/tests/e2e/841_pack_summarizes_many_outputs.sh
new file mode 100644
index 000000000..e803c376f
--- /dev/null
+++ b/tests/e2e/841_pack_summarizes_many_outputs.sh
@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# requires: python3
+# 841_pack_summarizes_many_outputs.sh -- the human report of `mcpp pack` for a
+# format that submits one output per file of a distribution tree.
+#
+# A format may declare one output per file (the validation project's release
+# format declares 1,309 for one program), and a `Packed` line per file then
+# buries the rest of the pass.
+#
+#   P1  more than eight outputs are reported by the entry each lies in below
+#       their common parent, with a count;
+#   P2  --verbose reports every output;
+#   P3  `--message-format json` lists every output.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+MCPP="${MCPP:-mcpp}"
+
+mkdir -p app/src && cd app
+cat > mcpp.toml <<'EOF'
+[package]
+name = "app"
+version = "1.0.0"
+
+[targets.app]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+printf 'int main() { return 0; }\n' > src/main.cpp
+cat > build.mcpp <<'EOF'
+import mcpp;
+#include <string>
+#include <string_view>
+int main() {
+    mcpp::provides_pack_format("tree");
+    if (std::string_view(mcpp::pack_format()) != "tree") return 0;
+    const std::string out = std::string(mcpp::out_dir()) + "/tree";
+    auto copy = [&](const std::string& id, const std::string& dst) {
+        mcpp::action a;
+        a.id = id.c_str();
+        a.role = "artifact";
+        a.arg("${mcpp.self}").arg("stage").arg("--verify").arg("content")
+         .arg("--output").arg(dst.c_str()).arg("${mcpp.target_file:app}")
+         .input("${mcpp.target_file:app}")
+         .output(dst.c_str())
+         .submit();
+    };
+    for (int i = 0; i < 6; ++i) {
+        copy("a" + std::to_string(i), out + "/bin/f" + std::to_string(i));
+        copy("b" + std::to_string(i), out + "/data/f" + std::to_string(i));
+    }
+    copy("m", out + "/manifest");
+    return 0;
+}
+EOF
+
+"$MCPP" pack --format tree > p1.log 2>&1 || fail "pack failed" p1.log
+
+# P1
+n=$(grep -c "Packed" p1.log)
+[ "$n" = 3 ] || fail "P1: $n Packed lines, expected 3" p1.log
+grep -qE "Packed .*tree[/\\\\]bin \(6 files\)" p1.log || fail "P1: bin/ is not summarised" p1.log
+grep -qE "Packed .*tree[/\\\\]data \(6 files\)" p1.log || fail "P1: data/ is not summarised" p1.log
+grep -qE "Packed .*tree[/\\\\]manifest$" p1.log || fail "P1: the single file is not named" p1.log
+
+# P2
+"$MCPP" pack --format tree --verbose > p2.log 2>&1 || fail "pack --verbose failed" p2.log
+n=$(grep -c "Packed" p2.log)
+[ "$n" = 13 ] || fail "P2: $n Packed lines under --verbose, expected 13" p2.log
+
+# P3
+"$MCPP" pack --format tree --message-format json > p3.json 2> p3.err || fail "pack json failed" p3.err
+python3 - p3.json <<'EOF' || fail "P3" p3.json
+import json, sys
+a = json.load(open(sys.argv[1]))["data"]["artifacts"]
+assert len(a) == 13, f"P3: {len(a)} artifacts"
+EOF
+
+echo "PASS: 841_pack_summarizes_many_outputs"
diff --git a/tests/e2e/842_the_build_reports_each_step_once.sh b/tests/e2e/842_the_build_reports_each_step_once.sh
new file mode 100755
index 000000000..da458e6a8
--- /dev/null
+++ b/tests/e2e/842_the_build_reports_each_step_once.sh
@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# requires: python3
+# 842_the_build_reports_each_step_once.sh -- build progress design 2026-09-29,
+# §4 and §5.2 (the log medium: the output is not a terminal).
+#
+# A workspace whose members are core and cli, where cli also depends on util,
+# a path package outside the workspace:
+#
+#   R1  a first build: each member's line is written with its outcome
+#       (`done <span>`), util is folded into `Compiling 1 dependency`, and one
+#       blank line precedes `Finished`; nothing redraws (no carriage return,
+#       no escape sequence);
+#   R2  a build program's line states `ran` on the first build and `cached`
+#       on a planned build that changed nothing it reads;
+#   R3  an edit to cli lists cli alone;
+#   R4  `--verbose` names util and prints each step as `[f/t] <command>`;
+#   R5  a failed step is reported while a slow `prepare` action of another
+#       package still runs: `error: build failed` arrives seconds before
+#       mcpp exits, not after ninja.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+MCPP="${MCPP:-mcpp}"
+
+mkdir -p ws/core/src ws/cli/src util/src
+cat > ws/mcpp.toml <<'EOF'
+[workspace]
+members = ["core", "cli"]
+EOF
+printf '[package]\nname = "core"\nversion = "0.1.0"\n\n[targets.core]\nkind = "lib"\n' > ws/core/mcpp.toml
+printf 'export module rp_core;\nexport int core_v() { return 1; }\n' > ws/core/src/core.cppm
+printf '[package]\nname = "util"\nversion = "0.2.0"\n\n[targets.util]\nkind = "lib"\n' > util/mcpp.toml
+printf 'export module rp_util;\nexport int util_v() { return 2; }\n' > util/src/util.cppm
+cat > ws/cli/mcpp.toml <<'EOF'
+[package]
+name = "cli"
+version = "0.1.0"
+
+[dependencies]
+core = { path = "../core" }
+util = { path = "../../util" }
+
+[targets.cli]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+printf 'import rp_core;\nimport rp_util;\nint main() { return core_v() + util_v() == 3 ? 0 : 1; }\n' > ws/cli/src/main.cpp
+printf 'import mcpp;\nint main() { mcpp::define("RP_CLI=1"); return 0; }\n' > ws/cli/build.mcpp
+
+cd ws
+"$MCPP" build --workspace > b1.log 2>&1 || fail "the first build failed" b1.log
+
+# R1
+grep -qE "^ +Compiling core \(core\) +done [0-9]" b1.log || fail "R1: core has no final line" b1.log
+grep -qE "^ +Compiling cli \(cli\) +done [0-9]" b1.log || fail "R1: cli has no final line" b1.log
+grep -qE "^ +Compiling 1 dependency +done" b1.log || fail "R1: util is not folded into one line" b1.log
+! grep -q "Compiling util" b1.log || fail "R1: the default output named a dependency" b1.log
+prev=$(grep -B1 -E "^ +Finished " b1.log | head -1)
+[ -z "$prev" ] || fail "R1: no blank line precedes Finished" b1.log
+! grep -q $'\r' b1.log || fail "R1: the log holds a carriage return" b1.log
+! grep -q $'\033' b1.log || fail "R1: the log holds an escape sequence" b1.log
+
+# R2
+grep -qE "^ *build\.mcpp cli +ran [0-9]" b1.log || fail "R2: the program's line does not state that it ran" b1.log
+"$MCPP" build --workspace --profile dev > b2.log 2>&1 || fail "the planned rebuild failed" b2.log
+grep -qE "^ *build\.mcpp cli +cached" b2.log || fail "R2: the second program line does not state cached" b2.log
+
+# R3
+printf 'import rp_core;\nimport rp_util;\nint main() { return core_v() + util_v() == 3 ? 0 : 2; }\n' > cli/src/main.cpp
+"$MCPP" build --workspace > b3.log 2>&1 || fail "the incremental build failed" b3.log
+grep -qE "^ +Compiling cli \(cli\) +done" b3.log || fail "R3: the edited member has no line" b3.log
+! grep -qE "Compiling (core|1 dependency)" b3.log || fail "R3: a package with nothing to do has a line" b3.log
+
+# R4
+printf 'export module rp_util;\nexport int util_v() { return 2; }\nint unused = 0;\n' > ../util/src/util.cppm
+"$MCPP" build --workspace -v > b4.log 2>&1 || fail "the verbose build failed" b4.log
+grep -qE "^ +Compiling util \(path\) +done" b4.log || fail "R4: --verbose does not name the dependency" b4.log
+grep -qE "^\[[0-9]+/[0-9]+\] " b4.log || fail "R4: --verbose prints no step" b4.log
+
+# R5 -- a separate project: app's source does not compile, and its path
+# dependency `slow` has a prepare action that takes six seconds.
+cd "$TMP"
+mkdir -p r5/app/src r5/slow/src
+printf '[package]\nname = "slow"\nversion = "0.1.0"\n\n[targets.slow]\nkind = "lib"\n' > r5/slow/mcpp.toml
+printf 'export module rp_slow;\nexport int slow_v() { return 3; }\n' > r5/slow/src/slow.cppm
+cat > r5/slow/build.mcpp <<'EOF'
+import mcpp;
+#include <string>
+int main() {
+    const std::string prefix = std::string(mcpp::out_dir()) + "/slow-install";
+    mcpp::action a;
+    a.id   = "slow:install";
+    a.role = mcpp::roles::prepare;
+    a.arg("python3").arg("-c")
+     .arg("import os, sys, time; time.sleep(6); os.makedirs(sys.argv[1], exist_ok=True); open(os.path.join(sys.argv[1], \"ready\"), \"w\").close()")
+     .arg(prefix.c_str())
+     .output((prefix + ".stamp").c_str())
+     .output_dir(prefix.c_str())
+     .submit();
+    return 0;
+}
+EOF
+cat > r5/app/mcpp.toml <<'EOF'
+[package]
+name = "app"
+version = "0.1.0"
+
+[dependencies]
+slow = { path = "../slow" }
+
+[targets.app]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+printf 'int main() { return R5_BROKEN; }\n' > r5/app/src/main.cpp
+cd r5/app
+python3 - "$MCPP" <<'PY' > r5.log 2>&1 || fail "R5" r5.log
+import subprocess, sys, time
+start = time.monotonic()
+p = subprocess.Popen([sys.argv[1], "build"], stdout=subprocess.PIPE,
+                     stderr=subprocess.STDOUT, text=True, bufsize=1)
+first_error = None
+lines = []
+for line in p.stdout:
+    lines.append(line.rstrip("\n"))
+    if first_error is None and line.startswith("error: build failed"):
+        first_error = time.monotonic() - start
+code = p.wait()
+end = time.monotonic() - start
+print("\n".join(lines))
+print(f"exit {code}; error at {first_error}; end at {end:.1f}")
+assert code != 0, "the broken build succeeded"
+assert first_error is not None, "no `error: build failed` line"
+assert end - first_error >= 3.0, \
+    f"the failure was reported {end - first_error:.1f}s before mcpp exited; it waited for ninja"
+PY
+
+echo "PASS: 842_the_build_reports_each_step_once"
diff --git a/tests/e2e/843_a_terminal_names_the_action_that_runs.sh b/tests/e2e/843_a_terminal_names_the_action_that_runs.sh
new file mode 100755
index 000000000..c8cd67aa3
--- /dev/null
+++ b/tests/e2e/843_a_terminal_names_the_action_that_runs.sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# requires: python3 unix-shell
+# 843_a_terminal_names_the_action_that_runs.sh -- build progress design
+# 2026-09-29, §4.4 and §5.1 (the terminal medium), through a pseudo-terminal.
+#
+#   T1  while a `prepare` action runs, the status line names its package, its
+#       label and its clock: ninja reports no step when it starts, and the
+#       engine's action wrapper does (§6.4);
+#   T2  the package's line becomes final with its outcome, and one blank line
+#       precedes `Finished`;
+#   T3  the status line is not drawn again after `Finished`.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+MCPP="${MCPP:-mcpp}"
+
+mkdir -p app/src
+cat > app/mcpp.toml <<'EOF'
+[package]
+name = "app"
+version = "0.1.0"
+
+[targets.app]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+printf 'int main() { return 0; }\n' > app/src/main.cpp
+cat > app/build.mcpp <<'EOF'
+import mcpp;
+#include <string>
+int main() {
+    const std::string prefix = std::string(mcpp::out_dir()) + "/tool";
+    mcpp::action a;
+    a.id   = "app:install";
+    a.role = mcpp::roles::prepare;
+    a.arg("python3").arg("-c")
+     .arg("import os, sys, time; time.sleep(4); os.makedirs(sys.argv[1], exist_ok=True); open(os.path.join(sys.argv[1], \"ready\"), \"w\").close()")
+     .arg(prefix.c_str())
+     .output((prefix + ".stamp").c_str())
+     .output_dir(prefix.c_str())
+     .submit();
+    return 0;
+}
+EOF
+cd app
+python3 - "$MCPP" <<'PY' > pty.log 2>&1 || fail "the terminal build" pty.log
+import fcntl, os, pty, re, struct, sys, termios
+pid, fd = pty.fork()
+if pid == 0:
+    os.environ["TERM"] = "xterm-256color"
+    os.environ.pop("NO_COLOR", None)
+    os.execvp(sys.argv[1], [sys.argv[1], "build"])
+fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", 40, 120, 0, 0))
+raw = b""
+while True:
+    try:
+        chunk = os.read(fd, 65536)
+    except OSError:
+        break
+    if not chunk:
+        break
+    raw += chunk
+_, status = os.waitpid(pid, 0)
+text = raw.decode("utf-8", "replace")
+
+# The screen the terminal shows at the end: carriage return, line feed,
+# cursor up (`CSI n A`), erase to the end of the screen (`CSI J`) and of the
+# line (`CSI K`); colour is ignored.
+def screen_of(s):
+    rows, r, c, i = [""], 0, 0, 0
+    while i < len(s):
+        ch = s[i]
+        if ch == "\x1b" and i + 1 < len(s) and s[i + 1] == "[":
+            j = i + 2
+            while j < len(s) and not ("@" <= s[j] <= "~"):
+                j += 1
+            params, final = s[i + 2:j], s[j] if j < len(s) else ""
+            n = int(params) if params.isdigit() else 1
+            if final == "A":
+                r = max(0, r - n)
+            elif final == "J":
+                rows[r] = rows[r][:c]
+                del rows[r + 1:]
+            elif final == "K":
+                rows[r] = "" if params == "2" else rows[r][:c]
+            i = j + 1
+            continue
+        if ch == "\r":
+            c = 0
+        elif ch == "\n":
+            r += 1
+            while len(rows) <= r:
+                rows.append("")
+        else:
+            line = rows[r].ljust(c)
+            rows[r] = line[:c] + ch + line[c + 1:]
+            c += 1
+        i += 1
+    return [row.rstrip() for row in rows]
+
+plain = re.sub(r"\x1b\[[0-9;?]*[A-Za-z]", "", text)
+screen = screen_of(text)
+print("\n".join(screen))
+assert os.WEXITSTATUS(status) == 0, "the build failed"
+# T1: from the stream, since the status line is erased at the end.
+assert re.search(r"app: app:install \d+:\d\d", plain), "T1: no status line named the running action"
+# T2
+at = max(i for i, row in enumerate(screen) if "Finished" in row)
+assert screen[at - 1] == "", "T2: no blank line precedes Finished"
+assert re.search(r"Compiling app v0\.1\.0 \(\.\) +done \d", screen[at - 2]), \
+    "T2: the package's final line does not come before Finished"
+# T3
+assert not any(("Building" in row or "Checking" in row) for row in screen[at:]), \
+    "T3: the status line was drawn after Finished"
+PY
+
+echo "PASS: 843_a_terminal_names_the_action_that_runs"
diff --git a/tests/e2e/89_build_mcpp.sh b/tests/e2e/89_build_mcpp.sh
index fb1b9ca4d..b70df6247 100755
--- a/tests/e2e/89_build_mcpp.sh
+++ b/tests/e2e/89_build_mcpp.sh
@@ -65,7 +65,7 @@ grep -qi "build.mcpp.*cached" b2.log || { cat b2.log; echo "FAIL: build.mcpp did
 # ── Build 3: a declared env input changed — forces a re-run ────────────────
 touch src/main.cpp
 MCPP_TEST_TOGGLE=1 "$MCPP" build > b3.log 2>&1 || { cat b3.log; echo "FAIL: build 3 errored"; exit 1; }
-grep -qi "build.mcpp.*\(running\|compiling\)" b3.log || { cat b3.log; echo "FAIL: changed env did not force build.mcpp re-run"; exit 1; }
+grep -qE "^ *build\.mcpp .* ran [0-9]" b3.log || { cat b3.log; echo "FAIL: changed env did not force build.mcpp re-run"; exit 1; }
 
 # ── CWD independence: build.mcpp must run with cwd = project root, so its
 #    relative file writes (the generated source) land in the project even when
diff --git a/tests/unit/test_build_progress.cpp b/tests/unit/test_build_progress.cpp
new file mode 100644
index 000000000..36dcae8ba
--- /dev/null
+++ b/tests/unit/test_build_progress.cpp
@@ -0,0 +1,334 @@
+#include <gtest/gtest.h>
+
+import std;
+import mcpp.ui;
+import mcpp.build.progress;
+
+// The build's report (.agents/docs/2026-09-29-build-progress-display-design.md):
+// its readers, the step record, the measures of text the renderer uses, and
+// the completion rule of §3.2.
+
+using namespace mcpp::build::progress;
+
+namespace {
+
+struct Tmp {
+    std::filesystem::path path;
+    Tmp() {
+        path = std::filesystem::temp_directory_path()
+             / std::format("mcpp_progress_test_{}", std::random_device{}());
+        std::filesystem::create_directories(path);
+    }
+    ~Tmp() {
+        std::error_code ec;
+        std::filesystem::remove_all(path, ec);
+    }
+};
+
+void append(const std::filesystem::path& p, std::string_view text) {
+    std::ofstream os(p, std::ios::binary | std::ios::app);
+    os << text;
+}
+
+std::size_t count(std::string_view hay, std::string_view needle) {
+    std::size_t n = 0;
+    for (auto at = hay.find(needle); at != std::string_view::npos;
+         at = hay.find(needle, at + needle.size()))
+        ++n;
+    return n;
+}
+
+} // namespace
+
+// ─── The readers ─────────────────────────────────────────────────────────
+
+TEST(ProgressStatus, ReadsTheCountsAndTheEndTime) {
+    auto s = parse_status("\x1b[0m@@mcpp 3 12 0.027@@ OBJ obj/a.o");
+    ASSERT_TRUE(s.has_value());
+    EXPECT_EQ(s->finished, 3u);
+    EXPECT_EQ(s->total, 12u);
+    EXPECT_EQ(s->endMs, 27);
+    EXPECT_EQ(s->text, "OBJ obj/a.o");
+
+    auto long_ = parse_status("\x1b[0m@@mcpp 1203 1203 2407.968@@ LINK bin/gui.exe");
+    ASSERT_TRUE(long_.has_value());
+    EXPECT_EQ(long_->endMs, 2407968);
+
+    // A nested ninja's status line, which the outer ninja relays with its
+    // escape sequence stripped, is output, not a status line.
+    EXPECT_FALSE(parse_status("@@mcpp 3 12 0.027@@ OBJ obj/a.o").has_value());
+    EXPECT_FALSE(parse_status("[3/12] OBJ obj/a.o").has_value());
+    EXPECT_FALSE(parse_status("src/a.cpp:1:2: error: @@mcpp").has_value());
+    EXPECT_FALSE(parse_status("").has_value());
+}
+
+TEST(ProgressLog, GroupsTheEntriesOfOneStep) {
+    // Measured on ninja 1.12.1: a module unit's object and BMI share start,
+    // end and hash; std.o and std.compat.o ended in the same millisecond with
+    // different hashes, and are two steps.
+    const std::string text =
+        "# ninja log v6\n"
+        "1\t3\t100\tobj/std.o\t3daa\n"
+        "1\t3\t100\tobj/std.compat.o\t73c1\n"
+        "8\t21\t101\tobj/lib2.m.o\t2745\n"
+        "8\t21\t101\tpcm.cache/pm_lib2.pcm\t2745\n"
+        "42\t385\t102\tobj/main.o\tadbb";   // still being written
+    std::size_t consumed = 0;
+    int version = 0;
+    std::vector<std::size_t> offsets;
+    auto steps = parse_log(text, &consumed, &version, &offsets);
+    EXPECT_EQ(version, 6);
+    ASSERT_EQ(steps.size(), 3u);
+    EXPECT_EQ(steps[0].outputs, std::vector<std::string>{"obj/std.o"});
+    EXPECT_EQ(steps[1].outputs, std::vector<std::string>{"obj/std.compat.o"});
+    EXPECT_EQ(steps[2].outputs, (std::vector<std::string>{"obj/lib2.m.o", "pcm.cache/pm_lib2.pcm"}));
+    EXPECT_EQ(steps[2].start, 8);
+    EXPECT_EQ(steps[2].end, 21);
+    EXPECT_EQ(consumed, text.rfind('\n') + 1);
+    ASSERT_EQ(offsets.size(), 3u);
+    EXPECT_EQ(text.substr(offsets[2], 3), "8\t2");
+}
+
+TEST(ProgressLog, ThisRunIsTheSuffixWhoseEndsTheStatusLinesStated) {
+    // A recompacted log: the old entries first, in no particular order, then
+    // this run's, whose ends the status lines gave.
+    std::vector<LogStep> steps{{0, 900, {"old/a.o"}}, {5, 40, {"old/b.o"}},
+                               {0, 12, {"new/x.o"}}, {3, 40, {"new/y.o"}}};
+    EXPECT_EQ(run_boundary(steps, {12, 40}), 2u);
+    // A status line whose entry is not written yet does not move the boundary.
+    EXPECT_EQ(run_boundary(steps, {12, 40, 55}), 2u);
+    EXPECT_EQ(run_boundary(steps, {}), 4u);
+}
+
+TEST(ProgressStarts, ReadsCompleteLinesOnly) {
+    std::size_t consumed = 0;
+    auto s = parse_starts("gen/vcpkg.stamp\t1700000000000\n"
+                          "./gen/b.stamp\t1700000000500\n"
+                          "gen/c.st", &consumed);
+    ASSERT_EQ(s.size(), 2u);
+    EXPECT_EQ(s[0].stamp, "gen/vcpkg.stamp");
+    EXPECT_EQ(s[1].stamp, "gen/b.stamp");
+    EXPECT_EQ(s[1].unixMs, 1700000000500);
+    EXPECT_EQ(consumed, std::string_view("gen/vcpkg.stamp\t1700000000000\n"
+                                         "./gen/b.stamp\t1700000000500\n").size());
+}
+
+// ─── The step record ─────────────────────────────────────────────────────
+
+TEST(ProgressRecord, EveryStatementIsRecordedWithItsOwner) {
+    Attribution a;
+    a.owner("app");
+    a.statement("build obj/main.o | pcm.cache/app.pcm : cxx_obj src/main.cpp\n  flags = -O2\n");
+    a.statement("build bin/app.bin: objcopy_bin bin/app\ndefault bin/app.bin\n\n");
+    a.owner("mcpplibs.lib");
+    a.statement("build obj/with$ space.o : cxx_obj src/with$ space.cpp\n");
+    a.statement("build C$:/abs/gen.stamp : mcpp_action_0 a.in\n");
+    a.action("C:/abs/gen.stamp", "vcpkg install");
+    a.owner("");
+    a.statement("build _mcpp_staged_cache : phony obj/x.o\n");   // not a step
+    a.statement("build obj/mcpp_ios_init.o : ios_init_object obj/mcpp_ios_init.c\n");
+    a.statement("rule cxx_obj\n  command = c++ $in\n");
+
+    const auto& steps = a.steps();
+    ASSERT_EQ(steps.size(), 5u);
+    EXPECT_EQ(steps[0].outputs, (std::vector<std::string>{"obj/main.o", "pcm.cache/app.pcm"}));
+    EXPECT_EQ(steps[0].rule, "cxx_obj");
+    EXPECT_EQ(steps[1].outputs, std::vector<std::string>{"bin/app.bin"});
+    EXPECT_EQ(steps[2].outputs, std::vector<std::string>{"obj/with space.o"});
+    EXPECT_EQ(steps[3].outputs, std::vector<std::string>{"C:/abs/gen.stamp"});
+    EXPECT_EQ(steps[4].owner, "");
+
+    auto r = a.record({{"app", true, "app v0.1.0 (.)", 0, 0}});
+    EXPECT_EQ(r.steps, 5u);
+    ASSERT_EQ(r.packages.size(), 2u);
+    EXPECT_EQ(r.packages[0].steps, 2u);
+    EXPECT_EQ(r.packages[0].subject, "app v0.1.0 (.)");
+    // An owner the plan did not declare is shown by its name, as a dependency.
+    EXPECT_EQ(r.packages[1].name, "mcpplibs.lib");
+    EXPECT_FALSE(r.packages[1].requested);
+    EXPECT_EQ(r.packages[1].steps, 2u);
+    EXPECT_EQ(r.owner.at("pcm.cache/app.pcm"), 0u);
+    EXPECT_EQ(r.owner.at("obj/with space.o"), 1u);
+    EXPECT_FALSE(r.owner.contains("obj/mcpp_ios_init.o"));
+    EXPECT_EQ(r.actions.at("C:/abs/gen.stamp"), "vcpkg install");
+
+    // The outputs of one step share its identity.
+    EXPECT_EQ(r.step.at("obj/main.o"), r.step.at("pcm.cache/app.pcm"));
+    EXPECT_NE(r.step.at("obj/main.o"), r.step.at("bin/app.bin"));
+
+    auto back = parse_record(format_record(r));
+    EXPECT_EQ(back.steps, r.steps);
+    ASSERT_EQ(back.packages.size(), 2u);
+    EXPECT_EQ(back.packages[0].subject, "app v0.1.0 (.)");
+    EXPECT_TRUE(back.packages[0].requested);
+    EXPECT_EQ(back.owner, r.owner);
+    EXPECT_EQ(back.step, r.step);
+    EXPECT_EQ(back.actions, r.actions);
+}
+
+TEST(ProgressRecord, PathsAreComparedNormalised) {
+    EXPECT_EQ(normalise("./obj\\a.o"), "obj/a.o");
+    EXPECT_EQ(normalise("obj/../obj/b.o"), "obj/b.o");
+}
+
+// ─── Measures of text ────────────────────────────────────────────────────
+
+TEST(ProgressText, DisplayWidthCountsColumns) {
+    EXPECT_EQ(mcpp::ui::display_width("abc"), 3u);
+    EXPECT_EQ(mcpp::ui::display_width("\033[1m\033[92mabc\033[0m"), 3u);
+    EXPECT_EQ(mcpp::ui::display_width("中文"), 4u);
+    EXPECT_EQ(mcpp::ui::display_width("a · b → c …"), 11u);
+}
+
+TEST(ProgressText, FitCutsByColumnsAndClosesColour) {
+    EXPECT_EQ(mcpp::ui::fit("abcdef", 6), "abcdef");
+    EXPECT_EQ(mcpp::ui::fit("abcdef", 4), "abc…");
+    EXPECT_EQ(mcpp::ui::fit("中文路径", 5), "中文…");
+    auto coloured = mcpp::ui::fit("\033[32mabcdef\033[0m", 3);
+    EXPECT_EQ(mcpp::ui::display_width(coloured), 3u);
+    EXPECT_TRUE(coloured.ends_with("\033[0m"));
+}
+
+TEST(ProgressText, OneFormatForEveryDuration) {
+    using ms = std::chrono::milliseconds;
+    EXPECT_EQ(mcpp::ui::format_duration(ms(840)), "0.84s");
+    EXPECT_EQ(mcpp::ui::format_duration(ms(12'340)), "12.34s");
+    EXPECT_EQ(mcpp::ui::format_duration(ms(192'000)), "3m12s");
+    EXPECT_EQ(mcpp::ui::format_duration(ms(3'720'000)), "1h02m");
+    EXPECT_EQ(mcpp::ui::format_clock(ms(872'000)), "14:32");
+    EXPECT_EQ(mcpp::ui::format_clock(ms(3'730'000)), "1:02:10");
+}
+
+TEST(ProgressText, TheStateStartsAtTheBlocksColumn) {
+    mcpp::ui::disable_color();
+    EXPECT_EQ(mcpp::ui::step_line("Compiling", "core (core)", 16, "done 1.20s"),
+              "   Compiling core (core)     done 1.20s");
+    // A longer subject pushes its state two columns further.
+    EXPECT_EQ(mcpp::ui::step_line("Compiling", "a-long-subject-here", 16, "failed"),
+              "   Compiling a-long-subject-here  failed");
+}
+
+// ─── The region ──────────────────────────────────────────────────────────
+
+TEST(ProgressRegion, TheStatusLineIsLastAfterABlankRow) {
+    mcpp::ui::Frame f{{"   Compiling gpp.gui (GPPGUI)  61 steps"}, "Building 612/1203 · 14:32"};
+    auto rows = mcpp::ui::region_rows({}, f, 10, true);
+    ASSERT_EQ(rows.size(), 3u);
+    EXPECT_EQ(rows[1], "");
+    EXPECT_EQ(rows[2], "Building 612/1203 · 14:32");
+    // Nothing above it and no live line: no blank row.
+    auto alone = mcpp::ui::region_rows({}, {{}, "Resolving · 0:01"}, 10, false);
+    ASSERT_EQ(alone.size(), 1u);
+}
+
+TEST(ProgressRegion, LinesBeyondTheRoomAreSummarised) {
+    mcpp::ui::Frame f;
+    for (int i = 0; i < 14; ++i) f.lines.push_back(std::format("line {}", i));
+    f.status = "Building";
+    auto rows = mcpp::ui::region_rows({}, f, 10, true);
+    ASSERT_EQ(rows.size(), 12u);   // 9 lines, the summary, the blank row, the status
+    EXPECT_NE(rows[9].find("… 5 more"), std::string::npos);
+}
+
+TEST(ProgressRegion, ARedrawReplacesThePreviousRows) {
+    auto bytes = mcpp::ui::redraw_bytes(3, {"a", "", "status"});
+    EXPECT_TRUE(bytes.starts_with("\r\033[2A\033[J"));
+    EXPECT_TRUE(bytes.ends_with("a\n\nstatus"));
+    EXPECT_EQ(mcpp::ui::redraw_bytes(0, {"x"}), "x");
+}
+
+// ─── The completion rule (§3.2) ──────────────────────────────────────────
+
+TEST(ProgressModel, APackageIsFinalWhenEveryStepOfItRan) {
+    mcpp::ui::disable_color();
+    Tmp tmp;
+    Record rec;
+    rec.packages = {{"app", true, "app v0.1.0 (.)", 0, 2}, {"dep", false, "dep v1.0.0", 0, 1},
+                    {"std", false, "std", 0, 2}};
+    rec.owner = {{"obj/main.o", 0}, {"bin/app", 0}, {"obj/dep.o", 1},
+                 {"pcm.cache/std.pcm", 2}, {"pcm.cache/std.compat.pcm", 2}};
+    rec.step  = {{"obj/main.o", 0}, {"bin/app", 1}, {"obj/dep.o", 2},
+                 {"pcm.cache/std.pcm", 3}, {"pcm.cache/std.compat.pcm", 4}};
+    rec.steps = 5;
+    Build b(tmp.path);
+    b.set_record(rec);
+    testing::internal::CaptureStdout();
+    b.pass_begin();
+    const auto log = tmp.path / ".ninja_log";
+    append(log, "# ninja log v6\n1\t10\t0\tobj/dep.o\taa\n");
+    b.status({1, 4, 10, {}});
+    append(log, "10\t30\t0\tobj/main.o\tbb\n");
+    b.status({2, 4, 30, {}});
+    auto mid = testing::internal::GetCapturedStdout();
+    // `dep` ran its one step, but `std` has a step that never runs
+    // (`std.compat`): the folded line waits, and states nothing early.
+    EXPECT_EQ(mid.find("dependenc"), std::string::npos) << mid;
+    EXPECT_EQ(mid.find("app v0.1.0"), std::string::npos) << mid;
+
+    testing::internal::CaptureStdout();
+    append(log, "30\t50\t0\tbin/app\tcc\n");
+    b.status({3, 4, 50, {}});
+    auto done = testing::internal::GetCapturedStdout();
+    EXPECT_NE(done.find("Compiling app v0.1.0 (.)"), std::string::npos) << done;
+    EXPECT_NE(done.find("done 0.04s"), std::string::npos) << done;   // 10 ms to 50 ms
+
+    testing::internal::CaptureStdout();
+    b.pass_end();
+    b.finish(true);
+    auto end = testing::internal::GetCapturedStdout();
+    EXPECT_NE(end.find("Compiling 1 dependency"), std::string::npos) << end;
+    EXPECT_EQ(count(end, "app v0.1.0"), 0u) << end;   // written once, earlier
+}
+
+TEST(ProgressModel, AfterAFailureAnOpenPackageStatesOnlyItsSteps) {
+    mcpp::ui::disable_color();
+    Tmp tmp;
+    Record rec;
+    rec.packages = {{"app", true, "app v0.1.0 (.)", 0, 3}, {"lib", true, "lib (lib)", 0, 2}};
+    rec.owner = {{"obj/a.o", 0}, {"obj/b.o", 0}, {"bin/app", 0}, {"obj/l.o", 1}, {"bin/l.a", 1}};
+    rec.step  = {{"obj/a.o", 0}, {"obj/b.o", 1}, {"bin/app", 2}, {"obj/l.o", 3}, {"bin/l.a", 4}};
+    Build b(tmp.path);
+    b.set_record(rec);
+    testing::internal::CaptureStdout();
+    b.pass_begin();
+    append(tmp.path / ".ninja_log", "# ninja log v6\n1\t10\t0\tobj/a.o\taa\n");
+    b.status({1, 5, 10, {}});
+    const bool first = b.failed("obj/l.o ");
+    b.status({2, 5, 12, {}});
+    b.pass_end();
+    b.finish(false);
+    auto out = testing::internal::GetCapturedStdout();
+    EXPECT_TRUE(first);
+    EXPECT_NE(out.find("lib (lib)"), std::string::npos) << out;
+    EXPECT_NE(out.find("failed"), std::string::npos) << out;
+    EXPECT_NE(out.find("app v0.1.0 (.)"), std::string::npos) << out;
+    EXPECT_NE(out.find("1 step"), std::string::npos) << out;
+    EXPECT_EQ(out.find("done"), std::string::npos) << out;
+}
+
+TEST(ProgressModel, AStepWhoseEntriesAreReadInTwoPiecesCountsOnce) {
+    // ninja writes one log entry per output and flushes each: a read can land
+    // between a module unit's object and its BMI.
+    mcpp::ui::disable_color();
+    Tmp tmp;
+    Record rec;
+    rec.packages = {{"lib", true, "lib (lib)", 0, 2}};
+    rec.owner = {{"obj/lib.m.o", 0}, {"pcm.cache/lib.pcm", 0}, {"bin/lib.a", 0}};
+    rec.step  = {{"obj/lib.m.o", 0}, {"pcm.cache/lib.pcm", 0}, {"bin/lib.a", 1}};
+    Build b(tmp.path);
+    b.set_record(rec);
+    testing::internal::CaptureStdout();
+    b.pass_begin();
+    const auto log = tmp.path / ".ninja_log";
+    append(log, "# ninja log v6\n1\t10\t0\tobj/lib.m.o\taa\n");
+    b.status({1, 2, 10, {}});
+    append(log, "1\t10\t0\tpcm.cache/lib.pcm\taa\n");
+    b.status({1, 2, 10, {}});
+    auto out = testing::internal::GetCapturedStdout();
+    // Two steps, one of them run: the package is not complete.
+    EXPECT_EQ(out.find("done"), std::string::npos) << out;
+    testing::internal::CaptureStdout();
+    b.pass_end();
+    b.finish(true);
+    (void)testing::internal::GetCapturedStdout();
+}