@unoverse-platform/studio 0.1.25 → 0.1.27

package/vendor/skills/unoverse-create/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: unoverse-create
-description: Create or edit Unoverse platform artifacts — UI components (including briefed/AI-filled components), templates, atoms and styles (rx/), agent skills and prompt blocks (prompts/), custom workflow nodes (nodes/), and workflows built live on the Canvas via the builder MCP. Use when the user wants to create, add, build, or modify a component, template, theme, agent skill, prompt block, custom node, or workflow in an Unoverse starter repo.
+description: Create or edit Unoverse platform artifacts: UI components (including briefed/AI-filled components), templates, atoms and styles (rx/), agent skills and prompt blocks (prompts/), custom workflow nodes (nodes/), and workflows built live on the Canvas via the builder MCP. Use when the user wants to create, add, build, or modify a component, template, theme, agent skill, prompt block, custom node, or workflow in an Unoverse starter repo.
 ---
 
 # Creating Unoverse Artifacts
 
-You are helping a developer build in the **Unoverse developer carve-out** — the three
+You are helping a developer build in the **Unoverse developer carve-out**, the three
 editable folders mounted into the running platform:
 
 | Folder | What lives there |
@@ -14,14 +14,14 @@ editable folders mounted into the running platform:
 | `apps/unoverse/prompts/` | **Behavior**: agent skills (`skills/`) + prompt blocks (`blocks/`) |
 | `apps/unoverse/nodes/` | **Logic**: custom workflow nodes, authored as YAML |
 
-## Step 1 — Identify the artifact, read its playbook
+## Step 1: Identify the artifact, read its playbook
 
 Decide what the user is creating, then **read the matching reference file before writing
 anything**:
 
 | The user wants… | Read |
 |---|---|
-| A UI component or shared atom — incl. a page/card the AI fills with content (briefed) | `references/component.md` (§Briefs for AI-filled) |
+| A UI component or shared atom, incl. a page/card the AI fills with content (briefed) | `references/component.md` (§Briefs for AI-filled) |
 | A template / app layout (chat surface, wizard shell) | `references/template.md` |
 | A style / theme / token change | `references/component.md` §Tokens |
 | An agent skill (behavior guide the AI follows) | `references/agent-skill.md` |
@@ -30,11 +30,11 @@ anything**:
 | A workflow (wire nodes into an agent/pipeline on the Canvas) | `references/workflow.md` |
 
 Workflows are the one artifact that is NOT files: they are built live on the running
-platform through the `canvas` MCP (registered by this repo's `.mcp.json`) —
-the playbook covers the bind/build/test contract.
+platform through the `canvas` MCP (registered by this repo's `.mcp.json`).
+The playbook covers the bind/build/test contract.
 
 If it's ambiguous (e.g. "add a card that shows weather"), it's usually a **component**
-(the UI) plus possibly a **node** (the data source) — confirm the scope with the user.
+(the UI) plus possibly a **node** (the data source). Confirm the scope with the user.
 
 **New to design artifacts?** The guided learning journey at `docs/design/` (README →
 quick-start → … → troubleshooting) teaches components, templates, the state model
@@ -42,32 +42,32 @@ quick-start → … → troubleshooting) teaches components, templates, the stat
 `docs/design/CLAUDE.md` is the condensed agent rulebook. The playbooks here assume that
 material.
 
-## Step 2 — Hard rules (apply to every artifact)
+## Step 2: Hard rules (apply to every artifact)
 
 1. **Only edit the three carve-out folders.** Never touch, vendor, or work around the
-   SDK, engine, or server — they are not yours to change. If a task seems to require an
-   SDK change, the answer is almost always "express it as data" — re-read the playbook.
+   SDK, engine, or server. They are not yours to change. If a task seems to require an
+   SDK change, the answer is almost always "express it as data". Re-read the playbook.
 2. **Docs are the source of truth.** The playbooks name the design journey and the deep
    references ([UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md), [UNOVERSE_STATE_MODEL](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_STATE_MODEL.md), [UNOVERSE_LAYERS](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_LAYERS.md),
    [UNOVERSE_CONFORMANCE](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_CONFORMANCE.md)). They live in the docs repo
    (https://github.com/unoverse-platform/docs), not in your repo. When the user's request goes beyond the playbook, read the named section rather
    than improvising conventions.
-3. **UI is data.** No pixels, hex colors, or CSS anywhere — token names only. No logic
-   in definitions — anything computed (totals, formatting, chosen colors) is computed in
+3. **UI is data.** No pixels, hex colors, or CSS anywhere: token names only. No logic
+   in definitions: anything computed (totals, formatting, chosen colors) is computed in
    the node and sent as a plain field.
 4. **Audit before you're done.** Every component/template must pass the conformance
    checklist ([UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md) §9). Walk it item by item.
-5. **Discovery meta is ranked, not read.** Any spatially-discoverable artifact — a
-   component or template with a manifest, an agent skill, a node — is selected by
+5. **Discovery meta is ranked, not read.** Any spatially-discoverable artifact (a
+   component or template with a manifest, an agent skill, a node) is selected by
    embedding `title`/`name` + `whenToUse`/`description` + `category` against the user's
    own words (or the planner's task). The strict contract is
    `docs/nodes/node-discoverability.md`: outcome-first, utterance-shaped, opening
    words dominate, disqualify by property (never name a sibling). Each playbook carries
    the summary; read doc 14 before writing any meta.
 
-## Step 3 — Deploy loop (after the artifact is written)
+## Step 3: Deploy loop (after the artifact is written)
 
-Components and templates have NO scaffold command — author them from the references
+Components and templates have NO scaffold command. Author them from the references
 (mirror the closest existing artifact). Validation lives in Studio: its publish step
 lints every definition before anything leaves the machine (0 errors required, doc-cited
 messages; justify any warning), and the conformance checklist is
@@ -75,7 +75,7 @@ messages; justify any warning), and the conformance checklist is
 
 | Artifact | To see it live |
 |---|---|
-| Component / atom / template / style | Preview in Studio (`unoverse studio`), then publish from Studio — the publish lint gates it |
+| Component / atom / template / style | Preview in Studio (`unoverse studio`), then publish from Studio: the publish lint gates it |
 | Existing component restyle/edit only | takes effect live (the SDK reads `rx/` directly) |
 | Agent skill / prompt block | publish from Studio, same gate |
 | Node | Studio's Nodes screen: Load sample → Run. A node is YAML; running it is the only proof (no build) |
@@ -85,4 +85,4 @@ on :4108 (`unoverse studio` from the project folder).
 
 > In the platform monorepo (not the starter), the node docs live at
 > `packages/docs/nodes/`, the design journey at `packages/docs/design/`, and the dev loop
-> is just `npm run dev` — component nodes synthesize from rx/ definitions at boot.
+> is just `npm run dev`. Component nodes synthesize from rx/ definitions at boot.

package/vendor/skills/unoverse-create/references/agent-skill.md

@@ -1,4 +1,4 @@
-# Playbook — Agent Skills (prompts/skills)
+# Playbook: Agent Skills (prompts/skills)
 
 An agent skill is a markdown behavior guide the platform's AI agents discover and follow
 at runtime (e.g. how to handle complaints, how to walk a user through a process). It is
@@ -8,7 +8,7 @@ at runtime (e.g. how to handle complaints, how to walk a user through a process)
 
 ```
 apps/unoverse/prompts/skills/<skill-name>/
-  SKILL.md           # required — frontmatter + instructions
+  SKILL.md           # required: frontmatter + instructions
 ```
 
 The runtime scans this folder and serves skills to agents; agents match on the
@@ -19,9 +19,9 @@ The runtime scans this folder and serves skills to agents; agents match on the
 ```markdown
 ---
 name: skill-name                # required: lowercase, numbers, hyphens; max 64 chars
-title: Skill Name               # human display name — shows as the item's title in listings
-description: What this skill IS — ONE short line (≤ 120 chars), the listing subtitle
-whenToUse: The SELECTION text — outcome-first, in the user's vocabulary; ranked against intent for spatial discovery. See docs/nodes/node-discoverability.md — the node rules apply verbatim.
+title: Skill Name               # human display name, shown as the item's title in listings
+description: What this skill IS: ONE short line (≤ 120 chars), the listing subtitle
+whenToUse: The SELECTION text: outcome-first, in the user's vocabulary; ranked against intent for spatial discovery. See docs/nodes/node-discoverability.md. The node rules apply verbatim.
 version: 1.0.0                  # optional, semver
 category: ai                    # optional: ai | integration | workflow | utility
 triggers:                       # optional, max 20 keywords/phrases (2–50 chars each)
@@ -36,24 +36,24 @@ nodeTypes: []                   # optional: workflow node types the skill relies
 [The situations that should activate this behavior]
 
 ## Approach / Instructions
-[Clear, step-by-step guidance. Concrete do/don't phrasing beats abstractions —
-include example lines the agent can use verbatim where tone matters.]
+[Clear, step-by-step guidance. Concrete do/don't phrasing beats abstractions.
+Include example lines the agent can use verbatim where tone matters.]
 
 ## Examples
 [Concrete before/after or dialogue examples]
 ```
 
-Stick to the keys above. The markdown body must exist — a skill with frontmatter only
+Stick to the keys above. The markdown body must exist: a skill with frontmatter only
 is invalid.
 
 ## Writing rules
 
 1. **`whenToUse` does the routing; `description` says what it is.** Never blend them
    into one field. `whenToUse` is embedded and ranked against user intent (spatial
-   discovery / findIntent) — write it **outcome-first in the user's vocabulary**
-   ("Handle an unhappy customer — a complaint, frustration, or a request to
+   discovery / findIntent). Write it **outcome-first in the user's vocabulary**
+   ("Handle an unhappy customer: a complaint, frustration, or a request to
    escalate…"), never mechanism-first. The full rules are
-   `docs/nodes/node-discoverability.md` — they apply to skills verbatim.
+   `docs/nodes/node-discoverability.md`. They apply to skills verbatim.
 2. **Study an existing skill** in `prompts/skills/` and match its voice and structure.
 3. Keep instructions outcome-focused and scannable: short sections, bulleted do/don't
    lists, explicit escalation/stop conditions.
@@ -61,5 +61,5 @@ is invalid.
 
 ## Ship
 
-`docker compose restart unoverse` — the runtime rescans skills at boot. Verify the
+`docker compose restart unoverse`. The runtime rescans skills at boot. Verify the
 skill appears via the platform's skill listing (`unoverse check` for overall health).

package/vendor/skills/unoverse-create/references/block.md

@@ -1,6 +1,6 @@
-# Playbook — Prompt Blocks (prompts/blocks)
+# Playbook: Prompt Blocks (prompts/blocks)
 
-A prompt block is a **reusable prompt fragment** — a named piece of agent prompt text
+A prompt block is a **reusable prompt fragment**: a named piece of agent prompt text
 (formatting rules, a reasoning pattern, a policy) that workflows compose into agent
 system prompts. Smaller than a skill: a skill is a discoverable behavior guide; a block
 is an ingredient.
@@ -23,7 +23,7 @@ description: What this block contributes to a prompt
 tags: [topic, topic2]
 ---
 
-[The prompt text itself — written as direct instructions to the agent,
+[The prompt text itself, written as direct instructions to the agent,
 present tense, no meta-commentary about being a block.]
 ```
 
@@ -31,7 +31,7 @@ present tense, no meta-commentary about being a block.]
 
 1. **Study an existing block** (e.g. `blocks/formatting/markdown-guidelines.md`) and
    match its shape: tight sections, imperative bullets.
-2. A block must stand alone — no references to other blocks, no assumptions about what
+2. A block must stand alone: no references to other blocks, no assumptions about what
    else is in the prompt.
 3. Keep it generic and reusable. Anything workflow-specific belongs in that workflow's
    own prompt, not in a shared block.
@@ -40,4 +40,4 @@ present tense, no meta-commentary about being a block.]
 
 ## Ship
 
-`docker compose restart unoverse` — the runtime rescans blocks at boot.
+`docker compose restart unoverse`. The runtime rescans blocks at boot.

package/vendor/skills/unoverse-create/references/component.md

@@ -1,116 +1,186 @@
-# Playbook — Components & Atoms (rx data)
+# Playbook: Components & Atoms (rx data)
 
 **Read first:** `docs/design/components.md` (the microapp anatomy) + `docs/design/state.md`
-(the reaction contract). Deep law: [UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md) §3 (three homes),
-`UNOVERSE_STATE_MODEL.md` §5b. **Study the exemplars before writing**: `rx/components/journeyfinder`
-and cardfinder — mirror them exactly.
+(the state model). Deep law: [UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md) §3 (three homes),
+`UNOVERSE_STATE_MODEL.md` §5 (the six rules), `UNOVERSE_LAYERS.md` (states own layouts).
+**Study the exemplar before writing**: `rx/sab/components/product-card` is the canonical
+State Model v2 component; mirror it exactly.
 
 ## The anatomy
 
 ```
-apps/unoverse/rx/components/<name>/            # DESIGN SYSTEM tier (generic, universal)
-apps/unoverse/rx/orgs/<org>/components/<name>/ # ORG tier (the client's own microapp, org-private)
-  <name>.json      # envelope: name/category/nodeSize/outputs/props/state/stateOrder/root
-  manifest.json    # RENDER CONTRACT: arrival defaultState (open name, default "inline")
-                   #   + discovery meta (title / description ≤120 / whenToUse utterance-shaped).
-                   #   Presence = spatially discoverable; envelope NEVER duplicates the meta.
-  layouts/         # the FACES — filename = state name: inline.json, focused.json, (custom).json
-  states/          # the component's PRIVATE steps (wizard questions) — listed in stateOrder
-  components/      # component-local shared partials (earned: 2+ states share a shape)
+apps/unoverse/rx/<project>/components/<name>/
+  <name>.yaml      # ROOT: envelope (name/category/nodeSize/outputs/props) + the STATE TREE + root
+  manifest.yaml    # RENDER CONTRACT + discovery meta (title / description ≤120 /
+                   #   whenToUse utterance-shaped). Presence = spatially discoverable;
+                   #   the envelope NEVER duplicates the meta.
+  layouts/         # the DRAWINGS: one file per state that owns an arrangement
+  components/      # component-local shared partials (earned: 2+ layouts share a shape)
 ```
 
-A **flat component** (simple card/chart) is just `<name>.json` + `root` — one face, no manifest,
-no folders. Structure is EARNED; start flat.
+A **flat component** (simple card/chart) is just `<name>.yaml` + `root`: one drawing, no
+manifest, no folders. Structure is EARNED; start flat.
 
-## The rules (Studio's publish lint enforces all of these — 0 errors required)
+## The state model (v2): data + a state tree
+
+A component is **data plus a state tree**; each state owns the layout(s) that draw it.
+The root's `state:` block IS the design, readable top to bottom. The canonical shape
+(`rx/sab/components/product-card/product-card.yaml`):
+
+```yaml
+state:
+  view:                      # the PUBLIC axis
+    initial: products
+    states:
+      products: {}                          # no layout key: same-name default, {} is complete
+      detail:                               # the full page
+        layout: product                     # declared ONLY because the filename differs
+        on: step                            # a PRIVATE axis: the steps inside detail
+        initial: detail
+        states:
+          detail: { layout: product-detail }
+          apply:  { layout: product-apply }
+root:
+  type: Box
+  children:
+    - type: Switch
+      on: view                              # the root switches on `view`, ONE case active
+      cases:
+        products: { $include: layouts/products }
+        detail:   { $include: layouts/product }
+```
+
+The rules, in the order they bite:
+
+- **The axis is `view`.** The component's public state lives in its slice under `view`.
+  The root is a `Switch on view`; buttons transition with
+  `setValue { values: [{ key: view, value: detail }] }`. That write is the ENTIRE
+  transition machinery: no guards, no events, no per-component machines.
+- **Public states are the top level of the `view` axis** and they are the template's
+  WHOLE vocabulary: everything templates can react to, nothing more. Steps nest
+  privately (`on: <key>` + `initial` + `states`), invisible outside the component.
+  The placement rule: **if the template must rearrange to show it, make it public;
+  if the template wouldn't move, nest it privately.** Privacy is the default;
+  promotion is deliberate.
+- **Each state owns its layout(s).** `layout:` is OPTIONAL: a state with no declaration
+  draws the layout of its own name, and `{}` is a complete state. Write `layout:` only
+  when the filename differs. A layout is never addressable on its own; only its owning
+  state selects it. Name states for what they MEAN (`detail`), never for their drawing.
+- **Shell vs steps.** A state's own layout is its SHELL, always on while the state is
+  active. Its nested substates are the STEPS, the only choices inside it, addressed by
+  state names (layout filenames are plumbing).
+- **Variants**: one meaning, several arrangements:
+  `focused: { layouts: { horizontal: focused-h, vertical: focused-v } }`. Variants bind
+  the SAME fields; anything that changes meaning or bound data is a second state
+  (lint-enforced). The component picks its variant by the space it finds itself in
+  (container queries); templates influence it only by controlling the container.
+- **Arrival: nobody sends a state.** The host template places the spawned actor: it
+  honors the component's declared `initial` when it has a matching state; otherwise it
+  scans its own states in declared order and takes the first name on the component's
+  public menu; no overlap and the component wakes in its own initial chain and renders
+  inline. The server compiles the tree to the public menu + initials it serves
+  (`publicStates`, `initialView`). Post-spawn, the template NEVER writes a component's
+  state.
+- **Unmatched view = inline. Always.** An ignored public state does not stay put, it
+  FALLS INLINE in the flow. A step that must never move the page belongs in the nest,
+  not on the public menu.
+- Legacy: v1's `defaultState` field and layout-name-sync are superseded; the SDK reads
+  `defaultState` only as a migration alias for `view`. New authoring writes `view`.
+
+## The rules (Studio's publish lint enforces all of these; 0 errors required)
 
 1. **Three homes for everything it shows** (AUTHORING §3):
    - static content → **hardcoded literals** in the layout (`value`, literal `items: []` on
-     Each, `src`) — never props, never `state`;
+     Each, `src`), never props, never `state`;
    - internal view-state → the **`state` block, SCALARS ONLY** (`step`, `phase`,
-     `progressPct`) — an array/object/URL in `state` is slop (workflow data → props;
+     `progressPct`): an array/object/URL in `state` is slop (workflow data → props;
      static → hardcode);
    - workflow-fed data → **`props` with `input: true`** (the `default` is the preview mock).
      Usually empty.
-   - **Prop names = the data contract — never invent them.** Source data hydrates props
+   - **Prop names = the data contract. Never invent them.** Source data hydrates props
      BY NAME (as-is, no mapping); a name the source doesn't carry silently renders the
      preview default (tell: title streams, image stays mock). Content-attached cards use
      the writer vocabulary: `title` `tagline` `description` `bodyCopy` `introParagraph`
      `primaryImage` `images` `link` `callToAction`. Guard:
      `server/src/runtime/content-card-hydration.test.ts`; law:
      `UNOVERSE_MCP_TEMPLATE_PROTOCOL.md` §Content-attached cards.
-2. **Root = `Switch on defaultState`** — the component is a switch of **views**, ONE active.
-   Cases `$include layouts/<state>` (filename = view name); `default` → the inline layout.
-   Arrival view = **manifest.defaultState**. Keep an `inline` case for any component that
-   lives in a conversation flow — it is its placeholder there. EXCEPTION — the
-   **single-face (permanent) component**: exactly ONE named view + `default` pointing at
-   the SAME face, NO inline. It arrives in its surface, cannot leave it (no ✕, no other
-   view), and is enriched in place via data merges to one stable instance — e.g. a
-   continuously-updated page living in a template's focus surface. Permanence is by
-   construction, never by a pinning rule.
-   **Lifetime (OPTIONAL manifest flag)** — `"lifetime": "conversation"` marks a durable,
+2. **Root = `Switch on view`**, cases per PUBLIC state, each `$include` of the state's
+   layout (the tree above). Keep an `inline` state for any component that lives in a
+   conversation flow: the flow is its placeholder there. One EXCEPTION is the
+   **single-state (permanent) component**: exactly ONE public state, NO inline. It
+   arrives in its surface, cannot leave it (no ✕, no other state), and is enriched in
+   place via data merges to one stable instance, e.g. a continuously-updated page
+   living in a template's focus state. Permanence is by construction, never by a
+   pinning rule.
+   **Lifetime (OPTIONAL manifest flag).** `"lifetime": "conversation"` marks a durable,
    conversation-scoped surface (a cart, an itinerary, a composed page): the platform keys
-   its instance by the CONVERSATION (every re-call hydrates the SAME slice — merge, not
+   its instance by the CONVERSATION (every re-call hydrates the SAME slice: merge, not
    re-place) and the new-turn reset skips it, so it stays on screen until it is replaced,
    closes itself, or a NEW TEMPLATE loads (the template swap is the hard refresh boundary).
-   Default `"turn"`: the instance returns to inline / retires on the next user turn.
-   Values are a closed set — `turn | conversation` (lint-checked; docs/design/04).
-3. **State is local; the VIEW is the interface** (STATE_MODEL §5b). Internal `state`
-   (`step`, `phase`, …) is the component's own business — the template never sees it. The
-   only thing that crosses to the template is the **active view** (`defaultState`). The
-   component writes ONLY its own slice (`setValue`): expand = `setValue { defaultState:
-   "course" }`; its expanded face carries its own ✕ back to `"inline"`. When a template has
-   a surface for that view, the instance **lifts out of the flow into the surface** — the
-   SDK renders each instance in exactly ONE placeholder, so you never hide a flow copy
-   yourself (no `hideBelow`, no overlay hack). ❌ NEVER `setTemplateValue` to open a surface
-   (the deprecated bridge — linted).
-4. **`stateOrder`** names exactly the `states/*.json` files, in order.
-5. **Atoms** (`rx/atoms/`, via `Ref`) are for shapes shared across components — authoring-time
+   Durable slices also opt out of `cancelBelow` retraction when a higher template state
+   takes over. Default `"turn"`: the instance returns to inline / retires on the next
+   user turn. Values are a closed set: `turn | conversation` (lint-checked; docs/design/04).
+3. **State is local; the `view` is the interface** (STATE_MODEL §5). Private axes
+   (`step`, `phase`, …) are the component's own business; the template never sees them.
+   The only thing that crosses is the public `view`. The component writes ONLY its own
+   slice (`setValue`): expand = `setValue { view: "detail" }`; its expanded layout
+   carries its own ✕ back down. When a hosting template has a state of that name, the
+   instance **lifts out of the flow into that state's slot**. The SDK renders each
+   instance in exactly ONE placeholder, so you never hide a flow copy yourself (no
+   `hideBelow`, no overlay hack). ❌ NEVER `setTemplateValue` to open a surface
+   (the deprecated bridge, linted). ❌ Never guard a layout against its own state:
+   the tree owns "which state is active"; a layout re-checking its discriminant is
+   the double-guard smell the model removes.
+4. **A new layout file is earned only by a different arrangement** (or a different set
+   of bound fields). Same shape, different values = ONE state, data-driven: seven wizard
+   questions sharing one shape are one `question` state whose data changes, never seven
+   files (LAYERS §4, §7).
+5. **Atoms** (`rx/atoms/`, via `Ref`) are for shapes shared across components, authoring-time
    only (the server expands them before serving; no Studio view). `Ref props` remaps FIELDS;
    **`Ref with` passes LITERALS**: `{ "type": "Ref", "ref": "button", "with": { "label":
-   "Learn more", "icon": "arrowRight" }, "action": { … } }` — a bind whose field is a `with`
+   "Learn more", "icon": "arrowRight" }, "action": { … } }`. A bind whose field is a `with`
    key becomes a hardcoded attribute, a truthy `with` key drops a matching `visibleWhen`
    guard (unprovided ⇒ that piece stays hidden), `{{key}}` style bindings take the value.
    ⚠ Icon: literal = `icon: "phone"`; bound = `bind: { name: field }`.
-6. **Briefs — components an AI fills** (docs/design/03 §Briefed components; deep law: [UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md) §3b). A `brief`
-   sits ON the node that renders what it describes, next to its `bind` — never in the
+6. **Briefs: components an AI fills** (docs/design/03 §Briefed components; deep law: [UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md) §3b). A `brief`
+   sits ON the node that renders what it describes, next to its `bind`, never in the
    manifest, never a separate file:
    - bound element → `"brief": { "description": "…", "maxLength": 60 }`
    - Each → `"brief": { "description": "…", "minItems": 3, "maxItems": 5 }` (its template's
-     binds define the item shape — brief those fields too)
-   - face/partial ROOT (no bind) → a plain-string brief = composition context
+     binds define the item shape; brief those fields too)
+   - layout/partial ROOT (no bind) → a plain-string brief = composition context
      (ordering, refinement rules like "update, never discard").
    The platform compiles briefs into the component's MCP tool schema (keys pass through
-   verbatim — the brief uses JSON Schema's OWN vocabulary) and injects the grounding law (fill ONLY from
-   spatial search results — never invent). The server REFEREES (invalid/empty args →
+   verbatim; the brief uses JSON Schema's OWN vocabulary) and injects the grounding law (fill ONLY from
+   spatial search results, never invent). The server REFEREES (invalid/empty args →
    instructive result, no render) and MIRRORS (success result returns the rendered page
-   for surgical refinement). **The schema IS the instruction channel** —
-   write briefs, never side-channel prompts/skills for filling a component. Shape is
-   closed + linted. Pairs with the single-face permanent pattern (rule 2) for
+   for surgical refinement). **The schema IS the instruction channel.**
+   Write briefs, never side-channel prompts/skills for filling a component. Shape is
+   closed + linted. Pairs with the single-state permanent pattern (rule 2) for
    continuously-enriched pages; exemplar: `rx/components/perfectday`.
 7. **Tokens only** (LAW 1) + closed style keys + real space-scale steps
-   (`docs/design/06`) — an invented step is silently broken CSS.
-8. **Lifecycle handlers — a component's own server-side code** (deep law:
+   (`docs/design/06`): an invented step is silently broken CSS.
+8. **Lifecycle handlers: a component's own server-side code** (deep law:
    [UNOVERSE_AUTHORING](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_AUTHORING.md) §3c). When a component needs live data from an
    API or a computation (not from an AI = brief, not from the workflow = `input` props), it
    may bring a small server-side script that runs when the component renders. It's for DATA,
    not styling or logic-in-the-def.
    - **Opt in via the manifest** (authorizes execution; auditable): `"lifecycle":
-     ["onStart"]` in `manifest.json`. A handler file with no opt-in is INERT.
-   - **The code is a sibling file named for the lifecycle** — `onStart` → `onstart.js`,
-     beside `<name>.json`. Its **default export** is the handler.
+     ["onStart"]` in the manifest. A handler file with no opt-in is INERT.
+   - **The code is a sibling file named for the lifecycle**: `onStart` → `onstart.js`,
+     beside the root file. Its **default export** is the handler.
    - **`onStart`** is the only lifecycle today; it runs SERVER-SIDE when the instance is
      created (the MCP render path), and whatever it returns is **merged into the instance
-     by prop name** (unknown keys inert — same contract as workflow-fed props). Return only
+     by prop name** (unknown keys inert, same contract as workflow-fed props). Return only
      the fields you're filling; **never overwrite a curated prop** you didn't intend to.
    - **`ctx` is a bounded sandbox**: `ctx.props` (the instance's current data),
      `ctx.instanceId`, `ctx.env(name)` (server config). The **API key comes from
-     `ctx.env`, NEVER hardcoded** — `rx/` is a shared design folder; a secret in it leaks.
+     `ctx.env`, NEVER hardcoded**: `rx/` is a shared design folder; a secret in it leaks.
    - Self-contained (the external call lives in the handler); errors never break the render.
-   Exemplar: `rx/orgs/yasisland/components/restaurantcard/onstart.js` (Google Maps details).
+   Exemplar: `rx/yasisland/components/restaurantcard/onstart.js` (Google Maps details).
 
    ```js
-   // onstart.js — manifest opts in with "lifecycle": ["onStart"]
+   // onstart.js: manifest opts in with "lifecycle": ["onStart"]
    export default async function onStart(ctx) {
      const key = ctx.env("SEARCHAPI_KEY");                 // secret from server config
      const res = await fetch(`https://…&q=${encodeURIComponent(ctx.props.title)}&api_key=${key}`);
@@ -119,34 +189,39 @@ no folders. Structure is EARNED; start flat.
    }
    ```
 
-## Discovery meta — write it to RANK (docs/nodes/node-discoverability.md)
+## Discovery meta: write it to RANK (docs/nodes/node-discoverability.md)
 
 A component with a manifest is an **MCP app**: spatial embeds `` `title. whenToUse||description
 [category]` `` and ranks it against the USER'S OWN WORDS (`findIntent`). The meta is the
-selection text, not documentation — weak meta makes a working component invisible. The
+selection text, not documentation. Weak meta makes a working component invisible. The
 strict contract (doc 14, applies verbatim):
 
-- **`title`** = the thing itself, human display name — no mechanism, no org prefix.
-- **`description`** = what it IS, ONE line ≤120 chars — the listing subtitle; never
+- **`title`** = the thing itself, human display name, no mechanism, no org prefix.
+- **`description`** = what it IS, ONE line ≤120 chars, the listing subtitle; never
   "use when…" inside it.
 - **`whenToUse`** = the selection text, **utterance-shaped**: the words a user would
-  actually say, outcome first — the OPENING words dominate the embedding. Never
+  actually say, outcome first; the OPENING words dominate the embedding. Never
   selector-shaped dev framing ("Pick when the user asks…"), never layout/mechanism first
-  ("A single-face page that…" ranks near rendering concepts and loses every intent query).
+  ("A single-state page that…" ranks near rendering concepts and loses every intent query).
 - **Disqualify by PROPERTY, never by naming a sibling** ("Not for answering a single
-  question, not for one item on its own") — naming rivals dates and tangles; the ranking
+  question, not for one item on its own"). Naming rivals dates and tangles; the ranking
   surfaces the alternative. A fallback/home surface never enumerates siblings' jobs
   (the generalist trap).
 - **`category`** = the domain of the JOB (Travel, Payments…), not the implementation.
 - Meta embeds **AS-IS** (no LLM rewrite); editing `whenToUse` re-embeds on the next train.
 
 Self-test before shipping: write the sentence the user would actually say to want this
-component — its key nouns/verbs must appear in `whenToUse`'s first sentence.
+component. Its key nouns/verbs must appear in `whenToUse`'s first sentence.
 
 ## Workflow
 
-1. Study the closest exemplar; copy its folder shape.
-2. Write the envelope + manifest + layouts; put every shown thing in its ONE home.
-3. Publish from Studio — its lint must report 0 errors (it cites the doc for every rule).
-4. Restart unoverse → Studio: mock (prop defaults + state picker + Inline/Focused
-   toggle), then live. Debug: stream log → state inspector → definition; never guess.
+1. Study `rx/sab/components/product-card`; copy its folder shape.
+2. Declare the state tree first: public states on top, steps nested, each state owning
+   its layout (same-name default, `layout:` only when the filename differs).
+3. Write the envelope + manifest + layouts; root = `Switch on view`; every shown thing
+   in its ONE home; transitions are `setValue` writes to `view` (or a private axis).
+4. Publish from Studio; its lint must report 0 errors (the rules are v2-aware and cite
+   the doc for every rule).
+5. Restart unoverse → Studio: mock (prop defaults + the state switcher reads the tree:
+   public states on top, steps beneath by state name), then live. Debug: stream log →
+   state inspector → definition; never guess.

package/vendor/skills/unoverse-create/references/node.md

@@ -161,7 +161,7 @@ the manifest describes the real service rather than something merely coherent.
   returns: "return response.items.map(helpers.row)"
   ```
 
-  A helper sees ONLY its arguments and its sibling helpers — never `config`, `credentials`
+  A helper sees ONLY its arguments and its sibling helpers, never `config`, `credentials`
   or the caller's scope. Same sandbox, no extra authority.
 
 ## Do not