unoverse 0.1.212 → 0.1.214

package/bin/unoverse.mjs

@@ -261,7 +261,7 @@ switch (cmd) {
       // No URL typed: the workspace's committed target is the obvious answer.
       const { findWorkspace, readConfig } = await import("../lib/workspace.mjs");
       const ws = findWorkspace();
-      if (ws?.kind === "assets") target = (await readConfig(ws.root)).universe;
+      if (ws?.kind === "assets" || ws?.kind === "org") target = (await readConfig(ws.root)).universe;
     }
     if (!target) {
       console.error(`\n  Which universe? unoverse login <url>\n  ${dim("(or run it from a workspace whose unoverse.yaml names one)")}\n`);
@@ -284,8 +284,8 @@ switch (cmd) {
     if (args[0] === "studio") {
       const { findWorkspace } = await import("../lib/workspace.mjs");
       const ws = findWorkspace();
-      if (ws?.kind !== "assets") {
-        console.log(`\n  deploy studio ships a design workspace, and there is none above ${process.cwd()}.\n  Start one with: unoverse create\n`);
+      if (ws?.kind !== "assets" && ws?.kind !== "org") {
+        console.log(`\n  deploy studio ships an org repo or design workspace, and there is none above ${process.cwd()}.\n  Start one with: unoverse create\n`);
         process.exit(1);
       }
       const { publish } = await import("../lib/publish.mjs");

package/lib/create/index.mjs

@@ -25,9 +25,25 @@ export async function create(nameArg) {
   try {
 
     if (choice === "1") {
-      console.log(`\n  ${dim("Launching Unoverse Studio. It creates and manages your projects.")}\n`);
+      // ONE ORG, ONE REPO (UNO-88). This folder becomes the org's own repo: its folders at
+      // the root, its name declared in unoverse.yaml, Git with a first commit. Studio makes
+      // it on first launch from the name asked here, then opens it.
+      const here = process.cwd();
+      const suggested = (nameArg || here.split(/[\\/]/).pop() || "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^[^a-z]+|-+$/g, "") || "my-org";
+      let org = "";
+      for (;;) {
+        org = (await ask(rl, `Org name ${dim(`[${suggested}]`)}: `)) || suggested;
+        if (/^[a-z][a-z0-9-]{0,63}$/.test(org)) break;
+        console.log(`  ${dim("Lowercase letters, digits and hyphens, starting with a letter.")}`);
+      }
       rl.close();
-      const r = spawnSync("npx", ["-y", "@unoverse-platform/studio@latest"], { stdio: "inherit" });
+      console.log(`\n  ${dim(`Making ${here} the org "${org}", then opening Studio.`)}\n`);
+      // In the platform monorepo, this repo's own Studio (so unreleased work can be tried);
+      // everywhere else, the published one.
+      const local = resolve(dirname(fileURLToPath(import.meta.url)), "../../../studio/bin/studio.mjs");
+      const r = existsSync(local)
+        ? spawnSync(process.execPath, [local, "--org", org], { stdio: "inherit" })
+        : spawnSync("npx", ["-y", "@unoverse-platform/studio@latest", "--org", org], { stdio: "inherit" });
       process.exit(r.status ?? 0);
     }
 

package/lib/lint.mjs

@@ -39,6 +39,17 @@ export async function lintProject({ lintForPublish, designRoot, project }) {
 export async function lint(args, importBase) {
   const positional = args.find((a) => !a.startsWith("--"));
   const ws = findWorkspace();
+  // AN ORG REPO (UNO-88): one org, declared; lint it whole with its declared name.
+  if (ws?.kind === "org") {
+    if (positional && positional !== ws.org) {
+      console.error(`\n  ${c.red}✗${c.off} this repo is the org "${ws.org}", not "${positional}"\n`);
+      process.exit(1);
+    }
+    const { lintOrg } = await importBase("items/publish.js");
+    console.log(`\n  ${c.bold}lint ${ws.org}${c.off}\n`);
+    const { errors } = await lintProject({ lintForPublish: () => lintOrg({ org: ws.org, dir: ws.root }), designRoot: ws.root, project: ws.org });
+    process.exit(errors.length ? 1 : 0);
+  }
   if (ws?.kind !== "assets") {
     console.error(`\n  ${c.red}✗${c.off} no design/ folder here or above. Run this inside your workspace.\n`);
     process.exit(1);

package/lib/login.mjs

@@ -174,7 +174,7 @@ export async function login(universeInput, { log = console.log } = {}) {
   if (!config.authEnabled) {
     throw new Error(
       `${origin} has authentication switched off, so there is no account to sign in with.\n` +
-        `  To deploy there, set UNOVERSE_TOKEN to a deploy key minted on the universe itself.`,
+        `  To deploy there, set UNOVERSE_TOKEN to a publish key minted on the universe itself.`,
     );
   }
   if (!config.issuer) throw new Error(`${origin} has no identity provider configured.`);
@@ -257,13 +257,13 @@ export async function tokenFor(origin, { interactive = true, log = console.log }
   } else if (!config.authEnabled) {
     throw new Error(
       `${origin} has authentication switched off.\n` +
-        `  To deploy there, set UNOVERSE_TOKEN to a deploy key minted on the universe itself.`,
+        `  To deploy there, set UNOVERSE_TOKEN to a publish key minted on the universe itself.`,
     );
   }
 
   if (!interactive || !process.stdin.isTTY) {
     throw new Error(
-      `No credential for ${origin}. In CI, set UNOVERSE_TOKEN to a deploy key.\n` +
+      `No credential for ${origin}. In CI, set UNOVERSE_TOKEN to a publish key.\n` +
         `  At a terminal, run: unoverse login ${origin}`,
     );
   }

package/lib/publish.mjs

@@ -1,5 +1,5 @@
 /**
- * unoverse publish — ship an asset workspace's items to its universe.
+ * unoverse deploy studio: ship an asset workspace's items to its universe.
  *
  * The terminal face of @unoverse-platform/base items/publish. The order is the safety:
  * LINT, then COMPARE (a dry-run per item against the universe), then a plan and a
@@ -49,7 +49,7 @@ const ask = async (question) => {
 };
 
 /**
- * `unoverse publish [project] [--to <universe>] [--dry-run] [--yes]`
+ * `unoverse deploy studio [project] [--to <universe> | --env <name>] [--dry-run] [--yes]`
  * Run from anywhere inside an asset workspace. bin/unoverse.mjs routes here only when
  * the nearest marker up from cwd is a design home.
  */
@@ -59,32 +59,58 @@ export async function publish(args) {
     const i = args.indexOf(`--${name}`);
     return i >= 0 ? args[i + 1] : undefined;
   };
-  const positional = args.find((a) => !a.startsWith("--") && a !== opt("to"));
+  // An option's value is never the project: `--env uat` must not read "uat" as one.
+  const optionValues = new Set(["to", "env"].map(opt).filter(Boolean));
+  const positional = args.find((a) => !a.startsWith("--") && !optionValues.has(a));
 
   const ws = findWorkspace();
-  if (ws?.kind !== "assets") die("no design/ folder here or above. Run this inside your workspace.");
-  const designRoot = designHome(ws.root);
+  if (ws?.kind !== "assets" && ws?.kind !== "org") die("no org repo or design/ folder here or above. Run this inside your workspace.");
 
-  const { collectProject, listProjects } = await importBase("items/collect.js");
-  const { lintForPublish, planPublish, sendPublish } = await importBase("items/publish.js");
+  const { collectProject, listProjects, collectOrg } = await importBase("items/collect.js");
+  const { lintForPublish, planPublish, sendPublish, lintOrg } = await importBase("items/publish.js");
 
   // ── which project ───────────────────────────────────────────────────────────
-  const projects = listProjects(designRoot);
-  if (!projects.length) die(`nothing to publish: ${designRoot} holds no projects`);
+  // An org repo (UNO-88) IS one org, declared in its unoverse.yaml; the monorepo shape
+  // (design/<project>/) may hold several and asks which.
   let project = positional;
-  if (!project) {
-    if (projects.length > 1) {
-      die(`several projects here. Say which:\n\n    unoverse deploy studio <project>\n\n  Found: ${projects.join(", ")}`);
+  let designRoot;
+  let collect;
+  let lintFor = lintForPublish;
+  if (ws.kind === "org") {
+    if (project && project !== ws.org) die(`this repo is the org "${ws.org}", not "${project}"`);
+    project = ws.org;
+    designRoot = ws.root;
+    collect = () => collectOrg({ org: ws.org, dir: ws.root });
+    lintFor = () => lintOrg({ org: ws.org, dir: ws.root });
+  } else {
+    designRoot = designHome(ws.root);
+    const projects = listProjects(designRoot);
+    if (!projects.length) die(`nothing to publish: ${designRoot} holds no projects`);
+    if (!project) {
+      if (projects.length > 1) {
+        die(`several projects here. Say which:\n\n    unoverse deploy studio <project>\n\n  Found: ${projects.join(", ")}`);
+      }
+      project = projects[0];
+    } else if (!projects.includes(project)) {
+      die(`no project "${project}" in ${designRoot}. Found: ${projects.join(", ") || "none"}`);
     }
-    project = projects[0];
-  } else if (!projects.includes(project)) {
-    die(`no project "${project}" in ${designRoot}. Found: ${projects.join(", ") || "none"}`);
+    collect = () => collectProject(designRoot, project);
   }
 
-  // ── which universe: --to overrides, unoverse.yaml remembers, the login answers,
-  //    and only a machine that knows nothing asks ─────────────────────────────
+  // ── which universe: --to overrides, --env names one from unoverse.yaml's
+  //    `environments:`, `universe:` is the default, the login answers, and only a
+  //    machine that knows nothing asks ─────────────────────────────────────────
   const config = await readConfig(ws.root);
-  let universe = opt("to") ?? config.universe;
+  const envName = opt("env");
+  let envUniverse;
+  if (envName && !opt("to")) {
+    envUniverse = config.environments?.[envName];
+    if (!envUniverse) {
+      const known = Object.keys(config.environments ?? {});
+      die(`no environment "${envName}" in unoverse.yaml. ${known.length ? `Found: ${known.join(", ")}` : "Add one:\n\n    environments:\n      " + envName + ": https://your-universe.example"}`);
+    }
+  }
+  let universe = opt("to") ?? envUniverse ?? config.universe;
   if (!universe) {
     // THE LOGIN ALREADY NAMED THE UNIVERSE. `unoverse login` takes an address and
     // keeps a session for it, so a machine signed in to exactly one universe has
@@ -115,14 +141,14 @@ export async function publish(args) {
   // ── 1. lint. Nothing is sent if this fails ──────────────────────────────────
   console.log(`\n  ${c.bold}deploy ${project}${c.off} ${c.dim}→ ${universe}${c.off}\n`);
   const { lintProject } = await import("./lint.mjs");
-  const { errors } = await lintProject({ lintForPublish, designRoot, project });
+  const { errors } = await lintProject({ lintForPublish: lintFor, designRoot, project });
   if (errors.length) {
     console.error(`  ${c.red}Nothing was sent.${c.off}\n`);
     process.exit(1);
   }
 
   // ── 2. the credential, only now that there is something worth sending ───────
-  const items = collectProject(designRoot, project);
+  const items = collect();
   if (!items.length) die(`nothing to publish in ${project}`);
   let token;
   try {

package/lib/ui.mjs

@@ -22,7 +22,7 @@ export async function ask(rl, q) {
 }
 
 export const OPTIONS = [
-  ["Studio", "Components, agents and workflows", "Most people start here"],
+  ["Studio", "Components, apps, agents and nodes", "Most people start here"],
   ["Universe", "Run the platform yourself, on your own infrastructure"],
   ["Client", "A client accelerator that talks to unoverse"],
 ];

package/lib/workspace.mjs

@@ -6,10 +6,11 @@
  * reason studio keeps one: this package is plain node and cannot import base's TypeScript.
  * Keep the three in step.
  *
- * `unoverse.yaml` at the workspace root is the COMMITTED project config — today one key,
- * `universe:`, the publish target. It is config, not a secret: the whole team and CI
- * publish to the same place, which is exactly why it belongs in the repo. Credentials
- * never live here (they are per machine, in ~/.unoverse — see session.mjs).
+ * `unoverse.yaml` at the workspace root is the COMMITTED project config: `universe:`, the
+ * default deploy target, and `environments:`, named targets (`uat`, `production`) that CI
+ * picks with `--env`. It is config, not a secret: the whole team and CI deploy to the same
+ * places, which is exactly why it belongs in the repo. Credentials never live here (they
+ * are per machine in ~/.unoverse, see session.mjs, or a CI secret in UNOVERSE_TOKEN).
  */
 import { existsSync, renameSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
@@ -33,7 +34,8 @@ export function designHome(root) {
 }
 
 /**
- * Walk up from `from` for the nearest marker. The NEAREST one decides what `publish`
+ * Walk up from `from` for the nearest marker. An org repo (`unoverse.yaml` with `org:`) wins
+ * at its own level, then a design home, then a universe. The NEAREST one decides what `publish`
  * means (LOCAL_STUDIO.md §Publish is terminal-only: one verb, the folder decides):
  * a design home → this is an asset workspace, publish means item rows; a
  * docker-compose.yml first → this is a universe, publish stays the operator's.
@@ -43,6 +45,8 @@ export function designHome(root) {
  */
 export function findWorkspace(from = process.cwd()) {
   for (let dir = resolve(from); ; ) {
+    const org = readOrgName(dir);
+    if (org) return { kind: "org", root: dir, org };
     if (hasDesignHome(dir)) return { kind: "assets", root: dir };
     if (existsSync(join(dir, "docker-compose.yml"))) return { kind: "universe", root: dir };
     const parent = resolve(dir, "..");
@@ -53,6 +57,18 @@ export function findWorkspace(from = process.cwd()) {
 
 const CONFIG_FILE = "unoverse.yaml";
 
+/**
+ * AN ORG REPO (UNO-88): its `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; sync, because the marker walk above is.
+ */
+export function readOrgName(root) {
+  const path = join(root, CONFIG_FILE);
+  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;
+}
+
 /** Read unoverse.yaml. Absent file is `{}`, not an error — first publish writes it. */
 export async function readConfig(root) {
   const path = join(root, CONFIG_FILE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.212",
+  "version": "0.1.214",
   "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/vendor/base/items/collect.js

@@ -18,7 +18,7 @@
  * performs correctly, and a half-published project is worse than either extreme.
  */
 import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
-import { join, relative, basename } from "node:path";
+import { join, relative, basename, dirname, extname } from "node:path";
 import { fingerprintOf } from "./fingerprint.js";
 import { parse as parseYaml } from "yaml";
 import { readDiskPackages } from "../manifests/source.js";
@@ -40,6 +40,34 @@ function designSystemDir(designRoot) {
         return bundled;
     return onDisk; // nothing found: the version will hash to an empty set, which is honest
 }
+const ORG_SLUG = /^[a-z][a-z0-9-]{0,63}$/;
+/** The org a folder declares in its `unoverse.yaml`, or null when it is not an org repo. */
+export function readOrgName(dir) {
+    const file = join(dir, "unoverse.yaml");
+    if (!existsSync(file))
+        return null;
+    try {
+        const doc = parseYaml(readFileSync(file, "utf8"));
+        const org = typeof doc?.org === "string" ? doc.org.trim() : "";
+        return ORG_SLUG.test(org) ? org : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** This folder as an org repo, or null. */
+export function orgRepo(dir) {
+    const org = readOrgName(dir);
+    return org ? { org, dir } : null;
+}
+/** An org repo's design system: only ever the bundle installed inside that repo. */
+function orgDesignSystemDir(dir) {
+    return join(dir, "plugins", "node_modules", "@unoverse-platform", "marketplace", "definitions");
+}
+/** Collect an org repo into items: the same walk as a monorepo project, rooted at the repo. */
+export function collectOrg(home) {
+    return collectFrom(home.dir, home.org, orgDesignSystemDir(home.dir));
+}
 /** Every project a developer could publish, by name. */
 export function listProjects(designRoot) {
     if (!existsSync(designRoot))
@@ -49,6 +77,46 @@ export function listProjects(designRoot) {
         .filter((e) => statSync(join(designRoot, e)).isDirectory())
         .sort();
 }
+/**
+ * AN ORG'S IMAGES TRAVEL INSIDE ITS DEFINITIONS. On disk the loader turns `src: assets/x.png`
+ * into the file's data URI (definitions/load/assets.ts); a universe holds the definition and
+ * never the org's folder, so a deploy that sent the bare path shipped a broken image. The same
+ * lookup, done here before sending: the file's folder upward to its org (the one holding
+ * `styles/`), then the shared design system's. Same types, same 256 KB cap. Self-contained on
+ * purpose: this file is vendored into the published CLI with only its own imports.
+ */
+const ASSET_TYPES = {
+    ".svg": "image/svg+xml", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif",
+};
+function assetUri(fromDir, src) {
+    const rel = src.slice("assets/".length);
+    const type = ASSET_TYPES[extname(rel).toLowerCase()];
+    if (!type)
+        return null;
+    let file = null;
+    for (let d = fromDir; dirname(d) !== d; d = dirname(d)) {
+        if (existsSync(join(d, "assets", rel))) {
+            file = join(d, "assets", rel);
+            break;
+        }
+        if (existsSync(join(d, "styles"))) {
+            const shared = join(dirname(d), "marketplace", "assets", rel);
+            if (existsSync(shared))
+                file = shared;
+            break;
+        }
+    }
+    return file && statSync(file).size <= 256 * 1024 ? `data:${type};base64,${readFileSync(file).toString("base64")}` : null;
+}
+const readDef = (p) => {
+    const text = readFileSync(p, "utf8");
+    if (!/\.ya?ml$/.test(p))
+        return text;
+    return text.replace(/^(\s*(?:-\s+)?[\w-]+:\s*)(["']?)(assets\/[^\s"'#]+)\2([ \t]*(?:#.*)?)$/gm, (whole, key, _q, src, rest) => {
+        const uri = assetUri(dirname(p), src);
+        return uri ? `${key}"${uri}"${rest}` : whole;
+    });
+};
 /** Every definition file under a folder, relative-pathed, as one object. */
 function filesUnder(dir) {
     const out = {};
@@ -62,7 +130,7 @@ function filesUnder(dir) {
             if (e.isDirectory())
                 walk(p);
             else if (isDef(e.name) || e.name.endsWith(".md"))
-                out[relative(dir, p)] = readFileSync(p, "utf8");
+                out[relative(dir, p)] = readDef(p);
         }
     };
     walk(dir);
@@ -80,10 +148,14 @@ export function collectProject(designRoot, project) {
     const root = join(designRoot, project);
     if (!existsSync(root))
         throw new Error(`No project "${project}" in ${designRoot}`);
+    return collectFrom(root, project, designSystemDir(designRoot));
+}
+/** The walk itself: one org's folder, its name, and the design system it was built on. */
+function collectFrom(root, project, designSystem) {
     // WHAT THIS WAS BUILT ON, stamped on every item. Computed once per collection: it is the
     // same design system for the whole project, and hashing it per item would be wasteful and
     // could disagree with itself mid-run if a file changed.
-    const base_version = designSystemVersion(designSystemDir(designRoot));
+    const base_version = designSystemVersion(designSystem);
     const items = [];
     // A COMPONENT (and, since 2026-08-24, a SKILL) row's name is the qualified ref
     // (`<org>/<name>`): the items table's identity is (kind, name) with no org in the
@@ -146,7 +218,7 @@ export function collectProject(designRoot, project) {
             else if (isDef(e.name)) {
                 // The name is the definition's, without the extension: `card.yaml` is `card`,
                 // addressed the same way whether it later grows into a folder.
-                add(kind, e.name.replace(/\.(ya?ml|json)$/, ""), { files: { [e.name]: readFileSync(join(home, e.name), "utf8") } });
+                add(kind, e.name.replace(/\.(ya?ml|json)$/, ""), { files: { [e.name]: readDef(join(home, e.name)) } });
             }
         }
     }

package/vendor/base/items/publish.js

@@ -75,6 +75,25 @@ export async function lintForPublish(designRoot, project) {
     const mine = result.problems.filter((p) => !p.file || !inDesign(p.file) || inProject(p.file));
     return { problems: mine, errors: mine.filter((p) => p.level === "error") };
 }
+/**
+ * Lint an org repo (UNO-88): the same four linters, told which folder is the org and what it
+ * is called. The repo holds one org, so every finding is that org's; nothing to filter.
+ */
+export async function lintOrg(home) {
+    const org = { name: home.org, dir: home.dir };
+    const { lintDefinitions } = await import("../lint/design/index.mjs");
+    const result = lintDefinitions(home.dir, { org });
+    const nodesHome = join(home.dir, "nodes");
+    if (existsSync(nodesHome)) {
+        const { lintNodes } = await import("../lint/nodes/index.mjs");
+        result.problems.push(...lintNodes(nodesHome).problems);
+    }
+    const { lintObjects } = await import("../lint/objects/index.mjs");
+    result.problems.push(...lintObjects(home.dir, { org }).problems);
+    const { lintPrompts } = await import("../lint/prompts/index.mjs");
+    result.problems.push(...lintPrompts(home.dir, { org }).problems);
+    return { problems: result.problems, errors: result.problems.filter((p) => p.level === "error") };
+}
 /**
  * What publishing WOULD do, without doing it.
  *
@@ -196,7 +215,8 @@ export async function sendPublish(plan, universe, token, fetchImpl = fetch) {
         const res = await fetchImpl(`${universe}/publish`, {
             method: "POST",
             headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-            body: JSON.stringify({ op: "remove", kind: r.kind, name: r.name }),
+            // The org is part of an item's identity (UNO-89): remove THIS org's row, never another's.
+            body: JSON.stringify({ op: "remove", kind: r.kind, name: r.name, org: r.org }),
         });
         const body = (await res.json().catch(() => ({})));
         if (res.ok)

package/vendor/base/lint/design/index.mjs

@@ -75,7 +75,17 @@ export function lintDefinitions(designRoot, options = {}) {
       });
   };
 
-  const DESIGN_ROOT = candidates.find((p) => holdsDesignSystem(p) || holdsOrgs(p));
+  /**
+   * AN ORG'S OWN REPO (RELEASE_LIFECYCLE.md §3, UNO-88). The repo IS the org: its folders sit
+   * at the root and its name is declared (`unoverse.yaml` org:), never read off a folder.
+   * The caller says so with `options.org = { name, dir }`, and then nothing here guesses:
+   * the org list is that one folder, and its name is the one given. Without it a flat repo
+   * would read as the legacy design-system layout (components/ at the root) and lint as
+   * nothing at all.
+   */
+  const ORG_REPO = options.org?.dir ? resolve(options.org.dir) : null;
+  const ORG_NAME = options.org?.name ?? null;
+  const DESIGN_ROOT = ORG_REPO ? dirname(ORG_REPO) : candidates.find((p) => holdsDesignSystem(p) || holdsOrgs(p));
   if (!DESIGN_ROOT)
     return {
       problems: [{ level: "error", file: candidates[0], msg: `no design/ folder here (looked in: ${candidates.join(", ")})` }],
@@ -94,6 +104,12 @@ export function lintDefinitions(designRoot, options = {}) {
   // styles/base/spacing, so a fallback finding only components would build a PARTIAL scale
   // and reject valid steps, reporting false errors on correct work. Mirrors definitions.ts.
   const DS = (() => {
+    // In an org repo the design system is only ever the installed bundle inside that repo:
+    // never a sibling folder, which would be another org's repo.
+    if (ORG_REPO) {
+      const bundled = join(ORG_REPO, "plugins", "node_modules", "@unoverse-platform", "marketplace", "definitions");
+      return existsSync(bundled) ? bundled : join(ORG_REPO, ".unoverse", "no-design-system");
+    }
     const onDisk = join(DESIGN_ROOT, "marketplace");
     if (existsSync(onDisk)) return onDisk;
     for (const c of [
@@ -102,8 +118,15 @@ export function lintDefinitions(designRoot, options = {}) {
       if (existsSync(c)) return c;
     return DESIGN_ROOT; // none anywhere: shared refs will not resolve, and the findings will say so
   })();
+/** Is a design system on disk at all? When not, checks that need it are skipped, not failed. */
+const HAS_DS = DS !== DESIGN_ROOT && existsSync(DS);
+/** The org a home folder belongs to: the declared name in an org repo, else the folder's name. */
+const orgName = (dir) => (ORG_REPO && dir === ORG_REPO ? ORG_NAME : basename(dir));
+/** Every home that can hold node packages, credentials or places: the design system and the orgs. */
+const tierHomes = () => (ORG_REPO ? [DS, ...orgDirs] : readdirSync(DESIGN_ROOT).map((t) => join(DESIGN_ROOT, t)));
 const legacyOrgsDir = join(DESIGN_ROOT, "orgs");
 const orgDirs = (() => {
+  if (ORG_REPO) return [ORG_REPO];
   if (existsSync(legacyOrgsDir))
     return readdirSync(legacyOrgsDir)
       .filter((e) => !e.startsWith("."))
@@ -448,7 +471,7 @@ for (const orgDir of orgDirs) {
       const name = statSync(join(home, e)).isDirectory() ? e : isDefFile(e) ? defName(e) : null;
       if (name) set.add(name.toLowerCase());
     }
-  orgComponentNames.set(basename(orgDir), set);
+  orgComponentNames.set(orgName(orgDir), set);
 }
 // TEMPLATE-LOCAL PARTS are addressed `<template>/<part>` (§9b rule 7) — the same
 // qualified shape as `<org>/<name>`, resolved against the template homes. The runtime
@@ -461,7 +484,7 @@ const orgTemplateNames = new Map(); // org (or DS basename) -> Set(lower block n
 for (const root of [DS, ...orgDirs]) {
   const home = join(root, "templates");
   if (!existsSync(home)) continue;
-  const blocks = orgTemplateNames.get(basename(root)) ?? new Set();
+  const blocks = orgTemplateNames.get(orgName(root)) ?? new Set();
   for (const t of readdirSync(home)) {
     if (isDefFile(t)) {
       blocks.add(defName(t).toLowerCase());
@@ -479,11 +502,11 @@ for (const root of [DS, ...orgDirs]) {
     }
     templatePartNames.set(t.toLowerCase(), set);
   }
-  orgTemplateNames.set(basename(root), blocks);
+  orgTemplateNames.set(orgName(root), blocks);
 }
 const orgOfFile = (file) => {
   const home = orgDirs.find((d) => file.startsWith(d + sep));
-  return home ? basename(home) : null;
+  return home ? orgName(home) : null;
 };
 // A valid Ref target if there's ANY resolvable home the FILE may reach: atoms, DS
 // components, or (from inside an org tree) that org's own components — bare or
@@ -747,7 +770,7 @@ const credentialDefs = new Set();
   // Every tier's node packages: the marketplace's and each org's, all at <tier>/nodes/.
   const nodesHomes = [];
   try {
-    for (const tier of readdirSync(DESIGN_ROOT)) nodesHomes.push(join(DESIGN_ROOT, tier, "nodes"));
+    for (const home of tierHomes()) nodesHomes.push(join(home, "nodes"));
   } catch {
     /* no design root: nothing declares a credential */
   }
@@ -924,6 +947,15 @@ function componentNamesForFile(file) {
   const org = projectSegs.join("/");
   const cached = componentNamesCache.get(org);
   if (cached !== undefined) return cached;
+  // A PARTIAL SET IS WORSE THAN NO SET (the app-sizes trap below, same cause). A developer's
+  // project has no design system on disk, so DS falls back to DESIGN_ROOT and only the org's
+  // own names would be left: every marketplace name a preview uses (`card`) then reads as
+  // unknown, and a fresh Studio workspace failed lint on its own sample. Unverifiable here,
+  // so not asserted.
+  if (!HAS_DS) {
+    componentNamesCache.set(org, null);
+    return null;
+  }
   const dirs = [
     join(DS, "components"),
     join(DESIGN_ROOT, ...projectSegs, "components"),
@@ -955,7 +987,7 @@ function placeNames() {
     if (n.type === "Place" && typeof n.name === "string") names.add(n.name);
     for (const v of Object.values(n)) walk(v);
   };
-  const roots = [DS, ...readdirSync(DESIGN_ROOT).filter((e) => !e.startsWith(".")).map((e) => join(DESIGN_ROOT, e))];
+  const roots = [DS, ...tierHomes().filter((d) => !basename(d).startsWith("."))];
   for (const root of new Set(roots))
     for (const f of jsonFiles(join(root, "apps"))) {
       try {

package/vendor/base/lint/objects/index.mjs

@@ -117,13 +117,19 @@ export function lintObjects(designRoot, options = {}) {
   loadAllSchemas();
 
   // ── the tiers: the marketplace, then every org folder ──
+  // An org's own repo is ONE tier with a DECLARED name (`options.org`, UNO-88): its folder may
+  // be called anything, and the org name is also the dataset table's (`dataset_<org>_<name>`).
   const marketplace = join(ROOT, "marketplace");
   const tiers = [];
-  if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
-  for (const e of readdirSync(ROOT)) {
-    if (e.startsWith(".") || e === "marketplace" || e === "_schema") continue;
-    const d = join(ROOT, e);
-    if (isDir(d)) tiers.push({ org: e, dir: d });
+  if (options.org?.dir) {
+    tiers.push({ org: options.org.name, dir: resolve(options.org.dir) });
+  } else {
+    if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
+    for (const e of readdirSync(ROOT)) {
+      if (e.startsWith(".") || e === "marketplace" || e === "_schema") continue;
+      const d = join(ROOT, e);
+      if (isDir(d)) tiers.push({ org: e, dir: d });
+    }
   }
 
   /**
@@ -233,7 +239,7 @@ export function lintObjects(designRoot, options = {}) {
   let objectCount = 0;
   for (const [, f] of objectIndex) {
     objectCount++;
-    const tier = { org: f.org, dir: f.org ? join(ROOT, f.org) : marketplace };
+    const tier = { org: f.org, dir: tiers.find((t) => t.org === f.org)?.dir ?? marketplace };
     const at = (file) => rel(join(f.dir, file));
     if (f.envelope === null) continue;
     validateAgainst(SCHEMA_ID.object, f.envelope, rel(f.envFile), `object ${f.name}: the envelope`);

package/vendor/base/lint/prompts/index.mjs

@@ -143,10 +143,15 @@ export function lintPrompts(designRoot, options = {}) {
   // ── the tiers: the marketplace, every flat org folder, and the legacy orgs/ container ──
   const tiers = [];
   const marketplace = join(ROOT, "marketplace");
-  if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
   const orgDirs = (base) => readdirSync(base).filter((e) => !e.startsWith(".") && !e.startsWith("_") && e !== "marketplace" && e !== "orgs" && isDir(join(base, e)));
-  for (const e of orgDirs(ROOT)) tiers.push({ org: e, dir: join(ROOT, e) });
-  if (isDir(join(ROOT, "orgs"))) for (const e of orgDirs(join(ROOT, "orgs"))) tiers.push({ org: e, dir: join(ROOT, "orgs", e) });
+  if (options.org?.dir) {
+    // An org's own repo: one tier, its name declared, never read off the folder (UNO-88).
+    tiers.push({ org: options.org.name, dir: resolve(options.org.dir) });
+  } else {
+    if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
+    for (const e of orgDirs(ROOT)) tiers.push({ org: e, dir: join(ROOT, e) });
+    if (isDir(join(ROOT, "orgs"))) for (const e of orgDirs(join(ROOT, "orgs"))) tiers.push({ org: e, dir: join(ROOT, "orgs", e) });
+  }
 
   let skillCount = 0;
   let blockCount = 0;