feat: show nested child runs and a distinct awaiting-child state - #708

What & why

Fixes #705. Two problems for anyone running loops within loops:

1. Awaiting child looked like pending. A step parked on its child run (awaiting_child) drew the same dashed grey ring as a step nothing has reached yet. In the reporter's graph, wave waiting on real work read the same as the idle wave_ok.
2. Children were invisible from the parent. To see which step a child was on, or to find the one that was slow or stuck with certain inputs, you had to open each child. With loops inside loops, you had to do that at every level.

What changes on the loop run page:

• A distinct state for delegated work. @compozy/ui StateGlyph gains a delegated state, an info ring around a dot ("work parked inside work it handed off"), and awaiting_child maps to it on every surface that draws a node state. The hue is the same info used for parked segments in the progress bar. Warning amber stays reserved for real warnings, per the StateGlyph contract.
• The graph, where the reporter works. A step that started a child carries a quiet line under its state: ↳ ◉ fix batch 6m 41s, meaning the step the child is on and how long it has been there, or the child's status once it has settled. The card is still the button that opens the node panel, so the line is a reading, not a control.
• The node panel shows the child open. Every child row shows:
  • the child loop name, linked to its run;
  • the inputs that set it apart from its siblings (batch: billing), with the full values in the tooltip;
  • its run status;
  • the step it is on, with the reason it is parked in plain words (— waiting for your decision, — paused, — waiting on a child run);
  • time on that step, which keeps counting while the step is parked;
  • the served step count and the run's elapsed time.
• Nested levels open in place. A child that started loops of its own opens them one level down, up to three levels, after which the child's own page is one click away.
• Progress keeps a closed-by-default "N child runs" disclosure under every step that started loop runs, with the same rows. The default view stays calm. Past eight children, the rest stay behind "Show N more".

There is no backend change. The roster already serves child_loop_run_id on awaiting_child rows from the moment the child is spawned (internal/loop/action_runloop.go). Each row reads the child through the same detail, briefing and roster query options the child's own page uses, so opening the child afterwards is a cache hit and polling stops once the child settles.

How you verified it

Real app, isolated QA lab, three levels deep, mirroring the reporter's graph. No agents or providers: nightly-waves.wave runs run-one-wave (wave: 2), which fans three batches into fix-one-batch (batch: api | billing | docs). Each batch parks on a durable 40-minute wait, and billing's wait was paused with compozy loop node pause. The same daemon served the main web (before) and this branch's web (after).

Before (main)	After (this PR)

Storybook (LoopRunPage/NestedLoopsExpanded, deterministic MSW fixture). A batch stuck waiting on a person reads "47m 00s on this step" while its run clock froze at 5m. The time-on-step reading exists for exactly this case.

Four defects showed up during the real walks and were fixed before this PR. Each now has a test:

• GET /loop-runs/:id serves a zeroed progress, so step counts come from the child's briefing. The story fixture serves the detail zeroed the same way, so the component test proves the right route is read.
• Branches of one fanned node all read "fix batch". They now carry their item slot, and the inputs that differ between siblings tell them apart.
• The run clock freezes at the last progress, so a stuck child read like a healthy one. Rows now show time on the current step.
• The roster does not record a start time for a step parked in a durable wait. That time now comes from the step's wait cell.

Tests, each added to the suite that owns the invariant:

• lib/__tests__/loop-run-dag-view.test.ts: awaiting_child has its own glyph and form, never pending's.
• lib/__tests__/loop-run-child-runs.test.ts (new lib module), covering:
  • slot selection and disambiguation;
  • current-step precedence: waiting on a person beats parked, which beats running;
  • current round only;
  • time on step that keeps counting while parked, and wait-cell timing;
  • grandchildren from the current round;
  • counts from the briefing rather than the zeroed detail.
• lib/__tests__/loop-run-child-inputs.test.ts (new lib module): only the inputs that differ between siblings; a lone child shows its inputs; long and structured values are shortened, with the full value kept in the title; nothing for identical or unread siblings.
• components/__tests__/loop-run-page.test.tsx, all over MSW (detail + briefing + roster):
  • Progress: closed by default, then every row reading opened, including the stuck child's 47 minutes and a grandchild opened a level down.
  • Graph: wave delegated vs wave_ok queued, plus the child line and its accessible sentence.
  • Node panel: the child is open without asking, with its inputs.
• packages/ui StateGlyph suite and the design-system showcase vocabulary cover the new delegated state.

Review follow-ups (CodeRabbit, Greptile), each fixed with a regression test:

• Child's current round. The daemon pages the roster oldest round first. A row now asks for the round the child's briefing names (generation filter) and converges that round's pages up to 5. Past that it says so rather than guessing the step.
• Read failures. Briefing and roster errors reach the row, and whatever did arrive stays on screen.
• Detached children. A child can outlive its parent's clock; once the page clock stops, a live child ticks on the shared clock.
• Failed pages. Automatic paging stops after a next-page error, and the regular poll retries it, so there is no tight request loop.
• Inputs. Sibling inputs are compared with types preserved (5 vs "5", absent vs "undefined").
• Docs. Docstrings were added for every touched function (CodeRabbit pre-merge: 5/5 passed).

Local checks (targeted; the full make gate and E2E lanes run in CI, as requested, to keep this machine free):

oxfmt --check (changed files) ........................ pass
oxlint --deny-warnings (web loops, ui) ............... pass
react-doctor 0.9.17 (CI version), changed sources .... 100/100
turbo typecheck web + @compozy/ui .................... pass
vitest web loops + showcase .......................... 77 files, 863 tests pass
vitest @compozy/ui state-glyph ....................... 16 tests pass
QA labs strict auditor (2 labs) ...................... PASS, 0 blockers; teardown clean

Impact

• Web surface: loop run page (Progress, Inspect graph, node panel). @compozy/ui gains the StateGlyph delegated state, an additive change. Docs, stories and the showcase are updated.
• No impact on CLI commands, HTTP/UDS routes or DTOs, config.toml, hooks, extension SDKs or native tools. No schema or migration.
• Workspace isolation: child reads are scoped to the parent's workspace and profile read scope. The runtime starts children in the parent's workspace and profile.
• Official skill (skills/compozy/) and site docs: no change needed. The awaiting_child state and run-loop semantics are unchanged; only how the Web draws them changed.
• QA: new scenario docs/qa/scenarios/LP-web-run-nested-child-runs.md (pass) and report docs/qa/reports/2026-10-07-issue-705-nested-child-runs.md.

• make gate passes locally; this PR is delivered only after its required CI checks are green. (Delegated to CI at the maintainer's request; the targeted checks above passed locally.)
• New or changed behavior is covered by tests, or I explained above why not
• If an agent wrote or co-wrote this, I named it above and verified the result myself. (Written by Claude Code, Opus 5.5, including both QA lab walks; awaiting maintainer review.)

🤖 Generated with Claude Code

Summary by CodeRabbit

• New Features
  • Loop run pages show linked child runs with their status, current step, elapsed time, inputs, and progress. Expand child runs recursively, and reveal larger lists in batches.
  • Run diagrams distinguish delegated work from queued work and show child-run status and timing.
  • Added a delegated state glyph to the design system showcase.