unoverse 0.1.44 → 0.1.46

package/bin/unoverse.mjs

@@ -123,13 +123,8 @@ switch (cmd) {
     // Runs AS the new version, in the developer's cwd. Outside a universe there is
     // nothing to refresh, and silence is the right answer.
     if (UNIVERSE) {
-      const skillSrc = join(dirname(fileURLToPath(import.meta.url)), "../operator/skills/unoverse-create");
-      if (existsSync(skillSrc)) {
-        const { cpSync, mkdirSync } = await import("node:fs");
-        mkdirSync(join(UNIVERSE.root, ".claude/skills"), { recursive: true });
-        cpSync(skillSrc, join(UNIVERSE.root, ".claude/skills/unoverse-create"), { recursive: true });
-        console.log("  ✓ authoring skill refreshed");
-      }
+      // The authoring skill is Studio's, not the universe's; update touches only what
+      // a universe actually has: this CLI and the platform images.
       operator(UNIVERSE, ["refresh-images"]);
     }
     process.exit(0);

package/lib/create.mjs

@@ -324,17 +324,10 @@ export async function create(nameArg) {
       const operatorScript = existsSync(vendored)
         ? vendored
         : resolve(here, "../../../scripts/operator.sh");
-      // The authoring skill, so Claude Code works in the new folder immediately. The
-      // starter tarball does not carry it; the CLI does, and `unoverse update` refreshes it.
-      const skillSrc = resolve(here, "../operator/skills/unoverse-create");
-      const skillFallback = resolve(here, "../../../.claude/skills/unoverse-create");
-      const skill = existsSync(skillSrc) ? skillSrc : skillFallback;
-      if (existsSync(skill)) {
-        const { cpSync } = await import("node:fs");
-        mkdirSync(`${name}/.claude/skills`, { recursive: true });
-        cpSync(skill, `${name}/.claude/skills/unoverse-create`, { recursive: true });
-      }
-
+      // NO authoring skill here, deliberately. Building components, nodes and agent
+      // skills is STUDIO work and its skill ships with Studio projects. What a universe
+      // offers Claude Code is the canvas MCP (.mcp.json in the scaffold): building and
+      // managing workflows on this universe's Canvas.
       const r = spawnSync("bash", [operatorScript, "init"], {
         stdio: "inherit",
         cwd: name,
@@ -349,11 +342,11 @@ export async function create(nameArg) {
     cd ${name}`}
     unoverse start
 
-  ${cyan("Build with Claude:")} this folder is ready for Claude Code. Open it
-  there and describe what you want, in plain words. Claude already knows how
-  to build unoverse components, custom nodes, agent skills, and workflows on
-  your Canvas.
+  ${cyan("Build with Claude:")} open this folder in Claude Code and describe the
+  workflow you want. Claude builds and manages workflows live on this
+  universe's Canvas.
 
+  ${dim("Components, nodes and agent skills are built in Studio: unoverse studio")}
   ${dim("How it works: https://github.com/unoverse-platform/docs")}
 `);
       return;

package/operator/lib/help.sh

@@ -22,6 +22,7 @@ cmd_help() {
   echo -e "    ${GREEN}stop${NC}        Stop it"
   echo -e "    ${GREEN}check${NC}       Is it healthy ${DIM}(services, schema, environment)${NC}"
   echo -e "    ${GREEN}logs${NC}        What is it doing ${DIM}(unoverse logs <service> for one)${NC}"
+  echo -e "    ${GREEN}ground${NC}      Prepare a server in your cloud ${DIM}(unoverse ground do|aws, prefills Terraform)${NC}"
   echo -e "    ${GREEN}deploy${NC}      Ship it to your server ${DIM}(images + your work + migrations)${NC}"
   echo ""
   # Owner-only lane. Printed ONLY when publish.sh is present, so a starter kit never
@@ -29,7 +30,6 @@ cmd_help() {
   if type cmd_publish >/dev/null 2>&1; then
     echo -e "  ${BOLD}${DIM}Platform owner${NC}"
     echo -e "    ${GREEN}publish${NC}     Full release. Every lane whose content changed"
-    echo -e "    ${GREEN}ground${NC}      Prefill terraform.tfvars from your cloud CLI ${DIM}(do|aws)${NC}"
     echo -e "    ${GREEN}dev${NC}         Run the monorepo locally"
     echo ""
   fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "The Unoverse front door — create a Studio project, a universe, or a client app, and launch Studio.",
   "license": "SEE LICENSE IN README.md",
   "type": "module",

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

@@ -1,88 +0,0 @@
----
-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.
----
-
-# Creating Unoverse Artifacts
-
-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 |
-|---|---|
-| `apps/unoverse/rx/` | **Design** (data, not code): components, atoms, org-scoped templates + styles |
-| `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
-
-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 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` |
-| A prompt block (reusable prompt fragment) | `references/block.md` |
-| A custom workflow node (integration, tool, logic) | `references/node.md` |
-| 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.
-
-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.
-
-**New to design artifacts?** The guided learning journey at `docs/design/` (README →
-quick-start → … → troubleshooting) teaches components, templates, the state model
-(incl. locked voice/native state), tokens, Studio, and validation in order;
-`docs/design/CLAUDE.md` is the condensed agent rulebook. The playbooks here assume that
-material.
-
-## 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.
-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
-   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
-   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)
-
-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
-[UNOVERSE_CONFORMANCE](https://github.com/unoverse-platform/docs/blob/main/unoverse/UNOVERSE_CONFORMANCE.md).
-
-| Artifact | To see it live |
-|---|---|
-| 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) |
-
-Verify the platform with `unoverse check` (services, schema, environment). Studio opens
-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.

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

@@ -1,65 +0,0 @@
-# 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
-**prose for an agent**, not code.
-
-## Where files go
-
-```
-apps/unoverse/prompts/skills/<skill-name>/
-  SKILL.md           # required — frontmatter + instructions
-```
-
-The runtime scans this folder and serves skills to agents; agents match on the
-`description` and `triggers`.
-
-## SKILL.md format
-
-```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.
-version: 1.0.0                  # optional, semver
-category: ai                    # optional: ai | integration | workflow | utility
-triggers:                       # optional, max 20 keywords/phrases (2–50 chars each)
-  - keyword or phrase
-credentials: []                 # optional: credential types the skill's flow needs
-nodeTypes: []                   # optional: workflow node types the skill relies on
----
-
-# Skill Name
-
-## When to Use This Skill
-[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.]
-
-## Examples
-[Concrete before/after or dialogue examples]
-```
-
-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
-   escalate…"), never mechanism-first. The full rules are
-   `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.
-4. One skill = one behavior. If you're writing "and also…", split it.
-
-## Ship
-
-`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/operator/skills/unoverse-create/references/block.md

@@ -1,43 +0,0 @@
-# Playbook — Prompt Blocks (prompts/blocks)
-
-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.
-
-## Where files go
-
-```
-apps/unoverse/prompts/blocks/<category>/<block-name>.md
-```
-
-The immediate subdirectory is the block's category (existing: `core/`, `formatting/`).
-The runtime scans this tree recursively and serves blocks by category/name.
-
-## Format
-
-```markdown
----
-name: Human Readable Name
-description: What this block contributes to a prompt
-tags: [topic, topic2]
----
-
-[The prompt text itself — written as direct instructions to the agent,
-present tense, no meta-commentary about being a block.]
-```
-
-## Writing rules
-
-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
-   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.
-4. Pick the existing category that fits; create a new subdirectory only for a genuinely
-   new family of blocks.
-
-## Ship
-
-`docker compose restart unoverse` — the runtime rescans blocks at boot.

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

@@ -1,152 +0,0 @@
-# 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 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)
-```
-
-A **flat component** (simple card/chart) is just `<name>.json` + `root` — one face, no manifest,
-no folders. Structure is EARNED; start flat.
-
-## 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`;
-   - internal view-state → the **`state` block, SCALARS ONLY** (`step`, `phase`,
-     `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
-     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,
-   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).
-   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
-   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`
-   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
-   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
-     (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 →
-   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
-   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:
-   [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`** 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
-     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.
-   - 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).
-
-   ```js
-   // 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}`);
-     const place = (await res.json()).local_results?.[0] ?? {};
-     return { rating: place.rating, address: place.address };   // merged by prop name
-   }
-   ```
-
-## 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
-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
-  "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
-  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).
-- **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
-  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.
-
-## 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.

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

@@ -1,175 +0,0 @@
-# Playbook: custom workflow nodes
-
-**Read first, in order:**
-
-1. `docs/nodes/CLAUDE.md`: the authoritative agent guide. The folder, the eight
-   non-negotiable rules, every file with an example, and the lint-error-to-fix table.
-2. `docs/nodes/manifest-nodes.md`: the format in full, including the run context.
-3. `docs/nodes/node-discoverability.md`: **read before writing `whenToUse`**.
-4. As needed: `credentials.md`, `who-can-run-it.md`, `config-schema.md`, `service-connectors.md`,
-   `mcp-services.md`, `signal-routing.md`, `testing-nodes.md`.
-
-This playbook adds the workflow around those docs. It never overrides them.
-
-## A node is YAML
-
-There is no TypeScript, no `src/`, no `package.json`, no build and no publish step. A node
-is a folder of YAML files that the platform interprets.
-
-**Never write a code node.** If the format cannot express what is needed, the platform is
-missing a capability. Say so and stop, rather than reaching for code.
-
-```
-apps/unoverse/nodes/<package>/
-  package.yaml              # name, category, allowedHosts, requires
-  credentials/
-    <name>Credential.yaml   # the SHAPE of a credential, never a value
-  shared/                   # fragments several nodes $ref, and helpers: they call
-  nodes/
-    <NodeName>/
-      node.yaml             # what it IS       (the only REQUIRED file)
-      interface.yaml        # what it CONNECTS TO
-      config.yaml           # the settings form
-      api/
-        run.yaml            # the calls it makes, ALWAYS a list
-        events.yaml         # everything that leaves the node
-      test.yaml             # a fixture that runs
-```
-
-## Before writing anything
-
-**Read the closest published node and mirror it.** They are all public:
-
-**[marketplace/definitions/nodes](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes)**
-
-| If the node needs | Read |
-|---|---|
-| The simplest case: one call, one answer | [SearchWeb](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/search/SearchWeb) |
-| Walking pages and accumulating the results | [AirtableFetch](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/airtable/AirtableFetch) |
-| Writing a collection in batches the API accepts | [AirtableInsert](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/airtable/AirtableInsert) |
-| A cheap existence check before an insert | [AirtableExists](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/airtable/AirtableExists) |
-| Caching an answer between runs | [ApolloCompany](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/gtm/ApolloCompany) |
-| Two calls, where the second uses the first | [HunterEnrich](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/gtm/HunterEnrich) |
-| Starting a job and waiting for it to finish | [HyperbrowserCrawl](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/hyperbrowser/HyperbrowserCrawl) |
-| Tokens streaming in as they are produced | [OpenAIStream](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/openai/OpenAIStream) |
-| A request whose shape changes with the settings | [OpenAIStructuredOutput](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/openai/OpenAIStructuredOutput) |
-| A node other nodes call, rather than a workflow step | [OpenAIEmbeddingService](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/openai/OpenAIEmbeddingService) |
-| Offering tools to an Agent | [HubspotMCP](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/hubspot/HubspotMCP) |
-| A tool loop, and a second model narrating progress | [OpenAIAgent](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/openai/OpenAIAgent) |
-
-Closer to a real service: [airtable](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/airtable), [gtm](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/gtm),
-[hubspot](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/hubspot), [salesforce](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/salesforce), [search](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/search),
-[slack](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/slack), [x-search](https://github.com/unoverse-platform/marketplace/tree/main/definitions/nodes/x-search).
-
-Adding a node to an existing package in the user's own repo is usually right. Create a
-package only for a new integration.
-
-## Workflow
-
-1. **Decide `kind`.** One call, one reply is `PromiseNode`. Streaming or a tool loop is
-   `CallbackNode`. Lint verifies it against the transport and `toolExchange`.
-2. **Write `node.yaml`.** Treat `whenToUse` as make-or-break: it decides whether the node is
-   ever offered. Outcome first, disqualify by property, never name another node, wiring fact
-   last. Then answer who may run it, which is compulsory on every node:
-
-   ```yaml
-   auth:
-     required: false      # adds no requirement of its own; does NOT mean public
-     # role: crm:write    # optional; implies required: true
-   ```
-
-   `required: false` is right for almost every node: the trigger already decided who was let
-   in. See `docs/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.
-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. Then add the two
-   run-authorization fields, which every node carries identically:
-
-   ```yaml
-   authRequired:
-     type: boolean
-     title: Require sign-in
-     default: false
-     "ui:widget": toggle
-   authRole:
-     type: string
-     title: Require role
-     default: ""
-     "ui:dependencies": { authRequired: true }
-   ```
-
-   These are the workflow BUILDER's control, per box on a canvas, separate from
-   `node.yaml`'s `auth`, which is your floor. The executor takes the stricter of the two. A
-   role usually belongs here rather than in the manifest: `finance:approve` is a claim one
-   deployment's identity provider mints, and a published node cannot know it. Add both to
-   `ui:order`.
-5. **Write `api/run.yaml`.** A list, each entry named. Include `error` wherever the service
-   can answer 200 with a failure body. Where one call is really many, name the capability on
-   the call rather than trying to express a loop: `paginate`, `chunk`, `poll` or `state`.
-   See `docs/nodes/calls-that-loop.md`, and declare each one in `requires`. A call
-   authenticates with `credential: { scheme, token }`, which is OUTBOUND: how the node proves
-   itself to the vendor. It is not `node.yaml`'s `auth`, which is who may run the node.
-6. **Write `api/events.yaml`.** One row per output connector, in the order `interface.yaml`
-   declares them. Streaming rows need `match`, and usually `accumulate: true`.
-7. **Add the host** to `allowedHosts` in `package.yaml`, and the credential file if the
-   service needs a key.
-8. **Write `test.yaml`.** Assert the shape, never exact words.
-
-## Verify
-
-```bash
-Studio → Nodes → your node (the catalog load reports schema errors)
-Studio's Nodes screen (Load sample → Run)
-```
-
-Both must pass before the node is done. Lint names the rule and the page behind it, so read
-the message rather than guessing.
-
-The Studio node runner calls the real service and needs no platform running. It reads keys from `.env`
-as `<CREDENTIAL>_<FIELD>` in upper snake case, so `openAICredential.apiKey` is
-`OPENAI_API_KEY`.
-
-A node that lints but has never run is not done. Running it is the only check that proves
-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
-  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.
-  Anything with text around it becomes a string.
-- **An output stays empty.** No row in `events.yaml` emits to it.
-- **A downstream node gets one word at a time.** The streaming row needs `accumulate: true`.
-- **The request was refused before it left.** The host is not in `allowedHosts`.
-- **An expression was rejected.** The sandbox has no `new`, so no `new Date(...)`. Use
-  `Date.now()` and `Date.iso(ms)`. Nothing mutates either: `.at(-1)` not `.pop()`,
-  `.toSorted()` not `.sort()`. No spread in call arguments: `reduce` into an object rather
-  than `Object.assign({}, ...list)`.
-- **An expression grew past a few lines.** Give it a name. Any `shared/*.yaml` may declare
-  `helpers:`, and every expression in the package can call them:
-
-  ```yaml
-  # shared/helpers.yaml
-  helpers:
-    row:
-      args: [r]
-      body: "return { id: r.id, title: r.title }"
-  ```
-  ```yaml
-  returns: "return response.items.map(helpers.row)"
-  ```
-
-  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
-
-- Write TypeScript, a `package.json` or a build step for a node
-- Put a credential value in any file
-- Hard-code instruction text. Use `{{prompt.<blockName>}}` so it tracks the block
-- Name another node in `whenToUse`
-- Set `cacheable: true` on anything effectful or non-deterministic
-- Claim a capability the platform does not implement
-- Write `auth:` on a call. That key is `credential:`; `auth` on a node is who may RUN it

package/operator/skills/unoverse-create/references/template.md

@@ -1,115 +0,0 @@
-# Playbook — Templates (MCP apps)
-
-**Read first:** `docs/design/templates.md` (layouts + manifest-as-envelope) +
-`docs/design/state.md` (the reaction contract + name-sync). Deep law:
-`UNOVERSE_STATE_MODEL.md` §5b, `UNOVERSE_LAYERS.md`. Everything in the component
-playbook (closed vocabulary, tokens, scale steps) applies here too.
-
-## THE model — layouts sync by name
-
-A component is a Switch of **faces**; a template is a set of **layouts** — same
-mechanism, two tiers, connected by ONE rule:
-
-> A component enters a view → the template presents the layout of the same name.
-> No matching layout → the default layout; the component renders inline.
-
-Derived off the store, never stored, no wiring — the component never knows templates
-exist. **Rule of thumb: component causes it = layout; template knows it = state.**
-
-## The anatomy — manifest-only (NO `<name>.json` envelope)
-
-```
-apps/unoverse/rx/orgs/<org>/templates/<name>/
-  manifest.json    # THE ENVELOPE — the whole app contract (below)
-  layouts/         # the ARRANGEMENTS — one per component view + the default
-    standard.json  #   the default (manifest.layout): the core alone
-    products.json  #   view "products" → core + cards rail
-    product.json   #   view "product"  → core + detail panel
-  components/      # template-local partials (core, header, composer-bar, turns…)
-  states/          # LOCAL states only (welcome, conversation, call phases) —
-                   # available in exactly the layouts whose trees include them
-```
-
-Each layout = a complete arrangement: `{ "$include": "components/core" }` + that view's
-surface. Shared chrome lives ONCE in `components/`; every layout includes it. A layout
-named after a view MUST contain a surface selecting that view (guard-enforced) — the
-name claims the instance, the surface renders it.
-
-## manifest.json (the app contract)
-
-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: docs/design/05 §Naming) ·
-`category` · `defaultState` (`"template"` = the full surface) · `inputSchema` ·
-`layout` (the DEFAULT layout name) · `stateOrder` (local states + layouts, picker order) ·
-`binding` (`workflow` + `trigger` — the app OWNS its workflow; without a real binding it
-is not done). Optional: `preview` (the per-LAYOUT mock map for Studio —
-`{ "products": ["productcard", "productcard"] }`; repeated name = several instances),
-`autoTrigger`, `expose`, `service` (`"voice"` — the channel instantiates the native
-service, which projects `callState` into scope).
-
-**The generalist trap:** a home/fallback surface must NOT enumerate its siblings' jobs —
-it owns general help and cedes specific jobs by property, naming none.
-
-## Sizing — each layout owns its widths
-
-The app = the ACTIVE layout's total, nothing else ever. Inside a layout: the core panel
-is always open (`appWidth` on the core box), the surface panel declares its width on the
-ComponentSlot. Lint-enforced:
-- `appWidth` = a NAMED size from the org's `styles/semantic/app-sizes.json`
-  (`chat` · `chat-slim` · `rail` · `panel`) — raw CSS is an ERROR.
-- ONE declaration per panel — the frame never declares width/flex.
-- NEVER on a layout root; NEVER `visibleWhen`-guarded (a conditional arrangement is a
-  LAYOUT, selected by name).
-- An OVERLAY surface (`inset: 0` over the core) declares NO appWidth and needs NO layout
-  of its own — reach for a layout when the ARRANGEMENT changes.
-- Nothing in the manifest sizes the app (`width`/`focusWidth` dead — lint error).
-- Layout root: `overflow: hidden`.
-
-## Surfaces — templates REACT, they never own
-
-One instance → one placeholder: the flow is the placeholder for `inline`; a surface (or
-a layout, via its inner surface) is the placeholder for a named view. The SDK keeps a
-claimed instance out of the flow — never hide a flow copy yourself.
-
-- **Flow slot**: `{ "type": "ComponentSlot", "select": {} }` — always present.
-- **Reaction surface**: select by the VIEW, never by type/id:
-  ```jsonc
-  { "type": "ComponentSlot", "appWidth": "panel",
-    "select": { "from": "all", "where": { "field": "defaultState", "eq": "product" }, "limit": 1 },
-    "frame": { /* chrome; an inner bare ComponentSlot marks the placement */ } }
-  ```
-  ❌ `select: { type: [...] }`, ❌ `where.field` ≠ `defaultState`, ❌ template chrome
-  writing a component's slice — all lint-flagged.
-- **Template state** (`setTemplateValue`) is ONLY for the template'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"] }`.
-- **A `limit: 1` surface's occupant FILLS it** automatically — never sprinkle
-  `minHeight: full` through faces. Rails (no limit) keep content-sized cards.
-- A full layer caps its height and scrolls its BODY only (`flex: 1` + `minHeight: 0` +
-  `overflow: auto`; header/footer pinned).
-
-## Voice templates
-
-`"service": "voice"` in the manifest. Call phases (`states/idle…user-speaking`) are
-LOCAL states included by the cores; typically a wide core in the default layout and a
-slim core (`chat-slim`) in the card layouts. Cards during a call select layouts by name
-exactly as in chat. Audio is never wired in a definition.
-
-## New org?
-
-`rx/orgs/<org>/` = `templates/` + optional `components/` (org-private microapps, names
-unique across tiers) + a **complete self-contained** `styles/` (copy
-`rx/orgs/default/styles` and re-value the base scales). Addresses: apps
-`unoverse://apps/<org>/<name>`, org components `unoverse://components/<org>/<name>`,
-themes `unoverse://theme/<org>/<theme>`.
-
-## Validate & ship
-
-1. Publish from Studio — its lint must report 0 errors (layout/name-sync rules, widths, reaction rules, tokens).
-2. Restart unoverse — the node re-synthesizes.
-3. **See it**: Studio — layout pills on top (default first, stateOrder order), local
-   states down the left, freely combinable; acting inside the preview transitions like
-   the runtime. Then run it live: the bound workflow streams components, and entering a
-   view swaps the layout end-to-end.

package/operator/skills/unoverse-create/references/workflow.md

@@ -1,52 +0,0 @@
-# Playbook: Build a workflow (via the builder MCP)
-
-Workflows are NOT files in the carve-out — they live in the platform and are built
-through the **builder MCP** (`canvas`, auto-registered by this repo's
-`.mcp.json`). You drive the platform's own authoring tools; the canvas updates live
-in the developer's browser as you build.
-
-## Prerequisites (check before starting)
-
-1. **The platform is running** (`unoverse start`, or `npm run dev` in the platform
-   repo). The builder listens on `localhost:4106` — local machine only, by design.
-2. **The MCP is connected**: `canvas` should show connected with 14 tools.
-   If it shows failed, the platform wasn't up when the session started — reconnect
-   via `/mcp` after starting it.
-3. **The developer gives you a pairing code.** Ask them to open a **new empty
-   workflow in Canvas** (http://localhost:3001), click **"Connect agent"** in the
-   toolbar, and paste the short code it shows (e.g. `FW9D-6QKA`). The code binds you
-   to that one workflow — single use, expires in 10 minutes. There is deliberately no
-   way to list or discover workflows from here — the code must come from the developer.
-   Prefer a fresh workflow: saves are provenance-scoped, so wiring into nodes you
-   didn't create may be rejected.
-
-## The contract
-
-1. **`bindWorkflow` first.** Every other tool refuses until the session is bound,
-   and every call after is pinned server-side to that one canvas.
-2. **Read the in-band guides before building.** The deep how-to is served by the
-   platform itself via `readBuilderSkill` — always current, never duplicated here:
-   - `solution-design` — read FIRST on any new goal
-   - `workflow-building` — the build protocol + response-field semantics
-   - `workflow-testing` — runTest / stepNode / reading traces
-   - `template-references` — the `{{...}}` grammar + fixing lint errors
-3. **Build ONE stage at a time.** The loop is: `saveWorkflow` one stage → `runTest`
-   → read the trace → add the next stage based on that evidence. Never design or
-   pre-wire the whole graph up front — you learn a node's real output fields by
-   running it, not by planning.
-4. **Ground truth rules:** `getCanvas` is the real graph; a nodeType is valid only
-   if `getNodeCatalog` returned it (search it fresh per step, with a one-line
-   `task`); layout and node ids are not yours to set.
-5. **The developer judges the result — never self-certify.** When the workflow runs
-   end-to-end with real, non-empty output, report what you built and what the test
-   showed. They watch the canvas live and accept, or ask for changes (which continue
-   on the same bound canvas).
-
-## Troubleshooting
-
-| Symptom | Cause / fix |
-|---|---|
-| Every tool returns "No workflow bound" | Call `bindWorkflow` with the pairing code from Canvas "Connect agent" |
-| Bind fails "invalid or expired pairing code" | Codes are single-use + 10-min TTL — ask the developer to click "Connect agent" again for a fresh one |
-| Tool calls error after working earlier | The platform restarted mid-session — `/mcp` → reconnect |
-| saveWorkflow rejects an edge into an existing node | Provenance guard: that node wasn't built this session — build on a fresh workflow, or recreate the stage yourself |