@orkestrel/scaffold 0.0.73 → 0.0.75

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

@@ -19,7 +19,7 @@ Read the current files in this order:
 3. [layer.md](references/layer.md) before importing, extending, or debugging the journey layer.
 4. [captures.md](references/captures.md) before registering a state or placing a capture.
 5. [styles.md](references/styles.md) before asserting anything the browser resolved.
-6. [statechart.md](references/statechart.md) before declaring a transition or building the harness.
+6. [statechart.md](references/statechart.md) before declaring a transition or mounting the harness.
 7. [decide.md](references/decide.md) before routing a question to an instrument.
 8. `guides/README.md`, the governing guide for the surface, and `ROADMAP.md` when present.
 9. The `*/types.ts` of every environment the journeys drive, plus the application's root component,
@@ -48,21 +48,142 @@ families a surface owes. It never switches what a declared family proves.
   scope finding and stop; never prove the remaining families around it.
 - Assert the declaration itself: a family listed with no proof, and a proof belonging to no listed
   family, each fail the run.
+- Bind the journey laws to every declared family, not to the journey family alone. A matrix reading
+  and a transport assertion reach their surface through the same verbs a journey reaches it through.
+- Change route and theme through the interface in the matrix family and the transport family. A
+  family that navigates by calling the application's own router proves the router, and says nothing
+  about the screen it reads afterwards.
+- Let the transport family construct the store it hands the application, and drive the application
+  from the interface after that. The constructed store is the fixture; it is never the drive.
+- Take an entity read or a storage read as corroboration beside a rendered assertion, never in place
+  of one.
+
+## Resolve the population
+
+Resolve every target and every population by ARIA role and accessible name as rendered.
+
+- Admit a selector only where the population carries no role at all — a paragraph set, a token
+  census, a style-escape walk. Declare that selector in the workspace's browser test setup module
+  with the reason beside it, and never in a test file.
+- Read a painted population through the platform: `element.checkVisibility()` reports what the box
+  tree renders, and a non-zero `getBoundingClientRect()` reports what occupies space. The layer
+  publishes no painted-population predicate.
+- Reach for `isRendered` and `isReachable` where the subject is one element's own reachability
+  ([layer.md](references/layer.md) → The resolver).
 
 ## Read the variant once
 
-Read one `variant` value at run start, and let it choose the capture destination, the matrix row,
-and the statechart run together. Never split the theme from the viewport; a split writes a filename
-naming a combination the run did not render.
-
-- Declare every variant once as a published `CaptureVariant` — its `name`, its `width`, its
-  `height`, and the `apply` that switches the theme — and read that list from the capture family and
-  the matrix family alike.
+A browser application born by `scaffold new` carries the journey axis: the
+`configs/app/vite.journey.config.ts` wrapper, the root `appJourney` factory, the `test:journey`
+script, and that script's place in the `test` chain. That wiring fans the journey suite out into one
+Vitest project per variant, and each project provides its own variant. Read the variant once at run
+start, and let it choose the capture destination, the matrix row, and the statechart run together.
+
+- Read `inject('variant')` for this run's variant name, `inject('variants')` for the declared list,
+  and `inject('capture')` for whether this run writes frames.
+- Declare the provided types once, by augmenting Vitest's own `ProvidedContext` in the workspace's
+  browser test setup module, so `inject` is typed rather than narrowed at each call.
+- Declare the variant list in `configs/app/vite.journey.config.ts`, the birth-owned wrapper a
+  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`
+  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.
+- 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 the journeys in `tests/app/browser/integration.test.ts`. Each variant project collects that
+  file alone, and the ordinary `app:browser` project excludes it while the axis is on, so a journey
+  written anywhere else runs in no variant.
 - Loop every declared variant inside one run for the matrix family
   ([styles.md](references/styles.md) → Run per variant).
 - 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.
+
+| 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`                                       |
+
+`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.
+
+### Prepare the capture theme
+
+- Where the application ships a theme control, await the theme action through that interface
+  before driving the state the journey captures. Pass the provided `JourneyVariant` list directly
+  to `createPortfolio` when capture needs no additional synchronous document change. Never attach
+  an asynchronous action to `CaptureVariant.apply` or re-resolve a covered theme control at capture
+  time.
+- Where the surface has no theme control, prepare the theme through the attribute the surface
+  reads. Use the optional `CaptureVariant.apply` hook only for a synchronous document change,
+  such as setting that attribute. Treat its `() => void` contract as synchronous: `createPortfolio`
+  invokes the hook without awaiting a returned promise.
+- Keep `applyTheme` as the workspace's own browser setup helper. Make it drive the theme control
+  through the published journey verbs and await the announced theme state and settled paint.
+- Put the provided-context declaration in the browser test setup module, and consume the injected
+  data in `tests/app/browser/integration.test.ts` through the following portfolio configuration.
+  Mount the shipped application entry with its real provisions before the acceptance journey runs.
+- From `tests/app/browser/integration.test.ts`, pass `../../../tmp/capture/states` as the capture
+  directory to write into the workspace's `tmp/capture/states` directory. The browser provider
+  resolves a custom screenshot path relative to the test file's directory.
+
+```ts
+import type { JourneyVariant } from '@orkestrel/test'
+
+declare module 'vitest' {
+	interface ProvidedContext {
+		readonly variant: string
+		readonly variants: readonly JourneyVariant[]
+		readonly capture: boolean
+	}
+}
+```
+
+```ts
+import { createPortfolio } from '@orkestrel/test/browser'
+import { inject } from 'vitest'
+import { applyTheme } from '../../setupBrowser.js'
+
+const VARIANT = inject('variant')
+const CAPTURE = inject('capture')
+const VARIANTS = inject('variants')
+const PORTFOLIO = createPortfolio({
+	states: ['home'],
+	variants: VARIANTS,
+	variant: VARIANT,
+	directory: '../../../tmp/capture/states',
+	enabled: CAPTURE,
+})
+```
+
+At the start of the existing home acceptance journey, insert the following theme preparation before
+that journey's actions.
+
+```ts
+await applyTheme(VARIANT)
+```
+
+Immediately after that journey's actual rendered-home assertion, insert the following placement.
+Keep the existing journey and its assertions as the consumer; add no screenshot-only test.
+
+```ts
+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
@@ -80,9 +201,10 @@ naming a combination the run did not render.
    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:** Enter, Tab away, or a named button. Report a
-   surface that commits on a timer, on an unpredictable event, or only after work the person cannot
-   observe as a surface finding, and never work around it in the layer.
+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 surface that commits on a timer, on an
+   unpredictable event, or only after work the person cannot observe as a surface finding, and never
+   work around it in the layer.
 7. **Type only what a person would.** Journeys carry trusted input; adversarial payloads belong to
    the transport family and the parser suites.
 8. **Perform every interaction step unconditionally.** Never gate a step on whether the control it
@@ -92,15 +214,21 @@ naming a combination the run did not render.
 
 ## Import the journey layer
 
-- Import every journey verb, reader, and fixture builder from `@orkestrel/test/browser`. Write one
-  of your own only where that package publishes none for the act
-  ([layer.md](references/layer.md) → Import, never implement).
+- 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
+  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.
+- Prove that setup module with `tests/setupBrowser.test.ts`, and activate its `setup:browser`
+  project in the order [layer.md](references/layer.md) → Import, never implement states.
 - Drive every step through the published verbs, and never dispatch a constructed event
   ([layer.md](references/layer.md) → What it drives).
-- Re-verify every target against what the application renders now whenever markup changes
+- Re-verify every target against what the application renders after any markup change
   ([layer.md](references/layer.md) → Role vocabulary).
 
 ## Derive journeys from intents
@@ -119,8 +247,9 @@ placement and scope `.claude/rules/tests.md` fixes.
   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: the new sentence is
-  present **and** the old one is gone.
+- 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 surface carries the
   statechart family.
@@ -131,6 +260,25 @@ placement and scope `.claude/rules/tests.md` fixes.
 - Report a bare accessible name that answers for more than one reachable element on one screen as a surface
   finding, and target through role or region until the surface is fixed.
 
+### The intents every surface owes
+
+Write a journey for each of the following wherever the surface has that state. Take the expected
+outcome from the product guide; this skill supplies the mechanism and invents no copy, no redirect,
+and no title scheme.
+
+| Intent            | The journey proves                                                              |
+| ----------------- | ------------------------------------------------------------------------------- |
+| Arrival           | The entry route renders its own screen, read through a named region             |
+| An unknown route  | What the application does with a route it does not carry, and what it says      |
+| An empty result   | What a query matching nothing renders, in the product's own words               |
+| The document name | The title each screen publishes, asserted per screen                            |
+| A render failure  | What a person reads when a component throws, rather than an unexplained surface |
+
+- Report a missing outcome as a product finding, with its evidence site, rather than inventing the
+  copy the surface owes.
+- Assert the title from `document.title` per screen, against the title the product guide names for
+  that screen. Report a screen the guide gives no title as a product finding.
+
 ## Prove the refusals
 
 - Give every surface a refusal family: the controls a person must not reach in the state the
@@ -146,30 +294,38 @@ placement and scope `.claude/rules/tests.md` fixes.
 ## Declare the transport family
 
 - Name the block for what it proves — persistence, restart, storage failure.
-- Drive it through the application's real session and store contracts. Build a store that stalls a
-  read, fails a fixed number of reads, or fails a write as an inert configurable implementation of
-  the published interface, under the real-implementation law in `AGENTS.md`.
+- Drive it through the application's real session and store contracts.
+- Build the host's own storage conditions with `createStorage`: `reads: false` and `writes: false`
+  withhold what a browser with site data blocked withholds, `quota` caps the accepted `setItem`
+  calls, and `permit()` grants the withheld permissions the way a person allowing site data grants
+  them. It replenishes no quota, because room and permission are different refusals.
+- Assert the withheld voice on its `name` as well as its message: a withheld operation raises a
+  `DOMException` named `SecurityError`, and a write past the quota raises one named
+  `QuotaExceededError`.
 - Prove the visible half in a journey: the failure sentence a person reads, and the retry control
-  that clears it.
+  that clears it. A storage failure whose visible half is a control that silently does nothing is a
+  surface finding.
 - Assert restart by starting a second session over the same store and polling the restored value.
+- Take a stalled read to the application's own asynchronous store contract, never to `Storage`.
+  `Storage` is synchronous, so a hanging read is not expressible against it and a fixture that fakes
+  one is proving a surface the application does not have.
 
 ## Prove the styles
 
 Follow [styles.md](references/styles.md) for the resolved-value law, the per-variant run, the
-composited contrast reading and its under-bar negative control, the authored-class census, the
+composited contrast reading and its published control, the authored-class census, the
 `extractStyles` reading, and the token comparison.
 
 ## Prove the statechart
 
 Follow [statechart.md](references/statechart.md) for the transition table, the scenario per
-transition, the runner, the harness a person watches, and the gate that drives the harness through
-the interface.
+transition, the runner, the mounted harness, and the gate that reads its tally.
 
 ## Generate the portfolio
 
 Follow [captures.md](references/captures.md) for the state registry and its placement rules, the
-theme-and-viewport variant matrix, the always-on filename proof, the capture-run membership proof,
-and how a state that exists only during an activation is captured.
+variant matrix, the always-on filename proof, the capture-run membership proof, and how a state that
+exists only during an activation is captured.
 
 Where a capture and a green suite disagree, take the capture as the evidence and the fixture as the
 defect.
@@ -181,27 +337,54 @@ Route review of the portfolio to the `orkestrel-polish-surface` campaign. Do not
 Follow [decide.md](references/decide.md) before spending a round on a question. It fixes which
 instrument judges which claim, what `prove` cannot serve, and what the run's written artifact holds.
 
+## Mutate each assertion class
+
+Mutate each assertion class once, read the red, restore, and read the green.
+`.claude/rules/quality.md` § Instruments owns the law this satisfies.
+
+| Assertion class | The mutation                                                         | What must change                  |
+| --------------- | -------------------------------------------------------------------- | --------------------------------- |
+| Journey         | Omit the act the journey performs, keeping collection valid          | The destination assertion reddens |
+| Refusal         | Make the withheld control reachable, or present, without renaming it | The asserted voice changes        |
+
+- Omit the act rather than weakening the assertion. An assertion a missing act leaves green cannot
+  tell arrival from never having left.
+- Change reachability rather than the name. A renamed control reddens on absence, which is a finding
+  the refusal family already carries.
+
 ## Accept
 
 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 surface owes present wherever the surface 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 surface the journeys cover;
 - a refusal family per surface, 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 instrument carrying the negative
-  control that must read under its bar in the same run;
+- 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 surface, each
   reporting the population it walked;
-- the statechart table driven to a terminal outcome with no failed row, and the harness gate green;
+- 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;
+- 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`.
 
+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.
+
 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 surface finding the layer's refusals
 exposed.

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

@@ -4,19 +4,38 @@ Take every screenshot from an acceptance journey, at the moment that journey is
 picture names. Never add a test whose only purpose is a screenshot, and never stage a state for the
 camera that a journey did not reach through the interface.
 
+## The vocabulary
+
+```ts
+import type { JourneyVariant } from '@orkestrel/test'
+import type {
+	CaptureVariant,
+	FrameOptions,
+	FrameReading,
+	PortfolioInterface,
+	PortfolioOptions,
+} from '@orkestrel/test/browser'
+import { captureFrame, createPortfolio, expandCaptures, readFrame } from '@orkestrel/test/browser'
+import { inject } from 'vitest'
+```
+
 ## The hook
 
 `createPortfolio(options)` is the capture door, and `place(state, element?)` is the hook. Build the
 portfolio once per file from a `PortfolioOptions` value carrying the registry as `states`, every
-declared `CaptureVariant` as `variants`, this run's `variant`, the `directory` each file is written
-to, and the flag as `enabled`.
+declared `CaptureVariant` as `variants`, this run's variant name as `variant`, the `directory` each
+file is written to, and the flag as `enabled`.
 
 - Place a state with `place(state)` for the whole page, and `place(state, element)` where the
   picture is one element.
-- Leave `enabled` unset in an ordinary run. `place` then returns `undefined`, resizes nothing,
-  writes nothing, and records nothing.
+- Take `enabled` from `inject('capture')`, which the generated root configuration provides from the
+  `CAPTURE` environment variable set to `1` in the shell that runs the axis. An ordinary run leaves
+  it false, so `place` returns `undefined`, resizes nothing, writes nothing, and records nothing.
 - Read `files` for the registry expanded across every variant, `placements` for what this run placed,
   and `paths` for what it wrote. Each hands back a snapshot.
+- Reach for `readFrame` where the written image itself is the subject — its decoded size, or its
+  pixels. `captureFrame` already reads each file back and compares its bytes against the frame it
+  shot.
 
 The package already refuses these, so assert none of them again:
 
@@ -30,8 +49,7 @@ The package already refuses these, so assert none of them again:
 
 ## The registry
 
-Declare the state names and the variants once in the journey file, and build the portfolio from
-that declaration.
+Declare the state names once in the journey file, and build the portfolio from that declaration.
 
 - Name a state for its surface and its condition — `answer-partial`, `start-storage-failure`,
   `case-delete-confirmation`.
@@ -44,22 +62,26 @@ that declaration.
 
 ## Variants
 
-The run axis is fixed in [SKILL.md](../SKILL.md) → Read the variant once, and the theme switch each
-variant's `apply` performs is fixed in [styles.md](styles.md) → Run per variant. The capture family
-adds these.
+The run axis is fixed in [SKILL.md](../SKILL.md) → Read the variant once. The capture family adds
+these.
 
-- Produce the portfolio — the registry times the variants — by repeating the run once per variant.
+- Declare the viewport list in the birth-owned `configs/app/vite.journey.config.ts` wrapper, as
+  `readonly JourneyVariant[]`. That file is the adopter's, so its names and its viewports are the
+  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.
-- Pass the whole variant list as `variants` and this run's name 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.
+- 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.
 
 ## The proofs the suite owes
 
-The package times the registry and refuses a bad placement. It asserts nothing about either, so the
-suite carries these.
+Write each of the following proofs into the suite. The package asserts none of them.
 
 | Proof                | Runs           | Asserts                                                                            |
 | -------------------- | -------------- | ---------------------------------------------------------------------------------- |
@@ -92,6 +114,9 @@ after the click returns.
 ## Hygiene
 
 - Keep the portfolio out of version control.
+- 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 surface change. Never judge a round
   against a portfolio that is part old and part new.
 - Route review of the portfolio to the `orkestrel-polish-surface` campaign, which owns preflight,

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

@@ -7,7 +7,7 @@ instrument here answers as open, and never answer it with the nearest instrument
 | -------------------------------------- | -------------------------------------------- |
 | A compiler, a linter, or a Node runner | The `prove` tool, with its negative control  |
 | A person's eye                         | The run's written artifact, named by variant |
-| A person watching a widget move        | A statechart harness deep link               |
+| A person watching a widget move        | The harness run's frames and its artifact    |
 | The browser's own resolved value       | The matrix family ([styles.md](styles.md))   |
 
 Never ask `prove` about pixels, and never ask a screenshot about types.
@@ -25,17 +25,26 @@ follow it there rather than restating it here.
 
 ## The limit that decides the split
 
-`prove` cannot serve a browser project in `@orkestrel/probe` 0.0.11. The following refusals are each
-reproduced:
+`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.
 
-- The runtime stage looks a project up by the name it infers, and a browser project is instantiated
-  under its browser-expanded name, so the lookup finds nothing and the claim is refused as missing.
-- The runtime stage pins the `threads` pool, so a browser project's specification runs in a Node
-  worker. `@orkestrel/test/browser` imports `vitest/browser` at module scope, so the browser setup
-  file throws before the case runs and the failure reads as the claim's.
+Read the pool pin, the project lookup, and the guide's own statement. Any of them holding is the
+limit holding:
 
-Never route a rendered question to `prove` while that holds. The pinned-pool refusal arrives as a
-case failure, which reads exactly like a broken claim.
+- **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.
 
 ## The rendered artifact
 
@@ -61,8 +70,18 @@ Rules the artifact obeys:
   old and part new.
 - Keep it out of version control.
 
-## The harness link
-
-Send a look a person decides on to a statechart harness deep link rather than to a file. Name the
-exact link in the round, and let the person watch the widget move rather than read a still of it
-([statechart.md](statechart.md) → Build the harness a person watches).
+## The harness run
+
+Send a look a person decides on to what the harness run itself produced, rather than to a still of a
+screen.
+
+- Place a capture inside the harness run at each state the decision is about, and name the frames in
+  the round. The run drove the widget through the interface, so the frames are a record of movement
+  rather than a staged pose.
+- Name the artifact beside them. Its accessible-tree lines and its journal say what the widget
+  announced while it moved, which a frame cannot carry.
+- Give the harness a final row or a demo step that leaves the widget in its most legible state, so
+  the last frame is the one a person wants to look at.
+- Name a deep link only where the workspace already ships a harness page
+  ([statechart.md](statechart.md) → A harness page is product). Never ask a round to open a link the
+  repository does not serve.