@orkestrel/scaffold 0.0.59 → 0.0.60

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

@@ -1,85 +1,112 @@
 # The journey layer
 
-Build every capability here before writing the first journey, and route every journey step through
-it. Treat a journey that works around a missing capability as a layer defect.
+Route every journey step through the published layer. Treat a journey that works around a missing
+capability by reaching for a selector as a layer defect.
 
-Implement the signatures below as a contract in the workspace's browser test setup module; never
-copy them as source. Name each helper for the human act it performs.
+## Import, never implement
+
+Import every journey helper from `@orkestrel/test/browser`. Write one of your own only where that
+package publishes none for the act.
+
+- Place a helper you write in the workspace's browser test setup module, export it from there, and
+  name it for the human act it performs.
+- Read the package's own exports before writing anything. A helper that renames a published one is a
+  defect under `AGENTS.md`, and a second implementation of one drifts from the first.
+- Code every journey against the vocabulary in this file, which is the published one. Diagnose a
+  target that stops resolving here, and fix it in the application.
 
 ## What it drives
 
-- Drive the real browser through the installed Vitest browser provider. Import its `page` locators
-  and `userEvent` from `vitest/browser`; the `@vitest/browser/context` specifier is deprecated and
-  is not the import a new layer uses.
-- Use the provider verbs for input: `click`, `keyboard`, `tab`, `type`, `clear`, `fill`, and
-  `selectOptions`. Use `page.viewport` and `page.screenshot` for captures, and the runner's file
-  command to read a written capture back.
-- Never dispatch a constructed event from the layer or from a journey. The centralized event
-  factories `.claude/rules/tests.md` prescribes serve unit tests whose subject is the handler; a
-  journey drives input through the provider verbs only.
-- Never let a helper take an element, a component instance, or a selector from the caller. Every
-  helper resolves its own target from role and accessible name.
+- Drive the real browser through the installed Vitest browser provider. The published verbs import
+  `page` and `userEvent` from `vitest/browser`; the `@vitest/browser/context` specifier is
+  deprecated and is not the import a workspace helper uses.
+- Never dispatch a constructed event from a journey. The published `createPointerEvent`,
+  `createDragEvent`, `typeInput`, and `commitInput` serve a unit test whose subject is the handler; a
+  journey drives input through `clickAccessible`, `clickAccessibleWithin`, `clickDisclosure`,
+  `typeAccessible`, `fillAccessible`, `pressKeys`, and `traverseAccessible` only.
+- Yield with `waitForFrame` where a step needs the browser to paint before the next reading. Never
+  guard a fact with a fixed delay.
+
+## Which helpers take an element
+
+A journey verb resolves its own target from role and accessible name, and refuses an element, a
+component instance, or a selector from the caller. A reader, a fixture builder, and a capture each
+take one, because their subject is a node the caller already holds.
+
+| Population                                                                                                                                                                                                                           | Takes an element |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------- |
+| `resolveAccessible`, `resolveRendered`, `clickAccessible`, `clickAccessibleWithin`, `clickDisclosure`, `typeAccessible`, `fillAccessible`, `pressKeys`, `traverseAccessible`, `readPerception`, `readPage`, `readFocus`, `readValue` | No               |
+| `readText`, `readRole`, `readName`, `readStates`, `describeTree`, `describeFocus`, `isReachable`, `isRendered`                                                                                                                       | Yes              |
+| `readContrast`, `readRing`, `readLayers`, `readBackdrop`, `readStyle`, `readToken`, `readPixels`, `readClasses`, `extractStyles`, `extractOrphans`, `readRows`                                                                       | Yes              |
+| `mount`, `typeInput`, `commitInput`, `captureFrame`, and a portfolio's `place`                                                                                                                                                       | Yes              |
+
+Never pass an element to a verb from a journey step. Read a step that would pass one as a missing
+verb, and add the verb instead.
 
 ## The resolver
 
-```ts
-resolveAccessible(name: string): HTMLElement
-resolveAccessible(role: string, name: string): HTMLElement
-```
+`resolveAccessible(name)` resolves across the published interactive roles, and
+`resolveAccessible(role, name)` resolves within exactly the named role. `resolveRendered` sits
+beneath it and applies the same match without the scroll, so an act does not fail on a target the
+act itself scrolls into view.
 
 - Match the accessible name exactly, never a substring.
-- Search a fixed set of interactive roles for the bare-name form, and exactly the named role for
-  the two-argument form.
-- Count a match as reachable only when every condition holds: it is connected; it passes a
-  visibility check that honours opacity and CSS; its box has non-zero width and height; its
-  `tabIndex` is at least zero; it matches neither `:disabled` nor `[aria-disabled="true"]`; and it
-  has no `[inert]` ancestor.
-- Scroll a wholly off-viewport target into view once, then measure reachability again. Count a
-  control a person can scroll to as reachable, and one that stays outside the viewport as
-  unreachable.
-- Give the layer a rendered-only resolver beneath the public one, and use it from the acting verbs
-  so a click does not fail on a target the act itself scrolls into view.
+- Read `ACCESSIBLE_ROLES` for the bare-name search set and `FOCUSABLE_SELECTOR` for what the layer
+  counts as focusable, rather than restating either list in a workspace.
+- Read reachability with `isReachable` and rendering with `isRendered` where a test needs the
+  condition rather than the throw. A reachable match is connected, passes a visibility check that
+  honours opacity and CSS, has a box with non-zero width and height, carries a `tabIndex` of at
+  least zero, matches neither `:disabled` nor `[aria-disabled="true"]`, and has no `[inert]`
+  ancestor.
+- Count a control a person can scroll to as reachable, and one that stays outside the viewport after
+  the scroll as unreachable.
 
 ### The failure voices
 
-Keep these distinct, and never merge any of them into one message.
-
-| Condition                                  | The voice it must throw                                          |
-| ------------------------------------------ | ---------------------------------------------------------------- |
-| No element carries the name                | `No interactive element has the accessible name "<name>"`        |
-| Every match fails a reachability condition | `Interactive target "<name>" is not visible and focus-reachable` |
-| Several matches are reachable              | `Interactive target "<name>" is ambiguous across <n> elements`   |
-| Still off-viewport after being scrolled to | `Interactive target "<name>" is unreachable after scrolling`     |
+Assert the one voice the case means. Never write an assertion that accepts more than one.
+
+| 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`             |
 
 - 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.
-- Report ambiguity as a finding about the surface. Name the match count in the message, and
+- Report ambiguity as a finding about the surface. Quote the match count from the message, and
   re-target the journey by role or region.
+- 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.
 
 ## Role vocabulary
 
-Never infer a role from markup. Confirm the computed role in the browser whenever a target stops
-resolving.
+Never infer a role from markup. Confirm the computed role in the browser with `readRole` whenever a
+target stops resolving, and read the exposed name with `readName` and the exposed state with
+`readStates` beside it.
 
 - A `list`-bearing input computes `combobox`, not `textbox`. Attaching native suggestion machinery
   to a field is a role change: re-target every journey that names that field, and read a resolver
   miss immediately after such a change as this before treating the element as missing.
 - Always target a tab by its role. A tab and its panel collide on a bare name by construction,
   because the panel is labelled by its tab.
-- `<summary>` is exposed as a native disclosure rather than through a role the provider's role
-  locators accept. Give the layer a separate disclosure verb keyed to the summary's rendered text,
-  applying the same reachability conditions and its own failure voices.
+- Drive a `<summary>` with `clickDisclosure`, which applies the same reachability conditions and
+  throws its own voices. The provider's role locators do not resolve it, because it is exposed as a
+  native disclosure rather than through a role.
 
 ## Region-scoped resolution
 
-```ts
-clickAccessibleWithin(region: string, role: string, name: string): Promise<void>
-```
-
-- Provide this form for repeated short verbs such as `Add`, and for a control whose accessible name
-  is completed by a status the row renders.
-- Apply the same reachability conditions inside the region, and throw voices that name the region
-  as well as the target.
+Reach for `clickAccessibleWithin(region, role, name)` where a short verb such as `Add` repeats
+across a page, and where a rendered status completes a control's accessible name. It applies the
+same reachability conditions inside the region and names the region in every voice it throws.
 
 ## Input and traversal
 
@@ -88,44 +115,45 @@ clickAccessibleWithin(region: string, role: string, name: string): Promise<void>
 | `typeAccessible(name, text)` | Focus the field, select all, delete, then send real keystrokes. Escape the provider's key syntax in the text. |
 | `fillAccessible(name, text)` | Replace the value in one operation for text too long to type. The real element still publishes real input.    |
 | `pressKeys(keys)`            | Send a provider keyboard sequence for Enter, arrows, modifiers, and combinations.                             |
-| `traverseAccessible(name)`   | Move focus by forward Tab from wherever focus is, and return the target once focus lands on it.               |
+| `traverseAccessible(name)`   | Move focus by forward Tab from wherever focus is, and return the target after focus lands on it.              |
 
-- Count a traversal step only when focus actually lands on an element, and never charge the step
-  bound for a Tab that moved nothing.
-- End the traversal when focus revisits an element, which is one complete cycle of the tab order,
-  and throw the traversal's own voice, carrying the trail of what focus did reach. Keep a hard cap
-  above the cycle so a page with no tab order fails instead of hanging.
-- Re-resolve the target by role and name on every step, and never hold a node reference across
-  steps. A framework may replace the node between resolution and focus arrival.
-- Never call the browser's focus method to place focus.
+- Reach for `typeAccessible` where the keystrokes are part of what the journey claims, and
+  `fillAccessible` where the text is only a payload the person pastes.
+- Let `traverseAccessible` end the walk. It counts a step only where focus lands, stops at one
+  complete cycle of the tab order, carries the trail of what focus reached in its voice, and holds a
+  cap above the cycle so a page with no tab order fails instead of hanging.
+- Never call the browser's focus method to place focus, and never hold a node reference across
+  traversal steps. A framework may replace the node between resolution and focus arrival.
 
 ## Perception
 
-```ts
-readPerception(name: string): string
-```
+`readPerception(name)` returns the normalized `innerText` of exactly one visible named region,
+dialog, table, tab panel, alert, or status. Quote that text in assertions.
 
-- Return the normalized `innerText` of exactly one visible named region, dialog, table, tab panel,
-  alert, or status. Collapse whitespace runs to single spaces and trim.
 - Read `innerText`, never `textContent`: `innerText` applies CSS transforms and leaves out content
-  the layout hides. Quote that text in assertions.
-- Include descendant visually-hidden text, which a screen reader perceives and which a clip-based
-  hiding technique leaves in `innerText`.
-- Throw when the named region is absent, hidden, or ambiguous.
-- Give the layer a whole-page perception reader for cross-region sentences and the vocabulary
-  sweep, a focus reader that returns the active element's rendered text, and a value reader that
-  returns a resolved control's value. A perception assertion may quote that value: it is a rendered
-  fact rather than internal state.
+  the layout hides. Descendant visually-hidden text stays in, which is what a screen reader
+  perceives.
+- Reach for `readPage` for a cross-region sentence and the vocabulary sweep, `readFocus` for the
+  active element's rendered text, and `readValue` for a resolved control's rendered value. A
+  perception assertion may quote that value: it is a rendered fact rather than internal state.
+- Reach for `describeTree` and `describeFocus` where the subject is the accessible tree itself —
+  roles, names, states, and focus order. They are the accessibility snapshot a written artifact
+  composes ([decide.md](decide.md) → The rendered artifact).
 
 ## Mounting and cleanup
 
 - Mount the shipped root component with its real provisions and return an idempotent cleanup that
-  unmounts the app and removes its container.
+  unmounts the app and removes its container. Reach for the published `mount`, `render`, and `build`
+  where a fixture needs a node rather than the application.
 - Undo everything a journey changed after each test: unmount, destroy the session, reset the theme,
-  clear the keys the application persisted, and return the route to its entry. Never let a journey
-  inherit the previous journey's state.
+  return the route to its entry, and clear what the application persisted with `clearStorage` and
+  `removeDatabase`. Never let a journey inherit the previous journey's state.
+- Record what a journey did with `createJournal`, started inside the journey and stopped in a
+  `finally`. Its `steps` and `output` are the evidence a failing journey hands back, and the input
+  the run's written artifact composes.
 
 ## The capture hook
 
-Give the layer exactly one capture helper. [captures.md](captures.md) owns the registry, the
-variant matrix, and the proofs that read what it wrote.
+`createPortfolio` is the capture door and `place(state, element?)` is the hook.
+[captures.md](captures.md) owns the registry, the variant matrix, and the proofs that read what it
+wrote.

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

@@ -0,0 +1,84 @@
+# The statechart family
+
+Declare one transition table, and give it to the automated run that asserts it and to the
+harness a person watches. Never write a second table for the harness.
+
+## Declare the table
+
+- Declare each transition as a `StateTransition` carrying its `name`, its `from` state, the `event`,
+  and its `to` state. Type it on the entity's own state and event unions, so a row naming a state the
+  entity does not have fails to typecheck.
+- Write one `StateScenario` per transition, carrying that `transition` plus `arrange`, `act`, and
+  `assert`. Each phase receives the context and the part of the transition it owns.
+- Put the scenarios in the workspace's browser test setup module. Put the table beside them until a
+  harness page ships; from then on declare it in the application's own constants module, typed on the
+  entity's unions, and import it from the page and from the setup alike, because a page cannot
+  import from `tests/` and a second table is what this reference forbids.
+- Declare a transition for every event the surface accepts in every state it accepts it, including
+  the event that leaves the state unchanged. A table that lists only the moves the happy path takes
+  proves the happy path.
+
+## Run the table
+
+- Run the table with `executeScenarios(scenarios, build)` from `@orkestrel/test`. It drives the rows
+  in the order they are written, builds a context per row, and stops at the first row that throws.
+- Run one row with `executeScenario(scenario, context)` where a single transition is the subject.
+- Build the context in `build`, which receives the row it is building for. That is what lets one
+  table mix fixtures.
+- Let the runner name the failure. It prepends the transition's `name` to whatever the row threw and
+  carries the original as the `cause`, so a bare assertion message still says which row failed.
+- Never assert the entity's internal state in `assert` where the transition is one a person drives.
+  Assert what the interface renders, through `readPerception`, `readValue`, or `readStates`.
+
+## Drive the act the way the transition happens
+
+- Drive `act` through the journey verbs — `clickAccessible`, `clickDisclosure`, `typeAccessible`,
+  `pressKeys`, `traverseAccessible` — for every transition a person can cause.
+- Drive `act` through the entity's own API only where the transition is the entity's rather than the
+  person's: a lifecycle event, a transport reply, a timer the surface owns.
+- Say which door each row used, in the row's `name`. A table that mixes the doors silently reads as
+  a set of user transitions and proves something else.
+
+## Build the harness a person watches
+
+Mount the harness on the same table. It stays in the repository that owns the surface: only
+`StateTransition`, `StateScenario`, `executeScenario`, `executeScenarios`, `STATECHART_ATTRIBUTES`,
+and `STATECHART_STATUSES` are published, and a workspace that spells a `data-statechart-*` string of
+its own has left the contract.
+
+- Render one play control per transition and one play-all control, each disabled while a run is in
+  flight.
+- Render a state badge carrying the entity's current state, an event log of what the entity emitted,
+  and a `role="status"` announcer that narrates each step in a sentence, so a screen reader and a
+  vision model both read the run without visual chrome.
+- Publish `STATECHART_ATTRIBUTES.status` on the harness root, and cycle its value through
+  `STATECHART_STATUSES`: `pending` before a run has a result for every row, `idle` standing ready,
+  `running` in flight, and `passed` or `failed` as the terminal reading. Publish
+  `STATECHART_ATTRIBUTES.passed`, `.failed`, and `.total` on the same element, so a gate finds the
+  harness and reads the tally from one node.
+- Publish `STATECHART_ATTRIBUTES.scenario` and `STATECHART_ATTRIBUTES.result` on each row, and
+  `STATECHART_ATTRIBUTES.state` on the element rendering the entity's current state.
+- Write every attribute from the map rather than from a literal. A harness that sets an attribute
+  the gate does not read fails silently as a run that never completes.
+- Deep-link one transition and the play-all run from the route, so a decision round names the exact
+  link it wants looked at ([decide.md](decide.md) → The rendered artifact).
+- Give the harness a demo step that leaves the widget in its most legible state after the run, for a
+  person or a vision model deciding on a look.
+- Pace the harness for a person to watch. The gate inherits that wall time, so budget the gate from
+  the row count and the pause rather than from a fixed timeout.
+
+## Gate the harness
+
+Prove the harness from the browser project, through the interface:
+
+- Mount the harness page and clear the route's query first, so a leftover deep link cannot start the
+  walk before the gate does.
+- Press the play-all control through `clickAccessible`, never through a constructed event and never
+  by setting the deep link.
+- Poll `STATECHART_ATTRIBUTES.status` until it reads `passed` or `failed`. Never assert it from one
+  read after the click.
+- Assert the status reads `passed`, the failed tally reads zero, and the passed tally equals the
+  total. Name the failing rows from `STATECHART_ATTRIBUTES.scenario` in the failure message, so a red
+  gate says which transition broke.
+- Assert the harness inventory before the rows: a page that mounted no transition passes every tally
+  assertion.

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

@@ -0,0 +1,87 @@
+# Proving what the browser resolved
+
+Prove a style from what the browser resolved on the mounted surface. The `enterprise-bootstrap`
+skill's [instruments reference](../../enterprise-bootstrap/references/inspection.md) names each
+instrument's property, its population, and the negative controls that must fail. Take those from
+there and the reading from here.
+
+## Assert the resolved value
+
+- Read one property with `readStyle(element, property)` and a length with `readPixels(element, property)`. A
+  class present in the markup and absent from the cascade resolves to nothing, and an assertion on
+  the class list passes on it.
+- Never substitute `findRule` for a resolved read. It proves a declaration exists, and another rule
+  may still win; reach for it where the stylesheet itself is the subject.
+- Compare a color through `matchesColor` or `parseCSSColor` rather than by string. A browser normalizes a color
+  expression, so a literal comparison fails on a value that resolved correctly.
+
+## Run per variant
+
+The run axis is fixed in [SKILL.md](../SKILL.md) → Read the variant once. The matrix family's own
+readings follow.
+
+- Apply each variant's `apply` and its `width` and `height` before the readings, and take every
+  reading for that variant before moving to the next.
+- Name the attribute the surface actually reads in `apply`; a Bootstrap surface switches on
+  `data-bs-theme`. An `apply` that sets another attribute leaves the run in the default theme, where
+  every reading passes.
+- Assert that the run read every declared variant. A matrix that silently walked one variant reports
+  a pass for the theme nobody exercised.
+- Report which variants a result covers beside it. A pairing that appears only in a state the run
+  never entered is unmeasured.
+
+## Contrast and focus chrome
+
+- Read a text pairing with `readContrast(element)`, which composites the painted ancestors to the first
+  opaque layer, so a translucent tint reads as a tint over what shows through it.
+- Pass `floor` only where the surface the stack really sits on is known, and pass `CANVAS_COLOR`
+  where the browser paints onto its own canvas. Omitting `floor` refuses a stack whose painted layers
+  are all translucent; take that refusal as the reading, because an assumed white canvas turns "this
+  surface declares no background" into a number that reads like a measurement.
+- Read focus chrome with `readRing(control)`, after focus arrived through `traverseAccessible`,
+  `pressKeys`, or a real click. Pass `worn` where the chrome is painted onto a second element such
+  as a label. It reports `undefined` for a control not matching `:focus-visible`, for the browser's
+  own automatic ring, and for a focus style that only repaints the fill — treat each as a finding
+  about the surface rather than as a pass.
+- Carry the negative controls the composited-contrast instrument names, in the same run and composed
+  in the harness rather than taken from the surface. An instrument whose negative control passes is
+  broken, and its readings are not evidence.
+- Reach for `measureContrast`, `measureLuminance`, `blendColor`, `readLayers`, and `readBackdrop`
+  only where the composite itself is the subject. Never re-derive `readContrast` from them.
+
+## The authored-class census
+
+Take the property, the population, and the negative controls from the instruments reference →
+Authored class in the shipped cascade. This is the reading.
+
+- Read the census as the difference between `readClasses(root)` of the mounted surface and
+  `readCascade()`. A token in the difference is a class the markup uses and no loaded stylesheet
+  declares.
+- Take `root` from the mounted surface, so the census covers what rendered rather than what a
+  template file spells.
+- Report what `readClasses` walked as the population, and fail a run that walked none.
+- Append the extraction-door negative control to that same `root`, so it reaches the difference
+  through `readClasses` rather than beside it.
+
+## Style escapes
+
+Take the property, the population, the named exemptions, and the negative control from the
+instruments reference → Style escapes. This is the reading.
+
+- Read escapes with `extractStyles(root)`, which returns the markup of every hit it found.
+- Take the reading before any journey drives the surface, because the population is the undriven
+  tree.
+- Append the harness-built negative control element to that same `root`, so it reaches the reading
+  through `extractStyles`.
+- Reach for `extractOrphans` where the finding is a child element rendered outside its required
+  parent, and `readRows` where the subject is a repeated row's rendered text.
+
+## Tokens
+
+- Read a token with `readToken(element, name)` where inheritance matters and `readRootToken(name)` where the
+  document declares it. The leading dashes are optional in each.
+- Compare values, never presence. An absent token and one declared empty both read as `''`, and a
+  `var()` naming an undeclared property resolves to the inherited color rather than refusing, so an
+  assertion on presence passes on a token nobody declared.
+- Read each token once per variant and assert the values differ where the design says the variants
+  differ. A pair of variants that resolves a token identically is a theme that did not switch.

package/dist/host/claude/agents/orkestrel.md

@@ -50,8 +50,9 @@ so network-controlled descriptions never enter agent instruction context.
 | `@orkestrel/brief`      | `0.0.6`  | L4    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/interpret` `^0.0.11`, `@orkestrel/reason` `^0.0.8`                                                                                                                                                                                             |
 | `@orkestrel/browser`    | `0.0.14` | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/html` `^0.0.7`, `@orkestrel/websocket` `^0.0.10`                                                                                                                                                                                               |
 | `@orkestrel/budget`     | `0.0.8`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
+| `@orkestrel/codec`      | `0.0.1`  | L0    |                                                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/console`    | `0.0.11` | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                             |
-| `@orkestrel/contract`   | `0.0.13` | L0    |                                                                                                                                                                                                                                                                                                                            |
+| `@orkestrel/contract`   | `0.0.15` | L0    |                                                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/csv`        | `0.0.5`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/database`   | `0.0.12` | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/indexeddb` `^0.0.9`, `@orkestrel/sqlite` `^0.0.9`                                                                                                                                                                                              |
 | `@orkestrel/emitter`    | `0.0.8`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
@@ -60,16 +61,16 @@ so network-controlled descriptions never enter agent instruction context.
 | `@orkestrel/html`       | `0.0.7`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/indexeddb`  | `0.0.9`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/interpret`  | `0.0.11` | L3    | `@orkestrel/reason` `^0.0.8`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/template` `^0.0.5`                                                                                                                                                                                               |
-| `@orkestrel/lsp`        | `0.0.4`  | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/process` `^0.0.7`                                                                                                                                                                                                                              |
+| `@orkestrel/lsp`        | `0.0.5`  | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/process` `^0.0.8`                                                                                                                                                                                                                              |
 | `@orkestrel/markdown`   | `0.0.12` | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/html` `^0.0.7`                                                                                                                                                                                                                                                                |
-| `@orkestrel/mcp`        | `0.0.26` | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/process` `^0.0.7`, `@orkestrel/sse` `^0.0.5`, `@orkestrel/tool` `^0.0.12`, `@orkestrel/websocket` `^0.0.10`                                                                                                                                    |
+| `@orkestrel/mcp`        | `0.0.27` | L3    | `@orkestrel/codec` `^0.0.1`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/process` `^0.0.8`, `@orkestrel/sse` `^0.0.5`, `@orkestrel/tool` `^0.0.12`, `@orkestrel/websocket` `^0.0.10`                                                                                                       |
 | `@orkestrel/middleware` | `0.0.18` | L2    | `@orkestrel/abort` `^0.0.8`, `@orkestrel/budget` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/timeout` `^0.0.8`                                                                                                                                                                                                  |
 | `@orkestrel/msg`        | `0.0.8`  | L0    |                                                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/ndjson`     | `0.0.8`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/ollama`     | `0.0.13` | L6    | `@orkestrel/agent` `^0.0.19`, `@orkestrel/budget` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/ndjson` `^0.0.8`, `@orkestrel/timeout` `^0.0.8`, `@orkestrel/tool` `^0.0.12`                                                                                                                                      |
 | `@orkestrel/pool`       | `0.0.9`  | L2    | `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                                                              |
-| `@orkestrel/probe`      | `0.0.10` | L4    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/lsp` `^0.0.4`, `@orkestrel/mcp` `^0.0.26`, `@orkestrel/queue` `^0.0.11`, `@orkestrel/timeout` `^0.0.8`, `@orkestrel/tool` `^0.0.12`                                                                                                            |
-| `@orkestrel/process`    | `0.0.7`  | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                             |
+| `@orkestrel/probe`      | `0.0.11` | L4    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/lsp` `^0.0.5`, `@orkestrel/mcp` `^0.0.27`, `@orkestrel/queue` `^0.0.11`, `@orkestrel/timeout` `^0.0.8`, `@orkestrel/tool` `^0.0.12`                                                                                                            |
+| `@orkestrel/process`    | `0.0.9`  | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                             |
 | `@orkestrel/program`    | `0.0.11` | L4    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/qualifier` `^0.0.12`, `@orkestrel/rater` `^0.0.12`, `@orkestrel/reason` `^0.0.8`                                                                                                                                                               |
 | `@orkestrel/qualifier`  | `0.0.12` | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/reason` `^0.0.8`                                                                                                                                                                                                                               |
 | `@orkestrel/queue`      | `0.0.11` | L3    | `@orkestrel/abort` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/timeout` `^0.0.8`                                                                                                                                                                |
@@ -77,19 +78,19 @@ so network-controlled descriptions never enter agent instruction context.
 | `@orkestrel/reason`     | `0.0.8`  | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                             |
 | `@orkestrel/relation`   | `0.0.10` | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                            |
 | `@orkestrel/router`     | `0.0.12` | L2    | `@orkestrel/abort` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                |
-| `@orkestrel/scaffold`   | `0.0.58` | L3    | `@orkestrel/console` `^0.0.11`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/markdown` `^0.0.12`, `@orkestrel/process` `^0.0.7`, `@orkestrel/template` `^0.0.5`                                                                                                                             |
-| `@orkestrel/sea`        | `0.0.12` | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/process` `^0.0.7`                                                                                                                                                                                                                              |
-| `@orkestrel/server`     | `0.0.16` | L3    | `@orkestrel/abort` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/router` `^0.0.12`, `@orkestrel/timeout` `^0.0.8`                                                                                                                                                                  |
+| `@orkestrel/scaffold`   | `0.0.59` | L3    | `@orkestrel/console` `^0.0.11`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/markdown` `^0.0.12`, `@orkestrel/process` `^0.0.8`, `@orkestrel/template` `^0.0.5`                                                                                                                             |
+| `@orkestrel/sea`        | `0.0.13` | L3    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/process` `^0.0.8`                                                                                                                                                                                                                              |
+| `@orkestrel/server`     | `0.0.17` | L3    | `@orkestrel/abort` `^0.0.8`, `@orkestrel/codec` `^0.0.1`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/router` `^0.0.12`, `@orkestrel/timeout` `^0.0.8`                                                                                                                                     |
 | `@orkestrel/sqlite`     | `0.0.9`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/sse`        | `0.0.5`  | L0    |                                                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/supervisor` | `0.0.1`  | L5    | `@orkestrel/contract` `^0.0.11`, `@orkestrel/database` `^0.0.9`, `@orkestrel/emitter` `^0.0.6`, `@orkestrel/workflow` `^0.0.12`                                                                                                                                                                                            |
 | `@orkestrel/table`      | `0.0.3`  | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                             |
 | `@orkestrel/template`   | `0.0.5`  | L2    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                             |
 | `@orkestrel/terminal`   | `0.0.13` | L3    | `@orkestrel/console` `^0.0.11`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/form` `^0.0.3`, `@orkestrel/sse` `^0.0.5`                                                                                                                                     |
-| `@orkestrel/test`       | `0.0.11` | L0    |                                                                                                                                                                                                                                                                                                                            |
+| `@orkestrel/test`       | `0.0.12` | L0    |                                                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/timeout`    | `0.0.8`  | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
 | `@orkestrel/tool`       | `0.0.12` | L1    | `@orkestrel/contract` `^0.0.13`                                                                                                                                                                                                                                                                                            |
-| `@orkestrel/toolbox`    | `0.0.10` | L6    | `@orkestrel/agent` `^0.0.19`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/form` `^0.0.3`, `@orkestrel/relation` `^0.0.10`, `@orkestrel/server` `^0.0.16`, `@orkestrel/terminal` `^0.0.13`, `@orkestrel/tool` `^0.0.12`, `@orkestrel/workflow` `^0.0.16`, `@orkestrel/workspace` `^0.0.6` |
+| `@orkestrel/toolbox`    | `0.0.11` | L6    | `@orkestrel/agent` `^0.0.19`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/form` `^0.0.3`, `@orkestrel/relation` `^0.0.10`, `@orkestrel/server` `^0.0.17`, `@orkestrel/terminal` `^0.0.13`, `@orkestrel/tool` `^0.0.12`, `@orkestrel/workflow` `^0.0.16`, `@orkestrel/workspace` `^0.0.6` |
 | `@orkestrel/websocket`  | `0.0.10` | L2    | `@orkestrel/emitter` `^0.0.8`                                                                                                                                                                                                                                                                                              |
 | `@orkestrel/worker`     | `0.0.10` | L4    | `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/pool` `^0.0.9`, `@orkestrel/queue` `^0.0.11`                                                                                                                                                                  |
 | `@orkestrel/workflow`   | `0.0.16` | L4    | `@orkestrel/abort` `^0.0.8`, `@orkestrel/budget` `^0.0.8`, `@orkestrel/contract` `^0.0.13`, `@orkestrel/database` `^0.0.12`, `@orkestrel/emitter` `^0.0.8`, `@orkestrel/queue` `^0.0.11`, `@orkestrel/timeout` `^0.0.8`                                                                                                    |

package/dist/host/claude/skills/orkestrel-prove-journey/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: orkestrel-prove-journey
-description: Prove a browser application the way a person uses it — real keystrokes, clicks, and Tab/Enter against only what is visible and reachable — and generate the capture portfolio from those same journeys. Use when accepting a UI build, proving an application end to end, deciding whether a surface is reachable by keyboard alone, proving what a screen refuses as well as what it does, auditing whether the interface speaks the user's vocabulary rather than the engine's, producing the screenshots a design review judges, or whenever the only evidence a screen works is a test that drove it through JavaScript instead of through the interface.
+description: Prove a browser application the way a person uses it — real keystrokes, clicks, and Tab/Enter against only what is visible and reachable — through the journey layer @orkestrel/test/browser publishes, and generate the capture portfolio, the resolved-style matrix, and the statechart outcome from those same journeys. Use when accepting a UI build, proving an application end to end, deciding whether a surface is reachable by keyboard alone, proving what a screen refuses as well as what it does, proving the styles a browser actually resolved under each theme and viewport, driving a transition table through the interface and watching it run, auditing whether the interface speaks the user's vocabulary rather than the engine's, producing the screenshots a design review judges, routing a rendered question to an artifact a model can read, or whenever the only evidence a screen works is a test that drove it through JavaScript instead of through the interface.
 ---
 
 # Load the canonical workflow