@orkestrel/scaffold 0.0.81 → 0.0.82

package/dist/host/AGENTS.md

@@ -16,14 +16,16 @@
 ## Project model
 
 ```text
-src/      published library: core, browser, server, optional styles
-app/      application: core, browser, server
+src/      published library: core, browser, server, optional styles, extension faces
+app/      application: core, browser, server, extension faces
 tests/    mirrors source; setup*.ts owns shared test infrastructure
 configs/  thin target wrappers around root Vite/TypeScript configuration
 ```
 
 - `core` is host-independent. Browser and server may import core; core imports neither; browser and server never import each other.
 - `app/core` is host-independent. `app/server` may import `app/core`, `src/core`, and `src/server`, never browser code. `app/browser` may import `app/core`, `src/core`, and `src/browser`, and reaches server behavior through shared contracts and transports only.
+- The browser surface is `src/browser`, `app/browser`, the journey, and the showcase; the styles surface is `src/styles` and its themes. An extension adds a face to a surface: the `vue` browser extension adds `src/vue` and `app/vue`, and a named styles extension adds `src/<name>`.
+- `src/vue` and each `src/<name>` may import `src/core` and `src/browser`. `app/vue` may import what `app/browser` may import, plus `app/browser` and `src/vue`. No extension face imports server code or another extension's face.
 - Published source never imports private app code.
 - Enforce boundaries with the toolchain (Oxlint import restrictions, scoped TypeScript projects, Vite graphs). Add no second parser for TypeScript, Oxlint, Vue, HTML, CSS, or Vite.
 - `tsconfig.json`, `vite.config.ts`, and each `*/types.ts` are their sources of truth. Keep structural files even when empty.
@@ -57,7 +59,7 @@ configs/  thin target wrappers around root Vite/TypeScript configuration
 - **Named discriminants.** Name the axis (`relationship`, `command`, `category`), never `kind` or `type`.
 - **Centralize by kind.** Types, constants, helpers, validators, parsers, factories, and errors live in their kind file. An implementation file holds one class plus imports.
 - **Export and test reusable logic.** Fold a trivial one-use helper into its caller or export it from its kind file and test it.
-- **No nested functions**, except an anonymous callback passed as an argument or returned as the result.
+- **No nested functions**, except a callback passed as an argument or returned as the result; `.claude/rules/architecture.md` § Functions and orchestration bounds the literal positions it climbs.
 - **Functional core, imperative shell.** Pure exported leaves; stateful orchestration as class methods. A method never forwards 1:1 to a helper.
 - **No superfluous wrappers.** A wrapper adds a boundary, invariant, composition, translation, lifecycle, or materially narrower contract, or it goes.
 - **Minimal public API.** Create or substantively expand a capability with its first real consumer; this gate applies at creation, never later. Expose an existing reusable capability through its environment barrel regardless of consumer count. Remove a symbol only when the capability itself must not exist. Prefer one minimal interface and one shared engine, with a native backend override only for a faster path.

package/dist/host/agents/skills/orkestrel-harden/references/centralization.md

@@ -28,8 +28,8 @@ execution and must explain why sibling imports cannot work.
 | Defining recursive or compositional spine  | Class method, after extracting its pure leaves       |
 | Trivial and genuinely one-use              | Inline it into the caller                            |
 
-Never move logic into a nested function to evade centralization. An anonymous callback
-passed directly to another operation stays a callback, not a hidden helper declaration.
+Apply `.claude/rules/architecture.md` § Functions and orchestration to nested functions and
+callback positions.
 
 ## Hunt the wrapper
 

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

@@ -1,6 +1,6 @@
 ---
 name: orkestrel-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 — 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.
+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 screen 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.
 ---
 
 # Prove an application through human journeys
@@ -23,25 +23,27 @@ each ruling was taken at.
 
 ## Declare the families
 
-Declare in the browser environment's `integration.test.ts` which families that surface carries, and
+Declare in the browser environment's `integration.test.ts` which families that screen carries, and
 assert in the always-on proofs that every declared family is present. A declaration names which
-families a surface owes. It never switches what a declared family proves.
+families a screen owes. It never switches what a declared family proves.
 
 | Family     | Declared                                                                                     | Proves                                                                 |
 | ---------- | -------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
 | Journey    | Always                                                                                       | Each user intent reaches its outcome through the interface             |
-| Refusal    | Always                                                                                       | Each control the surface withholds, through one exact failure voice    |
-| Matrix     | Where the surface ships more than one variant                                                | The values the browser resolved under each declared variant            |
+| Refusal    | Always                                                                                       | Each control the screen withholds, through one exact failure voice     |
+| Matrix     | Where the journey wrapper declares more than one variant                                     | The values the browser resolved under each declared variant            |
 | Statechart | Where a journey drives a transition of an entity carrying its own state and event vocabulary | Each declared transition, driven through the interface where it can be |
-| Transport  | Where the surface persists or restarts                                                       | Persistence, restart, and storage failure through real implementations |
+| Transport  | Where the screen persists or restarts                                                        | Persistence, restart, and storage failure through real implementations |
 | Capture    | Under the capture flag                                                                       | The registry times the variants, each registered file written to disk  |
 
-- Refuse a declaration that omits a family whose trigger the surface meets. Report the omission as a
+- Prove Matrix in the arrival journey `scaffold new` seeds while its wrapper declares more than one
+  variant: read one resolved value under each declared variant.
+- Refuse a declaration that omits a family whose trigger the screen meets. Report the omission as a
   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.
+  and a transport assertion reach their screen 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.
@@ -92,9 +94,10 @@ start, and let it choose the capture destination, the matrix row, and the statec
 - 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.
+- 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
+  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
@@ -120,7 +123,7 @@ whose text names `vitest`, so a script naming another runner's configuration rai
   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
+- Where the screen has no theme control, prepare the theme through the attribute the screen
   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.
@@ -194,15 +197,15 @@ await PORTFOLIO.place('home')
 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 surface that commits on a timer, on an
-   unpredictable event, or only after work the person cannot observe as a surface finding, and never
+   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; 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
    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 surface that removed the control.
+   the control was there, so the run goes green on a screen that removed the control.
 
 ## Import the journey layer
 
@@ -231,7 +234,7 @@ 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 surface's own controls through forward Tab traversal in at least one journey.
+- 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
@@ -243,38 +246,38 @@ placement and scope `.claude/rules/tests.md` fixes.
   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
+  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 surface
-  finding, and target through role or region until the surface is fixed.
+- 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.
 
-### The intents every surface owes
+### The intents every screen owes
 
-Write a journey for each of the following wherever the surface has that state. Take the expected
+Write a journey for each of the following wherever the screen 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 |
+| 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 screen |
 
 - Report a missing outcome as a product finding, with its evidence site, rather than inventing the
-  copy the surface owes.
+  copy the screen 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
-  journey has put the surface in.
+- Give every screen a refusal family: the controls a person must not reach in the state the
+  journey has put the screen in.
 - Assert the exact failure voice the case means. Never write an assertion that accepts more than
   one voice ([layer.md](references/layer.md) → The failure voices).
 - Cover the restrictions the interface imposes on itself: a collapsed panel's field, a verb
@@ -296,11 +299,11 @@ and no title scheme.
   `QuotaExceededError`.
 - Prove the visible half in a journey: the failure sentence a person reads, and the retry control
   that clears it. A storage failure whose visible half is a control that silently does nothing is a
-  surface finding.
+  screen 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.
+  one is proving a store contract the application does not have.
 
 ## Prove the styles
 
@@ -350,16 +353,16 @@ 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 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 surface the journeys cover;
-- a refusal family per surface, each asserting one exact failure voice;
+- 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 surface, each
+- 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;
@@ -378,5 +381,5 @@ block is the home of that limit and of the condition that reopens it. Cite that
 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
+variants it read, the statechart outcome it reached, and every screen finding the layer's refusals
 exposed.

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

@@ -51,12 +51,12 @@ The package already refuses these, so assert none of them again:
 
 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`,
+- 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.
 - Place a capture state from inside the journey that reaches it, immediately after the assertion
-  that proves the surface is in the condition that state names.
+  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.
 
@@ -117,7 +117,7 @@ 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 surface change. Never judge a round
+- 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.
 - 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

@@ -53,8 +53,8 @@ so a decision cites the exact file and reads it in one call.
 
 Compose each file from what the run already holds:
 
-- `describeTree` of the mounted surface, for the roles, names, and states a person meets.
-- `describeFocus` of the mounted surface, for the focus order the keyboard walk took.
+- `describeTree` of the mounted screen, for the roles, names, and states a person meets.
+- `describeFocus` of the mounted screen, for the focus order the keyboard walk took.
 - The resolved-style rows the matrix family read for that variant — the property, the element, and
   the value the browser returned.
 - The journal's `steps` and `output`, for what the run did and what the page said while it did it.
@@ -66,7 +66,7 @@ Rules the artifact obeys:
   combination nobody can reproduce.
 - Write one file per variant, never one file per journey. A decision is taken per variant, and a
   reader opening one file per journey pays a round trip per journey.
-- Regenerate the whole set after any surface change. Never judge a round against a set that is part
+- Regenerate the whole set after any screen change. Never judge a round against a set that is part
   old and part new.
 - Keep it out of version control.
 

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

@@ -185,13 +185,13 @@ the capture voices in [captures.md](captures.md).
 
 - 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. Quote the match count from the message, and
+- Report ambiguity as a finding about the screen. Quote the match count from the message, and
   re-target the journey by role or region.
 - Assert a `DOMException` on its `name` as well as its message. A withheld storage operation raises
   `SecurityError` and a write past the quota raises `QuotaExceededError`, which is the pair a denied
   or full origin raises.
 - Never assert a `could not be resolved` sentence. Each one is narrowing the resolver needs under
-  `noUncheckedIndexedAccess`, and no surface reaches it.
+  `noUncheckedIndexedAccess`, and no screen reaches it.
 - 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`.
@@ -211,7 +211,7 @@ the capture voices in [captures.md](captures.md).
   `fillAccessible` where the text is only a payload the person pastes.
 - Bring focus about first — through `traverseAccessible`, `clickAccessible`, or `typeAccessible` —
   and then press. The refusal is what `pressKeys` adds over the provider's own keyboard call: a key
-  sent to the body reaches no control, and every assertion after it reads a surface the key never
+  sent to the body reaches no control, and every assertion after it reads a screen the key never
   touched.
 - Escape the sequence yourself where the sequence is the subject. Reach for `typeAccessible` where
   the text is the subject and the key syntax is in the way.
@@ -245,7 +245,7 @@ the capture voices in [captures.md](captures.md).
 - Pass `absent: true` to `waitForState` where the claim is that the state went away, and read the
   returned states rather than taking a second reading afterwards.
 - Take `waitForState` as the published replacement for a settle keyed to a framework's own class
-  names. Where the control announces nothing, the finding is the surface's: give it `aria-expanded`,
+  names. Where the control announces nothing, the finding is the screen's: give it `aria-expanded`,
   `aria-pressed`, or `aria-busy` rather than reading the classes a stylesheet happens to use.
 - Take every style, contrast, and capture reading after `waitForAnimations` on the element whose
   paint was moving. A reading taken mid-transition reports an interpolated frame no state of the
@@ -274,7 +274,7 @@ the capture voices in [captures.md](captures.md).
   locators do not, because the platform exposes a native disclosure rather than a role.
 - Drive an ARIA disclosure as what it is: a button. Click it with `clickAccessible`, then settle it
   with `waitForState` on the state it announces.
-- Report a control that opens a panel and announces no state as a surface finding. Author
+- Report a control that opens a panel and announces no state as a screen finding. Author
   `aria-expanded` on it rather than settling on the classes its framework toggles.
 - Read a native summary's expansion with `readStates`, which reads the parent `details` element's
   own `open` where the summary declares no `aria-expanded`.

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

@@ -36,7 +36,7 @@ import {
   `assert`. Each phase receives the context and the part of the transition it owns.
 - Put the scenarios and the table in the workspace's browser test setup module, and import them from
   there.
-- Declare a transition for every event the surface accepts in every state it accepts it, including
+- Declare a transition for every event the screen 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.
 - Write the phases as module functions the whole table shares. Each phase reads its subject from its
@@ -184,7 +184,7 @@ it('walks the disclosure statechart', async () => {
 - Drive `act` through the journey verbs — `clickAccessible`, `clickDisclosure`, `typeAccessible`,
   `traverseAccessible`, `pressKeys` — 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.
+  person's: a lifecycle event, a transport reply, a timer the screen 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.
 
@@ -286,7 +286,7 @@ import it.
 
 - Name only the attribute contract such a page must honour: the names in `STATECHART_ATTRIBUTES`,
   the readings in `STATECHART_STATUSES`, and the tally on one root node.
-- Report the page itself as the repository owner's decision — which transitions a surface owes,
+- Report the page itself as the repository owner's decision — which transitions a screen owes,
   where the page is linked, and whether it ships at all.
 - Route a person who must watch the widget move to the harness run's own frames and its written
   artifact ([decide.md](decide.md) → The harness run), and name a deep link only where the workspace

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

@@ -1,6 +1,6 @@
 # Proving what the browser resolved
 
-Prove a style from what the browser resolved on the mounted surface. The `enterprise-bootstrap`
+Prove a style from what the browser resolved on the mounted screen. The `enterprise-bootstrap`
 skill's [instruments reference](../../enterprise-bootstrap/references/inspection.md) names each
 instrument's property, its population, and its coverage. Take those from there, the reading from
 here, and the control from the builder this layer publishes for it.
@@ -75,12 +75,12 @@ readings follow.
   reads the whole matrix, where the capture family renders one variant per run.
 - Compose each variant's `apply` in the test, and apply it with the variant's `width` and `height`
   before the readings. 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
+- Name the attribute the screen actually reads in `apply`; a Bootstrap screen switches on
   `data-bs-theme`. An `apply` that sets another attribute leaves the run in the default theme, where
   every reading passes.
-- Reach for the application's own theme control where the surface ships one, and assert the state it
+- Reach for the application's own theme control where the screen ships one, and assert the state it
   announces. Setting the attribute directly proves the stylesheet; driving the control proves the
-  surface.
+  screen.
 - 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
@@ -102,7 +102,7 @@ provided.
   `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.
+  about the screen rather than as a pass.
 - Reach for `measureContrast`, `measureLuminance`, `blendColor`, `readLayers`, and `readBackdrop`
   only where the composite itself is the subject. Never re-derive `readContrast` from them.
 
@@ -117,7 +117,7 @@ Take each reading's control from the builder this layer publishes for it.
 | `extractStyles` | `buildEscapes(permitted)` | An inline declaration, an embedded `<style>` element, and the sheet the id exempts     |
 | `readCensus`    | `buildCensus()`           | An HTML token and an SVG token, neither declared by any loaded stylesheet              |
 
-- Append each control's `root` to the same surface root the reading walks, take the reading, and
+- Append each control's `root` to the same screen root the reading walks, take the reading, and
   remove it afterwards. Every builder returns detached nodes and mounts nothing, so where the
   control is read is the caller's decision.
 - Assert on the fields the builder returns rather than on a token or a selector written down in the
@@ -134,12 +134,12 @@ Take each reading's control from the builder this layer publishes for it.
 Take the property, the population, and the coverage from the instruments reference → Authored class
 in the shipped cascade. This is the reading.
 
-- Read the census with `readCensus(root)`, which walks the mounted surface, reports `elements` as
+- Read the census with `readCensus(root)`, which walks the mounted screen, reports `elements` as
   the population it read, lists every `tokens` value the markup carries, and lists as `undeclared`
   the tokens no loaded stylesheet declares. It refuses a walk that read no element.
 - Assert on `elements` as well as on `undeclared`. An empty walk reports no undeclared token, and so
   does markup whose every class the cascade declares.
-- Take `root` from the mounted surface, so the census covers what rendered rather than what a
+- Take `root` from the mounted screen, so the census covers what rendered rather than what a
   template file spells.
 - Read `readClasses` and `readCascade` directly only where one side of the difference is the
   subject. `readCensus` is the reading, and re-deriving it drops the population it reports.
@@ -152,7 +152,7 @@ Take the property, the population, the named exemptions, and the coverage from t
 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
+- Take the reading before any journey drives the screen, because the population is the undriven
   tree.
 - Append `buildEscapes(permitted).root` to that same `root`, so the control reaches the reading
   through `extractStyles`.

package/dist/host/claude/rules/application.md

@@ -15,13 +15,25 @@ paths:
   are first-class.
 - The CLI names the independent selections `--src` and `--app`.
   `--surfaces` is not an alias and must fail as an unknown option.
+- `new` selects the styles surface with `--styles`, its themes target with `--themes` (requires
+  `--styles`), the showcase with `--showcase` (requires `--app browser`), and extensions with
+  `--extend <surface:name,…>`. Each `--extend` entry is `browser:vue`, applied to every selected
+  browser axis, or `styles:<name>`, which requires `--styles`. `--app browser` implies the journey.
 - Core-only, browser-only, and server-only applications are valid. A combined
   browser+server application includes app/core for shared contracts.
 - Every selected environment has an `index.ts` barrel. `main.ts` is an executable
   entry and never owns reusable declarations.
 - app/core is host-independent and check/test-only.
-- app/browser uses app/core contracts, Vue 3 when selected, an `index.html`
-  entry, `vue-tsc`, and real Chromium tests.
+- app/browser is framework-independent: it uses app/core contracts, an
+  `index.html` entry, a `main.ts` that renders through the DOM, `check:app:browser`
+  through `tsc`, and real Chromium tests.
+- The Vue application lives in app/vue: `main.ts`, `index.html`, `App.vue`,
+  `check:app:vue` through `vue-tsc`, `dev:vue`, and real Chromium tests.
+- When a target's app/browser holds a `.vue` file, move it to app/vue. The
+  generator's `repair` raises a blocking question naming that move until it lands.
+- The showcase builds one page per application, app/browser and each app-side
+  browser extension, into root `showcase/` with the final-page stamp;
+  `.claude/rules/workspace.md` § Build outputs owns its build.
 - app/server uses app/core contracts, parses environment values before binding,
   defaults to loopback, emits `dist/app/server/main.cjs`, and keeps only
   `node:*` external.
@@ -36,8 +48,9 @@ paths:
   generated-consumer tests exercise those real configurations.
 - Generated consumers must pass lint, scoped typechecking, production builds, and
   real integration tests.
-- Scoped checks include `.ts`, `.tsx`, `.mts`, and `.cts`. Vue SFCs and CSS
-  belong to browser environments; SCSS requires an authorized compiler dependency.
+- Include `.ts`, `.tsx`, `.mts`, and `.cts` in scoped checks. Publish only TypeScript from
+  `src/vue`, and put Vue SFCs in `app/vue`. Put CSS in browser code; compile SCSS through the
+  `sass` dependency the styles surface declares.
 - Published `src` environments never import private `app` modules. Src core is
   host-independent; src browser/server may import src core but never one
   another's implementation. Apply the same environment law to
@@ -45,8 +58,9 @@ paths:
   is its core API.
 - App-only manifests are unscoped and `private: true`, with no `main`,
   `module`, `types`, export map, or publish configuration. Mixed manifests
-  publish only `dist/src`, and Vue remains development-only because app output
-  is never published.
+  publish only `dist/src` and the SCSS sources a stylesheet export names, and
+  never app output; `vue` stays a development dependency apart from the optional
+  peer `.claude/rules/browser.md` admits.
 - Give app/server process signals to a tested, explicitly stoppable,
   generation-safe runner whose stale failures cannot release a newer run.
 - Return the runner from convenience startup, so normal cleanup cannot be hidden.

package/dist/host/claude/rules/architecture.md

@@ -49,7 +49,7 @@ Use only the centralized files an environment needs.
 - Extract local declarations by kind. “Only used here” and “not exported” are not exemptions.
 - Every declaration in a centralized file is exported. Fold away a trivial single-use declaration or export/test it; never leave it hidden.
 - The only permitted non-exported module-scope declarations are in a runtime entrypoint that must be self-contained and cannot import siblings, such as raw source loaded in a worker. Explain that necessity in a comment.
-- A runtime entry—`src/bin/main.ts`, `app/browser/main.ts`, `app/server/main.ts`—is a fixed name, not a centralized kind file. Both the data rule and the function rule reach it, so it declares no module-scope constant and no module-scope function: it imports what it needs and runs. The preceding self-contained exception covers only an entrypoint that cannot import siblings.
+- Treat `src/bin/main.ts`, `app/browser/main.ts`, `app/vue/main.ts`, and `app/server/main.ts` as fixed runtime entries. Declare no module-scope constant or function in them; import what they need and run. Apply the preceding self-contained exception only to an entrypoint that cannot import siblings.
 - Perform a cleanup pass after implementation: no stray implementation-file declarations, non-exported/wrong-kind centralized declarations, prohibited nested declarations, duplicate implementations, compatibility aliases, superfluous wrappers, stale imports/barrel rows, or untested extracted functions.
 
 ## Kind purity
@@ -166,7 +166,7 @@ A wrapper survives only when it adds a real boundary, invariant, composition, tr
 
 - Never declare or assign a function inside another function or method.
 - This bans local `function`, `function*`, and `const fn = () => ...`, regardless of caller count.
-- The only in-body function expressions allowed are an anonymous callback passed directly as an argument and an anonymous function returned directly as the result (the factory/combinator pattern).
+- Admit a named or anonymous function expression passed as a call or constructor argument, returned as a result, or used as an arrow body, through parentheses, non-computed object-literal property values, and array elements. Admit methods, getters, and setters of such an object literal. Refuse a climb out of a method or accessor body, or through a spread, computed key, class field, assignment, or local binding.
 - Instance-bound work that reaches state or sibling methods is a method, not a free function.
 
 Separate these roles:

package/dist/host/claude/rules/browser.md

@@ -1,13 +1,22 @@
 ---
 paths:
   - 'src/browser/**/*.ts'
+  - 'src/vue/**/*.ts'
   - 'app/browser/**/*.{ts,vue}'
+  - 'app/vue/**/*.{ts,vue}'
   - 'tests/{src,app}/browser/**/*'
+  - 'tests/{src,app}/vue/**/*'
   - 'tests/setupBrowser.ts'
 ---
 
 # Vue and browser rules
 
+- Publish only TypeScript composables and contracts from `src/vue`; put Vue single-file components
+  in `app/vue`. Keep `.vue` files and `vue` imports out of `src/browser` and `app/browser`.
+  Apply `AGENTS.md` § Project model to imports from each Vue face.
+- Declare `vue` in the manifest as an optional peer only for the `./vue` export. Until that
+  declaration exists, the `./vue` build refuses `vue`, `vue/*`, and `@vue/*`; after it, the build
+  externalizes `vue` and its subpaths and still refuses `@vue/*`.
 - Never use Vue `$emit`.
 - Coordinate reactivity through props, controllers, stores, services, and composables.
 - A composable exposes readonly refs plus methods; consumers never mutate returned refs directly:

package/dist/host/claude/rules/documentation.md

@@ -23,7 +23,8 @@ Documentation is an enforced contract, not explanatory decoration. The Writing r
 - `AGENTS.md` and its linked rules are the sole convention source. Do not create competing instruction copies in guides.
 - `guides/README.md` is the map: maintain both a concept index and a directory index. The concept index runs `spec ↔ source ↔ tests ↔ showcase` minus every column whose subject this workspace lacks, so an app-only workspace that publishes no library and builds no showcase still owes a full index over the columns it has.
 - Where the repository keeps one, `ROADMAP.md` is the sequenced plan of record. Each chunk reaches green before the next.
-- A showcase is executable proof of public API. A missing demonstration is a missing feature, detectable by parity.
+- Demonstrate public API in application source, prove its journeys there, and rebuild the selected showcase pages for publication.
+- Name each `showcase/<application>.html` page that demonstrates the row in the concept index's showcase column; name `browser.html` for the base modes.
 - An integration surface's guide documents the validated hookup for each supported client: the exact commands run, the authentication and approval model that client needs, and the honest limit wherever a client cannot reach part of the surface.
 
 ## Parity

package/dist/host/claude/rules/styles.md

@@ -2,7 +2,9 @@
 paths:
   - '**/*.{scss,css}'
   - 'src/styles/**/*'
+  - 'src/*/sheet.ts'
   - 'tests/setupStyles.ts'
+  - 'tests/setupStyles.test.ts'
   - 'tests/setupBrowser.ts'
 ---
 
@@ -12,19 +14,24 @@ SCSS mirrors TypeScript centralization. Concrete token prefixes are project-spec
 
 ## Centralized files
 
-| File           | Sole responsibility                                           |
-| -------------- | ------------------------------------------------------------- |
-| `_mixins.scss` | `@function` values and `@mixin` declaration emitters          |
-| `_tokens.scss` | `:root` public custom-property tokens and cascade-layer order |
-| `_theme.scss`  | Token overrides under theme selectors                         |
-| `index.scss`   | Sole compilation barrel                                       |
+| File                | Sole responsibility                                           |
+| ------------------- | ------------------------------------------------------------- |
+| `_mixins.scss`      | `@function` values and `@mixin` declaration emitters          |
+| `_tokens.scss`      | `:root` public custom-property tokens and cascade-layer order |
+| `_theme.scss`       | Token overrides under theme selectors                         |
+| `_reset.scss`       | The face's reset declarations, when that face owns a reset    |
+| `themes/index.scss` | Barrel of named theme packs, compiled into its own sheet      |
+| `index.scss`        | Sole compilation barrel                                       |
 
+- Apply this table and the folder barrels in § Folders to every sheet face: `src/styles` and each
+  `src/<name>` styles extension. `.claude/rules/workspace.md` § Environments fixes the `sheet.ts`
+  entry.
 - `_mixins.scss` emits no top-level CSS.
 - Consumers load it with `@use '../mixins' as *`.
 - Never load `mixins` from `index.scss`.
-- `index.scss` is the sole compilation barrel; it loads `tokens`, `theme`, and output partials with `@use`.
+- `index.scss` is the sole compilation barrel of its sheet; it loads `tokens`, `theme` where `_theme.scss` exists, and the output partials with `@use`. Never load `themes/` from `index.scss`.
 - `_tokens.scss` is the token source of truth. Adding a token is allowed; rename/removal is breaking.
-- `_theme.scss` only retunes tokens under selectors such as `[data-theme='…']`.
+- `_theme.scss` and each `themes/` pack only retune tokens under theme selectors such as `[data-theme='…']`.
 - Component partials never override global tokens.
 
 ## Sass mechanisms
@@ -39,8 +46,11 @@ SCSS mirrors TypeScript centralization. Concrete token prefixes are project-spec
 - Check `_tokens.scss` before inventing a token.
 - Put global tokens in `_tokens.scss`; put truly component-scoped custom properties on the component selector.
 - Never bury tokens in unrelated partials.
-- Never use literal colors. Use `var(--token)` or `color-mix()` over tokens. The one file a
-  literal color may appear in is `_tokens.scss`, where the token itself is declared.
+- Never use literal colors outside a pinned recreation. Use `var(--token)` or `color-mix()` over
+  tokens. The one file a literal color may appear in is `_tokens.scss`, where the token itself is
+  declared. A face whose contract is the exact recreation of a pinned external artifact keeps
+  the literals, declarations, and order the pin declares, and records tokenization and
+  accessibility additions in its separate authored face.
 - Never repeat per-color/per-variant blocks; drive shared structure with one `@each` over a shared list.
 - If a pattern appears in at least two partials, move it to `_mixins.scss`.
 - Treat a declaration block two partials share because each records an external value as a
@@ -50,8 +60,21 @@ SCSS mirrors TypeScript centralization. Concrete token prefixes are project-spec
 - Never `@extend` across partials; share through tokens/mixins.
 - Never declare a `transition:` without `prefers-reduced-motion: reduce`. Use the project transition mixin, which emits both.
 - Animations include `@include reduced-motion { animation: none }`.
-- Never wrap rules in a foreign cascade layer. Each partial uses its folder's own layer.
-- Declare cascade-layer order once in the consumer entry before `@import 'tailwindcss'`, so utilities win predictably.
+- Never wrap rules in a foreign cascade layer. Each partial uses its folder's own layer. A sheet
+  that recreates an external framework instead writes every normal declaration into one layer named
+  for that framework and every `!important` declaration outside every layer.
+- Declare cascade-layer order once in the consumer entry before `@import 'tailwindcss'`, so utilities win predictably. When a package publishes several sheets, open every published sheet with the same full order statement, so the order holds whichever sheet loads first.
+- Open `themes/index.scss` with `@use '../tokens'`, whose first emitted rule is the order statement, then `@use 'default'`; Sass refuses a `@use` after another rule, so never write the statement there literally.
+
+## Folders
+
+- Give each folder an `_index.scss` barrel that loads its partials with `@use`; keep the barrel when the folder is empty.
+- Put a rule that styles one element in `elements/`, a class skin that applies with no script running in `components/`, and a class that sets one property in `utilities/`.
+- Add another folder only for a job `elements/`, `components/`, and `utilities/` do not hold, and give it its own barrel and its own layer.
+
+## Proofs
+
+- Declare every CSSOM instrument a sheet proof reads in `tests/setupStyles.ts`, never in a test file. `tests/setupStyles.test.ts` proves each instrument under the root setup mirror in `.claude/rules/tests.md`.
 
 ## Naming