@orkestrel/scaffold 0.0.107 → 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,