@orkestrel/scaffold 0.0.108 → 0.0.109

package/dist/host/agents/skills/orkestrel-journey/SKILL.md

@@ -18,10 +18,6 @@ description: Prove a browser application the way a person uses it — real keyst
 7. The `*/types.ts` of every environment the journeys drive, plus the application's root component,
    route entry, and store contract.
 
-Treat a retained readiness verdict as evidence to re-verify against the current tip, never as a plan
-to resume. Re-take every ruling it records that this run's acceptance depends on, and name the commit
-each ruling was taken at.
-
 ## Declare the families
 
 Declare in the browser environment's `integration.test.ts` which families that screen carries, and
@@ -82,19 +78,19 @@ start, and let it choose the capture destination, the matrix row, and the statec
   browser application is born with. Its presence is the journey axis. Rename and extend the seeded
   viewports for this application.
 - Activate the axis in a workspace born before it: write `configs/app/vite.journey.config.ts`, run
-  `scaffold repair`, then add `npm run test:journey` to the `test` script after `npm run test:app`.
-  The repair defines `appJourney` in the root configuration, emits the `test:journey` script, and
-  excludes the journey suite from the ordinary `app:browser` project. It does not rewrite the `test`
+  `scaffold audit`, and add any missing planned dependencies it names before `scaffold repair`.
+  Then add `npm run test:journey` to the `test` script after `npm run test:app`.
+  The repair defines `appJourney` in the root configuration, emits `test:journey`, `journey`, and
+  `capture`, and excludes the journey suite from the ordinary `app:browser` project. It does not rewrite the `test`
   chain, so the chain entry is yours to add. Add that entry before the repair instead where you
   prefer: `test:journey` names a configuration rather than a project, so neither order blocks the
   repair.
-- Name each variant for the theme and the viewport it renders, such as `dark-390`. Never split the
-  theme from the viewport; a split writes a filename naming a combination the run did not render.
+- Name each variant per [captures.md](references/captures.md) → Variants.
 - Keep the provided variants as serializable `JourneyVariant` data: `name`, `width`, and `height`.
   Compose no callback merely to pass that data to a capture.
-- Run the axis with `npm run test:journey`, which runs that wrapper and joins the `test` chain. Set
-  `CAPTURE` to `1` in your own shell and run `npm run test:journey` again to write the frames; the
-  root configuration reads that variable and provides it as `capture`.
+- Keep `npm run test:journey` as the whole-suite gate in the `test` chain. Use the scoped commands
+  under Choosing what to run for iteration and stamped frames; keep the root configuration's
+  `CAPTURE === '1'` read and its `capture` provide unchanged.
 - Keep the journeys in `tests/app/browser/integration.test.ts`, and the journeys of the `vue`
   extension's application in `tests/app/vue/integration.test.ts`, which `npm run test:journey:vue`
   runs. Each variant project of a mode collects that file alone, and the application's ordinary
@@ -104,19 +100,65 @@ start, and let it choose the capture destination, the matrix row, and the statec
 - Render exactly one variant per run for the capture family
   ([captures.md](references/captures.md) → Variants).
 
-`scaffold audit` reports a manifest and a wrapper that disagree as one of the following questions.
-Settle the one it reports before trusting a green run.
+`scaffold audit` reports a manifest and a wrapper that disagree as one of these findings. Settle the one it reports before trusting a green run.
 
-| The question `scaffold audit` reports                                                                                                                                                                                                                                    | Settle it by                                                                                                      |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------- |
-| `The manifest at <target> names a Vitest configuration the plan does not emit and the target does not hold: test:journey --config configs/app/vite.journey.config.ts. Add the configuration, or remove the script that names it and its invocation from the test chain.` | Writing the wrapper and running `scaffold repair`, or removing the `test:journey` script and its chain invocation |
-| `The manifest at <target> does not invoke npm run test:journey from its test chain. Add npm run test:journey after npm run test:app.`                                                                                                                                    | Adding `npm run test:journey` to the `test` script after `npm run test:app`                                       |
+- The manifest names a Vitest configuration for `test:journey` that the plan does not emit and the target does not hold. Write the wrapper and run `scaffold repair`, or remove the `test:journey` script and its chain invocation.
+- The manifest does not invoke `npm run test:journey` from its `test` chain. Add `npm run test:journey` to the `test` script after `npm run test:app`.
 
 `scaffold audit` reports the invocation question only when no chain from `test` reaches
 `npm run test:journey` through literal `npm run` calls, so a chain reaching it through an
 intermediate script raises none. It reports the configuration question only for a `test:*` script
 whose text names `vitest`, so a script naming another runner's configuration raises none either.
 
+### Choosing what to run
+
+- Run the installed `@orkestrel/capture` package at `node_modules/@orkestrel/capture` through
+  `npm run journey -- <selector>` (`capture journey`) for owner-selected behavior with capture
+  off, and `npm run capture -- <selector>` (`capture frames`) for capture-bearing journeys with
+  `CAPTURE=1`. Keep the commands separate; never append capture work to a behavior run.
+- Before using scoped commands, wire the adopter-owned journey wrapper's discovery, selection
+  request, tags, portfolios, registry, and final-case records to the package protocol. Read the
+  `@orkestrel/capture` guide's Runner and Runner selection and process protocol sections; scaffold
+  seeds the commands and dependency, while the application supplies these declarations.
+- Select `all` or a colon-delimited owner path from the wrapper's tags: `<scope>`,
+  `<scope>:<owner>`, or further declared descendants. Use the wrapper's names, never infer them
+  from filenames. Keep behavior on the positive `owner:` filter and frames on its intersection
+  with the selected capture tags; include the final case in each selection.
+- Narrow with `--variant <name>` (repeatable) and `--case <exact-full-name>`. Use `--state <name>`
+  only with frames to resolve its declaring case from fresh evidence. Use `--config <path>` to
+  select another wrapper. Give each value-taking flag a nonempty value; use `--flag=value` when
+  the value starts with `-`. Pass no second `--` terminator to the executable.
+- Replace the selector with `--changed <ref>` to select changed owners; use `HEAD` for uncommitted
+  work. Inspect `--changed <ref> --plan` first: discovery runs, but no execution child starts.
+  Read each path's `own`, `shared`, or `outside` classification and the exact next commands.
+  Follow a shared-input refusal's explicit whole-suite command; never widen automatically.
+- Refuse a bare command, an unknown selector or variant, an unknown or command-inappropriate
+  flag, a repeated single-value flag, a selector beside `--changed`, and `--plan` without
+  `--changed`. Treat an empty workload as failure. Follow the reported refresh command when
+  state evidence or the accepted registry is missing, stale, or ambiguous.
+- Read the authenticated selection request in the wrapper. Before a behavioral body writes a
+  frame, refuse a selected case that declares a state outside the selected owner; split that
+  case instead of parking its outside states. Keep the full behavioral placement proof when
+  `--state` projects only the requested written frame.
+- Run selected journey variants together in declaration order with capture off. For frames,
+  produce the declared first variant in `narrow` before `rest`; when that variant is not
+  selected, run only `rest`. Stop after a failed stage, and add no unselected variant or owner.
+
+Climb this ladder using only declared owner, case, and variant names:
+
+1. One case on one variant: `npm run journey -- pages:mail --case 'mail shows the inbox' --variant light-390`.
+2. The changed set: inspect `npm run journey -- --changed HEAD --plan`, then run
+   `npm run journey -- --changed HEAD`. For frames, inspect `npm run capture -- --changed HEAD --plan`
+   before `npm run capture -- --changed HEAD`.
+3. A section or page: `npm run journey -- pages:mail:inbox` or `npm run journey -- pages:mail`.
+4. A group: `npm run journey -- pages`.
+5. `all` at the gate: `npm run journey -- all`, retaining `npm run test:journey` in the repository's
+   whole-suite test chain.
+
+Follow a refusal's exact next commands before widening a selection. Use the matching `capture`
+script only when the work needs frames, and apply [captures.md](references/captures.md) before
+judging their freshness or completeness.
+
 ### Prepare the capture theme
 
 - Where the application ships a theme control, await the theme action through that interface
@@ -182,41 +224,15 @@ await PORTFOLIO.place('home')
 
 ## Apply the journey laws
 
-1. **Drive only what a person can see and reach.** Resolve every interactive target by its ARIA
-   role and its accessible name as rendered. Never reach into a component instance, a store, a
-   transport, a copied credential, or a test-only hook to make a step succeed. Report a step that
-   cannot be performed through the interface as a finding about the interface.
-2. **Assert what is seen.** Quote the rendered text a person reads, which is `innerText` — a label
-   under `text-uppercase` asserts as `TRACE` where the source says `Trace`. Never let an entity
-   state read replace a perception assertion; it may only corroborate one, and
-   `.claude/rules/tests.md` fixes which entity state a test may read at all.
-3. **Assert what the interface withholds.** Assert every refusal through the resolver's exact
-   failure voice, and distinguish an absent control from a present but humanly unreachable one.
-4. **Keep transport and persistence proofs in their own declared block,** never inside a journey.
-   Assert every live or asynchronous fact by convergence — poll until it contains or equals — never
-   by an identity read of one frame.
-5. **Generate the portfolio from the acceptance journeys.** Place each registered state inside the
-   journey that reaches it, and never register a state no journey reaches.
-6. **Commit a value through an act a person performs:** `pressKeys('{Enter}')` on the focused
-   control, a Tab away, or a named button. Report a screen that commits on a timer, on an
-   unpredictable event, or only after work the person cannot observe as a screen finding, and never
-   work around it in the layer.
-7. **Type only what a person would.** Journeys carry trusted input; inputs no person would type
-   belong to the transport family and the parser suites.
-8. **Perform every interaction step unconditionally.** Never gate a step on whether the control it
-   is about to drive exists or is reachable, and never branch a journey on `readRefusal`. Let the
-   resolver's failure voice name what the interface withheld. A guarded step passes whether or not
-   the control was there, so the run goes green on a screen that removed the control.
+- Write every journey under `.claude/rules/tests.md` § Journey tests.
+- Generate the portfolio from the acceptance journeys. Place each registered state inside the
+  journey that reaches it, and never register a state no journey reaches.
 
 ## Import the journey layer
 
-- Import every journey verb, reader, wait, and fixture builder from `@orkestrel/test/browser`, and
-  every host-independent wait and table type from `@orkestrel/test`. Write one of your own only
-  where those entries publish none for the act ([layer.md](references/layer.md) → Import, never
+- Write a verb, reader, or wait of your own only where the entries `.claude/rules/tests.md`
+  § Journey tests names publish none for the act ([layer.md](references/layer.md) → Import, never
   implement).
-- Send every key sequence through `pressKeys`, which refuses a sequence sent while nothing but the
-  document body holds focus. Never reach past it to the provider's own keyboard function from a
-  journey, a matrix reading, or a statechart phase.
 - Place a helper you must write in the workspace's browser test setup module, name it for the act,
   and export it from there under `.claude/rules/tests.md`. Never declare a resolver inside a test
   file.
@@ -231,30 +247,8 @@ await PORTFOLIO.place('home')
 
 Write one journey per user intent, named for what the person achieves rather than for the
 components it passes through. Place them in the browser environment's `integration.test.ts`, whose
-placement and scope `.claude/rules/tests.md` fixes.
-
-- Enter through the real entry: mount the shipped root component with a real store and the route a
-  person lands on, and let the application load itself.
-- Reach each screen's own controls through forward Tab traversal in at least one journey.
-- Type keystroke by keystroke where the keystrokes are the subject; fill in one operation where the
-  text is only a payload the person pastes.
-- Poll every fact the application produces asynchronously until it converges. Never assert one from
-  a single read after the action. A poll's predicate must be able to go false-to-true after the
-  action it observes; a predicate already true when the poll starts binds nothing.
-- Assert the state the flow must reach, never the transient path taken to it. A criterion that bans
-  a harmless transient over-refuses and breaks on the next honest implementation.
-- Assert the negative beside the positive whenever a value replaces another: name the arriving
-  sentence and carry the replaced one in `absent`, so the reading that resolves carries one and not
-  the other ([layer.md](references/layer.md) → The waits).
-- Assert the state a control announces beside every drive that sets it, and on an unselected
-  sibling. A control announcing state owes this assertion whether or not the screen carries the
-  statechart family.
-- After a confirmed destructive action, assert through trusted input that focus landed on a visible,
-  announced location.
-- Assert the whole page's perception never matches the vocabulary the product does not speak —
-  engine, schema, and implementation words the interface is supposed to translate.
-- Report a bare accessible name that answers for more than one reachable element on one screen as a screen
-  finding, and target through role or region until the screen is fixed.
+placement and scope `.claude/rules/tests.md` fixes. Carry a replaced value in `absent` as
+[layer.md](references/layer.md) → The waits shows.
 
 ### The intents every screen owes
 
@@ -352,34 +346,17 @@ Mutate each assertion class once, read the red, restore, and read the green.
 
 Completion requires all of:
 
-- every in-scope user intent reaching its outcome through the interface, with no step that reaches
-  past it;
-- the intents every screen owes present wherever the screen has the state, each outcome taken from
-  the product guide and every missing one reported as a product finding;
-- keyboard-only reachability proven on every screen the journeys cover;
+- every in-scope user intent, the intents every screen owes included, reaching its outcome through the interface with no step that reaches past it, and keyboard-only reachability proven on every screen the journeys cover;
 - a refusal family per screen, each asserting one exact failure voice;
-- the transport family declared separately, driven through real implementations, and convergent;
-- the declared families each proven, and the declaration itself asserted;
-- the matrix family read once per declared variant, each style reading carrying its published
-  control from [styles.md](references/styles.md) → The published controls in the same run, and the
-  contrast reading's control straddling its declared bar;
-- the authored-class census and the `extractStyles` reading taken on the mounted screen, each
-  reporting the population it walked;
-- the statechart table driven to a terminal status with no failed row, and the harness tally read
-  from the object and from its markup;
-- the registry-times-variants filename proof and the state-placement proof green in an ordinary run;
-- one capture run per variant writing every registered file, and the disk-membership proof green;
-- the written artifact produced for every variant the run rendered, named by that variant;
-- perception assertions quoting rendered text, and the vocabulary sweep green on the whole page;
-- the browser test setup module proven by `tests/setupBrowser.test.ts` in the `setup:browser`
-  project `scaffold repair` registers;
+- the declared families each proven, the declaration asserted, and the transport family driven through real implementations;
+- the matrix family read once per declared variant, each style reading carrying its published control from [styles.md](references/styles.md) → The published controls, and the authored-class census and the `extractStyles` reading each reporting the population it walked;
+- the statechart table driven to a terminal status with no failed row, and the harness tally read from the object and from its markup;
+- the registry-times-variants filename proof and the state-placement proof green in an ordinary run, one capture run per variant writing every registered file, and the written artifact produced for every variant, named by that variant;
+- the browser test setup module proven by `tests/setupBrowser.test.ts` in the `setup:browser` project `scaffold repair` registers;
 - each assertion class mutated, with the red reading and the green reading recorded;
-- the repository gates green, under the independent-verification law in `.agents/orchestration.md`.
+- the repository gates green, per `.agents/orchestration.md` § Acceptance.
 
-State the engine bound with the verdict. The gate renders one engine, so a claim about a second
-engine is unproven until a reading on that engine records it. The emitted `configs/browsers.ts` doc
-block is the home of that limit and of the condition that reopens it. Cite that doc block, and copy
-neither into a verdict.
+State the engine bound with the verdict, per [styles.md](references/styles.md) → The engine bound.
 
 Report each journey by the intent it proves, the refusals it establishes, the states it placed, the
 variants it read, the statechart outcome it reached, and every screen finding the layer's refusals

package/dist/host/agents/skills/orkestrel-journey/references/captures.md

@@ -11,7 +11,7 @@ import type { JourneyVariant } from '@orkestrel/test'
 import type {
 	CaptureVariant,
 	FrameOptions,
-	FrameReading,
+	FrameResult,
 	PortfolioInterface,
 	PortfolioOptions,
 } from '@orkestrel/test/browser'
@@ -54,12 +54,38 @@ Declare the state names once in the journey file, and build the portfolio from t
 
 - Name a state for its screen and its condition — `answer-partial`, `start-storage-failure`,
   `case-delete-confirmation`.
-- Register the states the design work actually needs, and place every registered one. Never leave a
-  registered state unplaced.
+- Register the states the design work needs, and give every registered state a declaring case.
+  In a complete run, place every registered state; in a scoped run, place every state the cases
+  that ran declare.
 - Place a capture state from inside the journey that reaches it, immediately after the assertion
   that proves the screen is in the condition that state names.
 - Record each placed name in the suite's own set in the same step that calls `place`. That set, not
   `placements`, is what the always-on placement proof reads.
+- Give each owner-bearing case registry-derived `owner:` tags. Declare a placing case's states in
+  `meta.states`, derive its capture scope and part tags from those states, and place only states
+  of that owner. Give behavior-only cases no capture tag.
+- Derive variant-conditional declarations and placements from the same predicate. Keep the
+  ownerless infrastructure cases explicit, outside behavioral work counts and completeness.
+- Store frames in their declared per-scope directories, and pass those roots to the wrapper's
+  portfolio declarations.
+
+## Scoped commands
+
+- Run `npm run journey -- <selector>` for behavior and `npm run capture -- <selector>` for frames.
+  Take both commands from `node_modules/@orkestrel/capture`; follow
+  [SKILL.md](../SKILL.md#choosing-what-to-run) for selector grammar, flags, refusals, and the
+  case, changed-set, section or page, group, and `all` ladder. Retain `test:journey` as the
+  whole-suite gate.
+- Inspect the changed set with `--changed <ref> --plan` before executing it. Keep a shared-input
+  refusal explicit, and follow its next command without silently capturing the complement.
+- Use the authenticated selection request to refuse a case whose declared states cross the
+  selected owner before any behavioral body runs. Split the case; never park the outside states.
+- Resolve a frames-only `--state` request from fresh registry and passing case evidence. Keep the
+  declaring case's behavior and full placement proof, projecting only the written frames onto
+  the requested state. Follow the explicit refresh command when the lookup refuses.
+- Keep each variant project on one rendered variant. Produce the selected first variant in
+  `narrow`, then the remaining selected variants in `rest`; omit `narrow` when its variant is
+  not selected and stop after a failed stage.
 
 ## Variants
 
@@ -71,37 +97,47 @@ these.
   application's to set, and the presence of that file is the journey axis.
 - Prepare the theme under [SKILL.md](../SKILL.md#prepare-the-capture-theme) before driving the
   captured state, and use the variant list that preparation requires.
-- Name each variant for the theme and the viewport it renders, such as `dark-390`. The name is the
-  second half of every filename the run writes, so a variant named for one alone produces a
-  portfolio nobody can tell apart.
+- Name each variant for the theme and the viewport it renders, such as `dark-390`. Never split the
+  theme from the viewport. The name is the second half of every filename the run writes, so a
+  variant named for one alone writes a filename naming a combination the run did not render.
 - Pass the whole declared list as `variants` and `inject('variant')` as `variant`.
   `createPortfolio` refuses a `variant` no declared variant carries, and `files` expands the
   registry across the whole list rather than across the one being rendered.
-- Produce the portfolio — the registry times the variants — by running the axis once per variant,
-  which `npm run test:journey` does in one command.
+- Produce the complete stamped portfolio with `npm run capture -- all`, which runs the declared
+  variant projects through the capture runner. Keep `npm run test:journey` as the complete
+  behavioral gate; a bare capture-flag run supplies no manifest stamp.
 
 ## The proofs the suite owes
 
 Write each of the following proofs into the suite. The package asserts none of them.
 
-| Proof                | Runs           | Asserts                                                                            |
-| -------------------- | -------------- | ---------------------------------------------------------------------------------- |
-| Filename expansion   | Always         | `expandCaptures(states, variants)` has one entry per state and variant, all unique |
-| Placement membership | Always         | The suite's placed set equals the registry, as sets                                |
-| Disk membership      | Under the flag | The filenames on disk equal the expansion for this run's variant                   |
+| Proof                | Runs           | Asserts                                                                                                 |
+| -------------------- | -------------- | ------------------------------------------------------------------------------------------------------- |
+| Filename expansion   | Always         | `expandCaptures(states, variants)` has one entry per state and variant, all unique                      |
+| Declaration coverage | Always         | The case declarations cover the registry, are disjoint, and match the owner and capture tag definitions |
+| Placement membership | Always         | The suite's placed set equals the states declared by the cases that ran, as sets                        |
+| Disk membership      | Under the flag | The written filenames equal the selected expansion for this run's variant, with no orphan on disk       |
 
 - Keep the filename proof always-on, so a registry edit that introduces a duplicate or a collision
   fails the ordinary run. Compare `expandCaptures(states, variants)` against `files` and against a
   set built from it; a length equal to the set's size is what proves the expansion unique.
-- Assert placement as set equality against the registry, in every run.
+- Assert declaration coverage even in a scoped run: fail a registered state declared nowhere,
+  overlapping declarations, or an owner or capture tag definition that differs from the registry.
+- Assert placement as set equality against the union of the states the cases that ran declare.
+  When every case ran, require that union to equal the registry. Derive completeness from the
+  recorded cases that ran and passed, never from the selector or a task's mode alone.
 - Read the placement proof from the suite's own set rather than from `placements`, which stays empty
   in an ordinary run. `place` refuses an unregistered name and a second placement of one state in
   every run, but a registered state that no journey placed reaches no refusal; the always-on
   placement proof catches it.
-- Under the flag, assert the written filenames equal the registry expanded for the run's variant.
+- Under the flag, assert the written filenames equal the ran cases' declared states expanded for
+  the run's variant, or the explicit state's projection. Keep the full placement assertion in
+  that projected run, and refuse an orphan on disk while retaining untouched registered frames.
   `captureFrame` already reads each file back and compares its bytes against the frame it shot, so
   the path `place` returns is proof the file exists and holds that frame.
 - Put the membership proof last in the file, after every journey that feeds its tally.
+- At group closure, prove the union of the group's declarations and its cross-section
+  interactions. Run the whole-registry census only when complete reference coverage ran.
 
 ## Transient states
 
@@ -118,7 +154,8 @@ after the click returns.
 - Take each frame after the paint settles. Reach for `waitForAnimations` on the element whose
   transition was running ([layer.md](layer.md) → The waits); a frame shot mid-transition pictures a
   state the interface never rests in.
-- Regenerate the whole matrix from the journeys after any screen change. Never judge a round
-  against a portfolio that is part old and part new.
+- Judge only frames the capture manifest records as current: every source digest the frame
+  recorded must equal the tree's. Recapture what the staleness report names before the round.
+  Admit a portfolio assembled from several runs only when every judged frame is current.
 - Route review of the portfolio to the `orkestrel-polish` campaign, which owns preflight,
   verdicts, and reconciliation. This reference owns only how the journeys generate it.

package/dist/host/agents/skills/orkestrel-journey/references/decide.md

@@ -26,26 +26,7 @@ follow it there rather than restating it here.
 
 ## The limit that decides the split
 
-`prove` cannot serve a browser project, and the limit belongs to the installed `@orkestrel/probe`
-rather than to a version this file names. Confirm it against the copy this workspace holds before
-routing a rendered question, and record the version you read beside the ruling.
-
-Read the pool pin, the project lookup, and the guide's own statement. Any of them holding is the
-limit holding:
-
-- **The pool pin.** Read the runtime stage in the installed server entry. Where it pins the
-  `threads` pool, a browser project's specification runs in a Node worker,
-  `@orkestrel/test/browser` imports `vitest/browser` at module scope, and the browser setup file
-  throws before the case runs.
-- **The project lookup.** The runtime stage looks a project up by the name it infers from the test
-  path, and a browser project is instantiated under its browser-expanded name, so the lookup finds
-  nothing and the claim is refused as missing.
-- **The guide's statement.** Read what `@orkestrel/probe`'s own guide says the stages serve. Where
-  it names no browser project, no stage claims one.
-
-Never route a rendered question to `prove` while any of them holds. The pinned-pool refusal arrives
-as a case failure, which reads exactly like a broken claim. Record the version, the pool pin you
-read, and what the guide says, so the next round re-reads rather than re-deriving.
+`prove` cannot serve a browser project. The runtime stage of `@orkestrel/probe` creates each specification with the `threads` pool (the `createSpecification` call in `node_modules/@orkestrel/probe/dist/src/server/index.js`), so a browser project's specification runs in a Node worker, where `@orkestrel/test/browser` imports `vitest/browser` and the browser setup file throws before the case runs. The refusal arrives as a case failure and reads like a broken claim. Never route a rendered question to `prove`; re-read that call in the installed copy when the package changes.
 
 ## The rendered artifact
 

package/dist/host/agents/skills/orkestrel-journey/references/layer.md

@@ -153,35 +153,27 @@ act itself scrolls into view.
 ### The failure voices
 
 Assert the one voice the case means. Never write an assertion that accepts more than one. This table
-carries this layer's own voices. Read the statechart voices in [statechart.md](statechart.md) and
-the capture voices in [captures.md](captures.md).
-
-| Condition                                              | The voice thrown                                                                         | Thrown by               |
-| ------------------------------------------------------ | ---------------------------------------------------------------------------------------- | ----------------------- |
-| No element carries the name                            | `No interactive element has the accessible name "<name>"`                                | `resolveRendered`       |
-| Every match fails a reachability condition             | `Interactive target "<name>" is not visible and focus-reachable`                         | `resolveRendered`       |
-| Several matches are reachable                          | `Interactive target "<name>" is ambiguous across <n> elements`                           | `resolveRendered`       |
-| Still off-viewport after being scrolled to             | `Interactive target "<name>" is unreachable after scrolling`                             | `resolveAccessible`     |
-| The region holds no reachable match                    | `Interactive target "<name>" is not reachable inside "<region>"`                         | `clickAccessibleWithin` |
-| The region holds several reachable matches             | `Interactive target "<name>" is ambiguous across <n> elements inside "<region>"`         | `clickAccessibleWithin` |
-| No native disclosure is reachable under the name       | `Native disclosure "<name>" is not visible and focus-reachable`                          | `clickDisclosure`       |
-| Several native disclosures carry the name              | `Native disclosure "<name>" is ambiguous across <n> elements`                            | `clickDisclosure`       |
-| Forward Tab never lands on the target                  | `Interactive target "<name>" is not reachable through forward Tab traversal: <trail>`    | `traverseAccessible`    |
-| The named region is hidden                             | `Named region "<name>" is not visible`                                                   | `readPerception`        |
-| Several named regions carry the name                   | `Named region "<name>" is ambiguous across <n> elements`                                 | `readPerception`        |
-| The resolved control renders no value                  | `Interactive target "<name>" does not carry a value`                                     | `readValue`             |
-| A key sequence reached nothing                         | `Key sequence "<keys>" was sent with nothing focused`                                    | `pressKeys`             |
-| The state never arrived or never left                  | `Condition "<subject>" did not hold within <n>ms (waited <n>ms) (last states: <states>)` | `waitForState`          |
-| The animation subject is in no document                | `Animation subject is not connected`                                                     | `waitForAnimations`     |
-| The paint never stopped moving                         | `Animation "<subject>" did not settle within <n>ms (waited <n>ms): <animations>`         | `waitForAnimations`     |
-| The sentence never arrived                             | `Condition "<description>" did not hold within <n>ms (waited <n>ms)`                     | `waitForText`           |
-| A host withholds `getItem`, `setItem`, or `removeItem` | `Access is denied for <operation> "<key>"`                                               | `createStorage`         |
-| A host withholds `length`, `clear`, or `key`           | `Access is denied for <operation>`                                                       | `createStorage`         |
-| A write ran past the declared quota                    | `No room is left for <key>`                                                              | `createStorage`         |
-| A style reading has no computed color                  | `Computed foreground color is unavailable`                                               | `readContrast`          |
-| A class census walked nothing                          | `Class census walked no element`                                                         | `readCensus`            |
-| A contrast control cannot straddle its bar             | `Contrast control cannot straddle the bar <bar>`                                         | `buildContrast`         |
-| A database deletion was blocked                        | `IndexedDB database "<name>" is blocked by an open connection`                           | `removeDatabase`        |
+carries the voices a journey asserts. Read the statechart voices in [statechart.md](statechart.md),
+the capture voices in [captures.md](captures.md), and every other voice in `guides/test.md` § Voices.
+
+| Condition                                              | The voice thrown                                                                      | Thrown by               |
+| ------------------------------------------------------ | ------------------------------------------------------------------------------------- | ----------------------- |
+| No element carries the name                            | `No interactive element has the accessible name "<name>"`                             | `resolveRendered`       |
+| Every match fails a reachability condition             | `Interactive target "<name>" is not visible and focus-reachable`                      | `resolveRendered`       |
+| Several matches are reachable                          | `Interactive target "<name>" is ambiguous across <n> elements`                        | `resolveRendered`       |
+| Still off-viewport after being scrolled to             | `Interactive target "<name>" is unreachable after scrolling`                          | `resolveAccessible`     |
+| The region holds no reachable match                    | `Interactive target "<name>" is not reachable inside "<region>"`                      | `clickAccessibleWithin` |
+| The region holds several reachable matches             | `Interactive target "<name>" is ambiguous across <n> elements inside "<region>"`      | `clickAccessibleWithin` |
+| No native disclosure is reachable under the name       | `Native disclosure "<name>" is not visible and focus-reachable`                       | `clickDisclosure`       |
+| Several native disclosures carry the name              | `Native disclosure "<name>" is ambiguous across <n> elements`                         | `clickDisclosure`       |
+| Forward Tab never lands on the target                  | `Interactive target "<name>" is not reachable through forward Tab traversal: <trail>` | `traverseAccessible`    |
+| The named region is hidden                             | `Named region "<name>" is not visible`                                                | `readPerception`        |
+| Several named regions carry the name                   | `Named region "<name>" is ambiguous across <n> elements`                              | `readPerception`        |
+| The resolved control renders no value                  | `Interactive target "<name>" does not carry a value`                                  | `readValue`             |
+| A key sequence reached nothing                         | `Key sequence "<keys>" was sent with nothing focused`                                 | `pressKeys`             |
+| A host withholds `getItem`, `setItem`, or `removeItem` | `Access is denied for <operation> "<key>"`                                            | `createStorage`         |
+| A host withholds `length`, `clear`, or `key`           | `Access is denied for <operation>`                                                    | `createStorage`         |
+| A write ran past the declared quota                    | `No room is left for <key>`                                                           | `createStorage`         |
 
 - Report an absent control and a present-but-unreachable one as different findings: absence names
   a missing control, and unreachability names the interface gating one that exists.
@@ -195,8 +187,6 @@ the capture voices in [captures.md](captures.md).
 - Read a refused bound as a test defect rather than a finding. The wait family validates its budget
   and its interval and names the argument the caller passed, under the subject `Wait` or
   `Animation`.
-- Read the package's own voice table before asserting a message this file does not list. A workspace
-  that transcribes a voice by memory asserts a sentence the package does not throw.
 
 ## Input and traversal
 

package/dist/host/agents/skills/orkestrel-journey/references/styles.md

@@ -11,7 +11,7 @@ here, and the control from the builder this layer publishes for it.
 import type {
 	CaptureVariant,
 	CensusFixture,
-	CensusReading,
+	CensusResult,
 	Color,
 	ContrastFixture,
 	EscapeFixture,

package/dist/host/agents/skills/orkestrel-parallel/SKILL.md

@@ -16,13 +16,19 @@ description: >-
 - Read the page for each harness that hosts a lane before its first launch: `references/claude.md`, `references/codex.md`, `references/cursor.md`, or `references/t3.md`. A harness without a page carries no writer or runner lane until § Bring up a harness is answered on a page of its own.
 - Apply `.agents/orchestration.md` for routing, session reuse, consultation, independence, and acceptance.
 
+## Scripts
+
+Run from the checkout root. The script's opening comment owns its behavior.
+
+- `scripts/cases.ts --report FILE.json [--passed NAME ...] [--failed NAME ...]` reads a Vitest `--reporter=json` report and requires every case a `--passed` name matches to have passed and every case a `--failed` name matches to have failed. A name matches a case's full name or its own title exactly; both flags repeat. A name that matches no case is missing, and a failed case no name matches is refused, as is a test file that failed with no failed case (it did not collect, or a hook threw) and a report whose `success` is false while nothing in it failed. It prints one summary line, each difference, and `ok` or `differences=N`. Exit 0 when the report matches, 3 when it does not, 2 when the report cannot be read as a Vitest report, 64 usage.
+
 ## Bound the host
 
 The host budget counts every lane on the machine: this session's, each peer session's, and the Orchestrator's own commands.
 
 - Set the lane bound in the plan before the first dispatch. Run one process-running lane at a time on the host: tests, checks, builds, browsers, captures, and launchers, the Orchestrator's included. Report to the user before a launch that would start a second. Lanes that run no shell command run beside it.
 - Count running lanes and owned test processes at each launch.
-- Limit terminal launches: chain commands that do not gate each other into one launch, write long output to a file and read it once, never poll with repeated short calls, never retry a run in a loop, and check once for owned leftovers before a launch.
+- Limit terminal launches: chain commands that do not gate each other into one launch (as a plan for `.agents/skills/orkestrel-dispatch/scripts/chain.ts`), write long output to a file and read it once, never poll with repeated short calls, never retry a run in a loop, and check once for owned leftovers before a launch.
 - Find the cause of an interrupted run before relaunching it.
 - While a lane that runs shell commands is live, count orphaned console and window processes. Brief a lane that needs no shell to run no command. Kill only a recorded process id, and clear orphans only when none of your lanes is live. Never kill another session's or lane's process; ask the user.
 - While a timing or live-model measurement runs, start no other test, build, or model work on the host.
@@ -34,12 +40,12 @@ The host budget counts every lane on the machine: this session's, each peer sess
 
 ## Assign lanes
 
-| Lane         | Responsibility                                                   | Write boundary                                                        |
-| ------------ | ---------------------------------------------------------------- | --------------------------------------------------------------------- |
-| Orchestrator | Own the protocol, roster, scope, rulings, holds, and acceptance. | Assigned coordination records and serial integration.                 |
-| Runner       | Run requested tests, checks, and builds as the verifier.         | Assigned evidence and declared command outputs; never source repairs. |
-| Writer       | Implement its bounded unit under its assigned role.              | Owned files and regions, plus its own log.                            |
-| Reviewer     | Independently assess the subject the size gate names.            | None; return the verdict to the Orchestrator.                         |
+| Lane         | Responsibility                                           | Write boundary                                                        |
+| ------------ | -------------------------------------------------------- | --------------------------------------------------------------------- |
+| Orchestrator | Own the roster, scope, rulings, holds, and acceptance.   | Assigned coordination records and serial integration.                 |
+| Runner       | Run requested tests, checks, and builds as the verifier. | Assigned evidence and declared command outputs; never source repairs. |
+| Writer       | Implement its bounded unit under its assigned role.      | Owned files and regions.                                              |
+| Reviewer     | Independently assess the subject the size gate names.    | None; return the verdict to the Orchestrator.                         |
 
 - Keep active lanes within the harness limit and § Bound the host. Reserve capacity for the runner; queue work that does not fit.
 - Assign every editable region to one writer. Name shared regions by their declarations or sections. Serialize units that rewrite the same region.
@@ -48,21 +54,19 @@ The host budget counts every lane on the machine: this session's, each peer sess
 ## Prepare the round
 
 1. Commit the accepted baseline before a writing dispatch.
-2. Write `tmp/units/<round>/coord/protocol.md`: the skill path, baseline, lanes, owned regions, dependencies, acceptance commands, and exclusive resources. Mark each command whose input set must be held while it runs.
-3. Write `coord/roster.md` with each lane's roster fields per `.agents/orchestration.md` § Sessions and consultation. Create `coord/results/` and `coord/runs/`.
-4. Resume a suitable runner or launch one. Require its ready acknowledgment, then let its idle turn end.
-5. Resume or launch writers as capacity permits. Fill each roster row from the actual launch or continuation result, never from an earlier session's pattern, and send each lane the peer addresses it messages.
-6. When adopting a running lane, send the protocol, ownership, log path, and next request number. Require acknowledgment before coordinated work begins.
+2. Write `tmp/units/<round>/coord/roster.md`: each lane's roster fields per `.agents/orchestration.md` § Sessions and consultation, plus the baseline, owned regions, dependencies, acceptance commands, and exclusive resources. Create `coord/runs/` for journals, errors, and results.
+3. Resume a suitable runner or launch one, and start it with its first request.
+4. Resume or launch writers as capacity permits. Fill each roster row from the actual launch or continuation result, never from an earlier session's pattern, and send each lane the peer addresses it messages.
+5. When a running lane joins the round, put the roster path, its ownership, and its next request number in the first request you send it.
 
 ## Exchange requests and results
 
-- Append only to your own `coord/<lane>.md` log: `<lane> | <request or phase> | <kind> | <text>`. Reviewers write no log.
 - Number requests monotonically per lane across continuations and fixes. Preserve earlier requests and results.
-- Send each request through the wake-capable channel in the request shape that closes this section.
-- The runner publishes a result by writing it under a temporary name and renaming it to `coord/results/<lane>-<request>.md` after command exit and cleanup, then sends its path and request identity to the requester and the Orchestrator.
+- Send each request through the wake-capable channel in the request shape that closes this section. Name each hold in `holds:` and proceed on send; the named owners stop edits to the held inputs until the result arrives. Nobody acknowledges a request, a hold, or a withdrawn `FINAL`.
+- The runner writes a result to `coord/runs/<lane>-<request>.md` after command exit and cleanup, then sends its path and request identity to the requester and the Orchestrator.
 - Wait for the harness's completion or message notice; run no watcher agent and no file-poll loop. When the notice is missing and the result is needed, read that request's durable result or task status once, reconcile the request identity, and suspend an unresolved delivery rather than launching duplicate work.
 - Escalate per `.agents/orchestration.md` § Deviation protocol. Continue independent work. Share cross-lane facts directly; only the Orchestrator changes scope or rules on acceptance.
-- End an idle runner turn after acknowledging readiness or publishing a result, so queued requests reach it. Never hold the runner in a wait for requests.
+- End the runner's turn after it sends a result, so queued requests reach it. Never hold the runner in a wait for requests.
 - After compaction or a harness restart, reconcile the roster against the live session and process state. When continuation is unsupported or unavailable, dispatch a successor brief that carries the prior evidence and unresolved work.
 
 Use this request shape:
@@ -80,32 +84,32 @@ expect: <red or green, named cases, required artifact>
 
 ## Implement in phases
 
-- Log the applicable phases: types, failing proof, source, and documentation. Request the corresponding checks from the runner.
+- At each applicable phase (types, failing proof, source, and documentation), request the corresponding checks from the runner.
 - Read a shared region immediately before each small, syntactically complete patch. On a context mismatch, reread and reapply only the owned hunk.
 - Keep read-only shell searches within § Bound the host. Send every test, check, lint, format, and build request to the runner.
 - Run no formatter. Apply the exact formatting hunk the Orchestrator supplies, then request a read-only format check.
-- Before a temporary mutation, obtain the runner's hold on conflicting commands and each affected writer's hold on edits. Mutate only after their acknowledgments. Restore the exact input, verify the restoration, and release the holds through the runner.
+- Before a temporary mutation, send the runner a request whose `holds:` names the conflicting commands and each affected writer, and mutate after the command then running returns its result. Restore the exact input, verify the restoration, and release the holds in the next request.
 - When the unit's required checks pass, send `FINAL <lane>` with source identity and evidence, write the report, and end the turn. Preserve the session for suitable follow-up work.
 
 ## Run evidence commands
 
 - Before a command, verify its input holds and exclusive resources. Hold all writers when the command reads the whole tree; otherwise hold every owner in its input closure. Do not infer that closure from the requesting writer's files alone.
 - When a conflicting process occupies a declared resource, record its owner, process id, command, and a bounded wait based on the expected work. If it remains after that wait, suspend the request for an Orchestrator ruling. Never terminate another lane's or repository's process.
-- Launch through `node .agents/skills/orkestrel-dispatch/scripts/launch.ts` with a cap grounded in prior runs, separate journal and error paths under `coord/runs/`, and the request identity in each filename. Follow the `orkestrel-dispatch` skill's reference Long-running commands for ownership, process tracking, and cleanup.
+- Launch through `node .agents/skills/orkestrel-dispatch/scripts/launch.ts` with a cap grounded in prior runs, journal and error paths under `coord/runs/` carrying the request identity in each filename. Follow the `orkestrel-dispatch` skill's reference Long-running commands for ownership, process tracking, and cleanup.
 - State in each long command's request which line is its terminal record; that line ends the wait.
 - When the shell yields before the command exits, keep its output in the assigned file and resume its tracked session per the harness page until the terminal record arrives. Start nothing else meanwhile, and never replace the command with a second launch. Confirm owned descendants have exited before publishing completion. Escalate incomplete cleanup before releasing files or starting another command.
-- Run the commands the accepted unit and the size gate require, narrowest first, and add no standing root, guide, or entry check beyond the request. Preserve receipts and rerun checks per `.agents/orchestration.md` § Parallelism.
-- Stop on the first unexpected failure. Return the complete diagnostic and the owning file, and classify the failure as an assertion failure, an invocation error, a reporting failure, a cap, or an interruption. Preserve every receipt obtained before the stop.
+- Run the commands the accepted unit and the size gate require, narrowest first, and add no standing root, guide, or entry check beyond the request. Preserve receipts and rerun checks per `.agents/orchestration.md` § Pace.
+- Stop on the first unexpected failure. Return the complete diagnostic and the owning file, and classify the failure as an assertion failure, an invocation error, a reporting failure, a cap, or an interruption. Preserve every receipt obtained before the stop. Check an `expect:` that names cases against the command's `--reporter=json` report with `scripts/cases.ts`.
 - Record the command's input identity and expected outputs before launch. When an input changes during the run, report that result as invalid and retain each result whose input set stayed stable.
-- After every writer's current `FINAL`, the integrated review, and the acknowledged write holds, run the Orchestrator's closing acceptance request under a unique gate number. Publish `coord/results/closing-<gate>.md`, reply with that identity, and end the turn.
+- After every writer's current `FINAL` and the integrated review, run the Orchestrator's closing acceptance request under a unique gate number. Write `coord/runs/closing-<gate>.md`, reply with that identity, and end the turn.
 
 ## Integrate and close
 
 - Before ruling on an escalation, inspect its cited evidence. Bound the ruling to the changed claim and affected owners.
 - When the format check reports only a filename, inspect the difference and send the writer the exact hunk.
 - Run the size gate's independent review on a pinned subject; a unit review can overlap unrelated writing only while its whole subject stays unchanged. Use unit evidence for the integrated review, then run the closing acceptance gate in the order `.agents/orchestration.md` § Campaign fixes: Audit, then Verify.
-- Before reopening a writer, invalidate that lane's `FINAL` with the runner and require acknowledgment. Keep every other valid `FINAL` result. Release the reopened writer only when no active gate reads its inputs.
-- Before a closing request, obtain affected write-hold acknowledgments and hold your own source edits. Keep them until the matching complete result arrives. After a fix, request only the checks invalidated by that fix plus any unmet acceptance requirement.
+- Before reopening a writer, tell the runner in the next request that the lane's `FINAL` is withdrawn. Keep every other valid `FINAL` result. Release the reopened writer only when no active gate reads its inputs.
+- Name every affected writer in the closing request's `holds:` and hold your own source edits until the matching complete result arrives. After a fix, request only the checks invalidated by that fix plus any unmet acceptance requirement.
 - Commit after the required gates and review pass. When shared hunks form one integration, commit the batch and identify its units and fixes.
 
 ## Share an execution lane between sessions