unoverse 0.1.213 → 0.1.215

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/publish.mjs

@@ -64,23 +64,37 @@ export async function publish(args) {
   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, --env names one from unoverse.yaml's
@@ -127,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/workspace.mjs

@@ -34,16 +34,20 @@ 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.
  * Checked in that order at each level, so a universe folder that also holds a design
- * tree (the platform monorepo's apps/unoverse) is an asset workspace when you stand in
- * it, and a universe when you stand at its compose root.
+ * tree is an asset workspace when you stand in it, and a universe when you stand at its
+ * compose root. The platform monorepo holds no design tree (retired 2026-10-04), so
+ * anywhere inside it is the universe its compose root describes.
  */
 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, "..");
@@ -54,6 +58,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/operator/docker-compose.yml

@@ -6,10 +6,10 @@
 #   - unoverse (the platform runtime — engine in-process + node plane + native MCP),
 #     canvas, umap, memory. Code protected, pulled as images.
 #
-# LAYER 2: PLATFORM-DEV MOUNTS (monorepo only — sync-starter strips them)
-#   - apps/unoverse/design    — design (components, templates, styles)
-#   - apps/unoverse/prompts  — behavior (skills + blocks)
-#   In a STARTER/customer universe these folders do not exist: authoring is
+# LAYER 2: PLATFORM-DEV MOUNT (monorepo only; sync-starter strips it)
+#   - packages/marketplace/definitions  the marketplace tier (components, templates,
+#                                        styles, skills, blocks, nodes, objects, pipelines)
+#   In a STARTER/customer universe this folder does not exist: authoring is
 #   Studio's (publish over the API) and content is DB-driven (marketplace).
 #   Everything else under apps/unoverse (engine, server, web, tools) is image-only.
 #
@@ -296,7 +296,7 @@ services:
       - PLUGINS_DIR=/app/plugins
       # Dev-editable folders are mounted over the image below; NODE_PATH resolves
       # their hoisted deps from the local workspace node_modules. The plugins dir is
-      # also on NODE_PATH so locally-built component nodes (design/marketplace/nodes/*, which
+      # also on NODE_PATH so locally-built component nodes (packages/marketplace/definitions/nodes/*, which
       # live OUTSIDE /app/plugins) can resolve @unoverse-platform/plugin-base — the only
       # copy carrying a built dist. Without this the runtime hits MODULE_NOT_FOUND and
       # the nodes show "Package not installed".
@@ -307,10 +307,11 @@ services:
       # a `unoverse_base:/app/base` volume here between 2026-08-30 and 2026-09-03, holding a
       # base the entrypoint installed from npm at startup. Both are gone: base is compiled in
       # from the workspace, so the image and its runtime cannot disagree.
-      # ── Platform-dev mounts (monorepo only; sync-starter strips these two
-      # lines from the starter's copy — a customer universe serves what the DB
-      # says). Local edits are picked up on restart; design/prompts are data, no build.
-      - ./apps/unoverse/design:/app/apps/unoverse/design # every authored kind: components, templates, styles, skills, blocks, nodes
+      # ── Platform-dev mount (monorepo only; sync-starter strips this line from
+      # the starter's copy, so a customer universe serves what the DB says). Local
+      # edits are picked up on restart; definitions are data, no build. The design
+      # tree mount went with the design tree (2026-10-04).
+      - ./packages/marketplace/definitions:/app/packages/marketplace/definitions # the marketplace tier: every authored kind, read live, and also how base finds the content home (paths.ts findHome)
       - ./node_modules:/app/host_node_modules # Hoisted deps for locally-built nodes
     healthcheck:
       # Ready = internal runtime port up (nodes are loaded into memory BEFORE it binds).

package/operator/lib/publish-assets.mjs

@@ -40,6 +40,12 @@ const die = (msg) => {
   process.exit(1);
 };
 
+// The platform repo's design/ was retired 2026-10-04: no org is authored here any more. An
+// absent folder is no org tier, said plainly, rather than a lint error about a missing folder.
+if (!existsSync(designRoot)) {
+  die(`no design/ folder at ${designRoot}. An org lives in its own repo and publishes from there; pass --design <folder> for a design tree kept elsewhere.`);
+}
+
 if (!project) {
   const projects = listProjects(designRoot);
   die(`which project?\n\n    unoverse publish <project> --to <universe>\n\n  Found: ${projects.join(", ") || "none"}`);

package/operator/lib/start.sh

@@ -286,8 +286,8 @@ build_component_nodes() {
 
   banner "Component Nodes (definition-backed)"
 
-  echo "  Building the marketplace package locally (bundle-defs + tsc → dist)..."
-  if (cd "$ROOT/packages/marketplace" && node scripts/bundle-defs.mjs && npx tsc 2>/dev/null); then
+  echo "  Building the marketplace package locally (tsc → dist)..."
+  if (cd "$ROOT/packages/marketplace" && npx tsc 2>/dev/null); then
     ok "Marketplace package built → packages/marketplace/dist"
   elif [ -d "$ROOT/packages/marketplace/dist" ]; then
     # Starters can't build it (no workspace plugin-base) — the dist SHIPS with the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.213",
+  "version": "0.1.215",
   "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/baseVersion.js

@@ -69,7 +69,7 @@ function packageVersion(designSystemDir) {
 }
 /**
  * Compute the version of the design system at `designSystemDir` (the resolved marketplace
- * directory: on-disk design/marketplace, or the installed bundle).
+ * directory: the tier on disk, or the installed bundle).
  *
  * Hashes components, atoms and styles together, because they only mean anything as a set:
  * a universe holding half of them renders against a contract with holes.

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)) } });
             }
         }
     }
@@ -212,7 +284,7 @@ export function collectProject(designRoot, project) {
     // 2026-09-08 it looked at a `nodes/` folder beside design/ while every org already
     // kept its nodes INSIDE its project, so the same nodes were left behind again. Org
     // nodes are org-scoped like skills; the marketplace tier's own nodes sit under
-    // design/marketplace/, which is never collected.
+    // the marketplace tier, which is never collected.
     const nodesHome = join(root, "nodes");
     if (existsSync(nodesHome)) {
         for (const pkg of collectNodePackages(nodesHome)) {

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/file.mjs

@@ -175,7 +175,7 @@ function checkAppTree(json, root, file) {
             if (ref.includes("/"))
               report("error", file, `state "${where}" preview names "${ref}" with an org prefix. Studio seeds a preview by the component's bare name ("${ref.split("/").pop()}"); a prefixed name resolves to nothing and the state's tab shows nothing (docs.unoverse.ai/design/apps)`);
             else if (comps && !comps.has(ref.toLowerCase()))
-              report("error", file, `state "${where}" preview names "${ref}", which is no component or template this org can see (design/marketplace/, this org's components/ and templates/). Studio would seed nothing and the state's tab would show nothing (docs.unoverse.ai/design/apps)`);
+              report("error", file, `state "${where}" preview names "${ref}", which is no component or template this org can see (the marketplace's, this org's components/ and templates/). Studio would seed nothing and the state's tab would show nothing (docs.unoverse.ai/design/apps)`);
           }
         } else if (entry.preview !== undefined && (typeof entry.preview !== "object" || entry.preview === null))
           report("error", file, `state "${where}" preview must be a list of component names, or an object of app-state mock data (docs.unoverse.ai/design/apps)`);
@@ -578,7 +578,7 @@ function lintFile(file) {
             // 2026-09-11); the lookup is the name before the hash.
             for (const c of list)
               if (comps && !comps.has(String(c).split("#")[0].toLowerCase()))
-                report("error", file, `preview."${state}" names unknown component "${c}". No match in design/marketplace/components/ or this org's components/ (org-privacy: another org's components are out of reach; lookup is case-insensitive)`);
+                report("error", file, `preview."${state}" names unknown component "${c}". No match in the marketplace's components/ or this org's components/ (org-privacy: another org's components are out of reach; lookup is case-insensitive)`);
           }
         }
       }

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

@@ -42,10 +42,13 @@ export function lintDefinitions(designRoot, options = {}) {
     const hit = overlay[resolve(f)];
     return hit === undefined ? readFileSync(f, "utf8") : hit;
   };
-  const candidates = designRoot ? [resolve(designRoot)] : [resolve("apps/unoverse/design"), resolve("design")];
+  // With no root given: the platform repo's marketplace tier (linted as the root itself, as
+  // CI and the release do), else a developer's design/.
+  const candidates = designRoot ? [resolve(designRoot)] : [resolve("packages/marketplace/definitions"), resolve("design")];
 
-  /** The monorepo's shapes: the design system at `design/marketplace/`, or the legacy one
-   *  with `components/` and `atoms/` loose at the root. */
+  /** A design root holding the design system at `<root>/marketplace/`, or the design system
+   *  itself as the root, with `components/` and `atoms/` loose in it (how the platform repo
+   *  lints its tier, `packages/marketplace/definitions`). */
   const holdsDesignSystem = (p) =>
     existsSync(join(p, "marketplace")) || existsSync(join(p, "components")) || existsSync(join(p, "atoms"));
 
@@ -53,7 +56,7 @@ export function lintDefinitions(designRoot, options = {}) {
    * A DEVELOPER'S design/ HOLDS ONLY ORG FOLDERS, and looking for the monorepo's shapes there
    * finds nothing. `design/<org>/{components,styles,apps}` is what Studio scaffolds and
    * the only layout a developer ever has, because the design system is INSTALLED rather
-   * than authored (sync-starter.sh keeps `design/marketplace` out of a project on purpose).
+   * than authored (sync-starter.sh keeps the marketplace tier out of a project on purpose).
    *
    * So a project could not be linted, and since publishing lints first, it could not be
    * published either: "no design/ folder here", naming the folder it was standing in.
@@ -75,7 +78,34 @@ 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;
+  /**
+   * THE MARKETPLACE TIER BY NAME, when it is not `<root>/marketplace`. The platform repo
+   * authors it at packages/marketplace/definitions (base paths.ts `marketplace`), outside any
+   * design root, and a caller that knows that says so. The tier then reads exactly as
+   * `<root>/marketplace` would: the design system, and a home named `marketplace`.
+   */
+  const MARKETPLACE = !ORG_REPO && options.marketplace ? resolve(options.marketplace) : null;
+  const DESIGN_ROOT = ORG_REPO
+    ? dirname(ORG_REPO)
+    : candidates.find((p) => holdsDesignSystem(p) || holdsOrgs(p)) ??
+      (MARKETPLACE && (existsSync(candidates[0]) || existsSync(MARKETPLACE)) ? candidates[0] : undefined);
+  /**
+   * NO ORG TIER HERE. The platform repo authors no orgs (its design/ was retired 2026-10-04),
+   * so a caller naming the marketplace tier may hand a design root that does not exist. That
+   * means "lint the tier alone", never "nothing to lint": an error here would fail every save
+   * in the platform repo's Studio on a folder nobody is meant to have.
+   */
+  const NO_ORG_TIER = !ORG_REPO && !existsSync(DESIGN_ROOT ?? "");
   if (!DESIGN_ROOT)
     return {
       problems: [{ level: "error", file: candidates[0], msg: `no design/ folder here (looked in: ${candidates.join(", ")})` }],
@@ -83,17 +113,25 @@ export function lintDefinitions(designRoot, options = {}) {
     };
 
 // ── tree layout ──
-// New layout: design/marketplace/{atoms,components,styles} + one top-level folder per
+// New layout: <root>/marketplace/{atoms,components,styles} (or the tier named by
+// options.marketplace) + one top-level folder per
 // org (design/<org>/). Legacy layout: components/ + atoms/ at the root, orgs under design/orgs/.
 // The DESIGN SYSTEM is the primary lint target; org folders get the SAME generic
 // checks — nothing here may key on a specific org's name.
-// WHERE THE DESIGN SYSTEM ACTUALLY IS. `design/marketplace/` exists in this monorepo and is
-  // deliberately absent from a developer's project (sync-starter.sh): the platform installs
-  // @unoverse-platform/marketplace, whose `definitions/` bundle carries components, atoms
-  // AND styles (bundle-defs.mjs). All three matter — the space-scale check reads
+// WHERE THE DESIGN SYSTEM ACTUALLY IS. `<root>/marketplace/` when a root carries one; it
+  // is deliberately absent from a developer's project (sync-starter.sh): the platform installs
+  // @unoverse-platform/marketplace, whose `definitions/` folder carries components, atoms
+  // AND styles (authored there, packages/marketplace/definitions in the platform repo). All three matter — the space-scale check reads
   // 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");
+    }
+    if (MARKETPLACE) return MARKETPLACE;
     const onDisk = join(DESIGN_ROOT, "marketplace");
     if (existsSync(onDisk)) return onDisk;
     for (const c of [
@@ -102,8 +140,20 @@ 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] : [...(MARKETPLACE ? [DS] : []), ...(NO_ORG_TIER ? [] : readdirSync(DESIGN_ROOT).map((t) => join(DESIGN_ROOT, t)))];
+/** A file's path below the design root, the named marketplace tier reading as `marketplace/…`. */
+const underRoot = (f) =>
+  MARKETPLACE && (f === DS || f.startsWith(DS + sep)) ? ["marketplace", ...relative(DS, f).split(sep)] : relative(DESIGN_ROOT, f).split(sep);
 const legacyOrgsDir = join(DESIGN_ROOT, "orgs");
 const orgDirs = (() => {
+  if (ORG_REPO) return [ORG_REPO];
+  if (NO_ORG_TIER) return [];
   if (existsSync(legacyOrgsDir))
     return readdirSync(legacyOrgsDir)
       .filter((e) => !e.startsWith("."))
@@ -176,11 +226,11 @@ const isPropsExtract = (f) => {
 const isManifest = (f) => /^manifest\.(json|yaml)$/.test(basename(f));
 // WHICH HOME A FILE IS IN — asked of the path BELOW the design root, never the absolute
 // one. Testing the absolute path for an `apps` segment was true of every file in this
-// monorepo, because the design tree itself lives at `apps/unoverse/design`: every
+// monorepo, because the design tree itself lived at `apps/unoverse/design`: every
 // component manifest in the repo was linted as an APP manifest (two bogus warnings each,
 // while the real component-manifest rules never ran once). A rule that cannot tell the
 // homes apart is worse than no rule — it trains people to ignore its output.
-const homeSegments = (f) => relative(DESIGN_ROOT, f).split(sep);
+const homeSegments = (f) => underRoot(f);
 const isAppPath = (f) => homeSegments(f).includes("apps");
 // THE TEMPLATE KIND (UNOVERSE_TEMPLATE_MODEL.md §9b). Its folders answer to different
 // rules than an app's or a component's, so the rules that would misfire have to be able
@@ -448,7 +498,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 +511,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 +529,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 +797,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 */
   }
@@ -908,7 +958,7 @@ function appSizesForFile(file) {
   return appSizesCache.get(home);
 }
 
-// The universal component names (design/marketplace/components/*, case-insensitive) — for
+// The universal component names (the tier's components/*, case-insensitive) — for
 // validating an app manifest's `preview` map. null = the file is not under a design tree.
 const componentNamesCache = new Map();
 // Components an ORG's template may reference: the marketplace tier + that org's OWN
@@ -918,9 +968,10 @@ function componentNamesForFile(file) {
   // `${sep}orgs${sep}` and returned null for anything else, so on the flat layout — which
   // is every project now (`design/<org>/…`, "flat wins") — it answered "no list" and
   // every rule that asks it, preview names included, silently stopped checking.
-  const segs = relative(DESIGN_ROOT, file).split(sep);
+  const segs = underRoot(file);
   if (segs.length < 2 || segs[0] === "..") return null;
   const projectSegs = segs[0] === "orgs" ? segs.slice(0, 2) : segs.slice(0, 1);
+  const projectHome = MARKETPLACE && projectSegs[0] === "marketplace" ? DS : join(DESIGN_ROOT, ...projectSegs);
   const org = projectSegs.join("/");
   const cached = componentNamesCache.get(org);
   if (cached !== undefined) return cached;
@@ -929,17 +980,17 @@ function componentNamesForFile(file) {
   // 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 (DS === DESIGN_ROOT) {
+  if (!HAS_DS) {
     componentNamesCache.set(org, null);
     return null;
   }
   const dirs = [
     join(DS, "components"),
-    join(DESIGN_ROOT, ...projectSegs, "components"),
+    join(projectHome, "components"),
     // TEMPLATES ARE PEERS (§9c): a state that holds one seeds it by name like any
     // component, so the name set a preview is checked against includes them.
     join(DS, "templates"),
-    join(DESIGN_ROOT, ...projectSegs, "templates"),
+    join(projectHome, "templates"),
   ];
   let names = null;
   for (const dir of dirs) {
@@ -964,7 +1015,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/design/vocabulary.mjs

@@ -1,7 +1,7 @@
 /**
  * The CLOSED SETS. This file is the linter's ground truth.
  *
- * Mirrors apps/unoverse/design/_schema/unoverse.schema.json and the server guards, and UNOVERSE_CONFORMANCE
+ * Mirrors packages/docs/schemas/design/unoverse.schema.json and the server guards, and UNOVERSE_CONFORMANCE
  * §5 makes keeping them equal a maintenance rule: "One source for each closed set... Keep
  * them equal or they disagree silently."
  *
@@ -10,7 +10,7 @@
  * without extending the schema and the SDK in the same change.
  */
 
-// ── ground truth (mirrors design/_schema/unoverse.schema.json + server guards) ──
+// ── ground truth (mirrors packages/docs/schemas/design/unoverse.schema.json + server guards) ──
 export const PRIMITIVES = new Set([
   "Box", "Stack", "Row", "Column", "Each", "Switch", "ComponentSlot", "Timeline",
   "Text", "Image", "Button", "Input", "Select", "Markdown", "Skeleton", "Icon", "Ref", "Orb", "Template", "Place",

package/vendor/base/lint/nodes/_schema/_defs.schema.json

@@ -96,7 +96,7 @@
     },
     "template": {
       "type": "string",
-      "description": "A Handlebars template resolved against the node's input context before the request is sent.\n\nFive roots:\n  signal.<sourceId>.<outputHandle>.<field>   upstream node output, e.g. {{signal.inputtrigger1.output.message}}\n  config.<field>                              this node's own settings\n  credentials.<name>.<field>                  this node's resolved credential\n  services.<connector>                        RUNTIME service wiring, e.g. {{#unless services.mcpService.tools}}\n  prompt.<blockName>                          a PROMPT BLOCK from the library (alias: blocks.<name>)\n\nThe services root exists because some request shaping depends on what is WIRED rather than configured, a fact only the executor knows at run time.\n\nThe prompt root is why a manifest must NEVER hardcode instruction text. Blocks live in design/marketplace/blocks/**/*.md, are authored and toggled in Studio, and are camelCased from the filename (markdown-guidelines.md becomes {{prompt.markdownGuidelines}}). A copy of a block's words baked into a node is a fork that silently stops tracking the block. Text belongs in the library; the node references it. This is the prompt-side twin of the SDK owning no styles.\n\nEvery root works in ANY template field, including a user's own systemPrompt: that is what lets an author compose blocks and upstream values into a prompt without the node knowing anything about it.\n\nThere is NO {{input.*}} root: a wrong path resolves to EMPTY silently. Array elements and object keys are dot segments, never brackets: records.0.Name, not records[0].Name."
+      "description": "A Handlebars template resolved against the node's input context before the request is sent.\n\nFive roots:\n  signal.<sourceId>.<outputHandle>.<field>   upstream node output, e.g. {{signal.inputtrigger1.output.message}}\n  config.<field>                              this node's own settings\n  credentials.<name>.<field>                  this node's resolved credential\n  services.<connector>                        RUNTIME service wiring, e.g. {{#unless services.mcpService.tools}}\n  prompt.<blockName>                          a PROMPT BLOCK from the library (alias: blocks.<name>)\n\nThe services root exists because some request shaping depends on what is WIRED rather than configured, a fact only the executor knows at run time.\n\nThe prompt root is why a manifest must NEVER hardcode instruction text. Blocks live in packages/marketplace/definitions/blocks/**/*.md, are authored and toggled in Studio, and are camelCased from the filename (markdown-guidelines.md becomes {{prompt.markdownGuidelines}}). A copy of a block's words baked into a node is a fork that silently stops tracking the block. Text belongs in the library; the node references it. This is the prompt-side twin of the SDK owning no styles.\n\nEvery root works in ANY template field, including a user's own systemPrompt: that is what lets an author compose blocks and upstream values into a prompt without the node knowing anything about it.\n\nThere is NO {{input.*}} root: a wrong path resolves to EMPTY silently. Array elements and object keys are dot segments, never brackets: records.0.Name, not records[0].Name."
     }
   }
 }

package/vendor/base/lint/nodes/blocks.mjs

@@ -23,7 +23,7 @@ export const HANDLEBARS_HELPERS = new Set([
 ]);
 
 /**
- * The prompt-block library: design/marketplace/blocks/**\/*.md, keyed the way the resolver keys them
+ * The prompt-block library: the marketplace tier's blocks/**\/*.md, keyed the way the resolver keys them
  * (engine/src/template/promptBlocks.ts) — the filename camelCased, so markdown-guidelines.md is
  * referenced as {{prompt.markdownGuidelines}}.
  *
@@ -42,8 +42,8 @@ const CACHE = new Map();
 
 export function promptBlocks() {
   // The block library is the marketplace tier's. Beside the nodes when they ARE that
-  // tier (design/marketplace/{nodes,blocks}); one tier over for an org's own nodes
-  // (design/<org>/nodes → design/marketplace/blocks).
+  // tier (packages/marketplace/definitions/{nodes,blocks}); one tier over for an org's own
+  // nodes (design/<org>/nodes → design/marketplace/blocks, a design root carrying the tier).
   const home = [resolve(state.nodesHome, "../blocks"), resolve(state.nodesHome, "../../marketplace/blocks")]
     .find((d) => existsSync(d)) ?? resolve(state.nodesHome, "../../marketplace/blocks");
   const cached = CACHE.get(home);

package/vendor/base/lint/nodes/node.mjs

@@ -672,7 +672,7 @@ export function lintNode(dir, pkg) {
       for (const [, b] of body.matchAll(/\b(?:prompt|blocks)\.([A-Za-z0-9_]+)/g))
         if (!promptBlocks().has(b) && !seen.has(b)) {
           seen.add(b);
-          report("error", F.api, `references prompt block "{{prompt.${b}}}", which does not exist in design/marketplace/blocks/. It resolves to empty and the instruction silently disappears`);
+          report("error", F.api, `references prompt block "{{prompt.${b}}}", which does not exist in the marketplace's blocks/. It resolves to empty and the instruction silently disappears`);
         }
     }
   }

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

@@ -106,7 +106,13 @@ export function lintObjects(designRoot, options = {}) {
     }
   };
 
-  if (!isDir(ROOT)) {
+  // The marketplace tier: `<root>/marketplace`, unless the caller names it (options.marketplace:
+  // the platform repo authors it outside any design root, base paths.ts `marketplace`).
+  const marketplace = options.marketplace ? resolve(options.marketplace) : join(ROOT, "marketplace");
+  // NO ORG TIER HERE: a named marketplace tier with no design root beside it (the platform
+  // repo, whose design/ was retired 2026-10-04) lints the tier alone. Only a root with neither
+  // is "nothing to lint".
+  if (!isDir(ROOT) && !(options.marketplace && isDir(marketplace))) {
     report("error", ROOT, "no design/ folder here");
     return { problems: [...problems], objectCount: 0, pipelineCount: 0, designRoot: ROOT };
   }
@@ -117,13 +123,18 @@ export function lintObjects(designRoot, options = {}) {
   loadAllSchemas();
 
   // ── the tiers: the marketplace, then every org folder ──
-  const marketplace = join(ROOT, "marketplace");
+  // 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 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 isDir(ROOT) ? 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 +244,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`);
@@ -259,22 +270,38 @@ export function lintObjects(designRoot, options = {}) {
 
     // extends: resolves, no cycle, across the tiers the org can see.
     let parentProps = null;
+    // A BASE THAT CANNOT BE SEEN is not a missing base. An org repo carries no marketplace on
+    // disk (UNO-88), so `extends: need` names an object installed in every universe and present
+    // in none of the repo's folders. The same rule as the nodes above: step back to a hint, read
+    // a description-only prop as the re-brief of an inherited field (the only thing it can be),
+    // and leave the row keys, which need the base's fields, to the universe that has them.
+    let baseUnseen = false;
     const base = isRecord(f.envelope) ? f.envelope.extends : undefined;
     if (typeof base === "string") {
       const parent = findObject(base, f.org);
-      if (!parent) report("error", rel(f.envFile), `object ${f.name}: extends "${base}", which no tier holds`);
+      if (!parent && options.org?.dir && !marketplaceSeen) {
+        baseUnseen = true;
+        report("hint", rel(f.envFile), `object ${f.name}: extends "${base}", which is not on disk here (the marketplace is installed, not in the repo), so what it inherits was not checked`);
+        parentProps = Object.fromEntries(
+          Object.entries(isRecord(f.props) ? f.props : {}).filter(([, p]) => isRecord(p) && Object.keys(p).every((k) => k === "description")),
+        );
+      } else if (!parent) report("error", rel(f.envFile), `object ${f.name}: extends "${base}", which no tier holds`);
       else {
         parentProps = composedProps(parent, [f.name]);
         if (parentProps === null) report("error", rel(f.envFile), `object ${f.name}: extends cycle through ${base}`);
       }
     }
     say(propsFindings(f.name, f.props, parentProps, base, basename(f.propsFile)));
-    if (isRecord(f.props)) for (const [k, p] of Object.entries(f.props)) if (isRecord(p) && p.from != null) say(fromFindings(f.name, k, p.from, composedService(f), basename(f.propsFile)));
+    // With the base unseen, a function the object does not declare itself may be the base's
+    // (README: a prop may be written from an inherited function), so only its own are checked.
+    const fns = composedService(f);
+    const ownFn = (from) => typeof from === "string" && from.split(".")[0] in fns;
+    if (isRecord(f.props)) for (const [k, p] of Object.entries(f.props)) if (isRecord(p) && p.from != null && (!baseUnseen || ownFn(p.from))) say(fromFindings(f.name, k, p.from, fns, basename(f.propsFile)));
     say(serviceFindings(f.name, f.service, visibleNodes(tier)));
     say(makeFindings(f.name, f.make, f.service, visibleNodes(tier)));
     if (!marketplaceSeen && isRecord(f.service)) report("hint", rel(f.servicePath), `object ${f.name}: the marketplace is not on disk here, so the nodes its calls name were not checked`);
     const all = composedProps(f) ?? (isRecord(f.props) ? f.props : {});
-    say(rowKeyFindings(f.name, f.envelope, all, basename(f.envFile)));
+    if (!baseUnseen) say(rowKeyFindings(f.name, f.envelope, all, basename(f.envFile)));
     say(objectTestFindings(f.name, f.test, ownFunctions(f)));
     // An org may never take a marketplace name: a bare object_type must stay unambiguous.
     if (f.org && marketplaceObjects.has(f.name)) report("error", rel(f.envFile), `object ${f.name}: an org's object may not take a marketplace object's name; the row's object_type would be ambiguous. Rename it, or extend ${f.name} under a name of its own`);

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

@@ -135,18 +135,28 @@ export function lintPrompts(designRoot, options = {}) {
   const present = (f) => existsSync(f) || overlay[resolve(f)] !== undefined;
   const rel = (f) => (relative(process.cwd(), f).startsWith("..") ? f : relative(process.cwd(), f));
 
-  if (!isDir(ROOT)) {
+  // The marketplace tier: `<root>/marketplace`, unless the caller names it (options.marketplace:
+  // the platform repo authors it outside any design root, base paths.ts `marketplace`).
+  const marketplace = options.marketplace ? resolve(options.marketplace) : join(ROOT, "marketplace");
+  // NO ORG TIER HERE: a named marketplace tier with no design root beside it (the platform
+  // repo, whose design/ was retired 2026-10-04) lints the tier alone. Only a root with neither
+  // is "nothing to lint".
+  if (!isDir(ROOT) && !(options.marketplace && isDir(marketplace))) {
     report("error", ROOT, "no design/ folder here");
     return { problems: [...problems], skillCount: 0, blockCount: 0, designRoot: ROOT };
   }
 
   // ── 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 });
+    if (isDir(ROOT)) 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;