@unoverse-platform/studio 0.1.105 → 0.1.107

package/README.md

@@ -1,7 +1,7 @@
 # @unoverse-platform/studio
 
-Unoverse Studio: the standalone authoring app. It reads your own `rx/` project folder
-off disk and previews your components, templates, skills and nodes. No database, no
+Unoverse Studio: the standalone authoring app. It reads your org's own Git repo off
+disk and previews your components, templates, skills and nodes. No database, no
 Docker, no backend of its own.
 
 ```bash
@@ -9,18 +9,36 @@ npm install @unoverse-platform/studio
 npx unoverse-studio
 ```
 
-Studio opens on your project folder. Author in your editor, see it in Studio.
+Studio opens on your org repo. Author in your editor, see it in Studio. `unoverse create`
+(choose Studio) makes the org repo: the baseline only, then Studio opens it. A new org is a
+new repo, so Studio refuses New project inside an org repo.
 
 ## What you author
 
+One org, one repo. The org's folders sit at the repo root, and `unoverse.yaml` declares
+`org: <slug>`, so the org's name never comes from the folder name.
+
 ```
-rx/components/   components: definition-backed UI, rendered by the generic SDK
-rx/templates/    templates: whole app surfaces, states and layouts
-rx/styles/       themes and tokens
-prompts/         skills and prompt blocks
+unoverse.yaml    org: <slug>
+styles/          themes and tokens
+identity/        the org's four identity documents
+components/      components: definition-backed UI, rendered by the generic SDK
+templates/       templates: components that hold components
+apps/            whole app surfaces, states and layouts
+atoms/           shared building blocks
+skills/          Agent skills
+blocks/          prompt blocks
 nodes/           declarative YAML node manifests
+agents/          Agents
+objects/         objects
+pipelines/       pipelines
 ```
 
+A new org repo holds the baseline only: `styles/`, `identity/`, `unoverse.yaml` and a
+pull-request check that runs `unoverse lint`. Samples live in the public demo org repo,
+[org-acme](https://github.com/unoverse-platform/org-acme), to read and copy. `design/<org>/`
+is only the platform monorepo's shape.
+
 Everything is data. There is no codegen and no build step for your assets: the
 definition IS the artifact, and the same definition renders on web, in ChatGPT, in
 Claude, and on every other channel a universe serves.
@@ -34,9 +52,11 @@ full client:
   MCP-served app shell (`ui://unoverse/app.html`, the same one ChatGPT loads) and the
   app runs its own connections: chat, streaming, voice. Studio ships no renderer of
   its own; the renderer loads when required, from the universe that owns it.
-- **Publish**: your components, templates, skills and prompts publish into the
-  universe over its API, authorized by a publish key issued on that universe
-  (`unoverse key`). Lint runs first; nothing leaves your machine until the rules pass.
+- **Publish**: every universe pulls the org's repo; nothing is pushed in. Connect the
+  repo on the org page's Source tab, and a push arrives by webhook within seconds, by
+  polling within 5 minutes, or with Sync now. Until your universe runs a release with the Git sync,
+  `unoverse deploy studio` still publishes to your own universe over its API. Lint runs
+  first; nothing leaves your machine until the rules pass.
 
 The universe is somebody's deployment of the Unoverse platform. Yours, your team's, or
 a customer's. Studio never runs one.

package/bin/studio.mjs

@@ -22,8 +22,8 @@ import { fileURLToPath } from "url";
 import { existsSync, readdirSync } from "fs";
 import { createInterface } from "readline/promises";
 import { execSync } from "child_process";
-import { designHome, hasDesignHome } from "../local/design-home.mjs";
-import { createFirstProject, checkProjectName } from "../local/scaffold.mjs";
+import { hasDesignHome, orgRepoName, authoringRoot } from "../local/design-home.mjs";
+import { createOrgRepo, checkProjectName } from "../local/scaffold.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const appRoot = resolve(here, "..");
@@ -43,7 +43,7 @@ const appRoot = resolve(here, "..");
  *  (design/, or the legacy rx/). */
 function findProjectRootFromCwd() {
   for (let dir = process.cwd(); ; ) {
-    if (hasDesignHome(dir)) return dir;
+    if (orgRepoName(dir) || hasDesignHome(dir)) return dir;
     if (hasDesignHome(join(dir, "apps/unoverse"))) return join(dir, "apps/unoverse");
     const parent = resolve(dir, "..");
     if (parent === dir) return process.cwd();
@@ -67,7 +67,7 @@ function findProjectBelowCwd() {
   const cwd = process.cwd();
   const found = readdirSync(cwd, { withFileTypes: true })
     .filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules")
-    .filter((e) => hasDesignHome(join(cwd, e.name)))
+    .filter((e) => orgRepoName(join(cwd, e.name)) || hasDesignHome(join(cwd, e.name)))
     .map((e) => e.name);
 
   if (found.length === 1) return join(cwd, found[0]);
@@ -83,7 +83,7 @@ async function scaffoldIfEmpty() {
   // The same walk findProjectRoot does. A project ABOVE us is a project; do not offer to
   // make a second one inside it.
   for (let dir = cwd; ; ) {
-    if (hasDesignHome(dir) || hasDesignHome(join(dir, "apps/unoverse"))) return;
+    if (orgRepoName(dir) || hasDesignHome(dir) || hasDesignHome(join(dir, "apps/unoverse"))) return;
     const parent = resolve(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -113,7 +113,9 @@ async function scaffoldIfEmpty() {
   const home = cwd;
   // The folder's own name, when it can be a project name. It becomes an item's `org`
   // column, so `checkProjectName` is the same gate the UI's New project uses.
-  const derived = basename(cwd);
+  // `unoverse create` passes the org name it asked for (`--org <name>`); else the folder's.
+  const asked = process.argv.includes("--org") ? process.argv[process.argv.indexOf("--org") + 1] : undefined;
+  const derived = asked ?? basename(cwd);
   let name = checkProjectName(derived) ? null : derived;
 
   if (!name) {
@@ -125,11 +127,11 @@ async function scaffoldIfEmpty() {
     // being named or why one was needed. The name is the folder under rx/ AND the org
     // column on everything that project publishes, which is why the tool cannot pick it.
     console.log(`\n  Setting up Studio here.\n\n  ${cwd}\n`);
-    console.log(`  Your components live in design/<project>/, and that name is the org they`);
-    console.log(`  publish under. This folder is "${derived}", which cannot be one.\n`);
+    console.log(`  This folder becomes one org's own repo, and the org needs a name: it is`);
+    console.log(`  what everything you build is published under. "${derived}" cannot be one.\n`);
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     for (;;) {
-      name = (await rl.question("  Name your Studio project [my-project]: ")).trim() || "my-project";
+      name = (await rl.question("  Name your org [my-org]: ")).trim() || "my-org";
       const bad = checkProjectName(name);
       if (!bad) break;
       console.log(`  ${bad}\n`);
@@ -142,8 +144,11 @@ async function scaffoldIfEmpty() {
   // project (base collect.ts listProjects) and its folder name is the `org` that
   // publishes, so a flat rx/ could hold exactly one project and would read `components`
   // and `apps` as orgs.
-  createFirstProject(home, name);
-  console.log(`\n  Created design/${name}/ in ${cwd}\n`);
+  // ONE ORG, ONE REPO (UNO-88): the folder becomes the org's repo, its folders at the root
+  // and its name declared in unoverse.yaml. Never a design/ tree.
+  const repo = createOrgRepo(home, name);
+  console.log(`\n  Created the org "${name}" in ${cwd}${repo.state === "committed" ? " (a Git repo, first commit made)" : ""}\n`);
+  if (repo.message) console.log(`  ${repo.message}\n`);
 }
 
 await scaffoldIfEmpty();
@@ -172,9 +177,12 @@ process.env.UNOVERSE_HOME = projectRoot;
   // several — picking one here would drop a sample into an arbitrary org. Those
   // samples arrive with `createFirstProject`, which is the only moment a destination
   // is unambiguous; workspace-level samples (nodes) still top up on every launch.
-  try { topUpSamples(projectRoot); } catch { /* a read-only folder must not block launch */ }
+  // An org repo knows its org, so its new samples have somewhere to land.
+  const org = orgRepoName(projectRoot);
+  // An org repo gets no samples (they live in their own repo); the monorepo shape still tops up.
+  try { if (!org) topUpSamples(projectRoot); } catch { /* a read-only folder must not block launch */ }
 }
-console.log(`\n  Studio reading: ${designHome(projectRoot)}\n`);
+console.log(`\n  Studio reading: ${authoringRoot(projectRoot)}\n`);
 
 /**
  * LAUNCHING STUDIO IS THE DECISION; A STALE STUDIO YIELDS THE PORT.

package/local/authoring.ts

@@ -18,7 +18,7 @@
  *
  * See docs/architecture/authoring/LOCAL_STUDIO.md §Authoring in Studio.
  */
-import { designHome } from "./design-home.mjs";
+import { authoringRoot } from "./design-home.mjs";
 import { resolve } from "path";
 import { existsSync, readdirSync } from "fs";
 
@@ -89,7 +89,7 @@ export function vocabulary(
 
 /** Atom names off disk, for completion of `Ref.ref`. */
 export function atomNames(projectRoot: string): { name: string }[] {
-  const dirs = [resolve(designHome(projectRoot), "marketplace/atoms"), resolve(designHome(projectRoot), "atoms")];
+  const dirs = [resolve(authoringRoot(projectRoot), "marketplace/atoms"), resolve(authoringRoot(projectRoot), "atoms")];
   const names = new Set<string>();
   for (const d of dirs) {
     if (!existsSync(d)) continue;

package/local/catalog.ts

@@ -10,7 +10,7 @@
  *
  * See docs/architecture/authoring/LOCAL_STUDIO.md.
  */
-import { hasDesignHome } from "./design-home.mjs";
+import { hasDesignHome, orgRepoName } from "./design-home.mjs";
 import { resolve } from "path";
 import { existsSync } from "fs";
 
@@ -45,6 +45,8 @@ type Loaders = {
 export function findProjectRoot(from: string = process.cwd()): string {
   let dir = resolve(from);
   for (;;) {
+    // An org's own repo (UNO-88): unoverse.yaml declares the org; its folders sit at the root.
+    if (orgRepoName(dir)) return dir;
     // A developer's project (starter kit): rx/ sits at the root.
     if (hasDesignHome(dir)) return dir;
     // This monorepo, where Studio's author works: rx/ lives under apps/unoverse. Same
@@ -93,7 +95,13 @@ export async function loadCatalog(
    * first and every later import sees the developer's home.
    */
   const paths = await load(resolve(baseSrc, "paths.ts"));
-  (paths.setPaths as (n: { home: string }) => void)({ home: projectRoot });
+  // An org repo is ONE org, declared: base's projectDir(org) is the repo root and listOrgs()
+  // is that org alone (base definitions/registry/homes.ts).
+  const org = orgRepoName(projectRoot);
+  (paths.setPaths as (n: { home: string; orgRepo?: { org: string; dir: string } }) => void)({
+    home: projectRoot,
+    ...(org ? { orgRepo: { org, dir: projectRoot } } : {}),
+  });
 
   const defs = await load(resolve(baseSrc, "definitions/definitions.ts"));
   const theme = await load(resolve(baseSrc, "definitions/theme.ts"));

package/local/design-home.d.mts

@@ -1,2 +1,9 @@
 export function designHome(root: string): string;
 export function hasDesignHome(root: string): boolean;
+
+/** The org an org repo declares in its unoverse.yaml, or null when this is not an org repo (UNO-88). */
+export function orgRepoName(root: string): string | null;
+/** The folder Studio authors in and watches: the repo itself for an org repo, else design/. */
+export function authoringRoot(root: string): string;
+/** Lint options for this root: an org repo adds `org: { name, dir }`. */
+export function lintOptions<T extends object>(root: string, extra?: T): T & { org?: { name: string; dir: string } };

package/local/design-home.mjs

@@ -5,7 +5,7 @@
 // canonical rule lives in @unoverse-platform/base `paths.ts` (`designDir`); this copy
 // exists because the plain-node entrypoints (bin/studio.mjs, scaffold.mjs) cannot
 // import base's TypeScript source. Keep the two in step.
-import { existsSync, renameSync } from "node:fs";
+import { existsSync, renameSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 export function designHome(root) {
@@ -29,3 +29,26 @@ export function designHome(root) {
 export function hasDesignHome(root) {
   return existsSync(join(root, "design")) || existsSync(join(root, "rx"));
 }
+
+/**
+ * AN ORG REPO (UNO-88): `unoverse.yaml` declares `org: <slug>` and the org's folders sit at
+ * the root, with no design/. The name is declared, never read off the folder. Mirrors base
+ * items/collect.ts readOrgName (this file cannot import base's TypeScript). Keep in step.
+ */
+export function orgRepoName(root) {
+  const path = join(root, "unoverse.yaml");
+  if (!existsSync(path)) return null;
+  const m = /^org:\s*["']?([a-z][a-z0-9-]{0,63})["']?\s*(?:#.*)?$/m.exec(readFileSync(path, "utf8"));
+  return m ? m[1] : null;
+}
+
+/** The folder Studio authors in and watches: the repo itself for an org repo, else design/. */
+export function authoringRoot(root) {
+  return orgRepoName(root) ? root : designHome(root);
+}
+
+/** Lint options for this root: an org repo names its org and folder (base lint options.org). */
+export function lintOptions(root, extra = {}) {
+  const org = orgRepoName(root);
+  return org ? { ...extra, org: { name: org, dir: root } } : extra;
+}

package/local/plugin.ts

@@ -15,7 +15,7 @@
  *
  * See docs/architecture/authoring/LOCAL_STUDIO.md.
  */
-import { designHome } from "./design-home.mjs";
+import { designHome, authoringRoot, orgRepoName, lintOptions } from "./design-home.mjs";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { resolve, dirname } from "path";
@@ -53,7 +53,7 @@ function definitionHome(
     return null;
   }
   if (/\/atoms\//.test(uri)) {
-    const flat = resolve(designHome(projectRoot), "atoms", `${ref.toLowerCase()}.json`);
+    const flat = resolve(authoringRoot(projectRoot), "atoms", `${ref.toLowerCase()}.json`);
     return existsSync(flat) ? flat : null;
   }
   // Templates (unoverse://templates/): two tiers, folder form, like components.
@@ -62,14 +62,14 @@ function definitionHome(
     const [org, name] = i === -1 ? [null, ref] : [ref.slice(0, i), ref.slice(i + 1)];
     const homes = org
       ? [resolve(c.projectDir(org), "templates", name.toLowerCase())]
-      : [resolve(designHome(projectRoot), "marketplace/templates", ref.toLowerCase())];
+      : [resolve(authoringRoot(projectRoot), "marketplace/templates", ref.toLowerCase())];
     for (const dir of homes) if (existsSync(dir)) return dir;
     return null;
   }
   const folder = c.componentFolder(ref);
   if (folder) return folder;
   // A flat, folderless component: `rx/components/<name>.json` in either tier.
-  for (const dir of [resolve(designHome(projectRoot), "marketplace/components"), resolve(designHome(projectRoot), "components")]) {
+  for (const dir of [resolve(authoringRoot(projectRoot), "marketplace/components"), resolve(authoringRoot(projectRoot), "components")]) {
     const flat = resolve(dir, `${ref.toLowerCase()}.json`);
     if (existsSync(flat)) return flat;
   }
@@ -178,10 +178,12 @@ function readMarkdownLibrary(dir: string): MarkdownEntry[] {
  * another org's, the rule RX_ORG_MODEL.md settled for a project's assets.
  */
 function readLibrary(projectRoot: string, folder: "skills" | "blocks", orgs: string[], org?: string): MarkdownEntry[] {
-  const out = readMarkdownLibrary(resolve(designHome(projectRoot), "marketplace", folder));
+  const out = readMarkdownLibrary(resolve(authoringRoot(projectRoot), "marketplace", folder));
   for (const o of orgs) {
     if (org && org !== "all" && o !== org) continue;
-    for (const e of readMarkdownLibrary(resolve(designHome(projectRoot), o, folder))) {
+    // The org's own folder: the repo root in an org repo (UNO-88), else design/<org>/.
+    const orgHome = orgRepoName(projectRoot) ? projectRoot : resolve(designHome(projectRoot), o);
+    for (const e of readMarkdownLibrary(resolve(orgHome, folder))) {
       // A SKILL's lookup name carries its org, because that is the name every reader
       // addresses it by and two orgs may hold one bare name. A BLOCK's does not: the
       // server tags a block with its org and leaves the name alone, and the shape here
@@ -227,11 +229,15 @@ export function localStudioHost(): Plugin {
        * is what kept Studio from being publishable at all.
        */
       const vendored = resolve(dirname(fileURLToPath(import.meta.url)), "../vendor/base/src");
+      // AN INSTALLED STUDIO USES ONLY ITS OWN COPY. Node can still find a base on npm, an
+      // old one the marketplace package depends on (0.3.67, deprecated), and preferring it
+      // crashed 0.1.106 on a file that copy predates (orgDocuments.ts, 2026-10-03). Only
+      // the monorepo, where Studio is not under node_modules, resolves the live package.
+      const installed = fileURLToPath(import.meta.url).includes("/node_modules/");
       try {
-        baseSrc = resolve(
-          createRequire(import.meta.url).resolve("@unoverse-platform/base/package.json"),
-          "../src",
-        );
+        baseSrc = installed
+          ? vendored
+          : resolve(createRequire(import.meta.url).resolve("@unoverse-platform/base/package.json"), "../src");
       } catch {
         baseSrc = vendored;
       }
@@ -249,7 +255,7 @@ export function localStudioHost(): Plugin {
       };
       const nodes = () => (nodesOnce ??= nodesDirs().then((dirs) => loadLocalNodes(baseSrc, ssr, dirs)));
 
-      server.config.logger.info(`\n  Studio reading: ${designHome(projectRoot)}\n`);
+      server.config.logger.info(`\n  Studio reading: ${authoringRoot(projectRoot)}\n`);
 
       /**
        * WATCH THE PROJECT EXPLICITLY. Vite watches its own root, which is this package,
@@ -262,7 +268,7 @@ export function localStudioHost(): Plugin {
        *
        * Adding the paths puts them in the same watcher, so the existing hook fires.
        */
-      for (const dir of [designHome(projectRoot)]) {
+      for (const dir of [authoringRoot(projectRoot)]) {
         const full = resolve(projectRoot, dir);
         if (existsSync(full)) server.watcher.add(full);
       }
@@ -296,7 +302,7 @@ export function localStudioHost(): Plugin {
             case path === "/local/info":
               return json(res, {
                 projectRoot,
-                rx: designHome(projectRoot),
+                rx: authoringRoot(projectRoot),
                 nodes: await nodesDirs(),
                 envFiles: [resolve(projectRoot, "..", ".env"), resolve(projectRoot, ".env")],
               });
@@ -358,7 +364,9 @@ export function localStudioHost(): Plugin {
             }
 
             case path === "/dev/orgs":
-              return json(res, { orgs: c.themeOrgs() });
+              // `orgRepo` names the org when this folder is one org's repo (UNO-88): the picker
+              // then offers no second project, since a new org is a new repo.
+              return json(res, { orgs: c.themeOrgs(), orgRepo: orgRepoName(projectRoot) ?? null });
 
             /**
              * NEW PROJECT. The only thing Studio writes to disk that is not a definition.
@@ -373,6 +381,11 @@ export function localStudioHost(): Plugin {
              * project five are identical.
              */
             case path === "/dev/projects" && req.method === "POST": {
+              // ONE ORG, ONE REPO (UNO-88): a new org is a new repo, made with `unoverse create`
+              // in its own folder, never a second org inside this one.
+              if (orgRepoName(projectRoot)) {
+                return json(res, { error: "This repo is one org. A new org is a new repo: run `unoverse create` in a new folder." }, 400);
+              }
               const { createProject } = await import("./scaffold.mjs");
               const name = String((await body()).name ?? "");
               try {
@@ -482,9 +495,9 @@ export function localStudioHost(): Plugin {
               const p = String(b.path ?? "");
               if (!p || typeof b.text !== "string") return json(res, { error: "path and text are required" }, 400);
 
-              type LintModule = { lintDefinitions(designRoot: string): { problems: { level?: string; file?: string }[] } };
-              type ObjectsLintModule = { lintObjects(designRoot: string): { problems: { level?: string; file?: string }[] } };
-              type PromptsLintModule = { lintPrompts(designRoot: string): { problems: { level?: string; file?: string }[] } };
+              type LintModule = { lintDefinitions(designRoot: string, options?: Record<string, unknown>): { problems: { level?: string; file?: string }[] } };
+              type ObjectsLintModule = { lintObjects(designRoot: string, options?: Record<string, unknown>): { problems: { level?: string; file?: string }[] } };
+              type PromptsLintModule = { lintPrompts(designRoot: string, options?: Record<string, unknown>): { problems: { level?: string; file?: string }[] } };
               const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
               // OBJECTS AND PIPELINES TOO (objects README 9a, 2026-09-10): the same third linter
               // the publish gate runs, so a save here meets the sentence publish would print.
@@ -499,7 +512,7 @@ export function localStudioHost(): Plugin {
                 b.text as string,
                 writableRoots(projectRoot, c),
                 projectRoot,
-                (designRoot) => ({ problems: [...lintMod.lintDefinitions(designRoot).problems, ...objectsMod.lintObjects(designRoot).problems, ...promptsMod.lintPrompts(designRoot).problems] }),
+                (designRoot) => ({ problems: [...lintMod.lintDefinitions(designRoot, lintOptions(projectRoot)).problems, ...objectsMod.lintObjects(designRoot, lintOptions(projectRoot)).problems, ...promptsMod.lintPrompts(designRoot, lintOptions(projectRoot)).problems] }),
               );
               return json(res, result, result.saved ? 200 : result.error === "lint errors" ? 422 : 403);
             }
@@ -520,17 +533,19 @@ export function localStudioHost(): Plugin {
               type LintModule = {
                 lintDefinitions(
                   designRoot: string,
-                  options?: { overlay?: Record<string, string> },
+                  options?: { overlay?: Record<string, string>; org?: { name: string; dir: string } },
                 ): { problems: { level?: string; file?: string; line?: number; msg?: string }[] };
               };
-              type ObjectsLintModule = { lintObjects(designRoot: string, options?: { overlay?: Record<string, string> }): { problems: { level?: string; file?: string; line?: number; msg?: string }[] } };
-              type PromptsLintModule = { lintPrompts(designRoot: string, options?: { overlay?: Record<string, string> }): { problems: { level?: string; file?: string; line?: number; msg?: string }[] } };
+              type ObjectsLintModule = { lintObjects(designRoot: string, options?: { overlay?: Record<string, string>; org?: { name: string; dir: string } }): { problems: { level?: string; file?: string; line?: number; msg?: string }[] } };
+              type PromptsLintModule = { lintPrompts(designRoot: string, options?: { overlay?: Record<string, string>; org?: { name: string; dir: string } }): { problems: { level?: string; file?: string; line?: number; msg?: string }[] } };
               const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
               const objectsMod = (await ssr(`${baseSrc}/lint/objects/index.mjs`)) as unknown as ObjectsLintModule;
               const promptsMod = (await ssr(`${baseSrc}/lint/prompts/index.mjs`)) as unknown as PromptsLintModule;
               const abs = resolve(p);
               const overlay = { [abs]: b.text as string };
-              const problems = [...lintMod.lintDefinitions(designHome(projectRoot), { overlay }).problems, ...objectsMod.lintObjects(designHome(projectRoot), { overlay }).problems, ...promptsMod.lintPrompts(designHome(projectRoot), { overlay }).problems];
+              const root = authoringRoot(projectRoot);
+              const opts = lintOptions(projectRoot, { overlay });
+              const problems = [...lintMod.lintDefinitions(root, opts).problems, ...objectsMod.lintObjects(root, opts).problems, ...promptsMod.lintPrompts(root, opts).problems];
               return json(res, {
                 findings: problems.filter((f) => f.file && resolve(f.file) === abs),
                 elsewhere: problems.filter((f) => !f.file || resolve(f.file) !== abs).length,
@@ -590,11 +605,11 @@ export function localStudioHost(): Plugin {
               if (req.method === "POST") return json(res, { ok: true });
               return json(res, { entries: [] });
 
-            // ---- The developer's OWN nodes (design/<project>/nodes/). No marketplace. ----
+            // ---- The developer's OWN nodes (the org's nodes/). No marketplace. ----
 
             case path === "/nodes": {
               const n = await nodes();
-              if (!n) return json(res, { nodes: [], credentialTypes: [], reason: "no design/<project>/nodes/ folder in this workspace" });
+              if (!n) return json(res, { nodes: [], credentialTypes: [], reason: "no nodes/ folder in this org" });
               return json(res, { nodes: n.list(), credentialTypes: n.credentialTypes() });
             }
 
@@ -659,7 +674,7 @@ export function localStudioHost(): Plugin {
      * else, which means the developer's other editor, still reloads.
      */
     handleHotUpdate({ server, file }) {
-      const watched = [designHome(projectRoot)];
+      const watched = [authoringRoot(projectRoot)];
       if (!watched.some((w) => file.startsWith(w))) return;
       const self = recentSelfWrites.get(resolve(file));
       if (self !== undefined && Date.now() - self < SELF_WRITE_WINDOW_MS) return [];
@@ -669,10 +684,10 @@ export function localStudioHost(): Plugin {
 
     configResolved() {
       // Surface a clear failure at startup rather than an empty catalog later.
-      if (projectRoot && !existsSync(designHome(projectRoot))) {
+      if (projectRoot && !existsSync(authoringRoot(projectRoot))) {
         throw new Error(`No rx/ folder at ${projectRoot}`);
       }
-      if (projectRoot) statSync(designHome(projectRoot));
+      if (projectRoot) statSync(authoringRoot(projectRoot));
     },
   };
 }

package/local/sample-app/chat/components/chat-region.yaml

@@ -3,8 +3,7 @@
 # chips and the composer. The switching rides the projected conversation facts inside
 # the component; nothing is wired here. Shared by core and core-focus.
 #
-# A BARE ref resolves your own project's component: a ref inside a project's tree
-# matches that project first. Qualify it (`<project>/text-chat`) only if you ship two
-# projects that both carry the name.
+# QUALIFIED with the org: many orgs ship a text-chat, and a bare ref to a name two orgs
+# hold is an error. Studio writes the new org's name here when it copies this app.
 type: Ref
 ref: text-chat

package/local/scaffold.d.mts

@@ -9,8 +9,14 @@ export function checkProjectName(name: string): string | null;
 /** Create design/<name>/ under `home`. Returns the created path. Throws if unusable. */
 export function createProject(home: string, name: string): string;
 
-/** The first project, plus the editor settings and the CI template. Returns the project path. */
+/** The first project, plus the editor settings, the pull-request check, and a Git repo with a first commit. Returns the project path. */
 export function createFirstProject(home: string, name: string): string;
 
-/** Write .github/workflows/unoverse.yml for `project`, once. Never replaces an existing file. */
-export function writeCiWorkflow(home: string, project: string): void;
+/** Make `dir` one org's own repo (UNO-88): folders at the root, unoverse.yaml declaring the org, samples, editor globs, the check, Git. */
+export function createOrgRepo(dir: string, org: string): { state: "committed" | "no-identity" | "inside-repo" | "no-git"; message?: string };
+
+/** Make `home` a Git repo on main with a first commit, unless it already is one; never an author it was not given. */
+export function startRepo(home: string, project: string): { state: "committed" | "no-identity" | "inside-repo" | "no-git"; message?: string };
+
+/** Write .github/workflows/unoverse.yml for `project`, once: the pull-request check. Never replaces an existing file. */
+export function writeCiWorkflow(home: string, project: string | null): void;