@unoverse-platform/studio 0.1.104 → 0.1.106

package/local/scaffold.mjs

@@ -14,8 +14,9 @@
  * See docs/architecture/authoring/LOCAL_STUDIO.md.
  */
 import { existsSync, mkdirSync, writeFileSync, cpSync, readdirSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { designHome } from "./design-home.mjs";
-import { join, dirname, resolve } from "node:path";
+import { join, dirname, resolve, basename } from "node:path";
 import { fileURLToPath } from "node:url";
 
 /**
@@ -73,12 +74,25 @@ export function createProject(home, name) {
   const root = join(designHome(home), name);
   if (existsSync(root)) throw new Error(`${name} already exists in this workspace`);
 
+  return fillOrgFolder(root);
+}
+
+/**
+ * One org's folder, filled: the welcome component, the sample styles, identity, app and
+ * chat component. Shared by the monorepo shape (design/<org>/) and an org repo, whose root
+ * IS the org's folder (UNO-88), so the two can never drift.
+ */
+function fillOrgFolder(root, { baselineOnly = false } = {}) {
+  // THE BASELINE (decided 2026-10-03): what an org needs to work, its starting tokens and its
+  // identity. Everything else here is a sample; an org repo gets none (samples live in their
+  // own repo), the monorepo shape still does.
   // EVERY AUTHORED KIND LIVES UNDER THE ORG (2026-08-24). skills/ and blocks/ moved in
   // beside components/apps/styles so a skill is org-scoped exactly like a component —
   // two orgs may each ship an `hr-education-coach` without colliding on one flat name
   // (items/collect.ts qualifies a skill's row `<org>/<name>`).
-  for (const d of ["components/welcome", "apps", "styles", "skills", "blocks", "identity"]) mkdirSync(join(root, d), { recursive: true });
-  writeFileSync(join(root, "components/welcome/welcome.yaml"), WELCOME);
+  const dirs = baselineOnly ? ["styles", "identity"] : ["components/welcome", "apps", "styles", "skills", "blocks", "identity"];
+  for (const d of dirs) mkdirSync(join(root, d), { recursive: true });
+  if (!baselineOnly) writeFileSync(join(root, "components/welcome/welcome.yaml"), WELCOME);
 
   // Worked example styles (sample-styles: brand ingredients + the override rules), so
   // styles/ is never an empty folder with no hint of the token cascade. Per PROJECT,
@@ -103,7 +117,7 @@ export function createProject(home, name) {
   // so apps/ is never an empty folder and the first app is a rename away. Same
   // rule as the styles: copied only into an empty folder, then the developer's.
   const sampleApp = join(dirname(fileURLToPath(import.meta.url)), "sample-app/chat");
-  if (existsSync(sampleApp) && readdirSync(join(root, "apps")).length === 0) {
+  if (!baselineOnly && existsSync(sampleApp) && readdirSync(join(root, "apps")).length === 0) {
     cpSync(sampleApp, join(root, "apps/chat"), { recursive: true });
     // Its other half: the chat CX itself (welcome hero, timeline, suggestions,
     // composer) is a COMPONENT the app draws via `Ref`, so the surface lives once
@@ -111,6 +125,13 @@ export function createProject(home, name) {
     // it: an app whose chat-region resolves nothing renders an empty column.
     const sampleComponent = join(dirname(fileURLToPath(import.meta.url)), "sample-component/text-chat");
     if (existsSync(sampleComponent)) cpSync(sampleComponent, join(root, "components/text-chat"), { recursive: true });
+    // QUALIFIED WITH THIS ORG. Many orgs ship a `text-chat`, and a bare ref to a name two
+    // orgs hold is an error (homes.ts resolveComponentDirs), so the copy names its own.
+    // Only the monorepo shape takes samples, and there the folder's name is the org's.
+    const region = join(root, "apps/chat/components/chat-region.yaml");
+    if (existsSync(region)) {
+      writeFileSync(region, readFileSync(region, "utf8").replace(/^ref: text-chat$/m, `ref: ${basename(root)}/text-chat`));
+    }
   }
   return root;
 }
@@ -153,6 +174,7 @@ export function topUpSamples(home, project) {
   // An org-scoped sample has nowhere to go without a project. Called at launch (where
   // the project is not known) the org samples are simply skipped — they arrive with the
   // next `createFirstProject`, which is the only moment their destination exists.
+  // An org repo (UNO-88) holds the org at its root: `design/<org>/x` lands at `x`.
   const destOf = (s) => (typeof s.to === "function" ? s.to(project) : s.to);
   const placeable = (s) => typeof s.to !== "function" || !!project;
   let seen = [];
@@ -236,24 +258,131 @@ const NODE_SCHEMA_MAP = {
   [`${SCHEMAS.replace(/\/nodes$/, "/pipelines")}/interface.schema.json`]: ["design/*/pipelines/*/interface.yaml"],
   [`${SCHEMAS.replace(/\/nodes$/, "/pipelines")}/test.schema.json`]: ["design/*/pipelines/*/test.yaml"],
 };
-export function writeEditorSettings(home) {
+export function writeEditorSettings(home, flat = false) {
   const dir = join(home, ".vscode");
   mkdirSync(dir, { recursive: true });
   const settings = join(dir, "settings.json");
-  if (!existsSync(settings)) writeFileSync(settings, JSON.stringify({ "yaml.schemas": NODE_SCHEMA_MAP }, null, 2) + "\n");
+  // An org repo's folders sit at the root, so `design/*/nodes/...` becomes `nodes/...`.
+  const map = flat
+    ? Object.fromEntries(Object.entries(NODE_SCHEMA_MAP).map(([schema, globs]) => [schema, globs.map((g) => g.replace(/^design\/\*\//, ""))]))
+    : NODE_SCHEMA_MAP;
+  if (!existsSync(settings)) writeFileSync(settings, JSON.stringify({ "yaml.schemas": map }, null, 2) + "\n");
   const ext = join(dir, "extensions.json");
   if (!existsSync(ext)) writeFileSync(ext, JSON.stringify({ recommendations: ["redhat.vscode-yaml"] }, null, 2) + "\n");
 }
 
+/**
+ * THE CHECK, NOT A DEPLOY (RELEASE_LIFECYCLE.md §3a). Universes pull the org's repo
+ * themselves, so the repo needs no deploy pipeline and holds no keys. What it needs is the
+ * check every pull request runs: the same lint a universe runs before it applies a commit,
+ * so broken work cannot be merged. Written once; a later run never replaces the team's own.
+ */
+const CI_WORKFLOW = `# Checks every pull request with the same lint a universe runs before applying a commit.
+# Universes pull this repo themselves: there is nothing to deploy from here.
+# https://docs.unoverse.ai/architecture/environments
+name: unoverse
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npx --yes unoverse@latest lint PROJECT
+`;
+
+export function writeCiWorkflow(home, project) {
+  const dir = join(home, ".github", "workflows");
+  const file = join(dir, "unoverse.yml");
+  if (existsSync(file)) return;
+  mkdirSync(dir, { recursive: true });
+  // An org repo lints the org it declares, so the check names no project.
+  writeFileSync(file, CI_WORKFLOW.replaceAll(" PROJECT", project ? ` ${project}` : ""));
+}
+
+const GITIGNORE = `node_modules/
+.DS_Store
+*.log
+.env
+.env.*
+`;
+
+/**
+ * ONE ORG, ONE REPO (RELEASE_LIFECYCLE.md §3). A workspace is never without Git: Git is its
+ * history and its rollback, and the repo is what a universe pulls. So the first project
+ * leaves the folder as a repo on `main` with everything in a first commit.
+ *
+ * Never an author it was not given: if the developer has no Git name and email set, the
+ * repo is left initialised with nothing staged, and they are told how to finish. A folder
+ * already inside a repo is left alone, and a machine with no Git is told, not changed.
+ * Returns what happened, for the caller to say.
+ */
+export function startRepo(home, project) {
+  const git = (...args) => execFileSync("git", args, { cwd: home, stdio: "pipe" }).toString().trim();
+  try {
+    git("--version");
+  } catch {
+    return { state: "no-git", message: "Git is not installed, so this workspace has no history yet. Install Git, then run: git init -b main" };
+  }
+  try {
+    if (git("rev-parse", "--is-inside-work-tree") === "true") return { state: "inside-repo" };
+  } catch {
+    // not inside a repo: make one
+  }
+  if (!existsSync(join(home, ".gitignore"))) writeFileSync(join(home, ".gitignore"), GITIGNORE);
+  git("init", "-q", "-b", "main");
+  try {
+    git("add", "-A");
+    git("commit", "-q", "-m", `Start ${project}`);
+    return { state: "committed" };
+  } catch {
+    try { git("reset", "-q"); } catch { /* nothing staged */ }
+    return { state: "no-identity", message: `Set your Git name and email, then make the first commit: git add -A && git commit -m "Start ${project}"` };
+  }
+}
+
+/**
+ * AN ORG REPO (UNO-88): `dir` becomes one org's own repo. Its folders at the root, its name
+ * declared in unoverse.yaml, the samples, the editor's schema globs, the pull-request check,
+ * and Git with a first commit. This is what `unoverse create` makes; Studio only opens it.
+ * Refuses a folder that already holds an org or a design tree. Returns the Git outcome.
+ */
+export function createOrgRepo(dir, org) {
+  const bad = checkProjectName(org);
+  if (bad) throw new Error(bad);
+  mkdirSync(dir, { recursive: true });
+  if (existsSync(join(dir, "unoverse.yaml")) || existsSync(join(dir, "design")) || existsSync(join(dir, "components"))) {
+    throw new Error(`${dir} already holds a workspace`);
+  }
+  fillOrgFolder(dir, { baselineOnly: true });
+  writeFileSync(join(dir, "unoverse.yaml"), `# This repo is one org: its folders sit here, at the root.\n# Universes pull it from Git (RELEASE_LIFECYCLE.md).\norg: ${org}\n`);
+  writeEditorSettings(dir, true);
+  writeCiWorkflow(dir, null);
+  // No samples in an org repo: they live in their own repo, to read and copy (decided 2026-10-03).
+  return startRepo(dir, org);
+}
+
 export function createFirstProject(home, name) {
   const root = createProject(home, name);
   // NOTHING beside the design tree. skills/ and blocks/ moved INTO the org on 2026-08-24
   // and nodes/ followed on 2026-09-08 (the sample package lands at design/<org>/nodes/),
-  // so every authored kind sits in one place.
+  // so every authored kind sits in one place. The two exceptions are the editor's
+  // settings and the CI template, which belong to the repo, not to a project.
   writeEditorSettings(home);
+  writeCiWorkflow(home, name);
 
   topUpSamples(home, name);
 
+  const repo = startRepo(home, name);
+  if (repo.message) console.warn(`  ${repo.message}`);
+
   // SCAFFOLD WRITES NO `.claude/skills` (2026-08-21). It used to copy the Claude Code
   // authoring skills out of `vendor/skills` and into `<home>/.claude/skills`, which meant
   // every remote developer who launched Studio got the platform repo's own `.claude`

package/local/source.ts

@@ -21,7 +21,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, sep, relative } from "path";
 import { existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 
@@ -179,7 +179,7 @@ export async function saveSource(
 
   writeFileSync(abs, text, "utf8");
 
-  const designRoot = designHome(projectRoot);
+  const designRoot = authoringRoot(projectRoot);
   let problems: LintFinding[] = [];
   try {
     problems = (await lint(designRoot)).problems ?? [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.104",
+  "version": "0.1.106",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {

package/screens/EmptyLibrary.tsx

@@ -53,10 +53,10 @@ export function EmptyLibrary({
             <p className="mt-2 text-sm leading-relaxed text-gray-600">{shape}</p>
             <div className="mt-5 rounded-lg border border-gray-200 bg-gray-50 p-4">
               <div className="text-[10px] font-semibold uppercase tracking-wider text-gray-500">
-                {scoped ? `Author one for ${scoped}` : "Author one"}
+                {scoped ? `Author one in ${scoped}'s repo` : "Author one in the org's repo"}
               </div>
               <div className="mt-1.5 font-mono text-[12.5px] text-gray-800">
-                {scoped ? `design/${scoped}/${folder}/` : `design/<org>/${folder}/`}
+                {folder}/
               </div>
               {/* THE OTHER TIER, said once and quietly. An org asset is private to that
                   org; an unqualified one is universal and every client can install it.

package/screens/IdentityView.tsx

@@ -178,7 +178,7 @@ export function IdentityView({ org = "all" }: { org?: string } = {}) {
               name={current.name}
               category={current.manifest.category}
               version={current.manifest.version}
-              id={`design/${current.org}/${current.path}`}
+              id={`${current.org}: ${current.path}`}
               description={current.manifest.description}
               whenToUse={current.manifest.whenToUse}
               right={<ToggleSwitch on={available.isEnabled(current.name)} onClick={() => available.toggle(current.name)} label={current.doc === "organisation" ? "Grounding" : "Available"} />}

package/screens/TemplatesView.tsx

@@ -925,7 +925,7 @@ export function TemplatesView({
       <nav className={NAV}>
         <div className={NAV_SECTION}>Apps</div>
         {templates.length === 0 && (
-          <div className="p-2 text-xs text-gray-400">No apps yet — add one under design/&lt;project&gt;/apps/.</div>
+          <div className="p-2 text-xs text-gray-400">No apps yet. Add one under apps/ in the org's repo.</div>
         )}
         {templates.map((t) => (
           <div key={`${t.org ?? ""}/${t.name}`}>

package/src/App.tsx

@@ -79,16 +79,21 @@ function Shell() {
   const [variant, setVariant] = usePersistentState<string>("studio:variant", "light");
 
   const [projects, setProjects] = useState<string[]>([]);
+  // Set when this folder is one org's repo: there is no second project to create here.
+  const [orgRepo, setOrgRepo] = useState<string | null>(null);
   const [theme, setTheme] = useState<ResolvedTheme | null>(null);
   const [foundation, setFoundation] = useState<ResolvedTheme | null>(null);
   const [error, setError] = useState<string | null>(null);
 
-  // The projects in this developer's design/ folder. Flat, per RX_ORG_MODEL. Re-read after
-  // creating one, so a new project appears without a reload.
+  // The orgs Studio can see: the one org of an org repo, or each project in the monorepo's
+  // design/. Re-read after creating one, so a new project appears without a reload.
   const loadProjects = () =>
     fetch("/dev/orgs")
       .then((r) => r.json())
-      .then((d) => setProjects(d.orgs ?? []))
+      .then((d) => {
+        setProjects(d.orgs ?? []);
+        setOrgRepo(d.orgRepo ?? null);
+      })
       .catch((e) => setError(String(e)));
   useEffect(() => {
     loadProjects();
@@ -161,8 +166,8 @@ function Shell() {
                 {o}
               </option>
             ))}
-            <option disabled>──────────</option>
-            <option value="__new">New project…</option>
+            {!orgRepo && <option disabled>──────────</option>}
+            {!orgRepo && <option value="__new">New project…</option>}
           </select>
           <button
             onClick={() => setVariant(variant === "light" ? "dark" : "light")}

package/vendor/base/src/definitions/registry/homes.ts

@@ -9,7 +9,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { packagedDesignSystem } from "../dsPackage.js";
 import { defPath } from "../fsCache.js";
-import { DESIGN_HOME, INSTALLED_HOME, databaseOnly, designDir } from "../../paths.js";
+import { DESIGN_HOME, INSTALLED_HOME, databaseOnly, designDir, getPaths } from "../../paths.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -113,6 +113,9 @@ const RESERVED_DESIGN = new Set(["marketplace", "_schema"]);
  *  at the rx root (`rx/<name>` — the target) or under the legacy `rx/orgs/<name>`. Flat
  *  wins. A project folder carries at least one of styles/apps/components. */
 export function projectDir(name: string): string {
+  // An org repo (UNO-88): the repo root IS the org's folder.
+  const repo = getPaths().orgRepo;
+  if (repo && name === repo.org) return repo.dir;
   const installedProject = join(INSTALLED_DESIGN, name);
   if (databaseOnly()) return installedProject;
   const flat = join(DESIGN, name);
@@ -130,6 +133,9 @@ export function projectDir(name: string): string {
  *  A flat candidate must look like a project (styles/apps/components) so a stray dir
  *  isn't mistaken for one. */
 export function listOrgs(): string[] {
+  // An org repo holds exactly one org, declared; never its siblings or its folder names.
+  const repo = getPaths().orgRepo;
+  if (repo) return [repo.org];
   const isProject = (dir: string) =>
     existsSync(join(dir, "styles")) || existsSync(join(dir, "apps")) || existsSync(join(dir, "components")) ||
     existsSync(join(dir, "templates")) || existsSync(join(dir, "agents")) ||

package/vendor/base/src/definitions/registry/orgDocuments.ts

@@ -17,7 +17,8 @@
  * pack writer and the Studio scaffold so a new org and a new project start identical.
  */
 import { existsSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { basename, join, resolve } from "node:path";
+import { getPaths } from "../../paths.js";
 import { parse, stringify } from "yaml";
 import { readObject, type ObjectDefinition } from "./objects.js";
 
@@ -78,7 +79,9 @@ export function instanceText(doc: OrgDocument, values: Record<string, unknown> =
 export function readOrgDocument(root: string, doc: OrgDocument): IdentityDocument | null {
   const file = join(identityDir(root), `${doc}.yaml`);
   if (!existsSync(file)) return null;
-  const org = basename(root);
+  // The org this folder is: declared in an org repo (UNO-88), else the folder's name.
+  const repo = getPaths().orgRepo;
+  const org = repo && resolve(repo.dir) === resolve(root) ? repo.org : basename(root);
   const object = identityObject(doc, org);
   if (!object) throw new Error(`identity/${doc}.yaml: no object named ${doc} in any tier`);
   const instance = (parse(readFileSync(file, "utf8")) as Record<string, any>) ?? {};

package/vendor/base/src/items/collect.ts

@@ -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";
@@ -53,6 +53,48 @@ function designSystemDir(designRoot: string): string {
   return onDisk; // nothing found: the version will hash to an empty set, which is honest
 }
 
+/**
+ * ONE ORG, ONE REPO (RELEASE_LIFECYCLE.md §3, UNO-88). An org's own repo IS the org: its
+ * folders (components/, apps/, skills/, nodes/ ...) sit at the root, and its name is
+ * DECLARED in `unoverse.yaml` (`org: <slug>`), never read off the folder, which may be called
+ * `org-acme` or anything else. `design/<org>/` remains only the platform monorepo's shape.
+ */
+export interface OrgHome {
+  org: string;
+  dir: string;
+}
+
+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: string): string | null {
+  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: string): OrgHome | null {
+  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: string): string {
+  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: OrgHome): CollectedItem[] {
+  return collectFrom(home.dir, home.org, orgDesignSystemDir(home.dir));
+}
+
 /** Every project a developer could publish, by name. */
 export function listProjects(designRoot: string): string[] {
   if (!existsSync(designRoot)) return [];
@@ -62,6 +104,41 @@ export function listProjects(designRoot: string): string[] {
     .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: Record<string, string> = {
+  ".svg": "image/svg+xml", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif",
+};
+function assetUri(fromDir: string, src: string): string | null {
+  const rel = src.slice("assets/".length);
+  const type = ASSET_TYPES[extname(rel).toLowerCase()];
+  if (!type) return null;
+  let file: string | null = 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: string): string => {
+  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: string, _q: string, src: string, rest: string) => {
+    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: string): Record<string, string> {
   const out: Record<string, string> = {};
@@ -71,7 +148,7 @@ function filesUnder(dir: string): Record<string, string> {
       if (e.name.startsWith(".")) continue;
       const p = join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (isDef(e.name) || e.name.endsWith(".md")) out[relative(dir, p)] = readFileSync(p, "utf8");
+      else if (isDef(e.name) || e.name.endsWith(".md")) out[relative(dir, p)] = readDef(p);
     }
   };
   walk(dir);
@@ -89,11 +166,15 @@ function filesUnder(dir: string): Record<string, string> {
 export function collectProject(designRoot: string, project: string): CollectedItem[] {
   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: string, project: string, designSystem: string): CollectedItem[] {
   // 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: CollectedItem[] = [];
   // A COMPONENT (and, since 2026-08-24, a SKILL) row's name is the qualified ref
@@ -155,7 +236,7 @@ export function collectProject(designRoot: string, project: string): CollectedIt
       } 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/src/items/publish.ts

@@ -14,7 +14,7 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { collectProject, type CollectedItem } from "./collect.js";
+import { collectProject, type CollectedItem, type OrgHome } from "./collect.js";
 
 /** One lint finding. `error` blocks a publish; `warn` and `hint` inform. */
 export interface Finding {
@@ -98,6 +98,26 @@ export async function lintForPublish(designRoot: string, project: string): Promi
   return { problems: mine, errors: mine.filter((p: Finding) => 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: OrgHome): Promise<{ problems: Finding[]; errors: Finding[] }> {
+  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: Finding) => p.level === "error") };
+}
+
 /**
  * What publishing WOULD do, without doing it.
  *
@@ -224,7 +244,8 @@ export async function sendPublish(
     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 as { org?: string }).org }),
     });
     const body = (await res.json().catch(() => ({}))) as { error?: string };
     if (res.ok) sent.push({ ...(r as CollectedItem), mode: "removed" });

package/vendor/base/src/lint/design/index.d.mts

@@ -24,7 +24,14 @@ export interface DefinitionsResult {
 }
 
 /** Lint every definition under `rxHome`. Prints nothing, throws nothing for a lint failure. */
-export function lintDefinitions(rxHome?: string): DefinitionsResult;
+export interface LintDefinitionsOptions {
+  /** Absolute path -> text that stands in for what is on disk (an unsaved editor). */
+  overlay?: Record<string, string>;
+  /** An org's own repo (UNO-88): its folder and its DECLARED name. The org list is then this one. */
+  org?: { name: string; dir: string };
+}
+
+export function lintDefinitions(rxHome?: string, options?: LintDefinitionsOptions): DefinitionsResult;
 
 /** True when anything would fail a build. */
 export function hasErrors(result: DefinitionsResult): boolean;