@unoverse-platform/studio 0.1.68 → 0.1.70

package/vendor/sdk/main.tsx

@@ -27,7 +27,7 @@ function render() {
     <AppEngine
       serverUrl={current.serverUrl}
       apiUrl={current.apiUrl}
-      templateId={current.templateId}
+      appId={current.appId}
       userId={current.userId}
       conversationId={current.conversationId}
       // ANALYTICS (UNOVERSE_ANALYTICS.md). Host-supplied: the same bundle boots inside a
@@ -41,7 +41,7 @@ function render() {
       // tokenless boot made the SDK skip its guest-id substitution (connection.tsx), so
       // the session registered a non-guest id and the public-entry gate refused it.
       // No token ⇒ no accessor ⇒ the SDK mints/persists `guest-<uuid>` per the contract
-      // (UNOVERSE_MCP_TEMPLATE_PROTOCOL §5, AUTH_TOKEN_FLOW Run Authorization).
+      // (UNOVERSE_MCP_APP_PROTOCOL §5, AUTH_TOKEN_FLOW Run Authorization).
       getAccessToken={current.token ? readToken : undefined}
     />,
   );
@@ -82,21 +82,21 @@ connectMcpAppHost((r) => {
   // hardcode/guess it — a baked URL ties the bundle to one environment and hides a
   // missing config. If it's absent, fail loudly and don't mount.
   const serverUrl = (meta["unoverse/serverUrl"] as string) || (out.serverUrl as string);
-  const templateId = (out.app as string) || (meta["unoverse/app"] as string);
+  const appId = (out.app as string) || (meta["unoverse/app"] as string);
   const conversationId = (out.conversationId as string) || (meta["unoverse/conversationId"] as string);
   const token = (meta["unoverse/token"] as string) || undefined;
   const userId = (meta["unoverse/userId"] as string) || undefined;
-  if (!templateId || !serverUrl) {
+  if (!appId || !serverUrl) {
     // eslint-disable-next-line no-console
     console.warn("[unoverse:boot] cannot mount — tool result carried no serverUrl/app", {
       serverUrl,
-      templateId,
+      appId,
       structuredContent: out,
       metaKeys: Object.keys(meta),
     });
     return;
   }
   // eslint-disable-next-line no-console
-  console.log("[unoverse:boot] mounting from MCP host", { serverUrl, templateId, conversationId, userId, hasToken: Boolean(token) });
-  apply({ serverUrl, templateId, conversationId, userId, token });
+  console.log("[unoverse:boot] mounting from MCP host", { serverUrl, appId, conversationId, userId, hasToken: Boolean(token) });
+  apply({ serverUrl, appId, conversationId, userId, token });
 });

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

@@ -1,6 +1,6 @@
 ---
 name: unoverse-create
-description: "Create or edit Unoverse platform artifacts: UI components (including briefed/AI-filled components), templates, atoms and styles (design/), brand and org packs (themes, tokens, rebranding, cloning a universe for a new client), agent skills and prompt blocks (prompts/), custom workflow nodes (nodes/), and workflows built live on the Canvas via the builder MCP. Use whenever the user wants to create, add, build, or modify a component, template, card, page, theme, brand, org pack, agent skill, prompt block, custom node, or workflow in an Unoverse project, even if they don't say 'Unoverse' (they'll describe UI like 'a card with a button and an image' or 'a page the AI fills in')."
+description: "Create or edit Unoverse platform artifacts: UI components (including briefed/AI-filled components), apps, atoms and styles (design/), brand and org packs (themes, tokens, rebranding, cloning a universe for a new client), agent skills and prompt blocks (prompts/), custom workflow nodes (nodes/), and workflows built live on the Canvas via the builder MCP. Use whenever the user wants to create, add, build, or modify a component, app, card, page, theme, brand, org pack, agent skill, prompt block, custom node, or workflow in an Unoverse project, even if they don't say 'Unoverse' (they'll describe UI like 'a card with a button and an image' or 'a page the AI fills in')."
 ---
 
 # Creating Unoverse Artifacts
@@ -10,7 +10,7 @@ the platform reads.
 
 | Folder | What lives there |
 |---|---|
-| `design/` | **Design** (data, not code): per-project components, templates + styles; each project is `design/<project>/` |
+| `design/` | **Design** (data, not code): per-project components, apps + styles; each project is `design/<project>/` |
 | `prompts/` | **Behavior**: agent skills (`skills/`) + prompt blocks (`blocks/`) |
 | `nodes/` | **Logic**: custom workflow nodes, authored as YAML |
 
@@ -41,7 +41,7 @@ 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 template / app layout (chat surface, wizard shell) | `references/template.md` |
+| An app (chat surface, wizard shell) | `references/app.md` |
 | A style / theme / token change on ONE component | `references/component.md` §Tokens |
 | A brand: an org pack, a rebrand, a new client universe, cloning an org | `references/brand.md` |
 | An agent skill (behavior guide the AI follows) | `references/agent-skill.md` |
@@ -61,12 +61,12 @@ If it's ambiguous (e.g. "add a card that shows weather"), it's usually a **compo
 ([quick-start](https://docs.unoverse.ai/design/quick-start.md) →
 [components](https://docs.unoverse.ai/design/components.md) →
 [state](https://docs.unoverse.ai/design/state.md) →
-[templates](https://docs.unoverse.ai/design/templates.md) →
+[apps](https://docs.unoverse.ai/design/apps.md) →
 [styles-and-tokens](https://docs.unoverse.ai/design/styles-and-tokens.md) →
 [studio](https://docs.unoverse.ai/design/studio.md) →
 [validate-and-ship](https://docs.unoverse.ai/design/validate-and-ship.md) →
 [troubleshooting](https://docs.unoverse.ai/design/troubleshooting.md)) teaches
-components, templates, the state model (incl. locked voice/native state), tokens,
+components, apps, the state model (incl. locked voice/native state), tokens,
 Studio, and validation in order;
 [design/CLAUDE.md](https://docs.unoverse.ai/design/CLAUDE.md) is the condensed agent
 rulebook. The playbooks here assume that material. Append `.md` to any docs URL to
@@ -87,11 +87,11 @@ fetch it as raw markdown.
 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
+4. **Audit before you're done.** Every component/app must pass the conformance
    checklist ([UNOVERSE_AUTHORING](https://docs.unoverse.ai/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
+   component or app 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
    [node-discoverability](https://docs.unoverse.ai/nodes/node-discoverability.md):
@@ -101,7 +101,7 @@ fetch it as raw markdown.
 
 ## Step 3: Deploy loop (after the artifact is written)
 
-Components and templates have NO scaffold command. Author them from the references
+Components and apps have NO scaffold command. Author them from the references
 (mirror the closest existing artifact). Validation lives in the deploy lint (`unoverse deploy studio`): it
 lints every definition before anything leaves the machine (0 errors required, doc-cited
 messages; justify any warning), and the conformance checklist is
@@ -109,7 +109,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 `unoverse deploy studio`: the deploy lint gates it |
+| Component / atom / app / style | Preview in Studio (`unoverse studio`), then `unoverse deploy studio`: the deploy lint gates it |
 | Existing component restyle/edit only | takes effect live (the SDK reads `design/` directly) |
 | Agent skill / prompt block | `unoverse deploy studio`, same gate |
 | Node | Studio's Nodes screen: Load sample → Run. A node is YAML; running it is the only proof (no build) |

package/vendor/skills/unoverse-create/references/{template.md → app.md}

@@ -1,30 +1,30 @@
-# Playbook: Templates (MCP apps)
+# Playbook: Apps
 
-**Read first:** [design/templates](https://docs.unoverse.ai/design/templates.md)
+**Read first:** [design/apps](https://docs.unoverse.ai/design/apps.md)
 (layouts + manifest-as-envelope) +
 [design/state](https://docs.unoverse.ai/design/state.md) (the state model). Deep law:
 [UNOVERSE_STATE_MODEL](https://docs.unoverse.ai/unoverse/UNOVERSE_STATE_MODEL.md) §5
 (the six rules), [UNOVERSE_LAYERS](https://docs.unoverse.ai/unoverse/UNOVERSE_LAYERS.md).
 Everything in the component playbook (closed vocabulary, tokens, scale steps) applies
-here too. **Study an exemplar before writing**: templates are always a project's own
+here too. **Study an exemplar before writing**: apps are always a project's own
 (none ship in the base set), so your references are the canonical manifest tree inlined
-below, [design/templates](https://docs.unoverse.ai/design/templates.md), and any template
-already in the workspace. (Monorepo: `design/sab/templates/sab-chat-layout`.)
+below, [design/apps](https://docs.unoverse.ai/design/apps.md), and any app
+already in the workspace. (Monorepo: `design/sab/apps/sab-chat`.)
 
-## THE model: the component drives; the template reacts by name
+## THE model: the component drives; the app reacts by name
 
-A component is a state tree whose public states are its whole interface; a template
+A component is a state tree whose public states are its whole interface; an app
 declares its OWN state tree in the manifest and reacts to components by name:
 
-> A component enters a public view → the template asks "do I have a state with that
-> name?" Match: the template enters that state and its layout draws. No match: the
+> A component enters a public view → the app asks "do I have a state with that
+> name?" Match: the app enters that state and its layout draws. No match: the
 > component renders inline in the flow. Always.
 
-Derived off the store, never stored, no wiring. The component never knows templates
-exist, and post-spawn the template NEVER writes a component's state. Name-match is the
-default convention (`reactsTo:` on a template state is the rare escape hatch for
+Derived off the store, never stored, no wiring. The component never knows apps
+exist, and post-spawn the app NEVER writes a component's state. Name-match is the
+default convention (`reactsTo:` on an app state is the rare escape hatch for
 vocabulary mismatches). **Rule of thumb: component causes it = a reaction state;
-template knows it = a base substate or template state.**
+app knows it = a base substate or app state.**
 
 ## The manifest states tree: one declaration, everything follows
 
@@ -40,10 +40,10 @@ states:
   detail: {}
 ```
 
-- **Top-level order IS the priority ladder**, base first. The template can be in ONE
+- **Top-level order IS the priority ladder**, base first. The app can be in ONE
   state at a time: it walks the list top-down and enters the first of its states that
   ANY hosted component currently matches. The ladder is DERIVED from the tree; never
-  author `stateOrder` (that field survives only as the legacy form for templates
+  author `stateOrder` (that field survives only as the legacy form for apps
   without a tree).
 - **Nesting IS containment, enforced by compilation.** A declared base substate
   (`welcome`) is stripped from every non-base arrangement; no hand-written guard ever
@@ -52,9 +52,9 @@ states:
   substate. sab's conversation timeline is main's own shell, included by the shared
   chat chrome and legitimately drawn beside the rail, the page and under focus;
   declaring it would contain it to `main` and empty the chat column in every reaction
-  state. Only states the template must scope get declared.
-- **Arrival honors the component's declared initial** when the template has a matching
-  state; otherwise the template scans its own states in declared order and takes the
+  state. Only states the app must scope get declared.
+- **Arrival honors the component's declared initial** when the app has a matching
+  state; otherwise the app scans its own states in declared order and takes the
   first name on the component's public menu; no overlap and the component rides inline.
 - **A higher state CANCELS the claims below it**: while active, hosted components in
   lower-ranked states retract to inline (durable `lifetime: "conversation"` slices opt
@@ -62,20 +62,20 @@ states:
 - Ties (two components in the same view): most recent write wins (`limit: 1`).
 - **No word is special.** `focus` outranks `products` by list position only; the engine
   matches names and walks the list. Even priority is data.
-- The template's own condition-guarded moods (a welcome hero on an empty conversation)
-  are private substates of the base, never ladder entries: the template does not
+- The app's own condition-guarded moods (a welcome hero on an empty conversation)
+  are private substates of the base, never ladder entries: the app does not
   rearrange between them.
 
 ## The anatomy: manifest-only (NO `<name>.yaml` envelope)
 
 ```
-design/<project>/templates/<name>/
+design/<project>/apps/<name>/
   manifest.yaml    # THE ENVELOPE: the whole app contract, incl. the states tree
   layouts/         # the ARRANGEMENTS: one per state that owns one (same-name default)
     main.yaml      #   the base: the core alone
     products.yaml  #   state "products" → core + cards rail
     detail.yaml    #   state "detail"  → core + full record page
-  components/      # template-local partials (core, header, composer-bar, turns…)
+  components/      # app-local partials (core, header, composer-bar, turns…)
   states/          # base substates' drawings (welcome): included plainly by the
                    # chrome, own condition inside, containment compiled from the tree
 ```
@@ -90,8 +90,8 @@ ComponentSlot selecting the matching view.
 Required: `name` · `description` (what it IS, ≤120) · `whenToUse` (utterance-shaped: the
 USER's words; findIntent ranks on it, the OPENING words carry the ranking; disqualify by
 property, never by naming siblings; full contract:
-[design/templates](https://docs.unoverse.ai/design/templates.md) §Naming) ·
-`category` · `defaultState: "template"` (the app-level LOAD state, a protocol field,
+[design/apps](https://docs.unoverse.ai/design/apps.md) §Naming) ·
+`category` · `defaultState: "app"` (the app-level LOAD state, a protocol field,
 nothing to do with component views) · `inputSchema` · `layout` (the BASE layout name) ·
 `states` (the tree above) · `binding` (`workflow` + `trigger`: the app OWNS its
 workflow; without a real binding it is not done). Optional: `preview` (the per-state
@@ -117,7 +117,7 @@ ComponentSlot. Lint-enforced:
 - Nothing in the manifest sizes the app (`width`/`focusWidth` dead, a lint error).
 - Layout root: `overflow: hidden`.
 
-## Surfaces: templates REACT, they never own
+## Surfaces: apps REACT, they never own
 
 One instance → one placeholder: the flow is the placeholder for `inline`; a reaction
 state's layout (via its inner surface) is the placeholder for a matched view. The SDK
@@ -134,13 +134,13 @@ keeps a claimed instance out of the flow; never hide a flow copy yourself.
     limit: 1
   frame:  # chrome; an inner bare ComponentSlot marks the placement
   ```
-  ❌ `select: { type: [...] }`, ❌ `where.field` ≠ `view`, ❌ template chrome
+  ❌ `select: { type: [...] }`, ❌ `where.field` ≠ `view`, ❌ app chrome
   writing a component's slice, all lint-flagged. (`defaultState` as the select field
   is the v1 legacy spelling.)
-- **Input tools are template chrome** (unchanged rule): a composer, an edit form, a
-  picker is owned by the template, never a streamed component state; chrome never
-  "arrives". A card's Edit stages its data into the template's one input tool.
-- **Template state** (`setTemplateValue`) is ONLY for the template's own chrome (a
+- **Input tools are app chrome** (unchanged rule): a composer, an edit form, a
+  picker is owned by the app, never a streamed component state; chrome never
+  "arrives". A card's Edit stages its data into the app's one input tool.
+- **App state** (`setTemplateValue`) is ONLY for the app's own chrome (a
   disclosure, the composer `draft`). "Is something focused" is DERIVED, never stored.
 - **Chrome reacts via `surfacedView`** (SDK-projected active view name, `""` = all
   inline): `visibleWhen { field: surfacedView, in: ["", "products"] }`.
@@ -151,16 +151,16 @@ keeps a claimed instance out of the flow; never hide a flow copy yourself.
 - `pinned: true` on a reaction layout keeps late-arriving components from yanking the
   page from under a reading guest; the guest's own tap still moves it.
 
-## Voice templates
+## Voice apps
 
 `"service": "voice"` in the manifest. Call phases (idle…user-speaking) branch off the
 projected `callState` discriminant inside the base; typically a wide core in the base
 layout and a slim core (`chat-slim`) in the card layouts. Cards during a call match
-template states by name exactly as in chat. Audio is never wired in a definition.
+app states by name exactly as in chat. Audio is never wired in a definition.
 
 ## New project?
 
-`design/<project>/` = `templates/` + optional `components/` (project-private microapps;
+`design/<project>/` = `apps/` + optional `components/` (project-private microapps;
 names unique within the project and never shadowing a marketplace name; two projects
 may share a name, each addressed `<org>/<name>`) + `styles/` holding ONLY the org's
 overrides (the foundation cascades per token; the theme file is the one you copy
@@ -179,5 +179,5 @@ whole, see brand.md). Addresses: apps
 4. **See it**: in Studio, the state switcher reads the tree (base first, ladder order),
    base substates beneath, freely combinable; acting inside the preview transitions
    like the runtime. Then run it live: the bound workflow streams components, a card
-   entering a public view walks the ladder and rearranges the template end-to-end,
+   entering a public view walks the ladder and rearranges the app end-to-end,
    and its ✕ hands the lower state back.

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

@@ -66,7 +66,7 @@ design/<neworg>/
     themes/studio.yaml
     semantic/*.yaml          deltas only, omit what matches the foundation
   components/                org-private components (optional)
-  templates/                 the org's app layouts (optional)
+  apps/                 the org's app layouts (optional)
 ```
 
 **`base/` and `semantic/` cascade. The theme file does NOT.**
@@ -83,7 +83,7 @@ you want. That is the one place copying is correct, and it is the opposite of th
 Add `base/color.yaml` once you have brand ingredients to name, and `semantic/` only where
 you genuinely differ.
 
-Its theme is then served at `unoverse://theme/<neworg>/light`, and a template points at it.
+Its theme is then served at `unoverse://theme/<neworg>/light`, and an app points at it.
 
 ## 4. Anatomy of an org pack (`design/<org>/styles/`)
 
@@ -132,19 +132,19 @@ Copying an org pack is mechanical, and every gotcha is a name that exists in mor
 place. Work through them in order.
 
 1. **Copy the folder.** `design/<source>/` → `design/<neworg>/`, keeping `styles/`, `components/`,
-   `templates/`.
-2. **Rename the templates.** Folder AND the id inside the manifest. `bpp-chat-layout`
-   becomes `lyceum-chat-layout` in both places. Template ids are org-qualified and they
+   `apps/`.
+2. **Rename the apps.** Folder AND the id inside the manifest. `bpp-chat`
+   becomes `lyceum-chat-layout` in both places. App ids are org-qualified and they
    are referenced by string.
 3. **Component names stay as copied.** Names are unique per org, not across orgs, so a
    cloned pack carrying the same component names as its source is legal: each org's copy
    is addressed `unoverse://components/<org>/<name>`. The one forbidden case is a name
    that shadows a design-system (marketplace) component; the publish lint catches it.
-   Update template manifest `name`s only where the id itself is org-branded.
+   Update app manifest `name`s only where the id itself is org-branded.
 4. **Register the client surface** if a demo client serves it (platform monorepo only:
    `packages/demo/src/demo/clients.js`).
-5. **Point the app at the new theme.** Templates reference `unoverse://theme/<org>/<name>`.
-   A copied template still names the old org until you change it.
+5. **Point the app at the new theme.** Apps reference `unoverse://theme/<org>/<name>`.
+   A copied app still names the old org until you change it.
 
 ## 7. Done means all four
 

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

@@ -33,16 +33,16 @@ A component is **data plus a state tree**; each state owns the layout(s) that dr
 The root's `state:` block IS the design, readable top to bottom.
 
 > **THE GATE — answer this before adding ANY state to `view`:**
-> *"Would a hosting template rearrange the page to show this?"*
+> *"Would a hosting app rearrange the page to show this?"*
 > **No → it's a private step**: nest it under `on:` inside an existing public state.
 > **Yes → public.**
 > ⚠ "The user asked for N states" never means N public states. In-place swaps
 > (confirmation, success, empty, error, loading, a form's next step) are almost always
 > PRIVATE. Privacy is the default; promotion to `view` is a deliberate act with a
-> template consequence.
+> app consequence.
 
 The canonical shape (a product-card component). Note where each state landed and why:
-`products` and `detail` are PUBLIC because a template genuinely rearranges for each (a
+`products` and `detail` are PUBLIC because an app genuinely rearranges for each (a
 grid rail vs a full page); `detail`'s inner `detail`/`apply` are PRIVATE steps because
 applying swaps content in place — the page does not move:
 
@@ -75,20 +75,22 @@ The rules, in the order they bite:
   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
+- **Public states are the top level of the `view` axis** and they are the app's
+  WHOLE vocabulary: everything apps can react to, nothing more. Steps nest
   privately (`on: <key>` + `initial` + `states`), invisible outside the component.
-  The placement rule is THE GATE above: **if the template must rearrange to show it,
-  make it public; if the template wouldn't move, nest it privately.** Privacy is the
+  The placement rule is THE GATE above: **if the app must rearrange to show it,
+  make it public; if the app wouldn't move, nest it privately.** Privacy is the
   default; promotion is deliberate.
   **The tell in Studio:** non-initial public states preview FULL-BLEED (no stage
-  padding), precisely because they are template-liftable surfaces. If a state you
+  padding), precisely because they are app-liftable surfaces. If a state you
   meant as an in-place swap suddenly renders edge-to-edge, you promoted a private
   step to `view` — move it into the nest.
 - **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.
+  state selects it. Name states for what they MEAN (`detail`), never for their drawing. **Substate drawings are axis-prefixed**: a step's file carries its axis key
+  (`step-register`, `callState-idle`) and is declared via `layout:`; unprefixed
+  files are arrangements (exemplars: `course-application`, `voice-chat`).
 - **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).
@@ -96,13 +98,13 @@ The rules, in the order they bite:
   `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
+  (container queries); apps influence it only by controlling the container.
+- **Arrival: nobody sends a state.** The host app 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
+  (`publicStates`, `initialView`). Post-spawn, the app 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,
@@ -120,12 +122,30 @@ The rules, in the order they bite:
      static → hardcode);
    - workflow-fed data → **`props` with `input: true`** (the `default` is the preview mock).
      Usually empty.
+   - **Projected-field preview rule:** any LOCKED/projected field a
+     component branches on (`callState`, `isEmpty`, `hasMessages`) must ALSO be declared as
+     a prop with a preview default: Studio's bare component preview supplies ONLY prop
+     defaults, so an undeclared projected read renders NOTHING there; live, the projected
+     value wins and the default never applies. A Ref-embedded component's root Switch
+     likewise needs a `default:` case (`view` is absent without a spawned slice).
+   - **Who owns a mood: the DRIVER decides.** Ask what WRITES the discriminant:
+     (1) the component's own buttons (`setValue`) → component substates on a private axis,
+     names from the design (`course-application`); (2) a service projecting a NAMED value
+     (`callState`) → component substates named for those values + a preview prop
+     (`voice-chat`); (3) DERIVED from conversation facts (`isEmpty`/`hasMessages`) → the
+     APP tier owns it: a condition-guarded mood, or guarded drawings inside an
+     embedded component reacting to the same facts — the app has the state,
+     components just react. NEVER model a derived mood as component named substates, and
+     never borrow another field's values (`lifecycle`) as state names (bpp `text-chat`). Declare the axis as a prop with enum + default
+     (preview only; live the projection wins), give the root Switch a `default:` case for
+     Ref placement, and prefix the step drawings with the axis (`callState-idle`,
+     `lifecycle-active`). Exemplars: `voice-chat`, bpp `text-chat`.
    - **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`. Law:
-     `UNOVERSE_MCP_TEMPLATE_PROTOCOL.md` §Content-attached cards (platform spec; a
+     `UNOVERSE_MCP_APP_PROTOCOL.md` §Content-attached cards (platform spec; a
      guard test in the platform server enforces it).
 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
@@ -133,22 +153,22 @@ The rules, in the order they bite:
    **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
+   living in an app'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
    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).
-   Durable slices also opt out of `cancelBelow` retraction when a higher template state
+   closes itself, or a NEW APP loads (the app swap is the hard refresh boundary).
+   Durable slices also opt out of `cancelBelow` retraction when a higher app 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;
    [design/components](https://docs.unoverse.ai/design/components.md)).
 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.
+   (`step`, `phase`, …) are the component's own business; the app 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
+   carries its own ✕ back down. When a hosting app 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
@@ -298,6 +318,6 @@ component. Its key nouns/verbs must appear in `whenToUse`'s first sentence.
    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. Sanity-check the
-   switcher against THE GATE: every entry in its top row is a promise that a template
+   switcher against THE GATE: every entry in its top row is a promise that an app
    will rearrange for it, and a non-initial public state previews full-bleed. Debug:
    stream log → state inspector → definition; never guess.

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

@@ -87,7 +87,7 @@ package only for a new integration.
    `required: false` is right for almost every node: the trigger already decided who was let
    in. See [who-can-run-it](https://docs.unoverse.ai/nodes/who-can-run-it.md).
 3. **Write `interface.yaml`.** Name outputs for what they carry, because those names become
-   what someone types in a template.
+   what someone types in an app.
 4. **Write `config.yaml`.** Every value the workflow supplies needs `ui:field: template`. A
    `description` says what the setting does, not what it is called. NEVER declare
    `authRequired` or `authRole`: they are reserved names, injected by the platform into
@@ -126,7 +126,7 @@ the manifest describes the real service rather than something merely coherent.
 
 ## Things that go wrong
 
-- **A template resolved to empty.** Nothing errors. The node id or the output name does not
+- **An app resolved to empty.** Nothing errors. The node id or the output name does not
   match a real edge. There is no `input.*` root, and array indexes are dot segments
   (`records.0.Name`), never brackets.
 - **A number arrived as a string.** A field that is exactly one `{{ path }}` keeps its type.

package/vendor/skills/unoverse-prompt-component/SKILL.md

@@ -90,7 +90,7 @@ authored briefs go to die.
 - type: Each
   brief: { description: "...", minItems: 4, maxItems: 8 }
   bind: { items: risks }
-  template: { $include: components/bullet-list }
+  app: { $include: components/bullet-list }
 ```
 
 ### Trap 1: a brief on a `Ref` never compiles
@@ -163,7 +163,7 @@ abbreviate and never substitute characters. Say so in the page-level brief.
 ## Step 5: the workflow door
 
 If the component is filled by an agent inside a workflow rather than in chat, read
-`UNOVERSE_MCP_TEMPLATE_PROTOCOL.md` §The workflow door (platform spec; in the monorepo
+`UNOVERSE_MCP_APP_PROTOCOL.md` §The workflow door (platform spec; in the monorepo
 at `docs/unoverse/`). The load-bearing law:
 **a blank part is a valid final state.** A part the source does not cover stays blank, the
 `visibleWhen` guards render around it, and the page is complete. Gaps are orientation on

package/local/sample-template/chat/components/core-focus.yaml

@@ -1,46 +0,0 @@
-# THE CHAT COLUMN WITH A FOCUSED COMPONENT OVER IT — core, plus the focus surface
-# laid over the conversation region. A core VARIANT, not a copy: header, states and
-# composer are the same shared files core.yaml includes; the only difference is the
-# overlay slot.
-type: Box
-appWidth: chat
-style:
-  direction: column
-  minHeight: "0"
-children:
-  - type: Box
-    style:
-      direction: column
-      flex: 1
-      minHeight: "0"
-      position: relative
-    children:
-      - $include: components/header
-      - type: Box
-        style:
-          direction: column
-          flex: 1
-          minHeight: "0"
-          position: relative
-          when:
-            - field: hasMessages
-              eq: true
-              apply:
-                background: surface.base
-                radiusTopLeft: 2xl
-                overflow: hidden
-        children:
-          - $include: states/welcome
-          - $include: states/conversation
-      - type: Box
-        style:
-          position: absolute
-          bottom: "0"
-          left: "0"
-          right: "0"
-          direction: column
-        children:
-          - $include: components/suggestions
-      - $include: components/focus-overlay
-  - type: Ref
-    ref: composer-bar

package/local/sample-template/chat/components/core.yaml

@@ -1,41 +0,0 @@
-type: Box
-appWidth: chat
-style:
-  direction: column
-  minHeight: "0"
-children:
-  - type: Box
-    style:
-      direction: column
-      flex: 1
-      minHeight: "0"
-      position: relative
-    children:
-      - $include: components/header
-      - type: Box
-        style:
-          direction: column
-          flex: 1
-          minHeight: "0"
-          position: relative
-          when:
-            - field: hasMessages
-              eq: true
-              apply:
-                background: surface.base
-                radiusTopLeft: 2xl
-                overflow: hidden
-        children:
-          - $include: states/welcome
-          - $include: states/conversation
-      - type: Box
-        style:
-          position: absolute
-          bottom: "0"
-          left: "0"
-          right: "0"
-          direction: column
-        children:
-          - $include: components/suggestions
-  - type: Ref
-    ref: composer-bar